glenux-school/l3.libnazgul
glenux-school/l3.libnazgul
1
1
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Apply indent with -linux style

Browse source
This commit is contained in:
Glenn Y. Rolland 2020-03-04 00:06:43 +01:00
parent e2692e8547
commit c5f4cd8345
64 changed files with 2552 additions and 2232 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

346
src/allocate.c
View file

@ -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; i<nbLockedSem; i++) {
printf("Coef %d : %d\n",i,(int)semPoolCoef[i]);
if ((semPoolCoef[i] != -1)
&& (semPoolCoef[i] < minPoolCoef)) {
minPoolCoef = semPoolCoef[i];
idxPoolOptimum = i;
}
}
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;
}
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;
/* 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;
}

18
src/buffer.c
View file

@ -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;
}

55
src/bufferAttachProc.c
View file

@ -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;
}

57
src/bufferDetachProc.c
View file

@ -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;
}

68
src/bufferGetFreeIndex.c
View file

@ -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<bufferInfoNb)
&& (bufferInfoTabAddr[i].ownerPid != (pid_t)-1)){ i++; }
if (i == bufferInfoNb){ return -1; }
bufferFreeIndex=i;
if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
{
NZG_ERROR("munmap",bufferInfoTabId);
return -1;
}
return bufferFreeIndex;
i = 0;
while ((i < bufferInfoNb)
&& (bufferInfoTabAddr[i].ownerPid != (pid_t) - 1)) {
i++;
}
if (i == bufferInfoNb) {
return -1;
}
bufferFreeIndex = i;
if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
NZG_ERROR("munmap", bufferInfoTabId);
return -1;
}
return bufferFreeIndex;
}

92
src/bufferGetProcAttach.c
View file

@ -1,51 +1,61 @@
#include "libnazgul.h"
int msgBufferGetProcAttach(
msgPoolData * poolDataTabAddr,
int poolNb,
int * poolIndex,
int * bufferIndex,
void * addr
){
msgBufferInfoTabId bufferInfoTabId;
int bufferInfoTabFd;
msgBufferInfo * bufferInfoTabAddr;
int bufferInfoNb;
int msgBufferGetProcAttach(msgPoolData * poolDataTabAddr,
int poolNb,
int *poolIndex, int *bufferIndex, void *addr)
{
msgBufferInfoTabId bufferInfoTabId;
int bufferInfoTabFd;
msgBufferInfo *bufferInfoTabAddr;
int bufferInfoNb;
bool found=false;
int pIdx=0;
int bIdx;
while ((!found) && (pIdx < poolNb)){
/* Pour chaque pool */
//récuperer l'ID du BufferInfoTab;
strcpy(bufferInfoTabId, poolDataTabAddr[pIdx].bufferInfoTabId);
bufferInfoNb=poolDataTabAddr[pIdx].bufferNb;
bool found = false;
int pIdx = 0;
int bIdx;
while ((!found) && (pIdx < poolNb)) {
/* Pour chaque pool */
//récuperer l'ID du BufferInfoTab;
strcpy(bufferInfoTabId, poolDataTabAddr[pIdx].bufferInfoTabId);
bufferInfoNb = poolDataTabAddr[pIdx].bufferNb;
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 **/
bufferInfoTabAddr=mmap(NULL,bufferInfoNb*sizeof(msgBufferInfo),
PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0);
bufferInfoTabAddr =
mmap(NULL, bufferInfoNb * sizeof(msgBufferInfo), PROT_READ,
MAP_SHARED, bufferInfoTabFd, (off_t) 0);
/* on cherche dans chacun des buffers */
bIdx=0;
while((!found) && bIdx<bufferInfoNb){
if (bufferInfoTabAddr[bIdx].addr == addr){
found=true;
(*bufferIndex)=bIdx;
};
bIdx++;
/* on cherche dans chacun des buffers */
bIdx = 0;
while ((!found) && bIdx < bufferInfoNb) {
if (bufferInfoTabAddr[bIdx].addr == addr) {
found = true;
(*bufferIndex) = bIdx;
};
bIdx++;
}
if (found) {
(*poolIndex) = pIdx;
}
/* on détache le morceau de mémoire */
if (munmap
(bufferInfoTabAddr,
bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
NZG_ERROR("munmap", bufferInfoTabId);
return -1;
}
close(bufferInfoTabFd);
pIdx++;
}
if (found){ (*poolIndex)=pIdx; }
/* on détache le morceau de mémoire */
if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
{ NZG_ERROR("munmap",bufferInfoTabId); return -1; }
close(bufferInfoTabFd);
pIdx++;
}
if (found){ return 0; } else {return -1;}
if (found) {
return 0;
} else {
return -1;
}
}

