#include "Mng.h"

enum
{
    MAGIC_KEY=326, 
};

#include <stdarg.h>
static void Error(const char *fmt, ...)
{
    va_list ap;
    va_start(ap,fmt);
    printf("Error:");
    vprintf(fmt,ap);
    printf("\n");
    fflush(stdout);
    va_end(ap);
    exit(1);
}    

char *ShmAlloc(int nblk,int blksize)
{
    enum
    {
        MAXID=4,
        MAXSHM=1024*1024
    };
    static int ShmId[MAXID];
    static char *ShmBuf[MAXID];
    //static int ShmSize[MAXID];
    static int ShmOff[MAXID];
    static int nShm=0;
    
    char *p=0;
    int i;
    //nblk == -1 means to clean up
    if(nblk==-1)
    {
        for(i=0;i<nShm;i++)
        {
            if(shmdt(ShmBuf[i])==-1)
                Error("Fail to detach shared memory block %d(%s)",
                      i,strerror(errno));
            if(shmctl(ShmId[i],IPC_RMID,0)==-1)
                Error("Fail to remove shared memory(%s)",strerror(errno));
        }
        nShm=0;
    }
    else if(nblk*blksize > MAXSHM)
        Error("Size too large %d > %d",nblk*blksize, MAXSHM);
    else // Really an allocation
    {
        int nb;
        for(i=0;i<nShm;i++)
        {
            nb=ShmOff[i]%blksize;
            if(nb) nb=blksize-nb;
            if( ShmOff[i]+nb+blksize*nblk<= MAXSHM)
            {
                p=ShmBuf[i]+ShmOff[i]+nb;
                ShmOff[i]+=blksize*nblk+nb;
                break;
            }
        }
        if(i==nShm) //No block available
        {
            //We need to alloc a new one
            if(nShm==MAXID)
                Error("Out of shared memory blocks(max %d)!",MAXID);
            ShmId[nShm]=shmget(MAGIC_KEY+nShm,MAXSHM,IPC_CREAT|IPC_EXCL|0600);
            if(ShmId[nShm]==-1)
                Error("Fail to alloc %d bytes shared memory(%s)",
                      MAXSHM,strerror(errno));
            else
            {
                p=shmat(ShmId[nShm],0,0600);
                if((int)p==-1)
                {
                    Error("Fail to attach shared memory(%s)",strerror(errno));
                    shmctl(ShmId[nShm],IPC_RMID,0);
                    p=0;
                }
                else
                {
                    ShmBuf[nShm]=p;
                    ShmOff[nShm]=nblk*blksize;
                    nShm++;
                }
            }
        }
    }
    return p;
}        

static struct sembuf semopbuf;
static int SemId=-1;

void SemOp(int semnum,int semval) //Should optimze for speed.
{
    //if(i>=0 && i< SemNum) Error("Invalid semaphore id %d",i);
    semopbuf.sem_num=semnum;
    semopbuf.sem_op=semval;
    //printf("<[%d]semaphore op#(%d):%d--",ID,i,n);fflush(stdout);
    if(semop(SemId,&semopbuf,1)==-1)
        Error("SemaOp failed on SEM#%d[%d](%s)",semnum,semval,strerror(errno));
    //printf("--[%d]ok>\n",ID);fflush(stdout);
}

void SemInit(int n, int nMutex)
{
    int i;

    if(n==-1)
    {
        if(SemId==-1) Error("Destroy before initialize!");
        if(semctl(SemId,0,IPC_RMID,0)==-1)
            Error("Fail to remove semaphore(%s)",strerror(errno));
    }
    else
    {
        if(nMutex > n) Error("Invalid parameters!");
        if(SemId!=-1) Error("Multiply initializations of semaphore!");
        SemId=semget(MAGIC_KEY, n, IPC_CREAT|IPC_EXCL|0600);
        if(SemId==-1) Error("Fail to get %d semaphores(%s)",n,strerror(errno));
        for(i=0;i<nMutex;i++)
            SemOp(i,1);
    }
}