From c5f4cd8345aef8ba018ec9de42d9ec412a51f361 Mon Sep 17 00:00:00 2001 From: "Glenn Y. Rolland" Date: Wed, 4 Mar 2020 00:06:43 +0100 Subject: [PATCH] Apply indent with -linux style --- src/allocate.c | 346 +++++++++++++++++++------------------ src/buffer.c | 18 +- src/bufferAttachProc.c | 55 +++--- src/bufferDetachProc.c | 57 +++---- src/bufferGetFreeIndex.c | 68 ++++---- src/bufferGetProcAttach.c | 92 +++++----- src/bufferInfoTabCreate.c | 60 +++---- src/bufferInfoTabInit.c | 56 +++--- src/bufferMap.c | 89 +++++----- src/free.c | 103 ++++++----- src/get.c | 117 ++++++------- src/global.h | 8 +- src/global.h~ | 48 ++++++ src/ids.c | 204 +++++++++++----------- src/ids.h | 18 +- src/ids.h~ | 22 +++ src/iface.h | 94 +++++----- src/iface.h~ | 91 ++++++++++ src/libnazgul.h~ | 8 + src/poolCreate.c | 69 ++++---- src/poolDataTabClose.c | 19 ++- src/poolDataTabCreate.c | 67 ++++---- src/poolDataTabLock.c | 51 +++--- src/poolDataTabOpen.c | 43 +++-- src/poolDataTabUnlock.c | 53 +++--- src/poolDelete.c | 55 +++--- src/proto.h | 76 +++++---- src/proto.h~ | 118 +++++++++++++ src/put.c | 116 ++++++------- src/queueAdd.c | 67 ++++---- src/queueClose.c | 23 +-- src/queueDelete.c | 55 +++--- src/queueElemClose.c | 23 +-- src/queueElemCreate.c | 45 +++-- src/queueElemDelete.c | 52 +++--- src/queueElemOpen.c | 43 +++-- src/queueInit.c | 68 ++++---- src/queueOpen.c | 42 +++-- src/queueProtLock.c | 52 +++--- src/queueProtUnlock.c | 50 +++--- src/queueReadLock.c | 50 +++--- src/queueReadTryLock.c | 50 +++--- src/queueReadUnlock.c | 51 +++--- src/queueRem.c | 57 +++---- src/spaceClose.c | 21 +-- src/spaceCreate.c | 350 +++++++++++++++++++------------------- src/spaceDelete.c | 116 ++++++------- src/spaceListAdd.c | 75 ++++---- src/spaceListClose.c | 23 +-- src/spaceListElemClose.c | 18 +- src/spaceListElemCreate.c | 68 ++++---- src/spaceListElemLink.c | 5 +- src/spaceListElemOpen.c | 43 +++-- src/spaceListFindId.c | 146 ++++++++-------- src/spaceListInit.c | 121 +++++++------ src/spaceListLocking.c | 102 ++++++----- src/spaceListOpen.c | 46 +++-- src/spaceListRem.c | 212 ++++++++++++----------- src/spaceOpen.c | 39 ++--- src/spaceState.c | 1 - test/test_create_delete.c | 107 ++++++------ test/test_msgSpaceState.c | 177 ++++++++++--------- test/test_put_get_mono.c | 76 +++++---- test/test_put_get_multi.c | 89 +++++----- 64 files changed, 2552 insertions(+), 2232 deletions(-) create mode 100644 src/global.h~ create mode 100644 src/ids.h~ create mode 100644 src/iface.h~ create mode 100644 src/libnazgul.h~ create mode 100644 src/proto.h~ diff --git a/src/allocate.c b/src/allocate.c index 0f38c6c..9c9d4c2 100644 --- a/src/allocate.c +++ b/src/allocate.c @@ -9,38 +9,33 @@ /* TODO: prevoir le cas des négatifs dans la taille ... */ -void * msgAllocate(msgSpace *space, - int pool, - int taille, - int option - ){ - void * resultAddr=NULL; - int bufferFreeSize; - int i; - msgPoolId resultPoolId; - /* tableau des valeurs des semPoolCoef/pool pour identifier le pool - * qui sera libéré le plus rapidement */ - float semPoolCoef[space->poolNb]; - int idxPoolOptimum; - bool gotRessourceSem; - msgPoolDataTabSemId ressourceSemId; - sem_t * ressourceSemFd; - int ressourceSemVal; +void *msgAllocate(msgSpace * space, int pool, int taille, int option) +{ + void *resultAddr = NULL; + int bufferFreeSize; + int i; + msgPoolId resultPoolId; + /* tableau des valeurs des semPoolCoef/pool pour identifier le pool + * qui sera libéré le plus rapidement */ + float semPoolCoef[space->poolNb]; + int idxPoolOptimum; + bool gotRessourceSem; + msgPoolDataTabSemId ressourceSemId; + sem_t *ressourceSemFd; + int ressourceSemVal; int nbLockedSem; - float minPoolCoef; - int selectedPoolIndex; - int bufferFreeIndex; - msgPoolData * mSPoolDataTabAddr; - + float minPoolCoef; + int selectedPoolIndex; + int bufferFreeIndex; + msgPoolData *mSPoolDataTabAddr; - selectedPoolIndex=-1; + selectedPoolIndex = -1; - -mSPoolDataTabAddr=msgPoolDataTabOpen(space); -if (mSPoolDataTabAddr==NULL){ - NZG_ERROR("msgPoolDataTabOpen",space->poolDataTabId); - goto ERROR; -} + mSPoolDataTabAddr = msgPoolDataTabOpen(space); + if (mSPoolDataTabAddr == NULL) { + NZG_ERROR("msgPoolDataTabOpen", space->poolDataTabId); + goto ERROR; + } /* // verifier le premier arg du shm_open mSPoolDataTabFd=shm_open(space->poolDataTabId, @@ -64,152 +59,167 @@ if (mSPoolDataTabAddr==NULL){ return NULL; } */ - gotRessourceSem=false; + gotRessourceSem = false; - /* initialisation des coefs */ - for (i=0;i<(space->poolNb);i++){ - semPoolCoef[i]=-1; - } - - nbLockedSem=0; - if ( pool == ANYPOOL){ - fprintf(stderr,"[ ALLOCATION ANYPOOL : %d ]\n",(int)getpid()); - // choisir le pool au hasard (ou presque) - for(i=0; i<(space->poolNb); i++) { - printf("- boucle %d\n",i); fflush(stdout); - if(mSPoolDataTabAddr[i].bufferSize >= taille) { - printf("( buffSize > taille )\n"); fflush(stdout); - /* choisir le numero du semaphore - en fonction du nombre de lock poses / nombre de buffer */ - msgPoolSemIdIntern(ressourceSemId,space->id,i); - ressourceSemFd = sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0); - if (ressourceSemFd == SEM_FAILED){ - NZG_ERROR("sem_open",ressourceSemId); - return NULL; - } - /* on remplit le tableau avec les valeurs des semaphores */ - - if (sem_getvalue(ressourceSemFd, &ressourceSemVal) < 0){ - NZG_ERROR("sem_getvalue",ressourceSemId); - return NULL; - } - printf("RESSOURCESEMVAL %d\n",ressourceSemVal); - if (ressourceSemVal <= 0){ - printf("resVal < 0 : %d\n",ressourceSemVal); - /* il y a ressourceSemVal processus qui attendent déja... */ - semPoolCoef[nbLockedSem] = - (float) ((1-ressourceSemVal) / mSPoolDataTabAddr[i].bufferNb); - nbLockedSem++; - } - if(sem_trywait(ressourceSemFd)==0) { - printf("got try_wait\n"); - /* choisir la 1ere pool de taille plus grande - * libre si possible */ - gotRessourceSem=true; - selectedPoolIndex=i; - break; - } - if( sem_close(ressourceSemFd) <0){ - NZG_ERROR("sem_getvalue",ressourceSemId); - return NULL; - } - } // if buffSize > taille - } // for - - printf("ERRORDETECT outFor\n"); fflush(stdout); - - if (!gotRessourceSem) { - printf("Calcul du meilleur en cas de liberation\n"); - minPoolCoef= semPoolCoef[0]; - idxPoolOptimum = 0; - /* on cherche le pool avec le moins de lock poses / nbre de buffer - * le numéro du pool est stocké dans idxPoolOptimum */ - for(i=0; iexternId,selectedPoolIndex); - ressourceSemFd=sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0); - if(ressourceSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",ressourceSemId); - return NULL; + /* initialisation des coefs */ + for (i = 0; i < (space->poolNb); i++) { + semPoolCoef[i] = -1; } - //TODO:virer la ligne suivante: - sem_getvalue(ressourceSemFd, &ressourceSemVal); - - printf("SemWait... %s : %d\n",ressourceSemId,ressourceSemVal); - if (sem_wait(ressourceSemFd) < 0){ - NZG_ERROR("sem_wait",ressourceSemId); - sem_close(ressourceSemFd); - return NULL; - } - printf("Passed %s\n",ressourceSemId); - } + nbLockedSem = 0; + if (pool == ANYPOOL) { + fprintf(stderr, "[ ALLOCATION ANYPOOL : %d ]\n", (int)getpid()); + // choisir le pool au hasard (ou presque) + for (i = 0; i < (space->poolNb); i++) { + printf("- boucle %d\n", i); + fflush(stdout); + if (mSPoolDataTabAddr[i].bufferSize >= taille) { + printf("( buffSize > taille )\n"); + fflush(stdout); + /* choisir le numero du semaphore + en fonction du nombre de lock poses / nombre de buffer */ + msgPoolSemIdIntern(ressourceSemId, space->id, + i); + ressourceSemFd = + sem_open(ressourceSemId, O_CREAT, + SEM_DEFAULT_MODE, 0); + if (ressourceSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", ressourceSemId); + return NULL; + } + /* on remplit le tableau avec les valeurs des semaphores */ - - /* on a acqui un semaphore pour la ressouce */ - /* on acquiert le droit de modifier les infos sur la ressource */ - /* on protege le tableau des associations */ - msgPoolDataTabLock(space); - - /* on modifie maintenant les données */ - /* - on récupere l'index du premier buffer libre */ - bufferFreeIndex = msgBufferGetFreeIndex(mSPoolDataTabAddr,selectedPoolIndex); - if (bufferFreeIndex < 0){ - // aucun buffer libre ? - NZG_ERROR("msgBufferGetFreeIndex",""); - goto ERROR; - } - printf("Buffer selected : %d,%d\n",selectedPoolIndex,bufferFreeIndex); - /* mapper le buffer libre dans l'esp addr du proc */ - strcpy(resultPoolId,mSPoolDataTabAddr[selectedPoolIndex].poolId); + if (sem_getvalue + (ressourceSemFd, &ressourceSemVal) < 0) { + NZG_ERROR("sem_getvalue", + ressourceSemId); + return NULL; + } + printf("RESSOURCESEMVAL %d\n", ressourceSemVal); + if (ressourceSemVal <= 0) { + printf("resVal < 0 : %d\n", + ressourceSemVal); + /* il y a ressourceSemVal processus qui attendent déja... */ + semPoolCoef[nbLockedSem] = + (float)((1 - + ressourceSemVal) / + mSPoolDataTabAddr[i]. + bufferNb); + nbLockedSem++; + } + if (sem_trywait(ressourceSemFd) == 0) { + printf("got try_wait\n"); + /* choisir la 1ere pool de taille plus grande + * libre si possible */ + gotRessourceSem = true; + selectedPoolIndex = i; + break; + } + if (sem_close(ressourceSemFd) < 0) { + NZG_ERROR("sem_getvalue", + ressourceSemId); + return NULL; + } + } // if buffSize > taille + } // for - bufferFreeSize=mSPoolDataTabAddr[selectedPoolIndex].bufferSize; - printf("BufferSize : %d\n", bufferFreeSize); - - resultAddr=msgBufferMap(mSPoolDataTabAddr,selectedPoolIndex,bufferFreeIndex); - if (resultAddr==NULL){ - NZG_ERROR("msgBufferMap",mSPoolDataTabAddr[selectedPoolIndex].poolId); - goto ERROR; - } + printf("ERRORDETECT outFor\n"); + fflush(stdout); - /* - on s'enregistre aupres de ce buffer */ - msgBufferAttachProc(mSPoolDataTabAddr, - selectedPoolIndex, - bufferFreeIndex, - resultAddr); + if (!gotRessourceSem) { + printf("Calcul du meilleur en cas de liberation\n"); + minPoolCoef = semPoolCoef[0]; + idxPoolOptimum = 0; + /* on cherche le pool avec le moins de lock poses / nbre de buffer + * le numéro du pool est stocké dans idxPoolOptimum */ + for (i = 0; i < nbLockedSem; i++) { + printf("Coef %d : %d\n", i, + (int)semPoolCoef[i]); + if ((semPoolCoef[i] != -1) + && (semPoolCoef[i] < minPoolCoef)) { + minPoolCoef = semPoolCoef[i]; + idxPoolOptimum = i; + } + } - // munmap(mSPoolDataTabAddr,(space->poolNb) * sizeof( msgPoolData )); - /* unmapper le msgPoolDataTab */ - msgPoolDataTabClose(space,mSPoolDataTabAddr); - msgPoolDataTabUnlock(space); + if (minPoolCoef == -1) { + /* il n'y a aucune pool dont la taille satisfait la demande */ + return NULL; + } else { + selectedPoolIndex = idxPoolOptimum; + } + printf("Optimum : %d\n", selectedPoolIndex); + } + } else { + fprintf(stderr, "[ ALLOCATION : %d ]\n", (int)getpid()); + selectedPoolIndex = pool; + } - printf( "alloc de %p\n", (void *)resultAddr); - return resultAddr; + if (!gotRessourceSem) { + msgPoolSemIdIntern(ressourceSemId, space->externId, + selectedPoolIndex); + ressourceSemFd = + sem_open(ressourceSemId, O_CREAT, SEM_DEFAULT_MODE, 0); + if (ressourceSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", ressourceSemId); + return NULL; + } + //TODO:virer la ligne suivante: + sem_getvalue(ressourceSemFd, &ressourceSemVal); -ERROR: - NZG_ERROR("msgAllocate","error processing"); - msgPoolDataTabUnlock(space); - munmap(mSPoolDataTabAddr,(space->poolNb) * sizeof( msgPoolData )); - return NULL; + printf("SemWait... %s : %d\n", ressourceSemId, ressourceSemVal); + if (sem_wait(ressourceSemFd) < 0) { + NZG_ERROR("sem_wait", ressourceSemId); + sem_close(ressourceSemFd); + return NULL; + } + printf("Passed %s\n", ressourceSemId); + } + + /* on a acqui un semaphore pour la ressouce */ + /* on acquiert le droit de modifier les infos sur la ressource */ + /* on protege le tableau des associations */ + msgPoolDataTabLock(space); + + /* on modifie maintenant les données */ + /* - on récupere l'index du premier buffer libre */ + bufferFreeIndex = + msgBufferGetFreeIndex(mSPoolDataTabAddr, selectedPoolIndex); + if (bufferFreeIndex < 0) { + // aucun buffer libre ? + NZG_ERROR("msgBufferGetFreeIndex", ""); + goto ERROR; + } + printf("Buffer selected : %d,%d\n", selectedPoolIndex, bufferFreeIndex); + /* mapper le buffer libre dans l'esp addr du proc */ + strcpy(resultPoolId, mSPoolDataTabAddr[selectedPoolIndex].poolId); + + bufferFreeSize = mSPoolDataTabAddr[selectedPoolIndex].bufferSize; + printf("BufferSize : %d\n", bufferFreeSize); + + resultAddr = + msgBufferMap(mSPoolDataTabAddr, selectedPoolIndex, bufferFreeIndex); + if (resultAddr == NULL) { + NZG_ERROR("msgBufferMap", + mSPoolDataTabAddr[selectedPoolIndex].poolId); + goto ERROR; + } + + /* - on s'enregistre aupres de ce buffer */ + msgBufferAttachProc(mSPoolDataTabAddr, + selectedPoolIndex, bufferFreeIndex, resultAddr); + + // munmap(mSPoolDataTabAddr,(space->poolNb) * sizeof( msgPoolData )); + /* unmapper le msgPoolDataTab */ + msgPoolDataTabClose(space, mSPoolDataTabAddr); + msgPoolDataTabUnlock(space); + + printf("alloc de %p\n", (void *)resultAddr); + return resultAddr; + + ERROR: + NZG_ERROR("msgAllocate", "error processing"); + msgPoolDataTabUnlock(space); + munmap(mSPoolDataTabAddr, (space->poolNb) * sizeof(msgPoolData)); + return NULL; } diff --git a/src/buffer.c b/src/buffer.c index 623b689..cc3d116 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -1,15 +1,11 @@ #include "libnazgul.h" -int msgBufferGetAttachedProcIndex( - msgPoolData * poolDataTabAddr, - int poolIndex, - void * addr - ){ +int msgBufferGetAttachedProcIndex(msgPoolData * poolDataTabAddr, + int poolIndex, void *addr) +{ - //TODO: parcourrir tous les index, et regarder s'il y - //a une addresse qui correspond avec le meme processus... - //et renvoyer l'index du buffer correspondant a l'addresse... -return 0; + //TODO: parcourrir tous les index, et regarder s'il y + //a une addresse qui correspond avec le meme processus... + //et renvoyer l'index du buffer correspondant a l'addresse... + return 0; } - - diff --git a/src/bufferAttachProc.c b/src/bufferAttachProc.c index 9f1b976..8eb4f25 100644 --- a/src/bufferAttachProc.c +++ b/src/bufferAttachProc.c @@ -1,41 +1,36 @@ #include "libnazgul.h" -int msgBufferAttachProc( - msgPoolData * poolDataTabAddr, - int poolIndex, - int bufferIndex, - void * addr) +int msgBufferAttachProc(msgPoolData * poolDataTabAddr, + int poolIndex, int bufferIndex, void *addr) { - msgBufferInfoTabId bufferInfoTabId; - int bufferInfoTabFd; - msgBufferInfo * bufferInfoTabAddr; - int bufferInfoNb; + msgBufferInfoTabId bufferInfoTabId; + int bufferInfoTabFd; + msgBufferInfo *bufferInfoTabAddr; + int bufferInfoNb; - //récuperer l'ID du BufferInfoTab; - strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId); + //récuperer l'ID du BufferInfoTab; + strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId); - - bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE); - if (bufferInfoTabFd<0){ - NZG_ERROR("sem_open",bufferInfoTabId); - return -1; - } + bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE); + if (bufferInfoTabFd < 0) { + NZG_ERROR("sem_open", bufferInfoTabId); + return -1; + } /** on regarde dans le tableau d'infos de buffer **/ - bufferInfoNb=poolDataTabAddr[poolIndex].bufferNb; - bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo), - PROT_READ|PROT_WRITE,MAP_SHARED,bufferInfoTabFd,(off_t)0); - printf("atta gooo %s\n",bufferInfoTabId); + bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb; + bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo), + PROT_READ | PROT_WRITE, MAP_SHARED, + bufferInfoTabFd, (off_t) 0); + printf("atta gooo %s\n", bufferInfoTabId); - bufferInfoTabAddr[bufferIndex].ownerPid = getpid(); - bufferInfoTabAddr[bufferIndex].addr = addr; + bufferInfoTabAddr[bufferIndex].ownerPid = getpid(); + bufferInfoTabAddr[bufferIndex].addr = addr; - if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0) - { - NZG_ERROR("munmap",bufferInfoTabId); - return -1; } + if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) { + NZG_ERROR("munmap", bufferInfoTabId); + return -1; + } - return 0; + return 0; } - - diff --git a/src/bufferDetachProc.c b/src/bufferDetachProc.c index 457fcab..d389894 100644 --- a/src/bufferDetachProc.c +++ b/src/bufferDetachProc.c @@ -1,42 +1,37 @@ #include "libnazgul.h" -int msgBufferDetachProc( - msgPoolData * poolDataTabAddr, - int poolIndex, - int bufferIndex, - void * addr - ){ - msgBufferInfoTabId bufferInfoTabId; - int bufferInfoTabFd; - msgBufferInfo * bufferInfoTabAddr; - int bufferInfoNb; +int msgBufferDetachProc(msgPoolData * poolDataTabAddr, + int poolIndex, int bufferIndex, void *addr) +{ + msgBufferInfoTabId bufferInfoTabId; + int bufferInfoTabFd; + msgBufferInfo *bufferInfoTabAddr; + int bufferInfoNb; - printf("Detaching %d,%d\n",poolIndex,bufferIndex); - //récuperer l'ID du BufferInfoTab; + printf("Detaching %d,%d\n", poolIndex, bufferIndex); + //récuperer l'ID du BufferInfoTab; + strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId); - strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId); - - bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE); - if (bufferInfoTabFd<0){ - NZG_ERROR("shm_open",bufferInfoTabId); - return -1; - } + bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE); + if (bufferInfoTabFd < 0) { + NZG_ERROR("shm_open", bufferInfoTabId); + return -1; + } /** on regarde dans le tableau d'infos de buffer **/ - bufferInfoNb=poolDataTabAddr[poolIndex].bufferNb; - bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo), - PROT_READ|PROT_WRITE,MAP_SHARED,bufferInfoTabFd,(off_t)0); + bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb; + bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo), + PROT_READ | PROT_WRITE, MAP_SHARED, + bufferInfoTabFd, (off_t) 0); - bufferInfoTabAddr[bufferIndex].ownerPid = (pid_t)-1; - bufferInfoTabAddr[bufferIndex].addr = NULL; + bufferInfoTabAddr[bufferIndex].ownerPid = (pid_t) - 1; + bufferInfoTabAddr[bufferIndex].addr = NULL; - if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0) - { - NZG_ERROR("munmap",bufferInfoTabId); - return -1; - } + if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) { + NZG_ERROR("munmap", bufferInfoTabId); + return -1; + } - return 0; + return 0; } - diff --git a/src/bufferGetFreeIndex.c b/src/bufferGetFreeIndex.c index 89d7762..9d2db4d 100644 --- a/src/bufferGetFreeIndex.c +++ b/src/bufferGetFreeIndex.c @@ -1,39 +1,43 @@ #include "libnazgul.h" -int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr,int poolIndex){ - msgBufferInfoTabId bufferInfoTabId; -int bufferInfoTabFd; -msgBufferInfo * bufferInfoTabAddr; -int bufferInfoNb; -int bufferFreeIndex; -int i; +int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr, int poolIndex) +{ + msgBufferInfoTabId bufferInfoTabId; + int bufferInfoTabFd; + msgBufferInfo *bufferInfoTabAddr; + int bufferInfoNb; + int bufferFreeIndex; + int i; - //récuperer l'ID du BufferInfoTab; - strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId); - - bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE); - if (bufferInfoTabFd<0){ - NZG_ERROR("shm_open",bufferInfoTabId); - return -1; - } + //récuperer l'ID du BufferInfoTab; + strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId); + + bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE); + if (bufferInfoTabFd < 0) { + NZG_ERROR("shm_open", bufferInfoTabId); + return -1; + } /** on regarde dans le tableau d'infos de buffer **/ - bufferInfoNb=poolDataTabAddr[poolIndex].bufferNb; - bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo), - PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0); + bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb; + bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo), + PROT_READ, MAP_SHARED, bufferInfoTabFd, + (off_t) 0); - i=0; - while ((i>%s<<\n",poolIndex,bufferInfoTabId); - bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR,SHM_DEFAULT_MODE); - if (bufferInfoTabFd<0){ - NZG_ERROR("msgBufferInfoTabId open",bufferInfoTabId); - return -1; - } + //récuperer l'ID du BufferInfoTab; + strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId); + + printf("msgBufferInfoTabId %d open >>%s<<\n", poolIndex, + bufferInfoTabId); + bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE); + if (bufferInfoTabFd < 0) { + NZG_ERROR("msgBufferInfoTabId open", bufferInfoTabId); + return -1; + } /** on regarde dans le tableau d'infos de buffer **/ - bufferInfoNb=poolDataTabAddr[poolIndex].bufferNb; - bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo), - PROT_WRITE|PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0); + bufferInfoNb = poolDataTabAddr[poolIndex].bufferNb; + bufferInfoTabAddr = mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo), + PROT_WRITE | PROT_READ, MAP_SHARED, + bufferInfoTabFd, (off_t) 0); - for (i=0;ipoolDataTabSemId); - goto ERROR; - }; + int poolIndex; + int bufferIndex; + msgPoolData *poolDataTabAddr; + sem_t *ressourceSemFd; + msgPoolDataTabSemId ressourceSemId; + int err; + int bufferNb; + int bufferSize; + void *realAddr; + printf("[ FREE %p ]\n", (void *)addr); + /* on acquiert le droit de modifier les infos sur la ressource */ + /* on protege le tableau des associations */ + if (msgPoolDataTabLock(space) < 0) { + NZG_ERROR("msgPoolDataTabLock", space->poolDataTabSemId); + goto ERROR; + }; - /* verifier le premier arg du shm_open */ + /* verifier le premier arg du shm_open */ - poolDataTabAddr = msgPoolDataTabOpen(space); + poolDataTabAddr = msgPoolDataTabOpen(space); - // TODO: verouiller semaphore DataInfo ?? + // TODO: verouiller semaphore DataInfo ?? - poolIndex=-1; bufferIndex=-1; - err=msgBufferGetProcAttach( - poolDataTabAddr, - space->poolNb, - &poolIndex, - &bufferIndex, - addr - ); + poolIndex = -1; + bufferIndex = -1; + err = msgBufferGetProcAttach(poolDataTabAddr, + space->poolNb, + &poolIndex, &bufferIndex, addr); - printf("Found : %d\n",err); - printf("Freing pool: %d, buffer: %d\n",poolIndex,bufferIndex); - msgBufferDetachProc(poolDataTabAddr,poolIndex,bufferIndex,addr); + printf("Found : %d\n", err); + printf("Freing pool: %d, buffer: %d\n", poolIndex, bufferIndex); + msgBufferDetachProc(poolDataTabAddr, poolIndex, bufferIndex, addr); - /* unmapper le buffer */ - realAddr=addr; - bufferSize=poolDataTabAddr[poolIndex].bufferSize; - bufferNb=poolDataTabAddr[poolIndex].bufferNb; - realAddr=realAddr-poolIndex*bufferSize; - munmap(realAddr,bufferSize*bufferNb); + /* unmapper le buffer */ + realAddr = addr; + bufferSize = poolDataTabAddr[poolIndex].bufferSize; + bufferNb = poolDataTabAddr[poolIndex].bufferNb; + realAddr = realAddr - poolIndex * bufferSize; + munmap(realAddr, bufferSize * bufferNb); - msgPoolDataTabClose(space,poolDataTabAddr); + msgPoolDataTabClose(space, poolDataTabAddr); - // deverouiller semaphore DataInfo - msgPoolDataTabUnlock(space); + // deverouiller semaphore DataInfo + msgPoolDataTabUnlock(space); - // deverouiller semaphore ressource. - msgPoolSemIdIntern(ressourceSemId,space->externId,poolIndex); - ressourceSemFd = sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0); - if (ressourceSemFd == SEM_FAILED){ - NZG_ERROR("sem_open",ressourceSemId); - goto ERROR; - } - sem_post(ressourceSemFd); - sem_close(ressourceSemFd); - return 0; -ERROR: - return -1; + // deverouiller semaphore ressource. + msgPoolSemIdIntern(ressourceSemId, space->externId, poolIndex); + ressourceSemFd = sem_open(ressourceSemId, O_CREAT, SEM_DEFAULT_MODE, 0); + if (ressourceSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", ressourceSemId); + goto ERROR; + } + sem_post(ressourceSemFd); + sem_close(ressourceSemFd); + return 0; + ERROR: + return -1; } - diff --git a/src/get.c b/src/get.c index 0fd0306..5ab1e29 100644 --- a/src/get.c +++ b/src/get.c @@ -2,70 +2,71 @@ #define NONBLOCK -1 -void * msgGet(msgSpace * space,int queueIndex,int option){ - void * resultAddr; - msgQueueId queueId; - msgQueue * queue; - msgQueueElemId oldElemId; - msgQueueElem * oldElem; - msgPoolData * poolDataTab; - // on teste la possibilité de lecture sur la liste... - if (option == NONBLOCK){ - if (msgQueueReadTryLock(space->externId,queueIndex) <0){ - NZG_ERROR("msgQueueReadTryLock",space->externId); - goto ERROR; +void *msgGet(msgSpace * space, int queueIndex, int option) +{ + void *resultAddr; + msgQueueId queueId; + msgQueue *queue; + msgQueueElemId oldElemId; + msgQueueElem *oldElem; + msgPoolData *poolDataTab; + // on teste la possibilité de lecture sur la liste... + if (option == NONBLOCK) { + if (msgQueueReadTryLock(space->externId, queueIndex) < 0) { + NZG_ERROR("msgQueueReadTryLock", space->externId); + goto ERROR; + } + } else { + if (msgQueueReadLock(space->externId, queueIndex) < 0) { + NZG_ERROR("msgQueueReadLock", space->externId); + goto ERROR; + } } - } else { - if (msgQueueReadLock(space->externId,queueIndex) <0){ - NZG_ERROR("msgQueueReadLock",space->externId); - goto ERROR; + // la lecture est possible + // on essaye donc de modifier la liste + msgQueueProtLock(space->externId, queueIndex); + msgQueueIdIntern(queueId, space->externId, queueIndex); + // ouvrir la file + queue = msgQueueOpen(queueId); + if (queue == NULL) { + NZG_ERROR("msgQueueOpen", queueId); + goto ERROR; } - } - // la lecture est possible - // on essaye donc de modifier la liste - msgQueueProtLock(space->externId,queueIndex); - msgQueueIdIntern(queueId,space->externId,queueIndex); - // ouvrir la file - queue = msgQueueOpen(queueId); - if (queue==NULL){ - NZG_ERROR("msgQueueOpen",queueId); - goto ERROR; - } - // recupérer l'id de l'ancien element... - msgQueueRem(queue, oldElemId); + // recupérer l'id de l'ancien element... + msgQueueRem(queue, oldElemId); - oldElem = msgQueueElemOpen(oldElemId); - if (oldElem == NULL){ - NZG_ERROR("msgQueueElemOpen",oldElemId); - goto ERROR; - } - /* on récupere la taille des buffer dans la pool du buffer */ - poolDataTab=msgPoolDataTabOpen(space); - // mapper le buffer dans l'espace mémoire du processus - resultAddr=msgBufferMap(poolDataTab,oldElem->poolIndex,oldElem->bufferIndex); - // attacher au buffer... - if (msgBufferAttachProc(poolDataTab, - oldElem->poolIndex, - oldElem->bufferIndex, - resultAddr) <0){ - NZG_ERROR("msgBufferAttachProc",oldElemId); - goto ERROR; - } + oldElem = msgQueueElemOpen(oldElemId); + if (oldElem == NULL) { + NZG_ERROR("msgQueueElemOpen", oldElemId); + goto ERROR; + } + /* on récupere la taille des buffer dans la pool du buffer */ + poolDataTab = msgPoolDataTabOpen(space); + // mapper le buffer dans l'espace mémoire du processus + resultAddr = + msgBufferMap(poolDataTab, oldElem->poolIndex, oldElem->bufferIndex); + // attacher au buffer... + if (msgBufferAttachProc(poolDataTab, + oldElem->poolIndex, + oldElem->bufferIndex, resultAddr) < 0) { + NZG_ERROR("msgBufferAttachProc", oldElemId); + goto ERROR; + } - msgPoolDataTabClose(space,poolDataTab); - if (msgQueueElemClose(oldElem) <0){ - NZG_ERROR("msgQueueElemClose",oldElemId); - } + msgPoolDataTabClose(space, poolDataTab); + if (msgQueueElemClose(oldElem) < 0) { + NZG_ERROR("msgQueueElemClose", oldElemId); + } - shm_unlink(oldElemId); + shm_unlink(oldElemId); - // fermer la file - msgQueueClose(queue); + // fermer la file + msgQueueClose(queue); - // on a fini de modifier la liste - msgQueueProtUnlock(space->externId,queueIndex); + // on a fini de modifier la liste + msgQueueProtUnlock(space->externId, queueIndex); - return resultAddr; -ERROR: - return NULL; + return resultAddr; + ERROR: + return NULL; } diff --git a/src/global.h b/src/global.h index 7843fa7..fe16876 100644 --- a/src/global.h +++ b/src/global.h @@ -1,13 +1,13 @@ #ifndef _NZG_GLOBAL #define _NZG_GLOBAL 1 -#include /* POSIX et al */ +#include /* POSIX et al */ #include #include #include -#include /* pour O_RDWR */ +#include /* pour O_RDWR */ #include -#include /* shm_open */ +#include /* shm_open */ #include #include @@ -25,12 +25,10 @@ #define SEM_FAILED ((sem_t *)0) #endif - #ifndef MAP_FAILED #define MAP_FAILED ((void *)-1) #endif - #ifdef _NZG_REALFILEID #define DEFAULT_MSGSPACELISTID "/tmp/nzgSpaceList" #else diff --git a/src/global.h~ b/src/global.h~ new file mode 100644 index 0000000..7843fa7 --- /dev/null +++ b/src/global.h~ @@ -0,0 +1,48 @@ +#ifndef _NZG_GLOBAL +#define _NZG_GLOBAL 1 + +#include /* POSIX et al */ +#include +#include +#include +#include /* pour O_RDWR */ +#include +#include /* shm_open */ +#include +#include + +#define PAGESIZE sysconf(_SC_PAGESIZE) +#define MSGSPACE_DEFAULT_MODE 0600 +#define SEM_DEFAULT_MODE 0600 +#define SHM_DEFAULT_MODE 0600 +#define MSGSPACE_ID_LEN 32 +#define ERR_UNHANDLED "Gérer mieu les erreurs" + +#define ANYPOOL -1 +#define SPECIFICPOOL 0 + +#ifndef SEM_FAILED +#define SEM_FAILED ((sem_t *)0) +#endif + + +#ifndef MAP_FAILED +#define MAP_FAILED ((void *)-1) +#endif + + +#ifdef _NZG_REALFILEID +#define DEFAULT_MSGSPACELISTID "/tmp/nzgSpaceList" +#else +#define DEFAULT_MSGSPACELISTID "/nzgSpaceList" +#endif + +#ifdef _NZG_REALFILEID +#define DEFAULT_MSGSPACELISTSEMID "/tmp/nzgSpaceListSem" +#else +#define DEFAULT_MSGSPACELISTSEMID "/nzgSpaceListSem" +#endif + +#define NZG_ERROR(func,str) fprintf(stderr,"*** %s: %s***\n%s in %s:%d\n",func,strerror(errno),str,__FILE__,__LINE__); + +#endif diff --git a/src/ids.c b/src/ids.c index 5a33d4a..9e5623b 100644 --- a/src/ids.c +++ b/src/ids.c @@ -1,158 +1,150 @@ #include "libnazgul.h" #include "ids.h" -int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src ){ - if (strlen(src)>MSGSPACE_ID_LEN){ - return -1; - } - /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ +int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src) +{ + if (strlen(src) > MSGSPACE_ID_LEN) { + return -1; + } + /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ #ifdef _NZG_REALFILEID - sprintf(dest,"/tmp/nzgSpace%s",(char *)src); + sprintf(dest, "/tmp/nzgSpace%s", (char *)src); #else - sprintf(dest,"/nzgSpace%s",(char *)src); + sprintf(dest, "/nzgSpace%s", (char *)src); #endif - return 0; + return 0; } -int msgPoolDataTabSemIdIntern( - msgPoolSemId destSemId, - const msgSpaceId externId){ - if (strlen(externId)>MSGSPACE_ID_LEN*4){ - return -1; - } - /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ + +int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, const msgSpaceId externId) +{ + if (strlen(externId) > MSGSPACE_ID_LEN * 4) { + return -1; + } + /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ #ifdef _NZG_REALFILEID - sprintf(destSemId,"/tmp/nzgPoolDTSem-%s",(char *)externId); + sprintf(destSemId, "/tmp/nzgPoolDTSem-%s", (char *)externId); #else - sprintf(destSemId,"/nzgPoolDTSem-%s",(char *)externId); + sprintf(destSemId, "/nzgPoolDTSem-%s", (char *)externId); #endif - return 0; + return 0; } -int msgPoolSemIdIntern( - msgPoolSemId destSemId, - const msgSpaceId srcPoolId, - int poolIdx){ - if (strlen(srcPoolId)>MSGSPACE_ID_LEN*4){ - return -1; - } - /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ + +int msgPoolSemIdIntern(msgPoolSemId destSemId, + const msgSpaceId srcPoolId, int poolIdx) +{ + if (strlen(srcPoolId) > MSGSPACE_ID_LEN * 4) { + return -1; + } + /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ #ifdef _NZG_REALFILEID - sprintf(destSemId,"/tmp/nzgPoolSem-%s-%d",(char *)srcPoolId,poolIdx); + sprintf(destSemId, "/tmp/nzgPoolSem-%s-%d", (char *)srcPoolId, poolIdx); #else - sprintf(destSemId,"/nzgPoolSem-%s-%d",(char *)srcPoolId,poolIdx); + sprintf(destSemId, "/nzgPoolSem-%s-%d", (char *)srcPoolId, poolIdx); #endif - return 0; + return 0; } -int msgPoolDataIdIntern(msgPoolDataTabId dest,const msgSpaceId src ){ - if (strlen(src)>MSGSPACE_ID_LEN){ - return -1; - } - /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ +int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src) +{ + if (strlen(src) > MSGSPACE_ID_LEN) { + return -1; + } + /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ #ifdef _NZG_REALFILEID - sprintf(dest,"/tmp/nzgPoolData-%s",(char *)src); + sprintf(dest, "/tmp/nzgPoolData-%s", (char *)src); #else - sprintf(dest,"/nzgPoolData-%s",(char *)src); + sprintf(dest, "/nzgPoolData-%s", (char *)src); #endif - return 0; + return 0; } - -int msgPoolIdIntern(msgPoolId dest,msgPoolId src, int num){ - if (strlen(src)>MSGSPACE_ID_LEN){ - return -1; - } +int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num) +{ + if (strlen(src) > MSGSPACE_ID_LEN) { + return -1; + } #ifdef _NZG_REALFILEID - sprintf(dest,"/tmp/nzgPool-%s-%d",(char *)src,num); + sprintf(dest, "/tmp/nzgPool-%s-%d", (char *)src, num); #else - sprintf(dest,"/nzgPool-%s-%d",(char *)src,num); + sprintf(dest, "/nzgPool-%s-%d", (char *)src, num); #endif - return 0; + return 0; } -int msgBufferInfoTabIdIntern( - msgBufferInfoTabId dest, - msgSpaceId src, - int num){ - if (strlen(src)>MSGSPACE_ID_LEN){ - return -1; - } +int msgBufferInfoTabIdIntern(msgBufferInfoTabId dest, msgSpaceId src, int num) +{ + if (strlen(src) > MSGSPACE_ID_LEN) { + return -1; + } #ifdef _NZG_REALFILEID - sprintf(dest,"/tmp/nzgBufferInfo-%s-%d",(char *)src,num); + sprintf(dest, "/tmp/nzgBufferInfo-%s-%d", (char *)src, num); #else - sprintf(dest,"/nzgBufferInfo-%s-%d",(char *)src,num); + sprintf(dest, "/nzgBufferInfo-%s-%d", (char *)src, num); #endif - return 0; + return 0; } -int msgQueueProtSemIdIntern( - msgQueueSemId dest, - msgSpaceId externId, - int queueIdx){ - if (strlen(externId)>MSGSPACE_ID_LEN){ - return -1; - } +int msgQueueProtSemIdIntern(msgQueueSemId dest, + msgSpaceId externId, int queueIdx) +{ + if (strlen(externId) > MSGSPACE_ID_LEN) { + return -1; + } #ifdef _NZG_REALFILEID - sprintf(dest,"/tmp/nzgQueueProtSem-%s-%d",(char *)externId,queueIdx); + sprintf(dest, "/tmp/nzgQueueProtSem-%s-%d", (char *)externId, queueIdx); #else - sprintf(dest,"/nzgQueueProtSem-%s-%d",(char *)externId,queueIdx); + sprintf(dest, "/nzgQueueProtSem-%s-%d", (char *)externId, queueIdx); #endif - return 0; + return 0; } -int msgQueueReadSemIdIntern( - msgQueueSemId dest, - msgSpaceId externId, - int queueIdx){ - if (strlen(externId)>MSGSPACE_ID_LEN){ - return -1; - } +int msgQueueReadSemIdIntern(msgQueueSemId dest, + msgSpaceId externId, int queueIdx) +{ + if (strlen(externId) > MSGSPACE_ID_LEN) { + return -1; + } #ifdef _NZG_REALFILEID - sprintf(dest,"/tmp/nzgQueueReadSem-%s-%d",(char *)externId,queueIdx); + sprintf(dest, "/tmp/nzgQueueReadSem-%s-%d", (char *)externId, queueIdx); #else - sprintf(dest,"/nzgQueueReadSem-%s-%d",(char *)externId,queueIdx); + sprintf(dest, "/nzgQueueReadSem-%s-%d", (char *)externId, queueIdx); #endif - return 0; + return 0; } -int msgQueueIdIntern( - msgQueueId dest, - msgSpaceId externId, - int queueIdx){ - if (strlen(externId)>MSGSPACE_ID_LEN){ - return -1; - } +int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx) +{ + if (strlen(externId) > MSGSPACE_ID_LEN) { + return -1; + } #ifdef _NZG_REALFILEID - sprintf(dest,"/tmp/nzgQueue-%s-%d",(char *)externId,queueIdx); + sprintf(dest, "/tmp/nzgQueue-%s-%d", (char *)externId, queueIdx); #else - sprintf(dest,"/nzgQueue-%s-%d",(char *)externId,queueIdx); + sprintf(dest, "/nzgQueue-%s-%d", (char *)externId, queueIdx); #endif - return 0; + return 0; } -int msgQueueElemIdIntern( - msgQueueElemId dest, - msgQueueId src, - int counter){ - if (strlen(src)>MSGSPACE_ID_LEN){ - return -1; - } - sprintf(dest,"%s-%d",(char *)src,counter); - return 0; +int msgQueueElemIdIntern(msgQueueElemId dest, msgQueueId src, int counter) +{ + if (strlen(src) > MSGSPACE_ID_LEN) { + return -1; + } + sprintf(dest, "%s-%d", (char *)src, counter); + return 0; } -int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId,msgSpaceId externId){ - if (strlen(externId)>MSGSPACE_ID_LEN){ - return -1; - } - /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ +int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, msgSpaceId externId) +{ + if (strlen(externId) > MSGSPACE_ID_LEN) { + return -1; + } + /* sprintf(resNzgId,"/tmp/.nzg-%s",(char *)spaceId); */ #ifdef _NZG_REALFILEID - sprintf(elemListId,"/tmp/nzgSpaceListElem-%s",(char *)externId); + sprintf(elemListId, "/tmp/nzgSpaceListElem-%s", (char *)externId); #else - sprintf(elemListId,"/nzgSpaceListElem-%s",(char *)externId); + sprintf(elemListId, "/nzgSpaceListElem-%s", (char *)externId); #endif - return 0; - + return 0; + } - - - diff --git a/src/ids.h b/src/ids.h index 219eaa6..3f867fa 100644 --- a/src/ids.h +++ b/src/ids.h @@ -2,21 +2,13 @@ #define _NZG_IDS 1 #include "libnazgul.h" - - - /* nzg_ids.c */ int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src); -int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, int poolIdx); +int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, + int poolIdx); int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src); -int msgPoolIdIntern(msgPoolId dest,msgPoolId src, int num); -int msgQueueSemIdIntern( - msgQueueSemId dest, - msgSpaceId externId, - int queueIdx); -int msgQueueIdIntern( - msgQueueId dest, - msgSpaceId externId, - int queueIdx); +int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num); +int msgQueueSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx); +int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx); #endif diff --git a/src/ids.h~ b/src/ids.h~ new file mode 100644 index 0000000..219eaa6 --- /dev/null +++ b/src/ids.h~ @@ -0,0 +1,22 @@ +#ifndef _NZG_IDS +#define _NZG_IDS 1 +#include "libnazgul.h" + + + + +/* nzg_ids.c */ +int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src); +int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, int poolIdx); +int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src); +int msgPoolIdIntern(msgPoolId dest,msgPoolId src, int num); +int msgQueueSemIdIntern( + msgQueueSemId dest, + msgSpaceId externId, + int queueIdx); +int msgQueueIdIntern( + msgQueueId dest, + msgSpaceId externId, + int queueIdx); + +#endif diff --git a/src/iface.h b/src/iface.h index 4ba1bcf..1ea7b65 100644 --- a/src/iface.h +++ b/src/iface.h @@ -3,88 +3,86 @@ #include "global.h" -typedef enum { true=1, false=0} bool; +typedef enum { true = 1, false = 0 } bool; typedef char msgSpaceId[MSGSPACE_ID_LEN]; -typedef char msgSpaceListId[4*MSGSPACE_ID_LEN]; -typedef char msgSpaceListSemId[4*MSGSPACE_ID_LEN]; -typedef char msgSpaceListElemId[4*MSGSPACE_ID_LEN]; +typedef char msgSpaceListId[4 * MSGSPACE_ID_LEN]; +typedef char msgSpaceListSemId[4 * MSGSPACE_ID_LEN]; +typedef char msgSpaceListElemId[4 * MSGSPACE_ID_LEN]; -typedef char msgPoolDataTabId[4*MSGSPACE_ID_LEN]; -typedef char msgPoolDataTabSemId[4*MSGSPACE_ID_LEN]; +typedef char msgPoolDataTabId[4 * MSGSPACE_ID_LEN]; +typedef char msgPoolDataTabSemId[4 * MSGSPACE_ID_LEN]; -typedef char msgBufferInfoTabId[4*MSGSPACE_ID_LEN]; +typedef char msgBufferInfoTabId[4 * MSGSPACE_ID_LEN]; -typedef char msgPoolId[4*MSGSPACE_ID_LEN]; -typedef char msgPoolSemId[4*MSGSPACE_ID_LEN]; +typedef char msgPoolId[4 * MSGSPACE_ID_LEN]; +typedef char msgPoolSemId[4 * MSGSPACE_ID_LEN]; -typedef char msgQueueDataId[4*MSGSPACE_ID_LEN]; -typedef char msgQueueId[4*MSGSPACE_ID_LEN]; -typedef char msgQueueElemId[4*MSGSPACE_ID_LEN]; -typedef char msgQueueSemId[4*MSGSPACE_ID_LEN]; +typedef char msgQueueDataId[4 * MSGSPACE_ID_LEN]; +typedef char msgQueueId[4 * MSGSPACE_ID_LEN]; +typedef char msgQueueElemId[4 * MSGSPACE_ID_LEN]; +typedef char msgQueueSemId[4 * MSGSPACE_ID_LEN]; /* pid[] */ - /* liste des processus demandeurs */ + /* liste des processus demandeurs */ typedef struct MsgPool { - int bufferSize; - int bufferNb; + int bufferSize; + int bufferNb; } msgPool; typedef struct MsgBufferInfo { - pid_t ownerPid; - void * addr; + pid_t ownerPid; + void *addr; } msgBufferInfo; typedef struct MsgPoolData { - msgPoolId poolId; - msgBufferInfoTabId bufferInfoTabId; - int bufferNb; - int bufferSize; - int allocDispBuffer; + msgPoolId poolId; + msgBufferInfoTabId bufferInfoTabId; + int bufferNb; + int bufferSize; + int allocDispBuffer; } msgPoolData; /* TODO: queueId */ - typedef struct MsgSpace { - msgSpaceId id; - msgSpaceId externId; - int poolNb; - int queueNb; - int pid; - msgPoolDataTabId poolDataTabId; - msgPoolDataTabSemId poolDataTabSemId; + msgSpaceId id; + msgSpaceId externId; + int poolNb; + int queueNb; + int pid; + msgPoolDataTabId poolDataTabId; + msgPoolDataTabSemId poolDataTabSemId; } msgSpace; - typedef struct MsgSpaceListElem { - msgSpaceListElemId id; + msgSpaceListElemId id; - msgSpaceId spaceId; - msgSpaceListElemId next; + msgSpaceId spaceId; + msgSpaceListElemId next; } msgSpaceListElem; typedef struct MsgSpaceList { - msgSpaceListId id; - - int elemCounter; - msgSpaceListElemId headId; - msgSpaceListElemId tailId; + msgSpaceListId id; + + int elemCounter; + msgSpaceListElemId headId; + msgSpaceListElemId tailId; } msgSpaceList; typedef struct MsgQueueElem { - msgQueueElemId id; - int poolIndex; - int bufferIndex; - msgQueueElemId next; + msgQueueElemId id; + int poolIndex; + int bufferIndex; + msgQueueElemId next; } msgQueueElem; typedef struct MsgQueue { - msgQueueId id; - int elemCounter; - msgQueueElemId headId; - msgQueueElemId tailId; + msgQueueId id; + int elemCounter; + msgQueueElemId headId; + msgQueueElemId tailId; } msgQueue; #endif diff --git a/src/iface.h~ b/src/iface.h~ new file mode 100644 index 0000000..4ba1bcf --- /dev/null +++ b/src/iface.h~ @@ -0,0 +1,91 @@ +#ifndef _NZG_IFACE +#define _NZG_IFACE 1 + +#include "global.h" + +typedef enum { true=1, false=0} bool; + +typedef char msgSpaceId[MSGSPACE_ID_LEN]; + +typedef char msgSpaceListId[4*MSGSPACE_ID_LEN]; +typedef char msgSpaceListSemId[4*MSGSPACE_ID_LEN]; +typedef char msgSpaceListElemId[4*MSGSPACE_ID_LEN]; + +typedef char msgPoolDataTabId[4*MSGSPACE_ID_LEN]; +typedef char msgPoolDataTabSemId[4*MSGSPACE_ID_LEN]; + +typedef char msgBufferInfoTabId[4*MSGSPACE_ID_LEN]; + +typedef char msgPoolId[4*MSGSPACE_ID_LEN]; +typedef char msgPoolSemId[4*MSGSPACE_ID_LEN]; + +typedef char msgQueueDataId[4*MSGSPACE_ID_LEN]; +typedef char msgQueueId[4*MSGSPACE_ID_LEN]; +typedef char msgQueueElemId[4*MSGSPACE_ID_LEN]; +typedef char msgQueueSemId[4*MSGSPACE_ID_LEN]; + + /* pid[] */ + /* liste des processus demandeurs */ +typedef struct MsgPool { + int bufferSize; + int bufferNb; +} msgPool; + +typedef struct MsgBufferInfo { + pid_t ownerPid; + void * addr; +} msgBufferInfo; + +typedef struct MsgPoolData { + msgPoolId poolId; + msgBufferInfoTabId bufferInfoTabId; + int bufferNb; + int bufferSize; + int allocDispBuffer; +} msgPoolData; + +/* TODO: queueId */ + + +typedef struct MsgSpace { + msgSpaceId id; + msgSpaceId externId; + int poolNb; + int queueNb; + int pid; + msgPoolDataTabId poolDataTabId; + msgPoolDataTabSemId poolDataTabSemId; +} msgSpace; + + +typedef struct MsgSpaceListElem { + msgSpaceListElemId id; + + msgSpaceId spaceId; + msgSpaceListElemId next; +} msgSpaceListElem; + +typedef struct MsgSpaceList { + msgSpaceListId id; + + int elemCounter; + msgSpaceListElemId headId; + msgSpaceListElemId tailId; +} msgSpaceList; + +typedef struct MsgQueueElem { + msgQueueElemId id; + int poolIndex; + int bufferIndex; + msgQueueElemId next; +} msgQueueElem; + +typedef struct MsgQueue { + msgQueueId id; + int elemCounter; + msgQueueElemId headId; + msgQueueElemId tailId; +} msgQueue; + +#endif +/* */ diff --git a/src/libnazgul.h~ b/src/libnazgul.h~ new file mode 100644 index 0000000..c7d47b2 --- /dev/null +++ b/src/libnazgul.h~ @@ -0,0 +1,8 @@ +#ifndef _LIBNAZGUL +#define _LIBNAZGUL 1 + +#include "global.h" +#include "iface.h" +#include "proto.h" + +#endif diff --git a/src/poolCreate.c b/src/poolCreate.c index 1251982..56bd1f4 100644 --- a/src/poolCreate.c +++ b/src/poolCreate.c @@ -1,50 +1,52 @@ #include "libnazgul.h" #include "ids.h" -int msgPoolCreate( - msgSpaceId externId, - int poolIdx, - int buffNb, - int buffSize - ) { - +int msgPoolCreate(msgSpaceId externId, int poolIdx, int buffNb, int buffSize) +{ + int poolFd; - sem_t * ressourceSemFd; + sem_t *ressourceSemFd; msgPoolId poolId; msgPoolSemId poolRessourceSemId; /* creation des buffers DEBUT */ - if (msgPoolIdIntern(poolId,externId,poolIdx) == -1){ - fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId ); - return -1; + if (msgPoolIdIntern(poolId, externId, poolIdx) == -1) { + fprintf(stderr, "msgPoolId creation failed for id %s\n", + (char *)poolId); + return -1; } - poolFd=shm_open(poolId,O_RDWR|O_CREAT|O_EXCL|O_TRUNC,MSGSPACE_DEFAULT_MODE); - if (poolFd == -1 ) { - fprintf( stderr, "msgPool : %s creation failed: %s\n",poolId, - strerror( errno ) ); - return -1; + poolFd = + shm_open(poolId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC, + MSGSPACE_DEFAULT_MODE); + if (poolFd == -1) { + fprintf(stderr, "msgPool : %s creation failed: %s\n", poolId, + strerror(errno)); + return -1; } - if (ftruncate(poolFd, (buffSize*buffNb)) == -1){ - fprintf( stderr, "msgPool resizing failed: %s\n", - strerror( errno ) ); - return -1; + if (ftruncate(poolFd, (buffSize * buffNb)) == -1) { + fprintf(stderr, "msgPool resizing failed: %s\n", + strerror(errno)); + return -1; } /* creation des buffers FIN */ - if (msgPoolSemIdIntern(poolRessourceSemId,externId,poolIdx) == -1){ - fprintf( stderr, "msgPoolId creation failed for id %s\n", - (char*)poolRessourceSemId ); - return -1; + if (msgPoolSemIdIntern(poolRessourceSemId, externId, poolIdx) == -1) { + fprintf(stderr, "msgPoolId creation failed for id %s\n", + (char *)poolRessourceSemId); + return -1; } - // on met un semaphore sur le pool - ressourceSemFd = sem_open(poolRessourceSemId, O_CREAT|O_EXCL,SEM_DEFAULT_MODE, buffNb); - if (ressourceSemFd == SEM_FAILED){ - NZG_ERROR("sem_open : creation de la ressource",poolRessourceSemId); - goto ERROR; - } else { - printf("[ Created %s with %d ressources ]\n",poolRessourceSemId,buffNb); - } + ressourceSemFd = + sem_open(poolRessourceSemId, O_CREAT | O_EXCL, SEM_DEFAULT_MODE, + buffNb); + if (ressourceSemFd == SEM_FAILED) { + NZG_ERROR("sem_open : creation de la ressource", + poolRessourceSemId); + goto ERROR; + } else { + printf("[ Created %s with %d ressources ]\n", + poolRessourceSemId, buffNb); + } //TODO: verrifier les erreurs sur l'ouverture de la sem @@ -55,7 +57,6 @@ int msgPoolCreate( close(poolFd); return 0; -ERROR: + ERROR: return -1; } - diff --git a/src/poolDataTabClose.c b/src/poolDataTabClose.c index 79b1107..1119ec0 100644 --- a/src/poolDataTabClose.c +++ b/src/poolDataTabClose.c @@ -1,13 +1,14 @@ #include "libnazgul.h" -int msgPoolDataTabClose(msgSpace * space,void * addr){ - /* unmapper le msgPoolDataTab */ +int msgPoolDataTabClose(msgSpace * space, void *addr) +{ + /* unmapper le msgPoolDataTab */ - if (munmap(addr,(space->poolNb) * sizeof( msgPoolData )) < 0){ - NZG_ERROR("unmap",space->poolDataTabId); - goto ERROR; - } - return 0; -ERROR: - return -1; + if (munmap(addr, (space->poolNb) * sizeof(msgPoolData)) < 0) { + NZG_ERROR("unmap", space->poolDataTabId); + goto ERROR; + } + return 0; + ERROR: + return -1; } diff --git a/src/poolDataTabCreate.c b/src/poolDataTabCreate.c index c6adfda..37d1f9d 100644 --- a/src/poolDataTabCreate.c +++ b/src/poolDataTabCreate.c @@ -1,42 +1,39 @@ #include "libnazgul.h" #include "ids.h" -void * msgPoolDataTabCreate(msgSpace * space){ - int poolDataFd; // shm file descriptor - msgPoolData * poolDataTabAddr; - poolDataFd=shm_open( - space->poolDataTabId, - O_RDWR|O_CREAT|O_EXCL|O_TRUNC, - MSGSPACE_DEFAULT_MODE - ); - if (poolDataFd == -1 ) { - NZG_ERROR("shm_open :create",space->poolDataTabId); - goto ERROR; - } +void *msgPoolDataTabCreate(msgSpace * space) +{ + int poolDataFd; // shm file descriptor + msgPoolData *poolDataTabAddr; + poolDataFd = shm_open(space->poolDataTabId, + O_RDWR | O_CREAT | O_EXCL | O_TRUNC, + MSGSPACE_DEFAULT_MODE); + if (poolDataFd == -1) { + NZG_ERROR("shm_open :create", space->poolDataTabId); + goto ERROR; + } - /* allocation de la bonne zone mémoire pour le poolData */ - if (ftruncate(poolDataFd, (space->poolNb)*sizeof(msgPoolData)) == -1){ - NZG_ERROR("ftruncate",space->poolDataTabId); - goto ERROR; - } + /* allocation de la bonne zone mémoire pour le poolData */ + if (ftruncate(poolDataFd, (space->poolNb) * sizeof(msgPoolData)) == -1) { + NZG_ERROR("ftruncate", space->poolDataTabId); + goto ERROR; + } - close(poolDataFd); - poolDataTabAddr = msgPoolDataTabOpen(space); - if (poolDataTabAddr == NULL){ - NZG_ERROR("msgPoolDataTabOpen : create",space->poolDataTabId); - goto ERROR; - } - /*mmap( 0, sizeof( *mSAddr ), - PROT_READ | PROT_WRITE, - MAP_SHARED, mSFd, 0 ); - if( poolDataAddr == MAP_FAILED ) { - NZG_ERROR("mmap",poolDataTabId); - goto ERROR; - }*/ + close(poolDataFd); + poolDataTabAddr = msgPoolDataTabOpen(space); + if (poolDataTabAddr == NULL) { + NZG_ERROR("msgPoolDataTabOpen : create", space->poolDataTabId); + goto ERROR; + } + /*mmap( 0, sizeof( *mSAddr ), + PROT_READ | PROT_WRITE, + MAP_SHARED, mSFd, 0 ); + if( poolDataAddr == MAP_FAILED ) { + NZG_ERROR("mmap",poolDataTabId); + goto ERROR; + } */ - return poolDataTabAddr; -ERROR: - return NULL; + return poolDataTabAddr; + ERROR: + return NULL; } - - diff --git a/src/poolDataTabLock.c b/src/poolDataTabLock.c index fc4b633..62ce23a 100644 --- a/src/poolDataTabLock.c +++ b/src/poolDataTabLock.c @@ -3,34 +3,35 @@ #define DEBUG 0 -int msgPoolDataTabLock(msgSpace * space){ - int semval; - sem_t * poolDataTabSemFd; - semval=0; - if (DEBUG) {printf("Locking %s\n",space->poolDataTabSemId);} +int msgPoolDataTabLock(msgSpace * space) +{ + int semval; + sem_t *poolDataTabSemFd; + semval = 0; + if (DEBUG) { + printf("Locking %s\n", space->poolDataTabSemId); + } - poolDataTabSemFd=sem_open( - space->poolDataTabSemId - ,O_CREAT, - SEM_DEFAULT_MODE, - 1); - if(poolDataTabSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",space->poolDataTabSemId); - goto ERROR; - } + poolDataTabSemFd = sem_open(space->poolDataTabSemId, O_CREAT, + SEM_DEFAULT_MODE, 1); + if (poolDataTabSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", space->poolDataTabSemId); + goto ERROR; + } - if(sem_wait(poolDataTabSemFd)==-1){ - NZG_ERROR("sem_wait",space->poolDataTabSemId); - goto ERROR; - } + if (sem_wait(poolDataTabSemFd) == -1) { + NZG_ERROR("sem_wait", space->poolDataTabSemId); + goto ERROR; + } - sem_getvalue(poolDataTabSemFd,&semval); - if (DEBUG) { printf("(AfternValue:%d)\n",semval);} + sem_getvalue(poolDataTabSemFd, &semval); + if (DEBUG) { + printf("(AfternValue:%d)\n", semval); + } - sem_close(poolDataTabSemFd); + sem_close(poolDataTabSemFd); - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; } - diff --git a/src/poolDataTabOpen.c b/src/poolDataTabOpen.c index 14e6d8c..4bb4a85 100644 --- a/src/poolDataTabOpen.c +++ b/src/poolDataTabOpen.c @@ -1,31 +1,30 @@ #include "libnazgul.h" #include "ids.h" -void * msgPoolDataTabOpen(msgSpace * space){ - int poolDataTabFd; - void * poolDataTabAddr; +void *msgPoolDataTabOpen(msgSpace * space) +{ + int poolDataTabFd; + void *poolDataTabAddr; - poolDataTabFd=shm_open(space->poolDataTabId, - O_RDWR, - MSGSPACE_DEFAULT_MODE); - if (poolDataTabFd == -1 ) { - NZG_ERROR("shm_open",space->poolDataTabId); - goto ERROR; - } + poolDataTabFd = shm_open(space->poolDataTabId, + O_RDWR, MSGSPACE_DEFAULT_MODE); + if (poolDataTabFd == -1) { + NZG_ERROR("shm_open", space->poolDataTabId); + goto ERROR; + } + poolDataTabAddr = mmap(NULL, (space->poolNb) * sizeof(msgPoolData), + PROT_READ | PROT_WRITE, + MAP_SHARED, poolDataTabFd, 0); - poolDataTabAddr = mmap( NULL, (space->poolNb) * sizeof( msgPoolData ), - PROT_READ | PROT_WRITE, - MAP_SHARED, poolDataTabFd, 0 ); + if (poolDataTabAddr == MAP_FAILED) { + NZG_ERROR("mmap", space->poolDataTabId); + goto ERROR; + } - if( poolDataTabAddr == MAP_FAILED) { - NZG_ERROR("mmap",space->poolDataTabId); - goto ERROR; - } + close(poolDataTabFd); - close(poolDataTabFd); - - return poolDataTabAddr; -ERROR: - return NULL; + return poolDataTabAddr; + ERROR: + return NULL; } diff --git a/src/poolDataTabUnlock.c b/src/poolDataTabUnlock.c index e976f4e..2b461bf 100644 --- a/src/poolDataTabUnlock.c +++ b/src/poolDataTabUnlock.c @@ -3,33 +3,34 @@ #define DEBUG 0 -int msgPoolDataTabUnlock(msgSpace * space){ - int semval; - sem_t * poolDataTabSemFd; - if (DEBUG) { printf("Unlocking %s\n",space->poolDataTabSemId); } - poolDataTabSemFd=sem_open( - space->poolDataTabSemId - ,O_CREAT, - SEM_DEFAULT_MODE, - 1); - if(poolDataTabSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",space->poolDataTabSemId); - goto ERROR; - } +int msgPoolDataTabUnlock(msgSpace * space) +{ + int semval; + sem_t *poolDataTabSemFd; + if (DEBUG) { + printf("Unlocking %s\n", space->poolDataTabSemId); + } + poolDataTabSemFd = sem_open(space->poolDataTabSemId, O_CREAT, + SEM_DEFAULT_MODE, 1); + if (poolDataTabSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", space->poolDataTabSemId); + goto ERROR; + } - if(sem_post(poolDataTabSemFd)==-1){ - NZG_ERROR("sem_post",space->poolDataTabSemId); - goto ERROR; - } - - semval=0; - sem_getvalue(poolDataTabSemFd,&semval); - if (DEBUG) { printf("(AfternValue:%d)\n",semval); } + if (sem_post(poolDataTabSemFd) == -1) { + NZG_ERROR("sem_post", space->poolDataTabSemId); + goto ERROR; + } - sem_close(poolDataTabSemFd); + semval = 0; + sem_getvalue(poolDataTabSemFd, &semval); + if (DEBUG) { + printf("(AfternValue:%d)\n", semval); + } - return 0; -ERROR: - return -1; + sem_close(poolDataTabSemFd); + + return 0; + ERROR: + return -1; } - diff --git a/src/poolDelete.c b/src/poolDelete.c index 4fcecb2..7d91071 100644 --- a/src/poolDelete.c +++ b/src/poolDelete.c @@ -1,50 +1,49 @@ #include "libnazgul.h" #include "ids.h" -int msgPoolDelete( - msgSpaceId spaceId, - int poolIdx - ) { - +int msgPoolDelete(msgSpaceId spaceId, int poolIdx) +{ + msgPoolId poolId; msgBufferInfoTabId bufferInfoTabId; msgPoolSemId poolRessourceSemId; - /* suppression des infos sur buffers DEBUT */ - if (msgBufferInfoTabIdIntern(bufferInfoTabId,spaceId,poolIdx) == -1){ - fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId ); - return -1; + if (msgBufferInfoTabIdIntern(bufferInfoTabId, spaceId, poolIdx) == -1) { + fprintf(stderr, "msgPoolId creation failed for id %s\n", + (char *)poolId); + return -1; } - - if (shm_unlink(bufferInfoTabId) <0 ) { - fprintf( stderr, "msgInfoTab : %s deletion failed: %s\n",bufferInfoTabId, - strerror( errno ) ); - return -1; + + if (shm_unlink(bufferInfoTabId) < 0) { + fprintf(stderr, "msgInfoTab : %s deletion failed: %s\n", + bufferInfoTabId, strerror(errno)); + return -1; } - /* suppression des infos sur buffers FIN */ - + /* suppression des infos sur buffers FIN */ + /* suppression des buffers DEBUT */ - if (msgPoolIdIntern(poolId,spaceId,poolIdx) == -1){ - fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId ); - return -1; + if (msgPoolIdIntern(poolId, spaceId, poolIdx) == -1) { + fprintf(stderr, "msgPoolId creation failed for id %s\n", + (char *)poolId); + return -1; } - if (shm_unlink(poolId) <0 ) { - fprintf( stderr, "msgPool : %s deletion failed: %s\n",poolId, - strerror( errno ) ); - return -1; + if (shm_unlink(poolId) < 0) { + fprintf(stderr, "msgPool : %s deletion failed: %s\n", poolId, + strerror(errno)); + return -1; } /* suppression des buffers FIN */ /* suppression de la sémaphore */ - if (msgPoolSemIdIntern(poolRessourceSemId,spaceId,poolIdx) == -1){ - fprintf( stderr, "msgPoolId creation failed for id %s\n", - (char*)poolRessourceSemId ); - return -1; + if (msgPoolSemIdIntern(poolRessourceSemId, spaceId, poolIdx) == -1) { + fprintf(stderr, "msgPoolId creation failed for id %s\n", + (char *)poolRessourceSemId); + return -1; } // on met un semaphore sur le pool sem_unlink(poolRessourceSemId); //TODO: verrifier les erreurs sur l'ouverture de la sem - + return 0; } diff --git a/src/proto.h b/src/proto.h index e78ac12..dc72f6b 100644 --- a/src/proto.h +++ b/src/proto.h @@ -2,66 +2,77 @@ #define _NZG_PROTO 1 /* allocate.c */ -void *msgAllocate(msgSpace *space, int pool, int taille, int option); +void *msgAllocate(msgSpace * space, int pool, int taille, int option); /* bufferAttachProc.c */ -int msgBufferAttachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr); +int msgBufferAttachProc(msgPoolData * poolDataTabAddr, int poolIndex, + int bufferIndex, void *addr); /* buffer.c */ -int msgBufferGetAttachedProcIndex(msgPoolData *poolDataTabAddr, int poolIndex, void *addr); +int msgBufferGetAttachedProcIndex(msgPoolData * poolDataTabAddr, int poolIndex, + void *addr); /* bufferDetachProc.c */ -int msgBufferDetachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr); +int msgBufferDetachProc(msgPoolData * poolDataTabAddr, int poolIndex, + int bufferIndex, void *addr); /* bufferGetFreeIndex.c */ -int msgBufferGetFreeIndex(msgPoolData *poolDataTabAddr, int poolIndex); +int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr, int poolIndex); /* bufferGetProcAttach.c */ -int msgBufferGetProcAttach(msgPoolData *poolDataTabAddr, int poolNb, int *poolIndex, int *bufferIndex, void *addr); +int msgBufferGetProcAttach(msgPoolData * poolDataTabAddr, int poolNb, + int *poolIndex, int *bufferIndex, void *addr); /* bufferInfoTabCreate.c */ -int msgBufferInfoTabCreate(msgSpaceId externId, msgPoolData *poolDataTabAddr, int poolIdx, int bufferNb); +int msgBufferInfoTabCreate(msgSpaceId externId, msgPoolData * poolDataTabAddr, + int poolIdx, int bufferNb); /* bufferInfoTabInit.c */ -int msgBufferInfoTabInit(msgPoolData *poolDataTabAddr, int poolIndex); +int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr, int poolIndex); /* bufferMap.c */ -void *msgBufferMap(msgPoolData *poolDataTab, int poolIndex, int bufferIndex); +void *msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex); /* free.c */ -int msgFree(msgSpace *space, void *addr); +int msgFree(msgSpace * space, void *addr); /* get.c */ -void *msgGet(msgSpace *space, int queueIndex, int option); +void *msgGet(msgSpace * space, int queueIndex, int option); /* ids.c */ int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src); -int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, const msgSpaceId externId); -int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, int poolIdx); +int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, + const msgSpaceId externId); +int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, + int poolIdx); int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src); int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num); int msgBufferInfoTabIdIntern(msgBufferInfoTabId dest, msgSpaceId src, int num); -int msgQueueProtSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx); -int msgQueueReadSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx); +int msgQueueProtSemIdIntern(msgQueueSemId dest, msgSpaceId externId, + int queueIdx); +int msgQueueReadSemIdIntern(msgQueueSemId dest, msgSpaceId externId, + int queueIdx); int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx); int msgQueueElemIdIntern(msgQueueElemId dest, msgQueueId src, int counter); -int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, msgSpaceId externId); +int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, + msgSpaceId externId); /* list.c */ /* poolCreate.c */ int msgPoolCreate(msgSpaceId externId, int poolIdx, int buffNb, int buffSize); /* poolDataTabClose.c */ -int msgPoolDataTabClose(msgSpace *space, void *addr); +int msgPoolDataTabClose(msgSpace * space, void *addr); /* poolDataTabCreate.c */ -void *msgPoolDataTabCreate(msgSpace *space); +void *msgPoolDataTabCreate(msgSpace * space); /* poolDataTabLock.c */ -int msgPoolDataTabLock(msgSpace *space); +int msgPoolDataTabLock(msgSpace * space); /* poolDataTabOpen.c */ -void *msgPoolDataTabOpen(msgSpace *space); +void *msgPoolDataTabOpen(msgSpace * space); /* poolDataTabUnlock.c */ -int msgPoolDataTabUnlock(msgSpace *space); +int msgPoolDataTabUnlock(msgSpace * space); /* poolDelete.c */ int msgPoolDelete(msgSpaceId spaceId, int poolIdx); /* put.c */ -int msgPut(msgSpace *space, int queueIndex, void *addr); +int msgPut(msgSpace * space, int queueIndex, void *addr); /* queueAdd.c */ -int msgQueueAdd(msgQueue *queue, msgQueueElemId newElemId); +int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId); /* queueClose.c */ -int msgQueueClose(msgQueue *queue); +int msgQueueClose(msgQueue * queue); /* queueDelete.c */ int msgQueueDelete(msgQueueId externId, int queueIdx); /* queueElemClose.c */ -int msgQueueElemClose(msgQueueElem *queueElem); +int msgQueueElemClose(msgQueueElem * queueElem); /* queueElemCreate.c */ -int msgQueueElemCreate(msgQueueElemId finalQueueElemId, msgQueueId queueId, int counter); +int msgQueueElemCreate(msgQueueElemId finalQueueElemId, msgQueueId queueId, + int counter); /* queueElemDelete.c */ int msgQueueElemDelete(msgQueueElemId queueElemId); /* queueElemOpen.c */ @@ -81,21 +92,22 @@ int msgQueueReadTryLock(msgSpaceId externId, int queueIdx); /* queueReadUnlock.c */ int msgQueueReadUnlock(msgSpaceId externId, int queueIdx); /* queueRem.c */ -int msgQueueRem(msgQueue *queue, msgQueueElemId oldElemId); +int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId); /* spaceClose.c */ -int msgSpaceClose(msgSpace *space); +int msgSpaceClose(msgSpace * space); /* spaceCreate.c */ -msgSpace *msgSpaceCreate(msgSpaceId externId, int queueNb, int poolNb, msgPool *poolInfos); +msgSpace *msgSpaceCreate(msgSpaceId externId, int queueNb, int poolNb, + msgPool * poolInfos); /* spaceDelete.c */ int msgSpaceDelete(msgSpaceId externId); /* spaceListAdd.c */ int msgSpaceListAdd(msgSpaceListElemId newElemId); /* spaceListClose.c */ -int msgSpaceListClose(msgSpaceList *list); +int msgSpaceListClose(msgSpaceList * list); /* spaceListElemClose.c */ -int msgSpaceListElemClose(msgSpaceListElem *listElem); +int msgSpaceListElemClose(msgSpaceListElem * listElem); /* spaceListElemCreate.c */ -int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace *space); +int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace * space); /* spaceListElemLink.c */ /* spaceListElemOpen.c */ void *msgSpaceListElemOpen(msgSpaceListElemId listElemId); diff --git a/src/proto.h~ b/src/proto.h~ new file mode 100644 index 0000000..e78ac12 --- /dev/null +++ b/src/proto.h~ @@ -0,0 +1,118 @@ +#ifndef _NZG_PROTO +#define _NZG_PROTO 1 + +/* allocate.c */ +void *msgAllocate(msgSpace *space, int pool, int taille, int option); +/* bufferAttachProc.c */ +int msgBufferAttachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr); +/* buffer.c */ +int msgBufferGetAttachedProcIndex(msgPoolData *poolDataTabAddr, int poolIndex, void *addr); +/* bufferDetachProc.c */ +int msgBufferDetachProc(msgPoolData *poolDataTabAddr, int poolIndex, int bufferIndex, void *addr); +/* bufferGetFreeIndex.c */ +int msgBufferGetFreeIndex(msgPoolData *poolDataTabAddr, int poolIndex); +/* bufferGetProcAttach.c */ +int msgBufferGetProcAttach(msgPoolData *poolDataTabAddr, int poolNb, int *poolIndex, int *bufferIndex, void *addr); +/* bufferInfoTabCreate.c */ +int msgBufferInfoTabCreate(msgSpaceId externId, msgPoolData *poolDataTabAddr, int poolIdx, int bufferNb); +/* bufferInfoTabInit.c */ +int msgBufferInfoTabInit(msgPoolData *poolDataTabAddr, int poolIndex); +/* bufferMap.c */ +void *msgBufferMap(msgPoolData *poolDataTab, int poolIndex, int bufferIndex); +/* free.c */ +int msgFree(msgSpace *space, void *addr); +/* get.c */ +void *msgGet(msgSpace *space, int queueIndex, int option); +/* ids.c */ +int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src); +int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, const msgSpaceId externId); +int msgPoolSemIdIntern(msgPoolSemId destSemId, const msgSpaceId srcPoolId, int poolIdx); +int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src); +int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num); +int msgBufferInfoTabIdIntern(msgBufferInfoTabId dest, msgSpaceId src, int num); +int msgQueueProtSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx); +int msgQueueReadSemIdIntern(msgQueueSemId dest, msgSpaceId externId, int queueIdx); +int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx); +int msgQueueElemIdIntern(msgQueueElemId dest, msgQueueId src, int counter); +int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, msgSpaceId externId); +/* list.c */ +/* poolCreate.c */ +int msgPoolCreate(msgSpaceId externId, int poolIdx, int buffNb, int buffSize); +/* poolDataTabClose.c */ +int msgPoolDataTabClose(msgSpace *space, void *addr); +/* poolDataTabCreate.c */ +void *msgPoolDataTabCreate(msgSpace *space); +/* poolDataTabLock.c */ +int msgPoolDataTabLock(msgSpace *space); +/* poolDataTabOpen.c */ +void *msgPoolDataTabOpen(msgSpace *space); +/* poolDataTabUnlock.c */ +int msgPoolDataTabUnlock(msgSpace *space); +/* poolDelete.c */ +int msgPoolDelete(msgSpaceId spaceId, int poolIdx); +/* put.c */ +int msgPut(msgSpace *space, int queueIndex, void *addr); +/* queueAdd.c */ +int msgQueueAdd(msgQueue *queue, msgQueueElemId newElemId); +/* queueClose.c */ +int msgQueueClose(msgQueue *queue); +/* queueDelete.c */ +int msgQueueDelete(msgQueueId externId, int queueIdx); +/* queueElemClose.c */ +int msgQueueElemClose(msgQueueElem *queueElem); +/* queueElemCreate.c */ +int msgQueueElemCreate(msgQueueElemId finalQueueElemId, msgQueueId queueId, int counter); +/* queueElemDelete.c */ +int msgQueueElemDelete(msgQueueElemId queueElemId); +/* queueElemOpen.c */ +void *msgQueueElemOpen(msgQueueElemId queueElemId); +/* queueInit.c */ +msgQueue *msgQueueInit(msgSpaceId externId, int queueIdx); +/* queueOpen.c */ +void *msgQueueOpen(msgQueueId queueId); +/* queueProtLock.c */ +int msgQueueProtLock(msgSpaceId externId, int queueIdx); +/* queueProtUnlock.c */ +int msgQueueProtUnlock(msgSpaceId externId, int queueIdx); +/* queueReadLock.c */ +int msgQueueReadLock(msgSpaceId externId, int queueIdx); +/* queueReadTryLock.c */ +int msgQueueReadTryLock(msgSpaceId externId, int queueIdx); +/* queueReadUnlock.c */ +int msgQueueReadUnlock(msgSpaceId externId, int queueIdx); +/* queueRem.c */ +int msgQueueRem(msgQueue *queue, msgQueueElemId oldElemId); +/* spaceClose.c */ +int msgSpaceClose(msgSpace *space); +/* spaceCreate.c */ +msgSpace *msgSpaceCreate(msgSpaceId externId, int queueNb, int poolNb, msgPool *poolInfos); +/* spaceDelete.c */ +int msgSpaceDelete(msgSpaceId externId); +/* spaceListAdd.c */ +int msgSpaceListAdd(msgSpaceListElemId newElemId); +/* spaceListClose.c */ +int msgSpaceListClose(msgSpaceList *list); +/* spaceListElemClose.c */ +int msgSpaceListElemClose(msgSpaceListElem *listElem); +/* spaceListElemCreate.c */ +int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace *space); +/* spaceListElemLink.c */ +/* spaceListElemOpen.c */ +void *msgSpaceListElemOpen(msgSpaceListElemId listElemId); +/* spaceListFindId.c */ +int msgSpaceListFindId(msgSpaceId externId); +int msgSpaceListElemFindId(msgSpaceListElemId elemId, msgSpaceId spaceId); +/* spaceListInit.c */ +int msgSpaceListInit(void); +/* spaceListLocking.c */ +int msgSpaceListLock(void); +int msgSpaceListUnlock(void); +/* spaceListOpen.c */ +void *msgSpaceListOpen(void); +/* spaceListRem.c */ +int msgSpaceListRem(msgSpaceId spaceId); +/* spaceOpen.c */ +msgSpace *msgSpaceOpen(msgSpaceId externId); +/* spaceState.c */ + +#endif diff --git a/src/put.c b/src/put.c index 5a1295b..18a3a3c 100644 --- a/src/put.c +++ b/src/put.c @@ -1,74 +1,66 @@ #include "libnazgul.h" -int msgPut(msgSpace * space,int queueIndex, void * addr){ - // retrouver le pool, buffer qui correspondent à l'addresse... - msgPoolData * poolDataTabAddr; - int poolIndex; - int bufferIndex; - int err; - msgQueueElemId newElemId; - msgQueueElem * queueElem; - msgQueueId queueId; - msgQueue * queue; +int msgPut(msgSpace * space, int queueIndex, void *addr) +{ + // retrouver le pool, buffer qui correspondent à l'addresse... + msgPoolData *poolDataTabAddr; + int poolIndex; + int bufferIndex; + int err; + msgQueueElemId newElemId; + msgQueueElem *queueElem; + msgQueueId queueId; + msgQueue *queue; - msgPoolDataTabLock(space); - poolDataTabAddr=msgPoolDataTabOpen(space); - if (poolDataTabAddr == NULL){ - NZG_ERROR("msgPoolDataTabOpen",space->poolDataTabId); - goto ERROR; - } - err = msgBufferGetProcAttach( - poolDataTabAddr, - space->poolNb, - &poolIndex, - &bufferIndex, - addr - ); - if (err) { - //FIXME - } + msgPoolDataTabLock(space); + poolDataTabAddr = msgPoolDataTabOpen(space); + if (poolDataTabAddr == NULL) { + NZG_ERROR("msgPoolDataTabOpen", space->poolDataTabId); + goto ERROR; + } + err = msgBufferGetProcAttach(poolDataTabAddr, + space->poolNb, + &poolIndex, &bufferIndex, addr); + if (err) { + //FIXME + } + // ouvrir la queue avec le bon index + msgQueueIdIntern(queueId, space->externId, queueIndex); - // ouvrir la queue avec le bon index - msgQueueIdIntern(queueId,space->externId,queueIndex); + msgQueueProtLock(space->externId, queueIndex); + queue = msgQueueOpen(queueId); - msgQueueProtLock(space->externId,queueIndex); - queue = msgQueueOpen(queueId); + // creer un element vide - // creer un element vide + msgQueueElemCreate(newElemId, queueId, queue->elemCounter); + // ouvrir l'element + queueElem = msgQueueElemOpen(newElemId); - msgQueueElemCreate(newElemId,queueId,queue->elemCounter); - // ouvrir l'element - queueElem=msgQueueElemOpen(newElemId); + // modifier les index pour retrouver le buffer + queueElem->poolIndex = poolIndex; + queueElem->bufferIndex = bufferIndex; - // modifier les index pour retrouver le buffer - queueElem->poolIndex=poolIndex; - queueElem->bufferIndex=bufferIndex; + // fermer l'element + if (msgQueueElemClose(queueElem) < 0) { + NZG_ERROR("msgQueueElemClose", ""); + goto ERROR; + } + //ajouter le message a la bonne file... + if (msgQueueAdd(queue, newElemId) < 0) { + NZG_ERROR("msgQueueAdd", newElemId); + goto ERROR; + } + // fermer la file + msgQueueClose(queue); + msgQueueProtUnlock(space->externId, queueIndex); - // fermer l'element - if (msgQueueElemClose(queueElem) <0 ){ - NZG_ERROR("msgQueueElemClose",""); - goto ERROR; - } + msgPoolDataTabClose(space, poolDataTabAddr); + msgPoolDataTabUnlock(space); - //ajouter le message a la bonne file... - if (msgQueueAdd(queue,newElemId) < 0){ - NZG_ERROR("msgQueueAdd",newElemId); - goto ERROR; - } + // on laisse une nouvelle ressource de la liste au get + msgQueueReadUnlock(space->externId, queueIndex); + return 0; - // fermer la file - msgQueueClose(queue); - msgQueueProtUnlock(space->externId,queueIndex); - - msgPoolDataTabClose(space,poolDataTabAddr); - msgPoolDataTabUnlock(space); - - // on laisse une nouvelle ressource de la liste au get - msgQueueReadUnlock(space->externId,queueIndex); - return 0; - -ERROR: - return -1; + ERROR: + return -1; } - - diff --git a/src/queueAdd.c b/src/queueAdd.c index 393afb8..6fc5fa3 100644 --- a/src/queueAdd.c +++ b/src/queueAdd.c @@ -2,47 +2,48 @@ // on ajoute en fin de queue... -int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId){ - msgQueueElem * queueOldTailElem; - msgQueueElem * queueNewTailElem; - +int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId) +{ + msgQueueElem *queueOldTailElem; + msgQueueElem *queueNewTailElem; + // on informe l'element qu'il est le dernier - queueNewTailElem=msgQueueElemOpen(newElemId); - if (queueNewTailElem == NULL){ - NZG_ERROR("msgQueueElemOpen",newElemId); - goto ERROR; + queueNewTailElem = msgQueueElemOpen(newElemId); + if (queueNewTailElem == NULL) { + NZG_ERROR("msgQueueElemOpen", newElemId); + goto ERROR; + } + strcpy(queueNewTailElem->next, newElemId); + if (msgQueueElemClose(queueNewTailElem) < 0) { + NZG_ERROR("msgQueueElemClose", newElemId); + goto ERROR; } - strcpy(queueNewTailElem->next,newElemId); - if (msgQueueElemClose(queueNewTailElem) <0 ){ - NZG_ERROR("msgQueueElemClose",newElemId); - goto ERROR; - } /* TODO: verifier si la liste n'est pas vide... */ - if((strcmp(queue->headId,queue->id)==0) - && (strcmp(queue->tailId,queue->id)==0)) { - printf("- premier elem de queue -\n"); - // on donne a la queue l'id de l'element - strcpy(queue->headId,newElemId); - strcpy(queue->tailId,newElemId); + if ((strcmp(queue->headId, queue->id) == 0) + && (strcmp(queue->tailId, queue->id) == 0)) { + printf("- premier elem de queue -\n"); + // on donne a la queue l'id de l'element + strcpy(queue->headId, newElemId); + strcpy(queue->tailId, newElemId); } else { - /* on informe son prédecesseur qu'il a un suivant */ - queueOldTailElem=msgQueueElemOpen(queue->tailId); - if (queueOldTailElem == NULL){ - NZG_ERROR("msgQueueElemOpen",queue->tailId); - goto ERROR; - } - strcpy(queueOldTailElem->next,newElemId); - if (msgQueueElemClose(queueOldTailElem) < 0){ - NZG_ERROR("msgQueueElemClose",queue->tailId); - goto ERROR; - } - // on donne a la queue l'id du dernier element - strcpy(queue->tailId,newElemId); + /* on informe son prédecesseur qu'il a un suivant */ + queueOldTailElem = msgQueueElemOpen(queue->tailId); + if (queueOldTailElem == NULL) { + NZG_ERROR("msgQueueElemOpen", queue->tailId); + goto ERROR; + } + strcpy(queueOldTailElem->next, newElemId); + if (msgQueueElemClose(queueOldTailElem) < 0) { + NZG_ERROR("msgQueueElemClose", queue->tailId); + goto ERROR; + } + // on donne a la queue l'id du dernier element + strcpy(queue->tailId, newElemId); } // on incremente elemCounter queue->elemCounter++; return 0; -ERROR: + ERROR: return -1; } diff --git a/src/queueClose.c b/src/queueClose.c index cca58bc..bd344e9 100644 --- a/src/queueClose.c +++ b/src/queueClose.c @@ -1,16 +1,17 @@ #include "libnazgul.h" #include "ids.h" -int msgQueueClose(msgQueue * queue){ - msgQueueId qId; - strcpy(qId,queue->id); - - if (munmap(queue,sizeof(msgQueue)) < 0){ - NZG_ERROR("unmap",qId); - goto ERROR; - } +int msgQueueClose(msgQueue * queue) +{ + msgQueueId qId; + strcpy(qId, queue->id); - return 0; -ERROR: - return -1; + if (munmap(queue, sizeof(msgQueue)) < 0) { + NZG_ERROR("unmap", qId); + goto ERROR; + } + + return 0; + ERROR: + return -1; } diff --git a/src/queueDelete.c b/src/queueDelete.c index eddcc86..6657f70 100644 --- a/src/queueDelete.c +++ b/src/queueDelete.c @@ -1,35 +1,34 @@ #include "libnazgul.h" -int msgQueueDelete(msgQueueId externId,int queueIdx){ - msgQueue * queue; - msgQueueId queueId; - msgQueueSemId queueProtLockSemId; - msgQueueSemId queueReadLockSemId; - - msgQueueIdIntern(queueId,externId,queueIdx); - queue = msgQueueOpen(queueId); +int msgQueueDelete(msgQueueId externId, int queueIdx) +{ + msgQueue *queue; + msgQueueId queueId; + msgQueueSemId queueProtLockSemId; + msgQueueSemId queueReadLockSemId; - if (strcmp(queue->headId,queue->id)!=0){ - // liste non-vide - if (msgQueueElemDelete(queue->headId) <0){ - NZG_ERROR("msgQueueElemDelete",queue->headId); - goto ERROR; + msgQueueIdIntern(queueId, externId, queueIdx); + queue = msgQueueOpen(queueId); + + if (strcmp(queue->headId, queue->id) != 0) { + // liste non-vide + if (msgQueueElemDelete(queue->headId) < 0) { + NZG_ERROR("msgQueueElemDelete", queue->headId); + goto ERROR; + } } - } - - msgQueueProtSemIdIntern(queueProtLockSemId,externId,queueIdx); - msgQueueReadSemIdIntern(queueReadLockSemId,externId,queueIdx); - sem_unlink(queueProtLockSemId); - sem_unlink(queueReadLockSemId); - if (shm_unlink(queueId) < 0){ - NZG_ERROR("shm_unlink msgQueueElem",queueId); - goto ERROR; - } + msgQueueProtSemIdIntern(queueProtLockSemId, externId, queueIdx); + msgQueueReadSemIdIntern(queueReadLockSemId, externId, queueIdx); + sem_unlink(queueProtLockSemId); + sem_unlink(queueReadLockSemId); - return 0; -ERROR: - return -1; + if (shm_unlink(queueId) < 0) { + NZG_ERROR("shm_unlink msgQueueElem", queueId); + goto ERROR; + } + + return 0; + ERROR: + return -1; } - - diff --git a/src/queueElemClose.c b/src/queueElemClose.c index 1ff51bd..42c99b3 100644 --- a/src/queueElemClose.c +++ b/src/queueElemClose.c @@ -1,15 +1,16 @@ #include "libnazgul.h" -int msgQueueElemClose(msgQueueElem * queueElem){ - msgQueueElemId qId; - strcpy(qId,queueElem->id); - - if (munmap(queueElem,sizeof(msgQueueElem)) < 0){ - NZG_ERROR("unmap",qId); - goto ERROR; - } +int msgQueueElemClose(msgQueueElem * queueElem) +{ + msgQueueElemId qId; + strcpy(qId, queueElem->id); - return 0; -ERROR: - return -1; + if (munmap(queueElem, sizeof(msgQueueElem)) < 0) { + NZG_ERROR("unmap", qId); + goto ERROR; + } + + return 0; + ERROR: + return -1; } diff --git a/src/queueElemCreate.c b/src/queueElemCreate.c index b127d1f..6f6349d 100644 --- a/src/queueElemCreate.c +++ b/src/queueElemCreate.c @@ -1,31 +1,30 @@ #include "libnazgul.h" #include "ids.h" -int msgQueueElemCreate( - msgQueueElemId finalQueueElemId , - msgQueueId queueId, - int counter){ - msgQueueElemId queueElemId; - int queueElemFd; +int msgQueueElemCreate(msgQueueElemId finalQueueElemId, + msgQueueId queueId, int counter) +{ + msgQueueElemId queueElemId; + int queueElemFd; - msgQueueElemIdIntern(queueElemId,queueId,counter); - strcpy(finalQueueElemId,queueElemId); + msgQueueElemIdIntern(queueElemId, queueId, counter); + strcpy(finalQueueElemId, queueElemId); - queueElemFd=shm_open(queueElemId, - O_RDWR|O_CREAT|O_EXCL|O_TRUNC, - SHM_DEFAULT_MODE); - if (queueElemFd == -1 ) { - NZG_ERROR("shm_open : msgQueueElem creation",queueElemId); - goto ERROR; - } + queueElemFd = shm_open(queueElemId, + O_RDWR | O_CREAT | O_EXCL | O_TRUNC, + SHM_DEFAULT_MODE); + if (queueElemFd == -1) { + NZG_ERROR("shm_open : msgQueueElem creation", queueElemId); + goto ERROR; + } - if (ftruncate(queueElemFd, sizeof(msgQueueElem)) < 0){ - NZG_ERROR("ftruncate", queueElemId); - goto ERROR; - } + if (ftruncate(queueElemFd, sizeof(msgQueueElem)) < 0) { + NZG_ERROR("ftruncate", queueElemId); + goto ERROR; + } - close(queueElemFd); - return 0; -ERROR: - return -1; + close(queueElemFd); + return 0; + ERROR: + return -1; } diff --git a/src/queueElemDelete.c b/src/queueElemDelete.c index 79a60f3..94a48b4 100644 --- a/src/queueElemDelete.c +++ b/src/queueElemDelete.c @@ -1,33 +1,33 @@ #include "libnazgul.h" -int msgQueueElemDelete(msgQueueElemId queueElemId){ - msgQueueElem * queueElem; - msgQueueElemId nextIdToDie; - - queueElem = msgQueueElemOpen(queueElemId); - if (queueElem==NULL){ - NZG_ERROR("msgQueueElemOpen",queueElemId); - goto ERROR; - } +int msgQueueElemDelete(msgQueueElemId queueElemId) +{ + msgQueueElem *queueElem; + msgQueueElemId nextIdToDie; - strcpy(nextIdToDie, queueElem->next); - - if (msgQueueElemClose(queueElem) < 0){ - NZG_ERROR("msgQueueElemClose",queueElemId); - goto ERROR; - } + queueElem = msgQueueElemOpen(queueElemId); + if (queueElem == NULL) { + NZG_ERROR("msgQueueElemOpen", queueElemId); + goto ERROR; + } - // on détruit l'élément - shm_unlink(queueElemId); + strcpy(nextIdToDie, queueElem->next); - if (nextIdToDie != queueElemId){ - return msgQueueElemDelete(nextIdToDie); - } else { - printf("msgQueueElemDelete: EOL reached \n"); - // element unique... - return 0; - } + if (msgQueueElemClose(queueElem) < 0) { + NZG_ERROR("msgQueueElemClose", queueElemId); + goto ERROR; + } + // on détruit l'élément + shm_unlink(queueElemId); -ERROR: - return -1; + if (nextIdToDie != queueElemId) { + return msgQueueElemDelete(nextIdToDie); + } else { + printf("msgQueueElemDelete: EOL reached \n"); + // element unique... + return 0; + } + + ERROR: + return -1; } diff --git a/src/queueElemOpen.c b/src/queueElemOpen.c index d980083..d923a46 100644 --- a/src/queueElemOpen.c +++ b/src/queueElemOpen.c @@ -1,29 +1,28 @@ #include "libnazgul.h" #include "ids.h" -void * msgQueueElemOpen(msgQueueElemId queueElemId){ - int queueElemFd; - void * queueElemAddr; +void *msgQueueElemOpen(msgQueueElemId queueElemId) +{ + int queueElemFd; + void *queueElemAddr; - queueElemFd=shm_open(queueElemId,O_RDWR,SHM_DEFAULT_MODE); - if (queueElemFd == -1 ) { - NZG_ERROR("shm_open : msgQueue open",queueElemId); - goto ERROR; - } + queueElemFd = shm_open(queueElemId, O_RDWR, SHM_DEFAULT_MODE); + if (queueElemFd == -1) { + NZG_ERROR("shm_open : msgQueue open", queueElemId); + goto ERROR; + } - queueElemAddr=mmap(NULL, - sizeof(msgQueueElem), - PROT_READ|PROT_WRITE, - MAP_SHARED, - queueElemFd, - 0); - if( queueElemAddr == MAP_FAILED ) { - NZG_ERROR("mmap",queueElemId); - goto ERROR; - } + queueElemAddr = mmap(NULL, + sizeof(msgQueueElem), + PROT_READ | PROT_WRITE, + MAP_SHARED, queueElemFd, 0); + if (queueElemAddr == MAP_FAILED) { + NZG_ERROR("mmap", queueElemId); + goto ERROR; + } - close(queueElemFd); - return queueElemAddr; -ERROR: - return NULL; + close(queueElemFd); + return queueElemAddr; + ERROR: + return NULL; } diff --git a/src/queueInit.c b/src/queueInit.c index b07bb01..f7655c3 100644 --- a/src/queueInit.c +++ b/src/queueInit.c @@ -1,35 +1,34 @@ #include "libnazgul.h" #include "ids.h" -msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) { +msgQueue *msgQueueInit(msgSpaceId externId, int queueIdx) +{ int queueFd; - msgQueue * queue; - sem_t * semProtectFd; + msgQueue *queue; + sem_t *semProtectFd; msgQueueSemId queueSemProtectId; - sem_t * semReadableFd; + sem_t *semReadableFd; msgQueueSemId queueSemReadableId; msgQueueId queueId; queue = NULL; - - msgQueueProtSemIdIntern(queueSemProtectId,externId,queueIdx); - msgQueueReadSemIdIntern(queueSemReadableId,externId,queueIdx); + msgQueueProtSemIdIntern(queueSemProtectId, externId, queueIdx); + msgQueueReadSemIdIntern(queueSemReadableId, externId, queueIdx); // creation du semaphore de lecture - semReadableFd = sem_open(queueSemReadableId, - O_CREAT|O_EXCL, SEM_DEFAULT_MODE, 0); - if(semReadableFd == SEM_FAILED) { - NZG_ERROR("sem_open", queueSemReadableId); - goto ERROR; + semReadableFd = sem_open(queueSemReadableId, + O_CREAT | O_EXCL, SEM_DEFAULT_MODE, 0); + if (semReadableFd == SEM_FAILED) { + NZG_ERROR("sem_open", queueSemReadableId); + goto ERROR; } - // creation du semaphore de protection - semProtectFd = sem_open(queueSemProtectId, - O_CREAT|O_EXCL, SEM_DEFAULT_MODE, 0); - if(semProtectFd == SEM_FAILED) { - NZG_ERROR("sem_open", queueSemProtectId); - goto ERROR; + semProtectFd = sem_open(queueSemProtectId, + O_CREAT | O_EXCL, SEM_DEFAULT_MODE, 0); + if (semProtectFd == SEM_FAILED) { + NZG_ERROR("sem_open", queueSemProtectId); + goto ERROR; } /* if(sem_wait(semProtectFd)==-1){ @@ -37,35 +36,36 @@ msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) { goto ERROR; } */ - if(msgQueueIdIntern(queueId, externId, queueIdx) < 0) { + if (msgQueueIdIntern(queueId, externId, queueIdx) < 0) { return NULL; } - - queueFd = shm_open(queueId, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, MSGSPACE_DEFAULT_MODE); - if(queueFd == -1) { - NZG_ERROR("shm_open : queueInit",queueId); - return NULL; + + queueFd = + shm_open(queueId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC, + MSGSPACE_DEFAULT_MODE); + if (queueFd == -1) { + NZG_ERROR("shm_open : queueInit", queueId); + return NULL; } - if(ftruncate(queueFd, sizeof(msgQueue)) == -1) { - fprintf( stderr, "Queue resizing failed: %s\n", - strerror( errno ) ); - return NULL; + if (ftruncate(queueFd, sizeof(msgQueue)) == -1) { + fprintf(stderr, "Queue resizing failed: %s\n", strerror(errno)); + return NULL; } - queue=msgQueueOpen(queueId); + queue = msgQueueOpen(queueId); /* on remplit la structure msgQueue */ queue->elemCounter = 0; - strcpy(queue->id,queueId); - strcpy(queue->headId,queue->id); - strcpy(queue->tailId,queue->id); + strcpy(queue->id, queueId); + strcpy(queue->headId, queue->id); + strcpy(queue->tailId, queue->id); /* on ferme tout ce qu'il faut */ close(queueFd); - msgQueueProtUnlock(externId,queueIdx); + msgQueueProtUnlock(externId, queueIdx); return queue; -ERROR: + ERROR: return NULL; } diff --git a/src/queueOpen.c b/src/queueOpen.c index 514a620..b0453a8 100644 --- a/src/queueOpen.c +++ b/src/queueOpen.c @@ -1,29 +1,27 @@ #include "libnazgul.h" #include "ids.h" -void * msgQueueOpen(msgQueueId queueId){ - int queueFd; - void * queueAddr; +void *msgQueueOpen(msgQueueId queueId) +{ + int queueFd; + void *queueAddr; - queueFd=shm_open(queueId,O_RDWR,SHM_DEFAULT_MODE); - if (queueFd == -1 ) { - NZG_ERROR("shm_open : msgQueue open",queueId); - goto ERROR; - } + queueFd = shm_open(queueId, O_RDWR, SHM_DEFAULT_MODE); + if (queueFd == -1) { + NZG_ERROR("shm_open : msgQueue open", queueId); + goto ERROR; + } - queueAddr=mmap(NULL, - sizeof(msgQueue), - PROT_READ|PROT_WRITE, - MAP_SHARED, - queueFd, - 0); - if( queueAddr == MAP_FAILED ) { - NZG_ERROR("mmap",queueId); - goto ERROR; - } + queueAddr = mmap(NULL, + sizeof(msgQueue), + PROT_READ | PROT_WRITE, MAP_SHARED, queueFd, 0); + if (queueAddr == MAP_FAILED) { + NZG_ERROR("mmap", queueId); + goto ERROR; + } - close(queueFd); - return queueAddr; -ERROR: - return NULL; + close(queueFd); + return queueAddr; + ERROR: + return NULL; } diff --git a/src/queueProtLock.c b/src/queueProtLock.c index 7ff7a18..11d1133 100644 --- a/src/queueProtLock.c +++ b/src/queueProtLock.c @@ -2,32 +2,36 @@ #include "ids.h" #define DEBUG 0 -int msgQueueProtLock(msgSpaceId externId,int queueIdx){ - int semval; - sem_t * queueSemFd; - msgQueueSemId queueSemId; +int msgQueueProtLock(msgSpaceId externId, int queueIdx) +{ + int semval; + sem_t *queueSemFd; + msgQueueSemId queueSemId; - msgQueueProtSemIdIntern(queueSemId,externId,queueIdx); - if (DEBUG) { printf("Locking %s\n",queueSemId);} - queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1); - if(queueSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",queueSemId); - goto ERROR; - } + msgQueueProtSemIdIntern(queueSemId, externId, queueIdx); + if (DEBUG) { + printf("Locking %s\n", queueSemId); + } + queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1); + if (queueSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", queueSemId); + goto ERROR; + } - if(sem_wait(queueSemFd)==-1){ - NZG_ERROR("sem_wait",queueSemId); - goto ERROR; - } - semval=0; - sem_getvalue(queueSemFd,&semval); - if (DEBUG) { printf("(AfterValue:%d)\n",semval); } + if (sem_wait(queueSemFd) == -1) { + NZG_ERROR("sem_wait", queueSemId); + goto ERROR; + } + semval = 0; + sem_getvalue(queueSemFd, &semval); + if (DEBUG) { + printf("(AfterValue:%d)\n", semval); + } - sem_close(queueSemFd); - sem_close(queueSemFd); + sem_close(queueSemFd); + sem_close(queueSemFd); - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; } - diff --git a/src/queueProtUnlock.c b/src/queueProtUnlock.c index 89673cb..58f7f4b 100644 --- a/src/queueProtUnlock.c +++ b/src/queueProtUnlock.c @@ -3,32 +3,36 @@ #define DEBUG 0 -int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){ - int semval; - sem_t * queueSemFd; - msgQueueSemId queueSemId; +int msgQueueProtUnlock(msgSpaceId externId, int queueIdx) +{ + int semval; + sem_t *queueSemFd; + msgQueueSemId queueSemId; - msgQueueProtSemIdIntern(queueSemId,externId,queueIdx); - if (DEBUG) { printf("Unlocking %s\n",queueSemId); } + msgQueueProtSemIdIntern(queueSemId, externId, queueIdx); + if (DEBUG) { + printf("Unlocking %s\n", queueSemId); + } - queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1); - if(queueSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",queueSemId); - goto ERROR; - } + queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1); + if (queueSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", queueSemId); + goto ERROR; + } - if(sem_post(queueSemFd)==-1){ - NZG_ERROR("sem_post",queueSemId); - goto ERROR; - } - semval=0; - sem_getvalue(queueSemFd,&semval); - if (DEBUG) { printf("(AfterValue:%d)\n",semval); } + if (sem_post(queueSemFd) == -1) { + NZG_ERROR("sem_post", queueSemId); + goto ERROR; + } + semval = 0; + sem_getvalue(queueSemFd, &semval); + if (DEBUG) { + printf("(AfterValue:%d)\n", semval); + } - sem_close(queueSemFd); + sem_close(queueSemFd); - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; } - diff --git a/src/queueReadLock.c b/src/queueReadLock.c index 16e1653..7f44b11 100644 --- a/src/queueReadLock.c +++ b/src/queueReadLock.c @@ -3,31 +3,35 @@ #define DEBUG 0 -int msgQueueReadLock(msgSpaceId externId,int queueIdx){ - int semval; - sem_t * queueSemFd; - msgQueueSemId queueSemId; +int msgQueueReadLock(msgSpaceId externId, int queueIdx) +{ + int semval; + sem_t *queueSemFd; + msgQueueSemId queueSemId; - msgQueueReadSemIdIntern(queueSemId,externId,queueIdx); - if (DEBUG) { printf("Locking %s\n",queueSemId); } - queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1); - if(queueSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",queueSemId); - goto ERROR; - } + msgQueueReadSemIdIntern(queueSemId, externId, queueIdx); + if (DEBUG) { + printf("Locking %s\n", queueSemId); + } + queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1); + if (queueSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", queueSemId); + goto ERROR; + } - if(sem_wait(queueSemFd)==-1){ - NZG_ERROR("sem_wait",queueSemId); - goto ERROR; - } - semval=0; - sem_getvalue(queueSemFd,&semval); - if (DEBUG) { printf("(AfterValue:%d)\n",semval); } + if (sem_wait(queueSemFd) == -1) { + NZG_ERROR("sem_wait", queueSemId); + goto ERROR; + } + semval = 0; + sem_getvalue(queueSemFd, &semval); + if (DEBUG) { + printf("(AfterValue:%d)\n", semval); + } - sem_close(queueSemFd); + sem_close(queueSemFd); - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; } - diff --git a/src/queueReadTryLock.c b/src/queueReadTryLock.c index f2dc629..26784d9 100644 --- a/src/queueReadTryLock.c +++ b/src/queueReadTryLock.c @@ -3,31 +3,35 @@ #define DEBUG 0 -int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){ - int semval; - sem_t * queueSemFd; - msgQueueSemId queueSemId; +int msgQueueReadTryLock(msgSpaceId externId, int queueIdx) +{ + int semval; + sem_t *queueSemFd; + msgQueueSemId queueSemId; - msgQueueReadSemIdIntern(queueSemId,externId,queueIdx); - queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1); - if(queueSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",queueSemId); - goto ERROR; - } + msgQueueReadSemIdIntern(queueSemId, externId, queueIdx); + queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1); + if (queueSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", queueSemId); + goto ERROR; + } - if(sem_trywait(queueSemFd)==-1){ - NZG_ERROR("sem_wait",queueSemId); - goto ERROR; - } - if (DEBUG) { printf("Locking %s\n",queueSemId); } - semval=0; - sem_getvalue(queueSemFd,&semval); - if (DEBUG) { printf("(AfterValue:%d)\n",semval); } + if (sem_trywait(queueSemFd) == -1) { + NZG_ERROR("sem_wait", queueSemId); + goto ERROR; + } + if (DEBUG) { + printf("Locking %s\n", queueSemId); + } + semval = 0; + sem_getvalue(queueSemFd, &semval); + if (DEBUG) { + printf("(AfterValue:%d)\n", semval); + } - sem_close(queueSemFd); + sem_close(queueSemFd); - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; } - diff --git a/src/queueReadUnlock.c b/src/queueReadUnlock.c index 5e4fb32..1cad3bd 100644 --- a/src/queueReadUnlock.c +++ b/src/queueReadUnlock.c @@ -3,32 +3,35 @@ #define DEBUG 0 -int msgQueueReadUnlock(msgSpaceId externId,int queueIdx){ - int semval; - sem_t * queueSemFd; - msgQueueSemId queueSemId; +int msgQueueReadUnlock(msgSpaceId externId, int queueIdx) +{ + int semval; + sem_t *queueSemFd; + msgQueueSemId queueSemId; - msgQueueReadSemIdIntern(queueSemId,externId,queueIdx); - if (DEBUG) { printf("Unlocking %s\n",queueSemId); } - queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1); - if(queueSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",queueSemId); - goto ERROR; - } + msgQueueReadSemIdIntern(queueSemId, externId, queueIdx); + if (DEBUG) { + printf("Unlocking %s\n", queueSemId); + } + queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1); + if (queueSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", queueSemId); + goto ERROR; + } - if(sem_post(queueSemFd)==-1){ - NZG_ERROR("sem_post",queueSemId); - goto ERROR; - } - semval=0; - sem_getvalue(queueSemFd,&semval); - if (DEBUG) { printf("(AfterValue:%d)\n",semval); } + if (sem_post(queueSemFd) == -1) { + NZG_ERROR("sem_post", queueSemId); + goto ERROR; + } + semval = 0; + sem_getvalue(queueSemFd, &semval); + if (DEBUG) { + printf("(AfterValue:%d)\n", semval); + } + sem_close(queueSemFd); - sem_close(queueSemFd); - - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; } - diff --git a/src/queueRem.c b/src/queueRem.c index ff62839..84d03e0 100644 --- a/src/queueRem.c +++ b/src/queueRem.c @@ -2,37 +2,36 @@ // l'id de l'element enlevé vas dans oldElemId -int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId){ - msgQueueElem * queueOldHeadElem; +int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId) +{ + msgQueueElem *queueOldHeadElem; - - if (strcmp(queue->headId,queue->id)==0){ - NZG_ERROR("msgQueueElemRem : Empty queue",queue->id); - goto ERROR; - } - strcpy(oldElemId,queue->headId); + if (strcmp(queue->headId, queue->id) == 0) { + NZG_ERROR("msgQueueElemRem : Empty queue", queue->id); + goto ERROR; + } + strcpy(oldElemId, queue->headId); - queueOldHeadElem=msgQueueElemOpen(oldElemId); - if (queueOldHeadElem == NULL){ - NZG_ERROR("msgQueueElemOpen",oldElemId); - goto ERROR; - } + queueOldHeadElem = msgQueueElemOpen(oldElemId); + if (queueOldHeadElem == NULL) { + NZG_ERROR("msgQueueElemOpen", oldElemId); + goto ERROR; + } + // on indique à la queue le nouveau premier element + strcpy(queue->headId, queueOldHeadElem->next); + if (strcmp(queueOldHeadElem->next, oldElemId) == 0) { + strcpy(queue->headId, queue->id); + } + // on fait en sorte que l'element ne connaisse plus + // ses voisins (utile pour le Delete) + strcpy(queueOldHeadElem->next, queueOldHeadElem->id); - // on indique à la queue le nouveau premier element - strcpy(queue->headId,queueOldHeadElem->next); - if (strcmp(queueOldHeadElem->next,oldElemId)==0){ - strcpy(queue->headId,queue->id); - } - // on fait en sorte que l'element ne connaisse plus - // ses voisins (utile pour le Delete) - strcpy(queueOldHeadElem->next,queueOldHeadElem->id); + if (msgQueueElemClose(queueOldHeadElem) < 0) { + NZG_ERROR("msgQueueElemClose", oldElemId); + goto ERROR; - if (msgQueueElemClose(queueOldHeadElem)<0 ){ - NZG_ERROR("msgQueueElemClose",oldElemId); - goto ERROR; - - } - return 0; -ERROR: - return -1; + } + return 0; + ERROR: + return -1; } diff --git a/src/spaceClose.c b/src/spaceClose.c index 7470009..e8e2ad5 100644 --- a/src/spaceClose.c +++ b/src/spaceClose.c @@ -1,15 +1,16 @@ #include "libnazgul.h" -int msgSpaceClose(msgSpace * space){ - msgSpaceId spaceId; - strcpy(spaceId,space->id); +int msgSpaceClose(msgSpace * space) +{ + msgSpaceId spaceId; + strcpy(spaceId, space->id); - if (munmap(space,sizeof(msgSpace)) < 0){ - NZG_ERROR("unmap",spaceId); - goto ERROR; - } + if (munmap(space, sizeof(msgSpace)) < 0) { + NZG_ERROR("unmap", spaceId); + goto ERROR; + } - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; } diff --git a/src/spaceCreate.c b/src/spaceCreate.c index 9201177..2588a4b 100644 --- a/src/spaceCreate.c +++ b/src/spaceCreate.c @@ -2,10 +2,10 @@ #include "ids.h" /* prototypes des fonctions annexes à ne pas exporter */ -int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src ); -int msgPoolDataIdIntern(msgSpaceId dest,const msgSpaceId src ); -int msgPoolDataTabSemIdIntern( - msgPoolSemId destSemId,const msgSpaceId externId); +int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src); +int msgPoolDataIdIntern(msgSpaceId dest, const msgSpaceId src); +int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, + const msgSpaceId externId); /* * spaceId : identifiant externe de l'espace de msg * queueNb : nombre de files de messages @@ -13,185 +13,185 @@ int msgPoolDataTabSemIdIntern( * queueNbCar : tableau de caracteristiques des different pool */ -msgSpace * msgSpaceCreate( - msgSpaceId externId, - int queueNb, - int poolNb, - msgPool * poolInfos ){ - msgSpaceId nzgId; - /* msgSpaceList mSList; */ - int mSFd; // shm file descriptor - int i; - int err; - static int mSIdNum=-1; - msgSpace * space; - msgSpaceListElemId listElemId; +msgSpace *msgSpaceCreate(msgSpaceId externId, + int queueNb, int poolNb, msgPool * poolInfos) +{ + msgSpaceId nzgId; + /* msgSpaceList mSList; */ + int mSFd; // shm file descriptor + int i; + int err; + static int mSIdNum = -1; + msgSpace *space; + msgSpaceListElemId listElemId; - msgPoolDataTabId poolDataTabId; - msgPoolData * poolDataTabAddr; - msgBufferInfoTabId bufferInfoTabId; - msgPoolId poolId; - sem_t * mSDataTabSemFd; + msgPoolDataTabId poolDataTabId; + msgPoolData *poolDataTabAddr; + msgBufferInfoTabId bufferInfoTabId; + msgPoolId poolId; + sem_t *mSDataTabSemFd; - mSIdNum++; - space=NULL; + mSIdNum++; + space = NULL; /** recuperation de la liste des msgSpace **/ - /* (creation si elle n'existe pas */ + /* (creation si elle n'existe pas */ /** on créee le nouvel element **/ - printf("PAGESIZE : %d\n",(int)PAGESIZE); - if (msgSpaceIdIntern(nzgId,externId) < 0){ - return NULL; - } + printf("PAGESIZE : %d\n", (int)PAGESIZE); + if (msgSpaceIdIntern(nzgId, externId) < 0) { + return NULL; + } - if (msgSpaceListInit() <0){ - NZG_ERROR("msgSpaceListInit",nzgId); - goto ERROR; - }; - if (msgSpaceListLock() <0){ - NZG_ERROR("msgSpaceListLock",""); - goto ERROR; - } - if ((err=msgSpaceListFindId(externId)) < 1){ - if (err==0){ - // soit le msgSpace existe deja - NZG_ERROR("spaceListFindId : existing ",nzgId); + if (msgSpaceListInit() < 0) { + NZG_ERROR("msgSpaceListInit", nzgId); + goto ERROR; + }; + if (msgSpaceListLock() < 0) { + NZG_ERROR("msgSpaceListLock", ""); + goto ERROR; + } + if ((err = msgSpaceListFindId(externId)) < 1) { + if (err == 0) { + // soit le msgSpace existe deja + NZG_ERROR("spaceListFindId : existing ", nzgId); + } else { + // zut, il y a soit une erreur + NZG_ERROR("spaceListFindId : error ", nzgId); + } + msgSpaceListUnlock(); + // on quitte + goto ERROR; + } + printf("spaceListFind ok\n"); + if (msgSpaceListUnlock() < 0) { + NZG_ERROR("msgSpaceListUnlock", ""); + goto ERROR; + } + printf("spaceListUnlock ok\n"); + + fprintf(stderr, "Creating msgSpace with id : %s\n", nzgId); + mSFd = shm_open(nzgId, + O_RDWR | O_CREAT | O_EXCL | O_TRUNC, + MSGSPACE_DEFAULT_MODE); + if (mSFd == -1) { + NZG_ERROR("shm_open : msgSpace creation", nzgId); + goto ERROR; + } + + /* on redimentionne l'element */ + if (ftruncate(mSFd, sizeof(*space)) == -1) { + NZG_ERROR("ftruncate", nzgId); + goto ERROR; + } + + /* Map the memory object */ + space = mmap(0, sizeof(*space), + PROT_READ | PROT_WRITE, MAP_SHARED, mSFd, 0); + if (space == MAP_FAILED) { + NZG_ERROR("mmap", nzgId); + goto ERROR; + } + + printf("CREAT: msgSpace mapped to 0x%08lx in %d\n", (long)space, + (int)getpid()); + + /* on ferme le descripteur du fichier */ + close(mSFd); + + /* on remplit la structure */ + strcpy(space->id, nzgId); + space->poolNb = poolNb; + space->queueNb = queueNb; + space->pid = getpid(); + msgPoolDataTabSemIdIntern(space->poolDataTabSemId, externId); + /* creation du poolData */ + msgPoolDataIdIntern(poolDataTabId, externId); + strcpy(space->poolDataTabId, poolDataTabId); + strcpy(space->externId, externId); + + mSDataTabSemFd = sem_open(space->poolDataTabSemId, + O_CREAT | O_EXCL, SEM_DEFAULT_MODE, 0); + if (mSDataTabSemFd == SEM_FAILED) { + NZG_ERROR("sem_open : creation de la ressource", + space->poolDataTabSemId); + goto ERROR; } else { - // zut, il y a soit une erreur - NZG_ERROR("spaceListFindId : error ",nzgId); + /* NZG_ERROR("sem_open : creation oki", + space->poolDataTabSemId); */ } + sem_close(mSDataTabSemFd); + + /* attacher le tableau des msgPoolData */ + poolDataTabAddr = msgPoolDataTabCreate(space); + if (poolDataTabAddr == NULL) { + NZG_ERROR("msgPoolDataTabCreate", space->poolDataTabId); + goto ERROR; + } + + for (i = 0; i < poolNb; i++) { + /* Pour chacun des poolData + * - y écrire les informations passées en param + * - creer les zones mémoires de chacune des pool + */ + // creation d'une pool + poolDataTabAddr[i].bufferNb = poolInfos[i].bufferNb; + poolDataTabAddr[i].bufferSize = poolInfos[i].bufferSize; + poolDataTabAddr[i].allocDispBuffer = 0; + + if (msgBufferInfoTabIdIntern(bufferInfoTabId, externId, i) == + -1) { + fprintf(stderr, + "msgBufferInfoTabId creation failed for id %s\n", + (char *)poolId); + return NULL; + } + strcpy(poolDataTabAddr[i].bufferInfoTabId, bufferInfoTabId); + printf("buffIfoTab %d name : %s\n", i, + poolDataTabAddr[i].bufferInfoTabId); + msgBufferInfoTabCreate(externId, poolDataTabAddr, i, + poolInfos[i].bufferNb); + + if (msgPoolIdIntern(poolId, externId, i) == -1) { + fprintf(stderr, "msgPoolId creation failed for id %s\n", + (char *)poolId); + return NULL; + } + strcpy(poolDataTabAddr[i].poolId, poolId); + msgPoolCreate(externId, i, poolInfos[i].bufferNb, + poolInfos[i].bufferSize); + + } + + /* on crée queueNb files de messages */ + printf("Creating queues:\n"); + for (i = 0; i < queueNb; i++) { + printf("- queue %i...", i); + fflush(stdout); + if (msgQueueInit(space->externId, i) < 0) { + printf("fail.\n"); + NZG_ERROR("msgQueueInit : queue ?? for", + space->externId); + goto ERROR; + } + printf("ok.\n"); + } + msgPoolDataTabClose(space, poolDataTabAddr); + /* on ajoute spaceId a la liste des msgSpace connus */ + printf("spaceListInit...\n"); + + printf("ok\n"); + msgSpaceListLock(); + printf("spaceListLock...ok\n"); + msgSpaceListElemCreate(listElemId, space); + printf("spaceListElemCreate...ok\n"); + msgSpaceListAdd(listElemId); + printf("spaceListAdd...ok\n"); msgSpaceListUnlock(); - // on quitte - goto ERROR; - } - printf("spaceListFind ok\n"); - if (msgSpaceListUnlock() < 0){ - NZG_ERROR("msgSpaceListUnlock",""); - goto ERROR; - } - printf("spaceListUnlock ok\n"); + printf("spaceListUnlock...ok\n"); - fprintf(stderr,"Creating msgSpace with id : %s\n",nzgId); - mSFd=shm_open( - nzgId, - O_RDWR|O_CREAT|O_EXCL|O_TRUNC, - MSGSPACE_DEFAULT_MODE - ); - if (mSFd == -1 ) { - NZG_ERROR("shm_open : msgSpace creation",nzgId); - goto ERROR; - } - - /* on redimentionne l'element */ - if (ftruncate(mSFd, sizeof(* space)) == -1){ - NZG_ERROR("ftruncate",nzgId); - goto ERROR; - } - - /* Map the memory object */ - space = mmap( 0, sizeof( *space ), - PROT_READ | PROT_WRITE, - MAP_SHARED, mSFd, 0 ); - if( space == MAP_FAILED ) { - NZG_ERROR("mmap",nzgId); - goto ERROR; - } - - printf( "CREAT: msgSpace mapped to 0x%08lx in %d\n", (long)space,(int)getpid()); - - /* on ferme le descripteur du fichier */ - close(mSFd); - - /* on remplit la structure */ - strcpy(space->id,nzgId); - space->poolNb=poolNb; - space->queueNb=queueNb; - space->pid=getpid(); - msgPoolDataTabSemIdIntern(space->poolDataTabSemId,externId); - /* creation du poolData */ - msgPoolDataIdIntern(poolDataTabId,externId); - strcpy(space->poolDataTabId,poolDataTabId); - strcpy(space->externId,externId); - - mSDataTabSemFd=sem_open(space->poolDataTabSemId, - O_CREAT|O_EXCL,SEM_DEFAULT_MODE,0); - if (mSDataTabSemFd == SEM_FAILED){ - NZG_ERROR("sem_open : creation de la ressource", - space->poolDataTabSemId); - goto ERROR; - } else { - /* NZG_ERROR("sem_open : creation oki", - space->poolDataTabSemId); */ - } - sem_close(mSDataTabSemFd); - - /* attacher le tableau des msgPoolData */ - poolDataTabAddr=msgPoolDataTabCreate(space); - if (poolDataTabAddr == NULL){ - NZG_ERROR("msgPoolDataTabCreate",space->poolDataTabId); - goto ERROR; - } - - for (i=0;iexternId,i) < 0){ - printf("fail.\n"); - NZG_ERROR("msgQueueInit : queue ?? for",space->externId); - goto ERROR; - } - printf("ok.\n"); - } - msgPoolDataTabClose(space,poolDataTabAddr); - /* on ajoute spaceId a la liste des msgSpace connus */ - printf("spaceListInit...\n"); - - printf("ok\n"); - msgSpaceListLock(); - printf("spaceListLock...ok\n"); - msgSpaceListElemCreate(listElemId,space); - printf("spaceListElemCreate...ok\n"); - msgSpaceListAdd(listElemId); - printf("spaceListAdd...ok\n"); - msgSpaceListUnlock(); - printf("spaceListUnlock...ok\n"); - - /* on renvoie un pointeur sur le bon spaceId */ - msgPoolDataTabUnlock(space); - return space; -ERROR: - return NULL; + /* on renvoie un pointeur sur le bon spaceId */ + msgPoolDataTabUnlock(space); + return space; + ERROR: + return NULL; } - - - diff --git a/src/spaceDelete.c b/src/spaceDelete.c index 5a40cae..b09cb02 100644 --- a/src/spaceDelete.c +++ b/src/spaceDelete.c @@ -2,66 +2,66 @@ #include "ids.h" /* prototypes des fonctions annexes à ne pas exporter */ -int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src ); -int msgPoolDataIdIntern(msgSpaceId dest,const msgSpaceId src ); -int msgPoolDataTabSemIdIntern( - msgPoolSemId destSemId,const msgSpaceId externId); +int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src); +int msgPoolDataIdIntern(msgSpaceId dest, const msgSpaceId src); +int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, + const msgSpaceId externId); -int msgSpaceDelete(msgSpaceId externId){ - //int shmId; - msgSpaceId nzgId; - msgSpace * space; - int i; - fprintf(stderr,"Deleting msgSpace with id : %s\n",externId); - if (msgSpaceIdIntern(nzgId,externId) == -1){ - NZG_ERROR("msgSpaceIdIntern",externId); - goto ERROR; - } +int msgSpaceDelete(msgSpaceId externId) +{ + //int shmId; + msgSpaceId nzgId; + msgSpace *space; + int i; + fprintf(stderr, "Deleting msgSpace with id : %s\n", externId); + if (msgSpaceIdIntern(nzgId, externId) == -1) { + NZG_ERROR("msgSpaceIdIntern", externId); + goto ERROR; + } - space = msgSpaceOpen(externId); - /* supprimer chaque pool */ - for (i=0;ipoolNb;i++){ - msgPoolDelete(externId,i); - } + space = msgSpaceOpen(externId); + /* supprimer chaque pool */ + for (i = 0; i < space->poolNb; i++) { + msgPoolDelete(externId, i); + } - /* supprimer chaque queue */ - for (i=0;iqueueNb;i++){ - msgQueueDelete(externId,i); - } - printf("openned successfully !\n"); - printf("Unlinking DataTab... "); - if (shm_unlink(space->poolDataTabId) < 0){ - perror("shm_unlink"); + /* supprimer chaque queue */ + for (i = 0; i < space->queueNb; i++) { + msgQueueDelete(externId, i); + } + printf("openned successfully !\n"); + printf("Unlinking DataTab... "); + if (shm_unlink(space->poolDataTabId) < 0) { + perror("shm_unlink"); + return -1; + } + printf("ok\n"); + + printf("Unlinking DataTabSem... "); + if (sem_unlink(space->poolDataTabSemId) < 0) { + NZG_ERROR("sem_unlink", space->poolDataTabSemId); + return -1; + } + printf("ok\n"); + + if (shm_unlink(nzgId) < 0) { + NZG_ERROR("shm_unlink", nzgId); + goto ERROR; + }; + if (msgSpaceListLock() < 0) { + NZG_ERROR("msgSpaceListLock", ""); + goto ERROR; + } + + if (msgSpaceListRem(nzgId) < 0) { + NZG_ERROR("msgSpaceListRem", nzgId); + goto ERROR; + } + if (msgSpaceListUnlock() < 0) { + NZG_ERROR("msgSpaceListUnlock", ""); + goto ERROR; + } + return 0; + ERROR: return -1; - } - printf("ok\n"); - - printf("Unlinking DataTabSem... "); - if (sem_unlink(space->poolDataTabSemId) < 0){ - NZG_ERROR("sem_unlink",space->poolDataTabSemId); - return -1; - } - printf("ok\n"); - - if (shm_unlink(nzgId)<0){ - NZG_ERROR("shm_unlink",nzgId); - goto ERROR; - }; - if (msgSpaceListLock()<0){ - NZG_ERROR("msgSpaceListLock",""); - goto ERROR; - } - - if (msgSpaceListRem(nzgId) < 0){ - NZG_ERROR("msgSpaceListRem",nzgId); - goto ERROR; - } - if (msgSpaceListUnlock()< 0){ - NZG_ERROR("msgSpaceListUnlock",""); - goto ERROR; - } - return 0; -ERROR: - return -1; } - diff --git a/src/spaceListAdd.c b/src/spaceListAdd.c index 3addfb5..ca6187b 100644 --- a/src/spaceListAdd.c +++ b/src/spaceListAdd.c @@ -3,54 +3,55 @@ // ajoute un element en début de liste. // fait pointer l'ancien dernier vers lui // il s'enregistre en tant que dernier chez la liste -int msgSpaceListAdd(msgSpaceListElemId newElemId){ - msgSpaceListElem * listOldTailElem; - msgSpaceListElem * listNewTailElem; - msgSpaceList * list; +int msgSpaceListAdd(msgSpaceListElemId newElemId) +{ + msgSpaceListElem *listOldTailElem; + msgSpaceListElem *listNewTailElem; + msgSpaceList *list; - list=msgSpaceListOpen(); - if (list == NULL){ - NZG_ERROR("msgSpaceListOpen",""); - goto ERROR; + list = msgSpaceListOpen(); + if (list == NULL) { + NZG_ERROR("msgSpaceListOpen", ""); + goto ERROR; } // on informe l'element qui est le dernier - listNewTailElem=msgSpaceListElemOpen(newElemId); - if (listNewTailElem==NULL){ - NZG_ERROR("msgSpaceListElemOpen",newElemId); - goto ERROR; + listNewTailElem = msgSpaceListElemOpen(newElemId); + if (listNewTailElem == NULL) { + NZG_ERROR("msgSpaceListElemOpen", newElemId); + goto ERROR; + } + strcpy(listNewTailElem->next, newElemId); + if (msgSpaceListElemClose(listNewTailElem) < 0) { + NZG_ERROR("msgSpaceListElemClose", newElemId); + goto ERROR; } - strcpy(listNewTailElem->next,newElemId); - if (msgSpaceListElemClose(listNewTailElem) <0 ){ - NZG_ERROR("msgSpaceListElemClose",newElemId); - goto ERROR; - } /* verifier si la liste n'est pas vide... */ - if((strcmp(list->headId,list->id)==0) - && (strcmp(list->tailId,list->id)==0)) { - printf("- premier elem de spaceList -\n"); - // on donne a la queue l'id de l'element - strcpy(list->headId,newElemId); - strcpy(list->tailId,newElemId); + if ((strcmp(list->headId, list->id) == 0) + && (strcmp(list->tailId, list->id) == 0)) { + printf("- premier elem de spaceList -\n"); + // on donne a la queue l'id de l'element + strcpy(list->headId, newElemId); + strcpy(list->tailId, newElemId); } else { - /* on informe son prédecesseur qu'il a un suivant */ - listOldTailElem=msgSpaceListElemOpen(list->tailId); - if (listOldTailElem == NULL){ - NZG_ERROR("msgSpaceListElemOpen",list->tailId); - goto ERROR; - } - strcpy(listOldTailElem->next,newElemId); - if (msgSpaceListElemClose(listOldTailElem) < 0){ - NZG_ERROR("msgSpaceListElemClose",list->tailId); - goto ERROR; - } - // on donne a la queue l'id du dernier element - strcpy(list->tailId,newElemId); + /* on informe son prédecesseur qu'il a un suivant */ + listOldTailElem = msgSpaceListElemOpen(list->tailId); + if (listOldTailElem == NULL) { + NZG_ERROR("msgSpaceListElemOpen", list->tailId); + goto ERROR; + } + strcpy(listOldTailElem->next, newElemId); + if (msgSpaceListElemClose(listOldTailElem) < 0) { + NZG_ERROR("msgSpaceListElemClose", list->tailId); + goto ERROR; + } + // on donne a la queue l'id du dernier element + strcpy(list->tailId, newElemId); } // on incremente elemCounter msgSpaceListClose(list); return 0; -ERROR: + ERROR: return -1; } diff --git a/src/spaceListClose.c b/src/spaceListClose.c index 64864df..043447a 100644 --- a/src/spaceListClose.c +++ b/src/spaceListClose.c @@ -1,17 +1,18 @@ #include "libnazgul.h" #include "ids.h" -int msgSpaceListClose(msgSpaceList * list){ - - msgSpaceListId spaceListId; - strcpy(spaceListId,DEFAULT_MSGSPACELISTID); +int msgSpaceListClose(msgSpaceList * list) +{ - if (munmap(list,sizeof(msgSpaceList)) < 0){ - NZG_ERROR("unmap",spaceListId); - goto ERROR; - } + msgSpaceListId spaceListId; + strcpy(spaceListId, DEFAULT_MSGSPACELISTID); - return 0; -ERROR: - return -1; + if (munmap(list, sizeof(msgSpaceList)) < 0) { + NZG_ERROR("unmap", spaceListId); + goto ERROR; + } + + return 0; + ERROR: + return -1; } diff --git a/src/spaceListElemClose.c b/src/spaceListElemClose.c index 97fabeb..85bbe0f 100644 --- a/src/spaceListElemClose.c +++ b/src/spaceListElemClose.c @@ -4,15 +4,15 @@ int msgSpaceListElemClose(msgSpaceListElem * listElem) { - msgSpaceListElemId eId; - strcpy(eId,listElem->id); + msgSpaceListElemId eId; + strcpy(eId, listElem->id); - if (munmap(listElem,sizeof(msgSpaceListElem)) < 0){ - NZG_ERROR("unmap",eId); - goto ERROR; - } + if (munmap(listElem, sizeof(msgSpaceListElem)) < 0) { + NZG_ERROR("unmap", eId); + goto ERROR; + } - return 0; -ERROR: - return-1; + return 0; + ERROR: + return -1; }; diff --git a/src/spaceListElemCreate.c b/src/spaceListElemCreate.c index fa726ac..c585c38 100644 --- a/src/spaceListElemCreate.c +++ b/src/spaceListElemCreate.c @@ -2,47 +2,43 @@ #include "ids.h" // cree un nouvel elemen -int msgSpaceListElemCreate( - msgSpaceListElemId listElemId, - msgSpace * space) +int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace * space) { - int listElemFd; - msgSpaceListElem * listElem; - msgSpaceListElemIdIntern(listElemId,space->externId); + int listElemFd; + msgSpaceListElem *listElem; + msgSpaceListElemIdIntern(listElemId, space->externId); - listElemFd=shm_open(listElemId, - O_RDWR|O_CREAT|O_EXCL|O_TRUNC, - SHM_DEFAULT_MODE); + listElemFd = shm_open(listElemId, + O_RDWR | O_CREAT | O_EXCL | O_TRUNC, + SHM_DEFAULT_MODE); - if (listElemFd == -1 ) { - NZG_ERROR("shm_open : msgSpaceListElem creation",listElemId); - goto ERROR; - } + if (listElemFd == -1) { + NZG_ERROR("shm_open : msgSpaceListElem creation", listElemId); + goto ERROR; + } - if (ftruncate(listElemFd, sizeof(msgSpaceListElem)) < 0){ - NZG_ERROR("ftruncate", listElemId); - goto ERROR; - } + if (ftruncate(listElemFd, sizeof(msgSpaceListElem)) < 0) { + NZG_ERROR("ftruncate", listElemId); + goto ERROR; + } - close(listElemFd); - listElem=msgSpaceListElemOpen(listElemId); - if (listElem ==NULL){ - NZG_ERROR("msgSpaceListElemOpen",listElemId); - goto ERROR; - } - strcpy(listElem->id,listElemId); - strcpy(listElem->next,listElemId); - strcpy(listElem->spaceId,space->id); - printf("[ ListElem : id %s,next: %s, Sid: %s ]\n", - listElem->id, - listElem->next, - listElem->spaceId); - if (msgSpaceListElemClose(listElem) <0){ - NZG_ERROR("msgSpaceListElemClose",listElemId); - } - return 0; -ERROR: - return -1; + close(listElemFd); + listElem = msgSpaceListElemOpen(listElemId); + if (listElem == NULL) { + NZG_ERROR("msgSpaceListElemOpen", listElemId); + goto ERROR; + } + strcpy(listElem->id, listElemId); + strcpy(listElem->next, listElemId); + strcpy(listElem->spaceId, space->id); + printf("[ ListElem : id %s,next: %s, Sid: %s ]\n", + listElem->id, listElem->next, listElem->spaceId); + if (msgSpaceListElemClose(listElem) < 0) { + NZG_ERROR("msgSpaceListElemClose", listElemId); + } + return 0; + ERROR: + return -1; }; diff --git a/src/spaceListElemLink.c b/src/spaceListElemLink.c index cac4549..2078348 100644 --- a/src/spaceListElemLink.c +++ b/src/spaceListElemLink.c @@ -2,6 +2,5 @@ // modifie l'element suivant de l'element choisi // et le fait pointer sur un nouvel ID -int msgSpaceListElemLinkNext(msgSpaceListElemId current,msgSpaceListElemId next); - - +int msgSpaceListElemLinkNext(msgSpaceListElemId current, + msgSpaceListElemId next); diff --git a/src/spaceListElemOpen.c b/src/spaceListElemOpen.c index 6e461bf..f5bd65f 100644 --- a/src/spaceListElemOpen.c +++ b/src/spaceListElemOpen.c @@ -2,32 +2,29 @@ #include "ids.h" // cree un nouvel elemen -void * msgSpaceListElemOpen(msgSpaceListElemId listElemId){ - int listElemFd; - void * listElemAddr; +void *msgSpaceListElemOpen(msgSpaceListElemId listElemId) +{ + int listElemFd; + void *listElemAddr; - listElemFd=shm_open(listElemId,O_RDWR,SHM_DEFAULT_MODE); - if (listElemFd == -1 ) { - NZG_ERROR("shm_open : msgSpaceListElem open",listElemId); - goto ERROR; - } + listElemFd = shm_open(listElemId, O_RDWR, SHM_DEFAULT_MODE); + if (listElemFd == -1) { + NZG_ERROR("shm_open : msgSpaceListElem open", listElemId); + goto ERROR; + } - listElemAddr=mmap(NULL, - sizeof(msgQueueElem), - PROT_READ|PROT_WRITE, - MAP_SHARED, - listElemFd, - 0); + listElemAddr = mmap(NULL, + sizeof(msgQueueElem), + PROT_READ | PROT_WRITE, MAP_SHARED, listElemFd, 0); - if( listElemAddr == MAP_FAILED ) { - NZG_ERROR("mmap",listElemId); - goto ERROR; - } - - close(listElemFd); - return listElemAddr; -ERROR: - return NULL; + if (listElemAddr == MAP_FAILED) { + NZG_ERROR("mmap", listElemId); + goto ERROR; + } + close(listElemFd); + return listElemAddr; + ERROR: + return NULL; }; diff --git a/src/spaceListFindId.c b/src/spaceListFindId.c index 312530c..497d586 100644 --- a/src/spaceListFindId.c +++ b/src/spaceListFindId.c @@ -2,78 +2,84 @@ #define DEBUG 1 -int msgSpaceListFindId(msgSpaceId externId){ - msgSpaceList * list; - msgSpaceId spaceId; - msgSpaceListElemId listHeadElemId; - msgSpaceListElemId listTailElemId; - msgSpaceListId listId; +int msgSpaceListFindId(msgSpaceId externId) +{ + msgSpaceList *list; + msgSpaceId spaceId; + msgSpaceListElemId listHeadElemId; + msgSpaceListElemId listTailElemId; + msgSpaceListId listId; - msgSpaceIdIntern(spaceId,externId); - list=msgSpaceListOpen(); - if (list==NULL){ - NZG_ERROR("msgSpaceListOpen",""); - goto ERROR; - } - if (DEBUG) { printf("Before ListStrCpy\n"); } - strcpy(listHeadElemId,list->headId); - strcpy(listTailElemId,list->tailId); - strcpy(listId,list->id); - if (DEBUG) { printf("After ListStrCpy\n"); } - if ((strcmp(listHeadElemId,listId)==0) - && strcmp(listTailElemId,listId)==0){ - // si la liste est vide - if (DEBUG) { printf("SpaceList : vide\n"); } - return 1; - } else { - return msgSpaceListElemFindId(listHeadElemId,spaceId); - } - if (msgSpaceListClose(list) < 0){ - NZG_ERROR("msgSpaceListClose",""); - goto ERROR; - } - return 0; -ERROR: -return -1; -} - -int msgSpaceListElemFindId(msgSpaceListElemId elemId,msgSpaceId spaceId){ - msgSpaceListElem * listElem; - msgSpaceListElemId listElemIdNext; - msgSpaceId currentElemSpaceId; - - listElem=msgSpaceListElemOpen(elemId); - if (listElem==NULL){ - NZG_ERROR("msgSpaceListElemOpen",elemId); - goto ERROR; - } - strcpy(listElemIdNext,listElem->next); - strcpy(currentElemSpaceId,listElem->spaceId); - if (msgSpaceListElemClose(listElem) < 0){ - NZG_ERROR("msgSpaceListElemClose",elemId); - goto ERROR; - } - - printf("Current ListElem: Next:%s, Sid:%s\n", - listElemIdNext,currentElemSpaceId); - printf("comparisons...\n"); - if (strcmp(currentElemSpaceId,spaceId)==0) { - printf("Found %s in spaceList !\n",spaceId); - return 0; - } else { - if (strcmp(listElemIdNext,elemId)==0){ - printf("End of spaceList reached.\n"); - /* fin de liste ?? */ - return 1; - } else { - /* continuer sur l'element suivant */ - return msgSpaceListElemFindId(listElemIdNext,spaceId); + msgSpaceIdIntern(spaceId, externId); + list = msgSpaceListOpen(); + if (list == NULL) { + NZG_ERROR("msgSpaceListOpen", ""); + goto ERROR; } - } - - return 0; -ERROR: - return -1; + if (DEBUG) { + printf("Before ListStrCpy\n"); + } + strcpy(listHeadElemId, list->headId); + strcpy(listTailElemId, list->tailId); + strcpy(listId, list->id); + if (DEBUG) { + printf("After ListStrCpy\n"); + } + if ((strcmp(listHeadElemId, listId) == 0) + && strcmp(listTailElemId, listId) == 0) { + // si la liste est vide + if (DEBUG) { + printf("SpaceList : vide\n"); + } + return 1; + } else { + return msgSpaceListElemFindId(listHeadElemId, spaceId); + } + if (msgSpaceListClose(list) < 0) { + NZG_ERROR("msgSpaceListClose", ""); + goto ERROR; + } + return 0; + ERROR: + return -1; } +int msgSpaceListElemFindId(msgSpaceListElemId elemId, msgSpaceId spaceId) +{ + msgSpaceListElem *listElem; + msgSpaceListElemId listElemIdNext; + msgSpaceId currentElemSpaceId; + listElem = msgSpaceListElemOpen(elemId); + if (listElem == NULL) { + NZG_ERROR("msgSpaceListElemOpen", elemId); + goto ERROR; + } + strcpy(listElemIdNext, listElem->next); + strcpy(currentElemSpaceId, listElem->spaceId); + if (msgSpaceListElemClose(listElem) < 0) { + NZG_ERROR("msgSpaceListElemClose", elemId); + goto ERROR; + } + + printf("Current ListElem: Next:%s, Sid:%s\n", + listElemIdNext, currentElemSpaceId); + printf("comparisons...\n"); + if (strcmp(currentElemSpaceId, spaceId) == 0) { + printf("Found %s in spaceList !\n", spaceId); + return 0; + } else { + if (strcmp(listElemIdNext, elemId) == 0) { + printf("End of spaceList reached.\n"); + /* fin de liste ?? */ + return 1; + } else { + /* continuer sur l'element suivant */ + return msgSpaceListElemFindId(listElemIdNext, spaceId); + } + } + + return 0; + ERROR: + return -1; +} diff --git a/src/spaceListInit.c b/src/spaceListInit.c index eadf0f9..6a044e6 100644 --- a/src/spaceListInit.c +++ b/src/spaceListInit.c @@ -1,76 +1,73 @@ #include "libnazgul.h" #include "ids.h" -int msgSpaceListInit(){ - int spaceListFd; - sem_t * spaceListSemFd; - msgSpaceList *list; +int msgSpaceListInit() +{ + int spaceListFd; + sem_t *spaceListSemFd; + msgSpaceList *list; - msgSpaceListSemId spaceListSemId; - msgSpaceListId spaceListId; + msgSpaceListSemId spaceListSemId; + msgSpaceListId spaceListId; - strcpy(spaceListSemId,DEFAULT_MSGSPACELISTSEMID); - strcpy(spaceListId,DEFAULT_MSGSPACELISTID); + strcpy(spaceListSemId, DEFAULT_MSGSPACELISTSEMID); + strcpy(spaceListId, DEFAULT_MSGSPACELISTID); - /* Creation de semaphore */ - spaceListSemFd=sem_open(spaceListSemId,O_CREAT|O_EXCL,0666,0); - if(spaceListSemFd==SEM_FAILED){ - spaceListSemFd=sem_open(spaceListSemId,O_CREAT,0666,0); - if(spaceListSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",spaceListSemId); - goto ERROR; + /* Creation de semaphore */ + spaceListSemFd = sem_open(spaceListSemId, O_CREAT | O_EXCL, 0666, 0); + if (spaceListSemFd == SEM_FAILED) { + spaceListSemFd = sem_open(spaceListSemId, O_CREAT, 0666, 0); + if (spaceListSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", spaceListSemId); + goto ERROR; + } } - } - - - /*Fait un segment de memoir partager sur espace de listelement*/ - spaceListFd=shm_open(spaceListId, - O_RDWR|O_CREAT|O_EXCL|O_TRUNC, - 0666); - if (spaceListFd == -1){ - spaceListFd=shm_open(spaceListId,O_RDWR,0666); - if (spaceListFd == -1){ - NZG_ERROR("shm_open",spaceListId); - goto ERROR; - } else { - close(spaceListFd); - goto EXISTING; + /*Fait un segment de memoir partager sur espace de listelement */ + spaceListFd = shm_open(spaceListId, + O_RDWR | O_CREAT | O_EXCL | O_TRUNC, 0666); + if (spaceListFd == -1) { + spaceListFd = shm_open(spaceListId, O_RDWR, 0666); + if (spaceListFd == -1) { + NZG_ERROR("shm_open", spaceListId); + goto ERROR; + } else { + close(spaceListFd); + goto EXISTING; + } } - } - if (ftruncate(spaceListFd, sizeof(msgSpaceList)) < 0){ - NZG_ERROR("ftruncate",spaceListId); - goto ERROR; - } - close(spaceListFd); + if (ftruncate(spaceListFd, sizeof(msgSpaceList)) < 0) { + NZG_ERROR("ftruncate", spaceListId); + goto ERROR; + } + close(spaceListFd); - list=msgSpaceListOpen(); - if (list == NULL){ - NZG_ERROR("msgSpaceListOpen",""); - goto ERROR; - } - strcpy(list->id,spaceListId); - strcpy(list->headId,spaceListId); - strcpy(list->tailId,spaceListId); - if (msgSpaceListClose(list) <0){ - NZG_ERROR("msgSpaceListClose",""); - goto ERROR; - } + list = msgSpaceListOpen(); + if (list == NULL) { + NZG_ERROR("msgSpaceListOpen", ""); + goto ERROR; + } + strcpy(list->id, spaceListId); + strcpy(list->headId, spaceListId); + strcpy(list->tailId, spaceListId); + if (msgSpaceListClose(list) < 0) { + NZG_ERROR("msgSpaceListClose", ""); + goto ERROR; + } - if (msgSpaceListUnlock() < 0){ - NZG_ERROR("msgSpaceListUnlock",""); - goto ERROR; - } + if (msgSpaceListUnlock() < 0) { + NZG_ERROR("msgSpaceListUnlock", ""); + goto ERROR; + } - return 0; -ERROR: - return -1; -EXISTING: - if (msgSpaceListUnlock() < 0){ - NZG_ERROR("msgSpaceListUnlock",""); - goto ERROR; - } + return 0; + ERROR: + return -1; + EXISTING: + if (msgSpaceListUnlock() < 0) { + NZG_ERROR("msgSpaceListUnlock", ""); + goto ERROR; + } - return 0; + return 0; }; - diff --git a/src/spaceListLocking.c b/src/spaceListLocking.c index b6f6dd5..a5888c8 100644 --- a/src/spaceListLocking.c +++ b/src/spaceListLocking.c @@ -1,69 +1,65 @@ #include "libnazgul.h" - // verouille le semaphore de la liste -int msgSpaceListLock(){ - sem_t * msgSpaceListSemFd; - msgSpaceListSemId spaceListSemId; - strcpy(spaceListSemId,DEFAULT_MSGSPACELISTSEMID); +int msgSpaceListLock() +{ + sem_t *msgSpaceListSemFd; + msgSpaceListSemId spaceListSemId; + strcpy(spaceListSemId, DEFAULT_MSGSPACELISTSEMID); - /* Ouverture d'un semafore */ - msgSpaceListSemFd=sem_open(spaceListSemId,O_CREAT,0666,1); - if(msgSpaceListSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",spaceListSemId); - goto ERROR; - } + /* Ouverture d'un semafore */ + msgSpaceListSemFd = sem_open(spaceListSemId, O_CREAT, 0666, 1); + if (msgSpaceListSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", spaceListSemId); + goto ERROR; + } - /* Pose d'un semaphore et le verrouille */ - if(sem_wait(msgSpaceListSemFd)==-1){ - NZG_ERROR("sem_wait",spaceListSemId); - goto ERROR; - } + /* Pose d'un semaphore et le verrouille */ + if (sem_wait(msgSpaceListSemFd) == -1) { + NZG_ERROR("sem_wait", spaceListSemId); + goto ERROR; + } - /* Ferme le semaphore*/ - /* if(sem_close(msgSpaceListSemFd)==-1){ - NZG_ERROR("sem_close",spaceListSemId); - return -1; - }*/ - sem_close(msgSpaceListSemFd); + /* Ferme le semaphore */ + /* if(sem_close(msgSpaceListSemFd)==-1){ + NZG_ERROR("sem_close",spaceListSemId); + return -1; + } */ + sem_close(msgSpaceListSemFd); - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; } - // deverouille le semaphore de la liste -int msgSpaceListUnlock(){ - sem_t * msgSpaceListSemFd; - msgSpaceListSemId spaceListSemId; - strcpy(spaceListSemId,DEFAULT_MSGSPACELISTSEMID); +int msgSpaceListUnlock() +{ + sem_t *msgSpaceListSemFd; + msgSpaceListSemId spaceListSemId; + strcpy(spaceListSemId, DEFAULT_MSGSPACELISTSEMID); + /*Ouverture dun semaphore */ + msgSpaceListSemFd = sem_open(spaceListSemId, O_CREAT, 0666, 0); + if (msgSpaceListSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", spaceListSemId); + goto ERROR; + } - /*Ouverture dun semaphore*/ - msgSpaceListSemFd=sem_open(spaceListSemId,O_CREAT,0666,0); - if(msgSpaceListSemFd==SEM_FAILED){ - NZG_ERROR("sem_open",spaceListSemId); - goto ERROR; - } + /*Relachement du semaphore */ + if (sem_post(msgSpaceListSemFd) == -1) { + NZG_ERROR("sem_relache", spaceListSemId); + goto ERROR; + } + /* Ferme le semaphore */ + if (sem_close(msgSpaceListSemFd) == -1) { + NZG_ERROR("sem_close", spaceListSemId); + goto ERROR; + } - /*Relachement du semaphore*/ - if(sem_post(msgSpaceListSemFd)==-1){ - NZG_ERROR("sem_relache",spaceListSemId); - goto ERROR; - } - - - /* Ferme le semaphore */ - if(sem_close(msgSpaceListSemFd)==-1){ - NZG_ERROR("sem_close",spaceListSemId); - goto ERROR; - } - - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; }; - diff --git a/src/spaceListOpen.c b/src/spaceListOpen.c index da8b1e8..b24a3ae 100644 --- a/src/spaceListOpen.c +++ b/src/spaceListOpen.c @@ -1,32 +1,30 @@ #include "libnazgul.h" #include "ids.h" -void * msgSpaceListOpen(){ - int listFd; - void * listAddr; +void *msgSpaceListOpen() +{ + int listFd; + void *listAddr; - msgSpaceListId spaceListId; - strcpy(spaceListId,DEFAULT_MSGSPACELISTID); + msgSpaceListId spaceListId; + strcpy(spaceListId, DEFAULT_MSGSPACELISTID); - listFd=shm_open(spaceListId,O_RDWR,SHM_DEFAULT_MODE); - if (listFd == -1 ) { - NZG_ERROR("shm_open : msgSpaceList open",spaceListId); - goto ERROR; - } + listFd = shm_open(spaceListId, O_RDWR, SHM_DEFAULT_MODE); + if (listFd == -1) { + NZG_ERROR("shm_open : msgSpaceList open", spaceListId); + goto ERROR; + } - listAddr=mmap(NULL, - sizeof(msgSpaceList), - PROT_READ|PROT_WRITE, - MAP_SHARED, - listFd, - 0); - if( listAddr == MAP_FAILED ) { - NZG_ERROR("mmap",spaceListId); - goto ERROR; - } + listAddr = mmap(NULL, + sizeof(msgSpaceList), + PROT_READ | PROT_WRITE, MAP_SHARED, listFd, 0); + if (listAddr == MAP_FAILED) { + NZG_ERROR("mmap", spaceListId); + goto ERROR; + } - close(listFd); - return listAddr; -ERROR: - return NULL; + close(listFd); + return listAddr; + ERROR: + return NULL; } diff --git a/src/spaceListRem.c b/src/spaceListRem.c index 805eef6..13b5a9a 100644 --- a/src/spaceListRem.c +++ b/src/spaceListRem.c @@ -2,109 +2,127 @@ #define DEBUG 1 -int msgSpaceListRem(msgSpaceId spaceId){ - msgSpaceList * list; - msgSpaceListElemId listHeadElemId; - msgSpaceListElemId listTailElemId; - msgSpaceListId listId; +int msgSpaceListRem(msgSpaceId spaceId) +{ + msgSpaceList *list; + msgSpaceListElemId listHeadElemId; + msgSpaceListElemId listTailElemId; + msgSpaceListId listId; - msgSpaceListElemId prevElemId; - msgSpaceListElemId currElemId; - msgSpaceListElemId nextElemId; + msgSpaceListElemId prevElemId; + msgSpaceListElemId currElemId; + msgSpaceListElemId nextElemId; - msgSpaceListElem * prevElem; - msgSpaceListElem * currElem; - msgSpaceId currSpaceId; + msgSpaceListElem *prevElem; + msgSpaceListElem *currElem; + msgSpaceId currSpaceId; - list=msgSpaceListOpen(); - if (list==NULL){ - NZG_ERROR("msgSpaceListOpen",""); - goto ERROR; - } - if (DEBUG) { printf("Before ListStrCpy\n"); } - strcpy(listHeadElemId,list->headId); - strcpy(listTailElemId,list->tailId); - strcpy(listId,list->id); - if (DEBUG) { printf("After ListStrCpy\n"); } - if ((strcmp(listHeadElemId,listId)==0) - && strcmp(listTailElemId,listId)==0){ - if (DEBUG) { printf("SpaceList : vide\n"); } - return 1; - } else { - bool found=false; - - strcpy(prevElemId,list->headId); - strcpy(currElemId,list->headId); - while(!found){ - printf("Recherche dans l'element %s\n",listHeadElemId); - currElem=msgSpaceListElemOpen(currElemId); - if (currElem==NULL){ - NZG_ERROR("msgSpaceListElemOpen",currElemId); + list = msgSpaceListOpen(); + if (list == NULL) { + NZG_ERROR("msgSpaceListOpen", ""); goto ERROR; - } - strcpy(nextElemId,currElem->next); - strcpy(currSpaceId,currElem->spaceId); - if (msgSpaceListElemClose(currElem) <0){ - NZG_ERROR("msgSpaceListElemClose",currElemId); - goto ERROR; - } - if (strcmp(prevElemId,nextElemId)==0){ - // list à 1 seul élement - if (strcmp(currSpaceId,spaceId)==0){ - // on a trouvé l'elem - strcpy(list->headId,list->id); - strcpy(list->tailId,list->id); - // on efface - shm_unlink(currElemId); - found=true; - } else { - break; + } + if (DEBUG) { + printf("Before ListStrCpy\n"); + } + strcpy(listHeadElemId, list->headId); + strcpy(listTailElemId, list->tailId); + strcpy(listId, list->id); + if (DEBUG) { + printf("After ListStrCpy\n"); + } + if ((strcmp(listHeadElemId, listId) == 0) + && strcmp(listTailElemId, listId) == 0) { + if (DEBUG) { + printf("SpaceList : vide\n"); } - } else { - // liste à plusieurs élements... - if (strcmp(currSpaceId,spaceId)==0){ - // ca correspond - if (strcmp(prevElemId,currElemId)==0){ - // si on est en début de liste (prev=current) - // - la tete de liste pointe sur le suivant - strcpy(list->headId,nextElemId); - } else { - if (strcmp(currElemId,nextElemId)==0){ - // si on est en find de liste (current=next) - // - on fait pointer la queue de liste sur le précédent - strcpy(list->tailId,prevElemId); - // - on fait pointer le précédent sur lui-meme - prevElem=msgSpaceListElemOpen(prevElemId); - strcpy(prevElem->next,prevElemId); - msgSpaceListElemClose(prevElem); - }else { - // on est en milieu de liste - // - on fait pointer le précédent sur le suivant - prevElem=msgSpaceListElemOpen(prevElemId); - strcpy(prevElem->next,nextElemId); - msgSpaceListElemClose(prevElem); + return 1; + } else { + bool found = false; + + strcpy(prevElemId, list->headId); + strcpy(currElemId, list->headId); + while (!found) { + printf("Recherche dans l'element %s\n", listHeadElemId); + currElem = msgSpaceListElemOpen(currElemId); + if (currElem == NULL) { + NZG_ERROR("msgSpaceListElemOpen", currElemId); + goto ERROR; } - } - // - on détruit l'actuel - shm_unlink(currElemId); - found=true; - break; - } else { - //cela ne correspond pas - //on recopie - strcpy(prevElemId,currElemId); - strcpy(currElemId,nextElemId); + strcpy(nextElemId, currElem->next); + strcpy(currSpaceId, currElem->spaceId); + if (msgSpaceListElemClose(currElem) < 0) { + NZG_ERROR("msgSpaceListElemClose", currElemId); + goto ERROR; + } + if (strcmp(prevElemId, nextElemId) == 0) { + // list à 1 seul élement + if (strcmp(currSpaceId, spaceId) == 0) { + // on a trouvé l'elem + strcpy(list->headId, list->id); + strcpy(list->tailId, list->id); + // on efface + shm_unlink(currElemId); + found = true; + } else { + break; + } + } else { + // liste à plusieurs élements... + if (strcmp(currSpaceId, spaceId) == 0) { + // ca correspond + if (strcmp(prevElemId, currElemId) == 0) { + // si on est en début de liste (prev=current) + // - la tete de liste pointe sur le suivant + strcpy(list->headId, + nextElemId); + } else { + if (strcmp + (currElemId, + nextElemId) == 0) { + // si on est en find de liste (current=next) + // - on fait pointer la queue de liste sur le précédent + strcpy(list->tailId, + prevElemId); + // - on fait pointer le précédent sur lui-meme + prevElem = + msgSpaceListElemOpen + (prevElemId); + strcpy(prevElem->next, + prevElemId); + msgSpaceListElemClose + (prevElem); + } else { + // on est en milieu de liste + // - on fait pointer le précédent sur le suivant + prevElem = + msgSpaceListElemOpen + (prevElemId); + strcpy(prevElem->next, + nextElemId); + msgSpaceListElemClose + (prevElem); + } + } + // - on détruit l'actuel + shm_unlink(currElemId); + found = true; + break; + } else { + //cela ne correspond pas + //on recopie + strcpy(prevElemId, currElemId); + strcpy(currElemId, nextElemId); + } + } + } - } - + if (msgSpaceListClose(list) < 0) { + NZG_ERROR("msgSpaceListClose", ""); + goto ERROR; + } + return 0; } - if (msgSpaceListClose(list) < 0){ - NZG_ERROR("msgSpaceListClose",""); - goto ERROR; - } - return 0; - } -ERROR: - return -1; + ERROR: + return -1; } - diff --git a/src/spaceOpen.c b/src/spaceOpen.c index 6dac1b3..ab45b04 100644 --- a/src/spaceOpen.c +++ b/src/spaceOpen.c @@ -2,25 +2,26 @@ #include "ids.h" /* prototypes des fonctions annexes à ne pas exporter */ -int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src ); -int msgPoolDataIdIntern(msgSpaceId dest,const msgSpaceId src ); +int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src); +int msgPoolDataIdIntern(msgSpaceId dest, const msgSpaceId src); +msgSpace *msgSpaceOpen(msgSpaceId externId) +{ + int shmFd; + msgSpaceId nzgId; + msgSpace *mSAddr; + if (msgSpaceIdIntern(nzgId, externId) < 0) { + return NULL; + } + if ((shmFd = shm_open(nzgId, O_RDWR, MSGSPACE_DEFAULT_MODE)) < 0) { + perror("shm_open"); + return NULL; + } + mSAddr = + mmap(NULL, sizeof(msgSpace), PROT_READ | PROT_WRITE, MAP_SHARED, + shmFd, (off_t) 0); -msgSpace * msgSpaceOpen(msgSpaceId externId){ - int shmFd; - msgSpaceId nzgId; - msgSpace * mSAddr; - if (msgSpaceIdIntern(nzgId,externId) < 0){ - return NULL; - } - if ((shmFd=shm_open(nzgId,O_RDWR,MSGSPACE_DEFAULT_MODE)) < 0){ - perror("shm_open"); - return NULL; - } - mSAddr=mmap(NULL,sizeof(msgSpace),PROT_READ|PROT_WRITE,MAP_SHARED,shmFd,(off_t)0); - - printf( "OPEN: msgSpace mapped to %p in %d\n", (void *)mSAddr,(int)getpid()); - return mSAddr; + printf("OPEN: msgSpace mapped to %p in %d\n", (void *)mSAddr, + (int)getpid()); + return mSAddr; } - - diff --git a/src/spaceState.c b/src/spaceState.c index e04764f..178523d 100644 --- a/src/spaceState.c +++ b/src/spaceState.c @@ -1,2 +1 @@ #include "libnazgul.h" - diff --git a/test/test_create_delete.c b/test/test_create_delete.c index 431102d..6bc02ac 100644 --- a/test/test_create_delete.c +++ b/test/test_create_delete.c @@ -6,62 +6,61 @@ #include "libnazgul.h" -int main(void) { - // msgSpace mS=0; +int main(void) +{ + // msgSpace mS=0; - pid_t pid; - msgSpaceId testId; - msgSpace * mSPAC; - msgPool poolInfos[3]; - char * montext; + pid_t pid; + msgSpaceId testId; + msgSpace *mSPAC; + msgPool poolInfos[3]; + char *montext; - poolInfos[0].bufferNb=4; - poolInfos[0].bufferSize=200; - - poolInfos[1].bufferNb=5; - poolInfos[1].bufferSize=250; + poolInfos[0].bufferNb = 4; + poolInfos[0].bufferSize = 200; - poolInfos[2].bufferNb=5; - poolInfos[2].bufferSize=280; - - sprintf(testId,"test%d",(int)getuid()); - printf("RequestedId: %s\n",testId); - printf("Void size: %d\n",(int)sizeof(void)); - mSPAC=msgSpaceCreate(testId,0,3,poolInfos); - if (mSPAC ==NULL) { - NZG_ERROR("msgSpaceCreate",testId); - exit(0); - } + poolInfos[1].bufferNb = 5; + poolInfos[1].bufferSize = 250; - pid=fork(); - - - - if (pid ==0){ - mSPAC=msgSpaceOpen(testId); - sleep(5); - montext=msgAllocate(mSPAC,2,180,0); - sleep(5); - montext=msgAllocate(mSPAC,2,170,0); - sleep(5); - montext=msgAllocate(mSPAC,2,270,0); - - } else { - mSPAC=msgSpaceOpen(testId); - montext=msgAllocate(mSPAC,2,280,0); - *montext=42; - printf("### test Valeur0 %d ###\n",(int)*montext); - //sleep(2); - montext=msgAllocate(mSPAC,2,270,0); - *montext=17; - printf("### test Valeur1 %d ###\n",(int)*montext); - sleep(5); - montext=msgAllocate(mSPAC,2,270,0); - msgFree(mSPAC,(void *)montext); - //msgFree(mSPAC,(void *)montext); - //msgFree(mSPAC,(void *)montext); - wait(NULL); - msgSpaceDelete(testId); - } - return 0; + poolInfos[2].bufferNb = 5; + poolInfos[2].bufferSize = 280; + + sprintf(testId, "test%d", (int)getuid()); + printf("RequestedId: %s\n", testId); + printf("Void size: %d\n", (int)sizeof(void)); + mSPAC = msgSpaceCreate(testId, 0, 3, poolInfos); + if (mSPAC == NULL) { + NZG_ERROR("msgSpaceCreate", testId); + exit(0); + } + + pid = fork(); + + if (pid == 0) { + mSPAC = msgSpaceOpen(testId); + sleep(5); + montext = msgAllocate(mSPAC, 2, 180, 0); + sleep(5); + montext = msgAllocate(mSPAC, 2, 170, 0); + sleep(5); + montext = msgAllocate(mSPAC, 2, 270, 0); + + } else { + mSPAC = msgSpaceOpen(testId); + montext = msgAllocate(mSPAC, 2, 280, 0); + *montext = 42; + printf("### test Valeur0 %d ###\n", (int)*montext); + //sleep(2); + montext = msgAllocate(mSPAC, 2, 270, 0); + *montext = 17; + printf("### test Valeur1 %d ###\n", (int)*montext); + sleep(5); + montext = msgAllocate(mSPAC, 2, 270, 0); + msgFree(mSPAC, (void *)montext); + //msgFree(mSPAC,(void *)montext); + //msgFree(mSPAC,(void *)montext); + wait(NULL); + msgSpaceDelete(testId); + } + return 0; } diff --git a/test/test_msgSpaceState.c b/test/test_msgSpaceState.c index 68ca16d..a27297c 100644 --- a/test/test_msgSpaceState.c +++ b/test/test_msgSpaceState.c @@ -6,95 +6,106 @@ #include "libnazgul.h" -void usage(char * myname){ - printf("Usage: %s [--all | msgSpaceId1 msgSpaceId2 ... ]\n",myname); +void usage(char *myname) +{ + printf("Usage: %s [--all | msgSpaceId1 msgSpaceId2 ... ]\n", myname); } -int about(char * spaceId){ - msgPoolDataTabSemId ressourceSemId; - sem_t * ressourceSemFd; - int i; - msgPoolData * poolDataTab; - msgSpace * space; - int ressourceSemVal; - if (strlen(spaceId)> MSGSPACE_ID_LEN){ - //verif de la longueur - fprintf(stderr,"Too long ident : %s\n",spaceId); - goto ERROR; - } else { - int err; - msgSpaceListLock(); - err=msgSpaceListFindId(spaceId); - msgSpaceListUnlock(); - if (err < 1){ - if (err==0){ - // le msgSpace existe - space=msgSpaceOpen(spaceId); - // on lit les informations sur le msgSpace - // les pool - for (i=0;ipoolNb;i++){ - msgPoolSemIdIntern(ressourceSemId,space->externId,i); - ressourceSemFd = sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0); - if (ressourceSemFd == SEM_FAILED){ - NZG_ERROR("sem_open",ressourceSemId); - goto ERROR; - } - if (sem_getvalue(ressourceSemFd, &ressourceSemVal) < 0){ - NZG_ERROR("sem_getvalue",ressourceSemId); - goto ERROR; - } - msgPoolDataTabLock(space); - poolDataTab= msgPoolDataTabOpen(space); - // donner le nombre de buffer disponibles - printf("- %d/%d free buffers in pool #%d\n", - ressourceSemVal, - poolDataTab[i].bufferNb, - i); - msgPoolDataTabClose(space,poolDataTab); - msgPoolDataTabUnlock(space); - if(sem_close(ressourceSemFd) <0){ - NZG_ERROR("sem_getvalue",ressourceSemId); - goto ERROR; - } - // pour chaque buffer, dire s'il est libre ou pas - // et le processus/addresse associé +int about(char *spaceId) +{ + msgPoolDataTabSemId ressourceSemId; + sem_t *ressourceSemFd; + int i; + msgPoolData *poolDataTab; + msgSpace *space; + int ressourceSemVal; + if (strlen(spaceId) > MSGSPACE_ID_LEN) { + //verif de la longueur + fprintf(stderr, "Too long ident : %s\n", spaceId); + goto ERROR; + } else { + int err; + msgSpaceListLock(); + err = msgSpaceListFindId(spaceId); + msgSpaceListUnlock(); + if (err < 1) { + if (err == 0) { + // le msgSpace existe + space = msgSpaceOpen(spaceId); + // on lit les informations sur le msgSpace + // les pool + for (i = 0; i < space->poolNb; i++) { + msgPoolSemIdIntern(ressourceSemId, + space->externId, i); + ressourceSemFd = + sem_open(ressourceSemId, O_CREAT, + SEM_DEFAULT_MODE, 0); + if (ressourceSemFd == SEM_FAILED) { + NZG_ERROR("sem_open", + ressourceSemId); + goto ERROR; + } + if (sem_getvalue + (ressourceSemFd, + &ressourceSemVal) < 0) { + NZG_ERROR("sem_getvalue", + ressourceSemId); + goto ERROR; + } + msgPoolDataTabLock(space); + poolDataTab = msgPoolDataTabOpen(space); + // donner le nombre de buffer disponibles + printf + ("- %d/%d free buffers in pool #%d\n", + ressourceSemVal, + poolDataTab[i].bufferNb, i); + msgPoolDataTabClose(space, poolDataTab); + msgPoolDataTabUnlock(space); + if (sem_close(ressourceSemFd) < 0) { + NZG_ERROR("sem_getvalue", + ressourceSemId); + goto ERROR; + } + // pour chaque buffer, dire s'il est libre ou pas + // et le processus/addresse associé + } + msgSpaceClose(space); + } else { + // zut, il y a soit une erreur + NZG_ERROR("spaceListFindId : error ", spaceId); + } + } else { + // on quitte : l'element n'existe + fprintf(stderr, "Ident %s does not exist.\n", spaceId); } - msgSpaceClose(space); - } else { - // zut, il y a soit une erreur - NZG_ERROR("spaceListFindId : error ",spaceId); - } - } else { - // on quitte : l'element n'existe - fprintf(stderr,"Ident %s does not exist.\n",spaceId); } - } - return 0; -ERROR: - return -1; + return 0; + ERROR: + return -1; } -int main(int argc,char **argv){ - printf("Args %d\n",argc); - if (argc<2){ - usage(argv[0]); - }else { - if (argc==2){ - if (strcmp("--all",argv[1])==0){ - // listing - printf("[ Listing of msgSpaces ]\n"); - } else { - // only one msgSpaceId - printf("[ About %s ]\n",argv[1]); - about(argv[1]); - } +int main(int argc, char **argv) +{ + printf("Args %d\n", argc); + if (argc < 2) { + usage(argv[0]); } else { - int i; - for (i=1;i