60
src/bufferInfoTabCreate.c
View file

@ -1,37 +1,39 @@
#include "libnazgul.h"
#include "ids.h"
int msgBufferInfoTabCreate(
msgSpaceId externId,
msgPoolData * poolDataTabAddr,
int poolIdx,
int bufferNb) {
int msgBufferInfoTabCreate(msgSpaceId externId,
msgPoolData * poolDataTabAddr,
int poolIdx, int bufferNb)
{
int bufferInfoTabFd;
msgBufferInfoTabId bufferInfoTabId;
int bufferInfoTabFd;
msgBufferInfoTabId bufferInfoTabId;
/* creation des infos sur buffers DEBUT */
if (msgBufferInfoTabIdIntern(bufferInfoTabId, externId, poolIdx) == -1) {
NZG_ERROR("msgPoolId creation", bufferInfoTabId);
return -1;
}
bufferInfoTabFd =
shm_open(bufferInfoTabId, O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
MSGSPACE_DEFAULT_MODE);
if (bufferInfoTabFd == -1) {
fprintf(stderr, "msgInfoTab : %s creation failed: %s\n",
bufferInfoTabId, strerror(errno));
return -1;
}
if (ftruncate(bufferInfoTabFd, bufferNb * sizeof(msgBufferInfo)) == -1) {
fprintf(stderr, "msgBufferInfoTab resizing failed: %s\n",
strerror(errno));
return -1;
}
close(bufferInfoTabFd);
/* creation des infos sur buffers FIN */
msgBufferInfoTabInit(poolDataTabAddr, poolIdx);
/* creation des infos sur buffers DEBUT */
if (msgBufferInfoTabIdIntern(bufferInfoTabId,externId,poolIdx) == -1){
NZG_ERROR("msgPoolId creation",bufferInfoTabId);
return -1;
}
bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR|O_CREAT|O_EXCL|O_TRUNC,MSGSPACE_DEFAULT_MODE);
if (bufferInfoTabFd == -1 ) {
fprintf( stderr, "msgInfoTab : %s creation failed: %s\n",bufferInfoTabId,
strerror( errno ) );
NZG_ERROR("munmap", bufferInfoTabId);
return -1;
}
if (ftruncate(bufferInfoTabFd, bufferNb*sizeof(msgBufferInfo)) == -1){
fprintf( stderr, "msgBufferInfoTab resizing failed: %s\n",
strerror( errno ) );
return -1;
}
close(bufferInfoTabFd);
/* creation des infos sur buffers FIN */
msgBufferInfoTabInit(poolDataTabAddr,poolIdx);
return -1;NZG_ERROR("munmap",bufferInfoTabId);
return -1;
}

56
src/bufferInfoTabInit.c
View file

@ -1,34 +1,38 @@
#include "libnazgul.h"
int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr,int poolIndex){
msgBufferInfoTabId bufferInfoTabId;
int bufferInfoTabFd;
msgBufferInfo * bufferInfoTabAddr;
int bufferInfoNb;
int i;
int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr, int poolIndex)
{
msgBufferInfoTabId bufferInfoTabId;
int bufferInfoTabFd;
msgBufferInfo *bufferInfoTabAddr;
int bufferInfoNb;
int i;
//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;
}
//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;i<bufferInfoNb;i++){
bufferInfoTabAddr[i].ownerPid = (pid_t)-1;
}
if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
{ perror("munmap"); return -1; }
for (i = 0; i < bufferInfoNb; i++) {
bufferInfoTabAddr[i].ownerPid = (pid_t) - 1;
}
return 0;
if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
perror("munmap");
return -1;
}
return 0;
}

89
src/bufferMap.c
View file

@ -1,55 +1,50 @@
#include "libnazgul.h"
void *msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex)
{
void *resultAddr;
int bufferSize, bufferNb;
int poolBufferTabFd;
msgPoolId poolBufferTabId;
printf("Mapping buffer (%d,%d)\n", poolIndex, bufferIndex);
// TODO: récuperer l'ID du BufferInfoTab;
strcpy(poolBufferTabId, poolDataTab[poolIndex].poolId);
bufferSize = poolDataTab[poolIndex].bufferSize;
bufferNb = poolDataTab[poolIndex].bufferNb;
if (bufferNb < 0) {
// do something with bufferNb
}
void * msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex) {
void * resultAddr;
int bufferSize, bufferNb;
int poolBufferTabFd;
msgPoolId poolBufferTabId;
printf("Mapping buffer (%d,%d)\n",poolIndex,bufferIndex);
// TODO: récuperer l'ID du BufferInfoTab;
strcpy(poolBufferTabId, poolDataTab[poolIndex].poolId);
bufferSize = poolDataTab[poolIndex].bufferSize;
bufferNb = poolDataTab[poolIndex].bufferNb;
if (bufferNb < 0) {
// do something with bufferNb
}
poolBufferTabFd = shm_open(poolBufferTabId, O_RDWR, SHM_DEFAULT_MODE);
if (poolBufferTabFd < 0) {
NZG_ERROR("shm_open", poolBufferTabId);
goto ERROR;
}
// mapper le buffer dans l'espace mémoire du processus
/* on s'arrete juste derriere l'index qui nous intéresse */
resultAddr = mmap(NULL, bufferSize * (bufferIndex + 1), PROT_READ | PROT_WRITE, //PROT_NONE
MAP_SHARED, poolBufferTabFd, (off_t) 0);
if (resultAddr == MAP_FAILED) {
NZG_ERROR("mmap", poolBufferTabId);
goto ERROR;
}
printf("Mapped from %p to %p\n",
(void *)resultAddr,
(void *)(resultAddr + bufferSize * (bufferIndex + 1))
);
poolBufferTabFd=shm_open(poolBufferTabId,O_RDWR,SHM_DEFAULT_MODE);
if (poolBufferTabFd<0){
NZG_ERROR("shm_open",poolBufferTabId);
goto ERROR;
}
resultAddr = resultAddr + (bufferSize * bufferIndex);
printf("Moved to %p\n", (void *)resultAddr);
// mapper le buffer dans l'espace mémoire du processus
/* on s'arrete juste derriere l'index qui nous intéresse */
resultAddr=mmap(NULL,
bufferSize*(bufferIndex+1),
PROT_READ|PROT_WRITE, //PROT_NONE
MAP_SHARED,
poolBufferTabFd,
(off_t)0);
if(resultAddr == MAP_FAILED) {
NZG_ERROR("mmap", poolBufferTabId);
goto ERROR;
}
printf( "Mapped from %p to %p\n",
(void *)resultAddr,
(void *)(resultAddr+ bufferSize*(bufferIndex+1))
);
/* mprotect(
resultAddr,
bufferSize,
PROT_READ|PROT_WRITE
); */
resultAddr=resultAddr +( bufferSize*bufferIndex);
printf( "Moved to %p\n",(void *)resultAddr );
close(poolBufferTabFd);
/* mprotect(
resultAddr,
bufferSize,
PROT_READ|PROT_WRITE
);*/
close(poolBufferTabFd);
return resultAddr;
ERROR:
return NULL;
return resultAddr;
ERROR:
return NULL;
}

103
src/free.c
View file

@ -1,66 +1,63 @@
#include "libnazgul.h"
int msgFree(msgSpace * space, void * addr){
int msgFree(msgSpace * space, void *addr)
{
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;
};
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;
}

117
src/get.c
View file

@ -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;
}

8
src/global.h
View file

@ -1,13 +1,13 @@
#ifndef _NZG_GLOBAL
#define _NZG_GLOBAL 1
#include <unistd.h> /* POSIX et al */
#include <unistd.h> /* POSIX et al */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h> /* pour O_RDWR */
#include <fcntl.h> /* pour O_RDWR */
#include <sys/types.h>
#include <sys/mman.h> /* shm_open */
#include <sys/mman.h> /* shm_open */
#include <errno.h>
#include <semaphore.h>
@ -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

48
src/global.h~ Normal file
View file

@ -0,0 +1,48 @@
#ifndef _NZG_GLOBAL
#define _NZG_GLOBAL 1
#include <unistd.h> /* POSIX et al */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h> /* pour O_RDWR */
#include <sys/types.h>
#include <sys/mman.h> /* shm_open */
#include <errno.h>
#include <semaphore.h>
#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

204
src/ids.c
View file

@ -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;
}

18
src/ids.h
View file

@ -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

22
src/ids.h~ Normal file
View file

@ -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

94
src/iface.h
View file

@ -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

91
src/iface.h~ Normal file
View file

@ -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
/* */

8
src/libnazgul.h~ Normal file
View file

@ -0,0 +1,8 @@
#ifndef _LIBNAZGUL
#define _LIBNAZGUL 1
#include "global.h"
#include "iface.h"
#include "proto.h"
#endif

69
src/poolCreate.c
View file

@ -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;
}

19
src/poolDataTabClose.c
View file

@ -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;
}

67
src/poolDataTabCreate.c
View file

@ -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;
}

51
src/poolDataTabLock.c
View file

@ -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;
}

43
src/poolDataTabOpen.c
View file

@ -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;
}

53
src/poolDataTabUnlock.c
View file

@ -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;
}

55
src/poolDelete.c
View file

@ -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;
}

76
src/proto.h
View file

@ -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);

118
src/proto.h~ Normal file
View file

@ -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

116
src/put.c
View file

@ -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;
}

67
src/queueAdd.c
View file

@ -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;
}

23
src/queueClose.c
View file

@ -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;
}

55
src/queueDelete.c
View file

@ -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;
}

23
src/queueElemClose.c
View file

@ -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;
}

45
src/queueElemCreate.c
View file

@ -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;
}

52
src/queueElemDelete.c
View file

@ -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;
}

43
src/queueElemOpen.c
View file

@ -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;
}

68
src/queueInit.c
View file

@ -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;
}

42
src/queueOpen.c
View file

@ -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;
}

52
src/queueProtLock.c
View file

@ -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;
}

50
src/queueProtUnlock.c
View file

@ -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;
}

50
src/queueReadLock.c
View file

@ -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;
}

50
src/queueReadTryLock.c
View file

@ -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;
}

51
src/queueReadUnlock.c
View file

@ -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;
}

57
src/queueRem.c
View file

@ -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;
}

21
src/spaceClose.c
View file

@ -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;
}

350
src/spaceCreate.c
View file

@ -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;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();
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;
}

116
src/spaceDelete.c
View file

@ -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;i<space->poolNb;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;i<space->queueNb;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;
}

75
src/spaceListAdd.c
View file

@ -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;
}

23
src/spaceListClose.c
View file

@ -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;
}

18
src/spaceListElemClose.c
View file

@ -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;
};

68
src/spaceListElemCreate.c
View file

@ -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;
};

5
src/spaceListElemLink.c
View file

@ -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);

43
src/spaceListElemOpen.c
View file

@ -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;
};

146
src/spaceListFindId.c
View file

@ -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;
}

121
src/spaceListInit.c
View file

@ -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;
};

102
src/spaceListLocking.c
View file

@ -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;
};

46
src/spaceListOpen.c
View file

@ -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;
}

212
src/spaceListRem.c
View file

@ -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;
}

39
src/spaceOpen.c
View file

@ -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;
}

1
src/spaceState.c
View file

@ -1,2 +1 @@
#include "libnazgul.h"

107
test/test_create_delete.c
View file

@ -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;
}

177
test/test_msgSpaceState.c
View file

@ -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;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é
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<argc;i++){
printf("[ About %s ]\n",argv[i]);
about(argv[i]);
}
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]);
}
} else {
int i;
for (i = 1; i < argc; i++) {
printf("[ About %s ]\n", argv[i]);
about(argv[i]);
}
}
}
}
return 0;
return 0;
}

76
test/test_put_get_mono.c
View file

@ -6,49 +6,51 @@
#include "libnazgul.h"
int main(void) {
// msgSpace mS=0;
int main(void)
{
// msgSpace mS=0;
msgSpaceId testId;
msgSpace * mSPAC;
msgPool poolInfos[3];
char * montext;
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;
sprintf(testId,"test%d",(int)getuid());
printf("RequestedId: %s\n",testId);
printf("Void size: %d\n",(int)sizeof(void));
//creation de l'espace de messages
mSPAC=msgSpaceCreate(testId,1,2,poolInfos);
if (mSPAC ==NULL) {
NZG_ERROR("msgSpaceCreate",testId);
exit(0);
}
poolInfos[0].bufferNb = 4;
poolInfos[0].bufferSize = 200;
printf("CREATION ------------------ ok\n");
poolInfos[1].bufferNb = 5;
poolInfos[1].bufferSize = 250;
mSPAC=msgSpaceOpen(testId);
sprintf(testId, "test%d", (int)getuid());
printf("RequestedId: %s\n", testId);
printf("Void size: %d\n", (int)sizeof(void));
//creation de l'espace de messages
mSPAC = msgSpaceCreate(testId, 1, 2, poolInfos);
if (mSPAC == NULL) {
NZG_ERROR("msgSpaceCreate", testId);
exit(0);
}
printf("CREATION ------------------ ok\n");
mSPAC = msgSpaceOpen(testId);
/***** TEST 1 *****/
montext=msgAllocate(mSPAC,1,280,0);
*montext=42;
printf("### test Valeur0 %d ###\n",(int)*montext);
printf("Put..."); fflush(stdout);
msgPut(mSPAC,0,montext);
printf("put-ok\n");
montext = msgAllocate(mSPAC, 1, 280, 0);
*montext = 42;
printf("### test Valeur0 %d ###\n", (int)*montext);
printf("Put...");
fflush(stdout);
msgPut(mSPAC, 0, montext);
printf("put-ok\n");
printf("Get..."); fflush(stdout);
montext=msgGet(mSPAC,0,0);
printf("get-ok\n");
printf("### test Reception %d ###\n",(int)*montext);
msgFree(mSPAC,montext);
printf("Get...");
fflush(stdout);
montext = msgGet(mSPAC, 0, 0);
printf("get-ok\n");
printf("### test Reception %d ###\n", (int)*montext);
msgFree(mSPAC, montext);
/***** TEST 1 *****/
msgSpaceDelete(testId);
return 0;
msgSpaceDelete(testId);
return 0;
}

89
test/test_put_get_multi.c
View file

@ -6,50 +6,53 @@
#include "libnazgul.h"
int main(void) {
// msgSpace mS=0;
int main(void)
{
// msgSpace mS=0;
msgSpaceId testId;
msgSpace * mSPAC;
msgPool poolInfos[3];
char * montext;
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;
sprintf(testId,"test%d",(int)getuid());
printf("RequestedId: %s\n",testId);
printf("Void size: %d\n",(int)sizeof(void));
//creation de l'espace de messages
mSPAC=msgSpaceCreate(testId,1,2,poolInfos);
if (mSPAC ==NULL) {
NZG_ERROR("msgSpaceCreate",testId);
exit(0);
}
poolInfos[0].bufferNb = 4;
poolInfos[0].bufferSize = 200;
printf("CREATION ------------------ ok\n");
pid_t pid=fork();
if (pid==0){
sleep(2);
mSPAC=msgSpaceOpen(testId);
montext=msgAllocate(mSPAC,1,280,0);
*montext=42;
printf("### test Valeur0 %d ###\n",(int)*montext);
printf("Put1..."); fflush(stdout);
msgPut(mSPAC,0,montext);
printf("put1-ok\n");
} else {
mSPAC=msgSpaceOpen(testId);
printf("Get..."); fflush(stdout);
montext=msgGet(mSPAC,0,0);
printf("get-ok\n");
printf("### test Reception %d ###\n",(int)*montext);
msgFree(mSPAC,montext);
wait(NULL);
msgSpaceDelete(testId);
}
return 0;
poolInfos[1].bufferNb = 5;
poolInfos[1].bufferSize = 250;
sprintf(testId, "test%d", (int)getuid());
printf("RequestedId: %s\n", testId);
printf("Void size: %d\n", (int)sizeof(void));
//creation de l'espace de messages
mSPAC = msgSpaceCreate(testId, 1, 2, poolInfos);
if (mSPAC == NULL) {
NZG_ERROR("msgSpaceCreate", testId);
exit(0);
}
printf("CREATION ------------------ ok\n");
pid_t pid = fork();
if (pid == 0) {
sleep(2);
mSPAC = msgSpaceOpen(testId);
montext = msgAllocate(mSPAC, 1, 280, 0);
*montext = 42;
printf("### test Valeur0 %d ###\n", (int)*montext);
printf("Put1...");
fflush(stdout);
msgPut(mSPAC, 0, montext);
printf("put1-ok\n");
} else {
mSPAC = msgSpaceOpen(testId);
printf("Get...");
fflush(stdout);
montext = msgGet(mSPAC, 0, 0);
printf("get-ok\n");
printf("### test Reception %d ###\n", (int)*montext);
msgFree(mSPAC, montext);
wait(NULL);
msgSpaceDelete(testId);
}
return 0;
}