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

66
src/allocate.c
View file

@ -9,11 +9,8 @@
/* TODO: prevoir le cas des négatifs dans la taille ... */
void * msgAllocate(msgSpace *space,
int pool,
int taille,
int option
){
void *msgAllocate(msgSpace * space, int pool, int taille, int option)
{
void *resultAddr = NULL;
int bufferFreeSize;
int i;
@ -32,10 +29,8 @@ void * msgAllocate(msgSpace *space,
int bufferFreeIndex;
msgPoolData *mSPoolDataTabAddr;
selectedPoolIndex = -1;
mSPoolDataTabAddr = msgPoolDataTabOpen(space);
if (mSPoolDataTabAddr == NULL) {
NZG_ERROR("msgPoolDataTabOpen", space->poolDataTabId);
@ -76,29 +71,40 @@ if (mSPoolDataTabAddr==NULL){
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);
printf("- boucle %d\n", i);
fflush(stdout);
if (mSPoolDataTabAddr[i].bufferSize >= taille) {
printf("( buffSize > taille )\n"); fflush(stdout);
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);
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);
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);
printf("resVal < 0 : %d\n",
ressourceSemVal);
/* il y a ressourceSemVal processus qui attendent déja... */
semPoolCoef[nbLockedSem] =
(float) ((1-ressourceSemVal) / mSPoolDataTabAddr[i].bufferNb);
(float)((1 -
ressourceSemVal) /
mSPoolDataTabAddr[i].
bufferNb);
nbLockedSem++;
}
if (sem_trywait(ressourceSemFd) == 0) {
@ -110,13 +116,15 @@ if (mSPoolDataTabAddr==NULL){
break;
}
if (sem_close(ressourceSemFd) < 0) {
NZG_ERROR("sem_getvalue",ressourceSemId);
NZG_ERROR("sem_getvalue",
ressourceSemId);
return NULL;
}
} // if buffSize > taille
} // for
printf("ERRORDETECT outFor\n"); fflush(stdout);
printf("ERRORDETECT outFor\n");
fflush(stdout);
if (!gotRessourceSem) {
printf("Calcul du meilleur en cas de liberation\n");
@ -125,7 +133,8 @@ if (mSPoolDataTabAddr==NULL){
/* 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]);
printf("Coef %d : %d\n", i,
(int)semPoolCoef[i]);
if ((semPoolCoef[i] != -1)
&& (semPoolCoef[i] < minPoolCoef)) {
minPoolCoef = semPoolCoef[i];
@ -147,13 +156,14 @@ if (mSPoolDataTabAddr==NULL){
}
if (!gotRessourceSem) {
msgPoolSemIdIntern(ressourceSemId,space->externId,selectedPoolIndex);
ressourceSemFd=sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);
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);
@ -166,7 +176,6 @@ if (mSPoolDataTabAddr==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 */
@ -174,7 +183,8 @@ if (mSPoolDataTabAddr==NULL){
/* on modifie maintenant les données */
/* - on récupere l'index du premier buffer libre */
bufferFreeIndex = msgBufferGetFreeIndex(mSPoolDataTabAddr,selectedPoolIndex);
bufferFreeIndex =
msgBufferGetFreeIndex(mSPoolDataTabAddr, selectedPoolIndex);
if (bufferFreeIndex < 0) {
// aucun buffer libre ?
NZG_ERROR("msgBufferGetFreeIndex", "");
@ -187,17 +197,17 @@ if (mSPoolDataTabAddr==NULL){
bufferFreeSize = mSPoolDataTabAddr[selectedPoolIndex].bufferSize;
printf("BufferSize : %d\n", bufferFreeSize);
resultAddr=msgBufferMap(mSPoolDataTabAddr,selectedPoolIndex,bufferFreeIndex);
resultAddr =
msgBufferMap(mSPoolDataTabAddr, selectedPoolIndex, bufferFreeIndex);
if (resultAddr == NULL) {
NZG_ERROR("msgBufferMap",mSPoolDataTabAddr[selectedPoolIndex].poolId);
NZG_ERROR("msgBufferMap",
mSPoolDataTabAddr[selectedPoolIndex].poolId);
goto ERROR;
}
/* - on s'enregistre aupres de ce buffer */
msgBufferAttachProc(mSPoolDataTabAddr,
selectedPoolIndex,
bufferFreeIndex,
resultAddr);
selectedPoolIndex, bufferFreeIndex, resultAddr);
// munmap(mSPoolDataTabAddr,(space->poolNb) * sizeof( msgPoolData ));
/* unmapper le msgPoolDataTab */

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

19
src/bufferAttachProc.c
View file

@ -1,10 +1,7 @@
#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;
@ -14,7 +11,6 @@ int msgBufferAttachProc(
//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);
@ -24,18 +20,17 @@ int msgBufferAttachProc(
/** 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);
PROT_READ | PROT_WRITE, MAP_SHARED,
bufferInfoTabFd, (off_t) 0);
printf("atta gooo %s\n", bufferInfoTabId);
bufferInfoTabAddr[bufferIndex].ownerPid = getpid();
bufferInfoTabAddr[bufferIndex].addr = addr;
if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
{
if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
NZG_ERROR("munmap", bufferInfoTabId);
return -1; }
return -1;
}
return 0;
}

17
src/bufferDetachProc.c
View file

@ -1,11 +1,8 @@
#include "libnazgul.h"
int msgBufferDetachProc(
msgPoolData * poolDataTabAddr,
int poolIndex,
int bufferIndex,
void * addr
){
int msgBufferDetachProc(msgPoolData * poolDataTabAddr,
int poolIndex, int bufferIndex, void *addr)
{
msgBufferInfoTabId bufferInfoTabId;
int bufferInfoTabFd;
msgBufferInfo *bufferInfoTabAddr;
@ -14,7 +11,6 @@ int msgBufferDetachProc(
printf("Detaching %d,%d\n", poolIndex, bufferIndex);
//récuperer l'ID du BufferInfoTab;
strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId);
bufferInfoTabFd = shm_open(bufferInfoTabId, O_RDWR, SHM_DEFAULT_MODE);
@ -26,17 +22,16 @@ int msgBufferDetachProc(
/** 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);
PROT_READ | PROT_WRITE, MAP_SHARED,
bufferInfoTabFd, (off_t) 0);
bufferInfoTabAddr[bufferIndex].ownerPid = (pid_t) - 1;
bufferInfoTabAddr[bufferIndex].addr = NULL;
if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
{
if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
NZG_ERROR("munmap", bufferInfoTabId);
return -1;
}
return 0;
}

18
src/bufferGetFreeIndex.c
View file

@ -1,6 +1,7 @@
#include "libnazgul.h"
int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr,int poolIndex){
int msgBufferGetFreeIndex(msgPoolData * poolDataTabAddr, int poolIndex)
{
msgBufferInfoTabId bufferInfoTabId;
int bufferInfoTabFd;
msgBufferInfo *bufferInfoTabAddr;
@ -20,20 +21,23 @@ int i;
/** 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);
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; }
&& (bufferInfoTabAddr[i].ownerPid != (pid_t) - 1)) {
i++;
}
if (i == bufferInfoNb) {
return -1;
}
bufferFreeIndex = i;
if (munmap(bufferInfoTabAddr,bufferInfoNb*sizeof(msgBufferInfo))< 0)
{
if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
NZG_ERROR("munmap", bufferInfoTabId);
return -1;
}
return bufferFreeIndex;
}

42
src/bufferGetProcAttach.c
View file

@ -1,12 +1,9 @@
#include "libnazgul.h"
int msgBufferGetProcAttach(
msgPoolData * poolDataTabAddr,
int msgBufferGetProcAttach(msgPoolData * poolDataTabAddr,
int poolNb,
int * poolIndex,
int * bufferIndex,
void * addr
){
int *poolIndex, int *bufferIndex, void *addr)
{
msgBufferInfoTabId bufferInfoTabId;
int bufferInfoTabFd;
msgBufferInfo *bufferInfoTabAddr;
@ -21,13 +18,17 @@ int msgBufferGetProcAttach(
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;
@ -38,14 +39,23 @@ int msgBufferGetProcAttach(
};
bIdx++;
}
if (found){ (*poolIndex)=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; }
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;
}
}

18
src/bufferInfoTabCreate.c
View file

@ -1,11 +1,10 @@
#include "libnazgul.h"
#include "ids.h"
int msgBufferInfoTabCreate(
msgSpaceId externId,
int msgBufferInfoTabCreate(msgSpaceId externId,
msgPoolData * poolDataTabAddr,
int poolIdx,
int bufferNb) {
int poolIdx, int bufferNb)
{
int bufferInfoTabFd;
msgBufferInfoTabId bufferInfoTabId;
@ -16,10 +15,12 @@ int msgBufferInfoTabCreate(
return -1;
}
bufferInfoTabFd=shm_open(bufferInfoTabId,O_RDWR|O_CREAT|O_EXCL|O_TRUNC,MSGSPACE_DEFAULT_MODE);
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 ) );
fprintf(stderr, "msgInfoTab : %s creation failed: %s\n",
bufferInfoTabId, strerror(errno));
return -1;
}
if (ftruncate(bufferInfoTabFd, bufferNb * sizeof(msgBufferInfo)) == -1) {
@ -32,6 +33,7 @@ int msgBufferInfoTabCreate(
msgBufferInfoTabInit(poolDataTabAddr, poolIdx);
return -1;NZG_ERROR("munmap",bufferInfoTabId);
return -1;
NZG_ERROR("munmap", bufferInfoTabId);
return -1;
}

16
src/bufferInfoTabInit.c
View file

@ -1,6 +1,7 @@
#include "libnazgul.h"
int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr,int poolIndex){
int msgBufferInfoTabInit(msgPoolData * poolDataTabAddr, int poolIndex)
{
msgBufferInfoTabId bufferInfoTabId;
int bufferInfoTabFd;
msgBufferInfo *bufferInfoTabAddr;
@ -10,7 +11,8 @@ int i;
//récuperer l'ID du BufferInfoTab;
strcpy(bufferInfoTabId, poolDataTabAddr[poolIndex].bufferInfoTabId);
printf("msgBufferInfoTabId %d open >>%s<<\n",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);
@ -20,15 +22,17 @@ int i;
/** 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);
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; }
if (munmap(bufferInfoTabAddr, bufferInfoNb * sizeof(msgBufferInfo)) < 0) {
perror("munmap");
return -1;
}
return 0;
}

13
src/bufferMap.c
View file

@ -1,7 +1,7 @@
#include "libnazgul.h"
void * msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex) {
void *msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex)
{
void *resultAddr;
int bufferSize, bufferNb;
int poolBufferTabFd;
@ -20,15 +20,10 @@ void * msgBufferMap(msgPoolData * poolDataTab, int poolIndex, int bufferIndex) {
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);
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;

15
src/free.c
View file

@ -1,6 +1,7 @@
#include "libnazgul.h"
int msgFree(msgSpace * space, void * addr){
int msgFree(msgSpace * space, void *addr)
{
int poolIndex;
int bufferIndex;
@ -25,14 +26,11 @@ int msgFree(msgSpace * space, void * addr){
// TODO: verouiller semaphore DataInfo ??
poolIndex=-1; bufferIndex=-1;
err=msgBufferGetProcAttach(
poolDataTabAddr,
poolIndex = -1;
bufferIndex = -1;
err = msgBufferGetProcAttach(poolDataTabAddr,
space->poolNb,
&poolIndex,
&bufferIndex,
addr
);
&poolIndex, &bufferIndex, addr);
printf("Found : %d\n", err);
printf("Freing pool: %d, buffer: %d\n", poolIndex, bufferIndex);
@ -63,4 +61,3 @@ int msgFree(msgSpace * space, void * addr){
ERROR:
return -1;
}

9
src/get.c
View file

@ -2,7 +2,8 @@
#define NONBLOCK -1
void * msgGet(msgSpace * space,int queueIndex,int option){
void *msgGet(msgSpace * space, int queueIndex, int option)
{
void *resultAddr;
msgQueueId queueId;
msgQueue *queue;
@ -42,12 +43,12 @@ void * msgGet(msgSpace * space,int queueIndex,int option){
/* 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);
resultAddr =
msgBufferMap(poolDataTab, oldElem->poolIndex, oldElem->bufferIndex);
// attacher au buffer...
if (msgBufferAttachProc(poolDataTab,
oldElem->poolIndex,
oldElem->bufferIndex,
resultAddr) <0){
oldElem->bufferIndex, resultAddr) < 0) {
NZG_ERROR("msgBufferAttachProc", oldElemId);
goto ERROR;
}

2
src/global.h
View file

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

62
src/ids.c
View file

@ -1,7 +1,8 @@
#include "libnazgul.h"
#include "ids.h"
int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src ){
int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src)
{
if (strlen(src) > MSGSPACE_ID_LEN) {
return -1;
}
@ -13,9 +14,9 @@ int msgSpaceIdIntern(msgSpaceId dest,const msgSpaceId src ){
#endif
return 0;
}
int msgPoolDataTabSemIdIntern(
msgPoolSemId destSemId,
const msgSpaceId externId){
int msgPoolDataTabSemIdIntern(msgPoolSemId destSemId, const msgSpaceId externId)
{
if (strlen(externId) > MSGSPACE_ID_LEN * 4) {
return -1;
}
@ -27,10 +28,10 @@ int msgPoolDataTabSemIdIntern(
#endif
return 0;
}
int msgPoolSemIdIntern(
msgPoolSemId destSemId,
const msgSpaceId srcPoolId,
int poolIdx){
int msgPoolSemIdIntern(msgPoolSemId destSemId,
const msgSpaceId srcPoolId, int poolIdx)
{
if (strlen(srcPoolId) > MSGSPACE_ID_LEN * 4) {
return -1;
}
@ -43,7 +44,8 @@ int msgPoolSemIdIntern(
return 0;
}
int msgPoolDataIdIntern(msgPoolDataTabId dest,const msgSpaceId src ){
int msgPoolDataIdIntern(msgPoolDataTabId dest, const msgSpaceId src)
{
if (strlen(src) > MSGSPACE_ID_LEN) {
return -1;
}
@ -56,8 +58,8 @@ int msgPoolDataIdIntern(msgPoolDataTabId dest,const msgSpaceId src ){
return 0;
}
int msgPoolIdIntern(msgPoolId dest,msgPoolId src, int num){
int msgPoolIdIntern(msgPoolId dest, msgPoolId src, int num)
{
if (strlen(src) > MSGSPACE_ID_LEN) {
return -1;
}
@ -69,10 +71,8 @@ int msgPoolIdIntern(msgPoolId dest,msgPoolId src, int num){
return 0;
}
int msgBufferInfoTabIdIntern(
msgBufferInfoTabId dest,
msgSpaceId src,
int num){
int msgBufferInfoTabIdIntern(msgBufferInfoTabId dest, msgSpaceId src, int num)
{
if (strlen(src) > MSGSPACE_ID_LEN) {
return -1;
}
@ -84,10 +84,9 @@ int msgBufferInfoTabIdIntern(
return 0;
}
int msgQueueProtSemIdIntern(
msgQueueSemId dest,
msgSpaceId externId,
int queueIdx){
int msgQueueProtSemIdIntern(msgQueueSemId dest,
msgSpaceId externId, int queueIdx)
{
if (strlen(externId) > MSGSPACE_ID_LEN) {
return -1;
}
@ -99,10 +98,9 @@ int msgQueueProtSemIdIntern(
return 0;
}
int msgQueueReadSemIdIntern(
msgQueueSemId dest,
msgSpaceId externId,
int queueIdx){
int msgQueueReadSemIdIntern(msgQueueSemId dest,
msgSpaceId externId, int queueIdx)
{
if (strlen(externId) > MSGSPACE_ID_LEN) {
return -1;
}
@ -114,10 +112,8 @@ int msgQueueReadSemIdIntern(
return 0;
}
int msgQueueIdIntern(
msgQueueId dest,
msgSpaceId externId,
int queueIdx){
int msgQueueIdIntern(msgQueueId dest, msgSpaceId externId, int queueIdx)
{
if (strlen(externId) > MSGSPACE_ID_LEN) {
return -1;
}
@ -129,10 +125,8 @@ int msgQueueIdIntern(
return 0;
}
int msgQueueElemIdIntern(
msgQueueElemId dest,
msgQueueId src,
int counter){
int msgQueueElemIdIntern(msgQueueElemId dest, msgQueueId src, int counter)
{
if (strlen(src) > MSGSPACE_ID_LEN) {
return -1;
}
@ -140,7 +134,8 @@ int msgQueueElemIdIntern(
return 0;
}
int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId,msgSpaceId externId){
int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId, msgSpaceId externId)
{
if (strlen(externId) > MSGSPACE_ID_LEN) {
return -1;
}
@ -153,6 +148,3 @@ int msgSpaceListElemIdIntern(msgSpaceListElemId elemListId,msgSpaceId externId){
return 0;
}

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

2
src/iface.h
View file

@ -46,7 +46,6 @@ typedef struct MsgPoolData {
/* TODO: queueId */
typedef struct MsgSpace {
msgSpaceId id;
msgSpaceId externId;
@ -57,7 +56,6 @@ typedef struct MsgSpace {
msgPoolDataTabSemId poolDataTabSemId;
} msgSpace;
typedef struct MsgSpaceListElem {
msgSpaceListElemId id;

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

27
src/poolCreate.c
View file

@ -1,12 +1,8 @@
#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;
@ -15,10 +11,13 @@ int msgPoolCreate(
/* creation des buffers DEBUT */
if (msgPoolIdIntern(poolId, externId, poolIdx) == -1) {
fprintf( stderr, "msgPoolId creation failed for id %s\n", (char*)poolId );
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);
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));
@ -36,14 +35,17 @@ int msgPoolCreate(
(char *)poolRessourceSemId);
return -1;
}
// on met un semaphore sur le pool
ressourceSemFd = sem_open(poolRessourceSemId, O_CREAT|O_EXCL,SEM_DEFAULT_MODE, 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);
NZG_ERROR("sem_open : creation de la ressource",
poolRessourceSemId);
goto ERROR;
} else {
printf("[ Created %s with %d ressources ]\n",poolRessourceSemId,buffNb);
printf("[ Created %s with %d ressources ]\n",
poolRessourceSemId, buffNb);
}
//TODO: verrifier les erreurs sur l'ouverture de la sem
@ -58,4 +60,3 @@ int msgPoolCreate(
ERROR:
return -1;
}

3
src/poolDataTabClose.c
View file

@ -1,6 +1,7 @@
#include "libnazgul.h"
int msgPoolDataTabClose(msgSpace * space,void * addr){
int msgPoolDataTabClose(msgSpace * space, void *addr)
{
/* unmapper le msgPoolDataTab */
if (munmap(addr, (space->poolNb) * sizeof(msgPoolData)) < 0) {

11
src/poolDataTabCreate.c
View file

@ -1,14 +1,13 @@
#include "libnazgul.h"
#include "ids.h"
void * msgPoolDataTabCreate(msgSpace * space){
void *msgPoolDataTabCreate(msgSpace * space)
{
int poolDataFd; // shm file descriptor
msgPoolData *poolDataTabAddr;
poolDataFd=shm_open(
space->poolDataTabId,
poolDataFd = shm_open(space->poolDataTabId,
O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
MSGSPACE_DEFAULT_MODE
);
MSGSPACE_DEFAULT_MODE);
if (poolDataFd == -1) {
NZG_ERROR("shm_open :create", space->poolDataTabId);
goto ERROR;
@ -38,5 +37,3 @@ void * msgPoolDataTabCreate(msgSpace * space){
ERROR:
return NULL;
}

19
src/poolDataTabLock.c
View file

@ -3,17 +3,17 @@
#define DEBUG 0
int msgPoolDataTabLock(msgSpace * space){
int msgPoolDataTabLock(msgSpace * space)
{
int semval;
sem_t *poolDataTabSemFd;
semval = 0;
if (DEBUG) {printf("Locking %s\n",space->poolDataTabSemId);}
if (DEBUG) {
printf("Locking %s\n", space->poolDataTabSemId);
}
poolDataTabSemFd=sem_open(
space->poolDataTabSemId
,O_CREAT,
SEM_DEFAULT_MODE,
1);
poolDataTabSemFd = sem_open(space->poolDataTabSemId, O_CREAT,
SEM_DEFAULT_MODE, 1);
if (poolDataTabSemFd == SEM_FAILED) {
NZG_ERROR("sem_open", space->poolDataTabSemId);
goto ERROR;
@ -25,7 +25,9 @@ int msgPoolDataTabLock(msgSpace * space){
}
sem_getvalue(poolDataTabSemFd, &semval);
if (DEBUG) { printf("(AfternValue:%d)\n",semval);}
if (DEBUG) {
printf("(AfternValue:%d)\n", semval);
}
sem_close(poolDataTabSemFd);
@ -33,4 +35,3 @@ int msgPoolDataTabLock(msgSpace * space){
ERROR:
return -1;
}

7
src/poolDataTabOpen.c
View file

@ -1,19 +1,18 @@
#include "libnazgul.h"
#include "ids.h"
void * msgPoolDataTabOpen(msgSpace * space){
void *msgPoolDataTabOpen(msgSpace * space)
{
int poolDataTabFd;
void *poolDataTabAddr;
poolDataTabFd = shm_open(space->poolDataTabId,
O_RDWR,
MSGSPACE_DEFAULT_MODE);
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);

19
src/poolDataTabUnlock.c
View file

@ -3,15 +3,15 @@
#define DEBUG 0
int msgPoolDataTabUnlock(msgSpace * space){
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 (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;
@ -24,7 +24,9 @@ int msgPoolDataTabUnlock(msgSpace * space){
semval = 0;
sem_getvalue(poolDataTabSemFd, &semval);
if (DEBUG) { printf("(AfternValue:%d)\n",semval); }
if (DEBUG) {
printf("(AfternValue:%d)\n", semval);
}
sem_close(poolDataTabSemFd);
@ -32,4 +34,3 @@ int msgPoolDataTabUnlock(msgSpace * space){
ERROR:
return -1;
}

17
src/poolDelete.c
View file

@ -1,32 +1,31 @@
#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 );
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 ) );
fprintf(stderr, "msgInfoTab : %s deletion failed: %s\n",
bufferInfoTabId, strerror(errno));
return -1;
}
/* 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 );
fprintf(stderr, "msgPoolId creation failed for id %s\n",
(char *)poolId);
return -1;
}
if (shm_unlink(poolId) < 0) {

36
src/proto.h
View file

@ -4,17 +4,22 @@
/* allocate.c */
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);
/* 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);
/* bufferMap.c */
@ -25,16 +30,21 @@ int msgFree(msgSpace *space, void *addr);
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);
@ -61,7 +71,8 @@ int msgQueueDelete(msgQueueId externId, int queueIdx);
/* queueElemClose.c */
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 */
@ -85,7 +96,8 @@ int msgQueueRem(msgQueue *queue, msgQueueElemId oldElemId);
/* spaceClose.c */
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 */

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

16
src/put.c
View file

@ -1,6 +1,7 @@
#include "libnazgul.h"
int msgPut(msgSpace * space,int queueIndex, void * addr){
int msgPut(msgSpace * space, int queueIndex, void *addr)
{
// retrouver le pool, buffer qui correspondent à l'addresse...
msgPoolData *poolDataTabAddr;
int poolIndex;
@ -17,17 +18,12 @@ int msgPut(msgSpace * space,int queueIndex, void * addr){
NZG_ERROR("msgPoolDataTabOpen", space->poolDataTabId);
goto ERROR;
}
err = msgBufferGetProcAttach(
poolDataTabAddr,
err = msgBufferGetProcAttach(poolDataTabAddr,
space->poolNb,
&poolIndex,
&bufferIndex,
addr
);
&poolIndex, &bufferIndex, addr);
if (err) {
//FIXME
}
// ouvrir la queue avec le bon index
msgQueueIdIntern(queueId, space->externId, queueIndex);
@ -49,13 +45,11 @@ int msgPut(msgSpace * space,int queueIndex, void * addr){
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);
@ -70,5 +64,3 @@ int msgPut(msgSpace * space,int queueIndex, void * addr){
ERROR:
return -1;
}

3
src/queueAdd.c
View file

@ -2,7 +2,8 @@
// on ajoute en fin de queue...
int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId){
int msgQueueAdd(msgQueue * queue, msgQueueElemId newElemId)
{
msgQueueElem *queueOldTailElem;
msgQueueElem *queueNewTailElem;

3
src/queueClose.c
View file

@ -1,7 +1,8 @@
#include "libnazgul.h"
#include "ids.h"
int msgQueueClose(msgQueue * queue){
int msgQueueClose(msgQueue * queue)
{
msgQueueId qId;
strcpy(qId, queue->id);

5
src/queueDelete.c
View file

@ -1,6 +1,7 @@
#include "libnazgul.h"
int msgQueueDelete(msgQueueId externId,int queueIdx){
int msgQueueDelete(msgQueueId externId, int queueIdx)
{
msgQueue *queue;
msgQueueId queueId;
msgQueueSemId queueProtLockSemId;
@ -31,5 +32,3 @@ int msgQueueDelete(msgQueueId externId,int queueIdx){
ERROR:
return -1;
}

3
src/queueElemClose.c
View file

@ -1,6 +1,7 @@
#include "libnazgul.h"
int msgQueueElemClose(msgQueueElem * queueElem){
int msgQueueElemClose(msgQueueElem * queueElem)
{
msgQueueElemId qId;
strcpy(qId, queueElem->id);

7
src/queueElemCreate.c
View file

@ -1,10 +1,9 @@
#include "libnazgul.h"
#include "ids.h"
int msgQueueElemCreate(
msgQueueElemId finalQueueElemId ,
msgQueueId queueId,
int counter){
int msgQueueElemCreate(msgQueueElemId finalQueueElemId,
msgQueueId queueId, int counter)
{
msgQueueElemId queueElemId;
int queueElemFd;

4
src/queueElemDelete.c
View file

@ -1,6 +1,7 @@
#include "libnazgul.h"
int msgQueueElemDelete(msgQueueElemId queueElemId){
int msgQueueElemDelete(msgQueueElemId queueElemId)
{
msgQueueElem *queueElem;
msgQueueElemId nextIdToDie;
@ -16,7 +17,6 @@ int msgQueueElemDelete(msgQueueElemId queueElemId){
NZG_ERROR("msgQueueElemClose", queueElemId);
goto ERROR;
}
// on détruit l'élément
shm_unlink(queueElemId);

7
src/queueElemOpen.c
View file

@ -1,7 +1,8 @@
#include "libnazgul.h"
#include "ids.h"
void * msgQueueElemOpen(msgQueueElemId queueElemId){
void *msgQueueElemOpen(msgQueueElemId queueElemId)
{
int queueElemFd;
void *queueElemAddr;
@ -14,9 +15,7 @@ void * msgQueueElemOpen(msgQueueElemId queueElemId){
queueElemAddr = mmap(NULL,
sizeof(msgQueueElem),
PROT_READ | PROT_WRITE,
MAP_SHARED,
queueElemFd,
0);
MAP_SHARED, queueElemFd, 0);
if (queueElemAddr == MAP_FAILED) {
NZG_ERROR("mmap", queueElemId);
goto ERROR;

12
src/queueInit.c
View file

@ -1,7 +1,8 @@
#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;
@ -12,7 +13,6 @@ msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) {
queue = NULL;
msgQueueProtSemIdIntern(queueSemProtectId, externId, queueIdx);
msgQueueReadSemIdIntern(queueSemReadableId, externId, queueIdx);
@ -23,7 +23,6 @@ msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) {
NZG_ERROR("sem_open", queueSemReadableId);
goto ERROR;
}
// creation du semaphore de protection
semProtectFd = sem_open(queueSemProtectId,
O_CREAT | O_EXCL, SEM_DEFAULT_MODE, 0);
@ -41,15 +40,16 @@ msgQueue * msgQueueInit(msgSpaceId externId, int queueIdx) {
return NULL;
}
queueFd = shm_open(queueId, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, MSGSPACE_DEFAULT_MODE);
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 ) );
fprintf(stderr, "Queue resizing failed: %s\n", strerror(errno));
return NULL;
}

8
src/queueOpen.c
View file

@ -1,7 +1,8 @@
#include "libnazgul.h"
#include "ids.h"
void * msgQueueOpen(msgQueueId queueId){
void *msgQueueOpen(msgQueueId queueId)
{
int queueFd;
void *queueAddr;
@ -13,10 +14,7 @@ void * msgQueueOpen(msgQueueId queueId){
queueAddr = mmap(NULL,
sizeof(msgQueue),
PROT_READ|PROT_WRITE,
MAP_SHARED,
queueFd,
0);
PROT_READ | PROT_WRITE, MAP_SHARED, queueFd, 0);
if (queueAddr == MAP_FAILED) {
NZG_ERROR("mmap", queueId);
goto ERROR;

12
src/queueProtLock.c
View file

@ -2,13 +2,16 @@
#include "ids.h"
#define DEBUG 0
int msgQueueProtLock(msgSpaceId externId,int queueIdx){
int msgQueueProtLock(msgSpaceId externId, int queueIdx)
{
int semval;
sem_t *queueSemFd;
msgQueueSemId queueSemId;
msgQueueProtSemIdIntern(queueSemId, externId, queueIdx);
if (DEBUG) { printf("Locking %s\n",queueSemId);}
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);
@ -21,7 +24,9 @@ int msgQueueProtLock(msgSpaceId externId,int queueIdx){
}
semval = 0;
sem_getvalue(queueSemFd, &semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
if (DEBUG) {
printf("(AfterValue:%d)\n", semval);
}
sem_close(queueSemFd);
sem_close(queueSemFd);
@ -30,4 +35,3 @@ int msgQueueProtLock(msgSpaceId externId,int queueIdx){
ERROR:
return -1;
}

12
src/queueProtUnlock.c
View file

@ -3,13 +3,16 @@
#define DEBUG 0
int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){
int msgQueueProtUnlock(msgSpaceId externId, int queueIdx)
{
int semval;
sem_t *queueSemFd;
msgQueueSemId queueSemId;
msgQueueProtSemIdIntern(queueSemId, externId, queueIdx);
if (DEBUG) { printf("Unlocking %s\n",queueSemId); }
if (DEBUG) {
printf("Unlocking %s\n", queueSemId);
}
queueSemFd = sem_open(queueSemId, O_CREAT, SEM_DEFAULT_MODE, 1);
if (queueSemFd == SEM_FAILED) {
@ -23,7 +26,9 @@ int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){
}
semval = 0;
sem_getvalue(queueSemFd, &semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
if (DEBUG) {
printf("(AfterValue:%d)\n", semval);
}
sem_close(queueSemFd);
@ -31,4 +36,3 @@ int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){
ERROR:
return -1;
}

12
src/queueReadLock.c
View file

@ -3,13 +3,16 @@
#define DEBUG 0
int msgQueueReadLock(msgSpaceId externId,int queueIdx){
int msgQueueReadLock(msgSpaceId externId, int queueIdx)
{
int semval;
sem_t *queueSemFd;
msgQueueSemId queueSemId;
msgQueueReadSemIdIntern(queueSemId, externId, queueIdx);
if (DEBUG) { printf("Locking %s\n",queueSemId); }
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);
@ -22,7 +25,9 @@ int msgQueueReadLock(msgSpaceId externId,int queueIdx){
}
semval = 0;
sem_getvalue(queueSemFd, &semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
if (DEBUG) {
printf("(AfterValue:%d)\n", semval);
}
sem_close(queueSemFd);
@ -30,4 +35,3 @@ int msgQueueReadLock(msgSpaceId externId,int queueIdx){
ERROR:
return -1;
}

12
src/queueReadTryLock.c
View file

@ -3,7 +3,8 @@
#define DEBUG 0
int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){
int msgQueueReadTryLock(msgSpaceId externId, int queueIdx)
{
int semval;
sem_t *queueSemFd;
msgQueueSemId queueSemId;
@ -19,10 +20,14 @@ int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){
NZG_ERROR("sem_wait", queueSemId);
goto ERROR;
}
if (DEBUG) { printf("Locking %s\n",queueSemId); }
if (DEBUG) {
printf("Locking %s\n", queueSemId);
}
semval = 0;
sem_getvalue(queueSemFd, &semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
if (DEBUG) {
printf("(AfterValue:%d)\n", semval);
}
sem_close(queueSemFd);
@ -30,4 +35,3 @@ int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){
ERROR:
return -1;
}

13
src/queueReadUnlock.c
View file

@ -3,13 +3,16 @@
#define DEBUG 0
int msgQueueReadUnlock(msgSpaceId externId,int queueIdx){
int msgQueueReadUnlock(msgSpaceId externId, int queueIdx)
{
int semval;
sem_t *queueSemFd;
msgQueueSemId queueSemId;
msgQueueReadSemIdIntern(queueSemId, externId, queueIdx);
if (DEBUG) { printf("Unlocking %s\n",queueSemId); }
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);
@ -22,8 +25,9 @@ int msgQueueReadUnlock(msgSpaceId externId,int queueIdx){
}
semval = 0;
sem_getvalue(queueSemFd, &semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
if (DEBUG) {
printf("(AfterValue:%d)\n", semval);
}
sem_close(queueSemFd);
@ -31,4 +35,3 @@ int msgQueueReadUnlock(msgSpaceId externId,int queueIdx){
ERROR:
return -1;
}

5
src/queueRem.c
View file

@ -2,10 +2,10 @@
// l'id de l'element enlevé vas dans oldElemId
int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId){
int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId)
{
msgQueueElem *queueOldHeadElem;
if (strcmp(queue->headId, queue->id) == 0) {
NZG_ERROR("msgQueueElemRem : Empty queue", queue->id);
goto ERROR;
@ -17,7 +17,6 @@ int msgQueueRem(msgQueue * queue, msgQueueElemId oldElemId){
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) {

3
src/spaceClose.c
View file

@ -1,6 +1,7 @@
#include "libnazgul.h"
int msgSpaceClose(msgSpace * space){
int msgSpaceClose(msgSpace * space)
{
msgSpaceId spaceId;
strcpy(spaceId, space->id);

48
src/spaceCreate.c
View file

@ -4,8 +4,8 @@
/* 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 msgPoolDataTabSemIdIntern(msgPoolSemId destSemId,
const msgSpaceId externId);
/*
* spaceId : identifiant externe de l'espace de msg
* queueNb : nombre de files de messages
@ -13,11 +13,9 @@ int msgPoolDataTabSemIdIntern(
* queueNbCar : tableau de caracteristiques des different pool
*/
msgSpace * msgSpaceCreate(
msgSpaceId externId,
int queueNb,
int poolNb,
msgPool * poolInfos ){
msgSpace *msgSpaceCreate(msgSpaceId externId,
int queueNb, int poolNb, msgPool * poolInfos)
{
msgSpaceId nzgId;
/* msgSpaceList mSList; */
int mSFd; // shm file descriptor
@ -72,11 +70,9 @@ msgSpace * msgSpaceCreate(
printf("spaceListUnlock ok\n");
fprintf(stderr, "Creating msgSpace with id : %s\n", nzgId);
mSFd=shm_open(
nzgId,
mSFd = shm_open(nzgId,
O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
MSGSPACE_DEFAULT_MODE
);
MSGSPACE_DEFAULT_MODE);
if (mSFd == -1) {
NZG_ERROR("shm_open : msgSpace creation", nzgId);
goto ERROR;
@ -90,14 +86,14 @@ msgSpace * msgSpaceCreate(
/* Map the memory object */
space = mmap(0, sizeof(*space),
PROT_READ | PROT_WRITE,
MAP_SHARED, mSFd, 0 );
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());
printf("CREAT: msgSpace mapped to 0x%08lx in %d\n", (long)space,
(int)getpid());
/* on ferme le descripteur du fichier */
close(mSFd);
@ -142,14 +138,18 @@ msgSpace * msgSpaceCreate(
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",
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);
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",
@ -157,17 +157,20 @@ msgSpace * msgSpaceCreate(
return NULL;
}
strcpy(poolDataTabAddr[i].poolId, poolId);
msgPoolCreate(externId,i,poolInfos[i].bufferNb,poolInfos[i].bufferSize);
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);
printf("- queue %i...", i);
fflush(stdout);
if (msgQueueInit(space->externId, i) < 0) {
printf("fail.\n");
NZG_ERROR("msgQueueInit : queue ?? for",space->externId);
NZG_ERROR("msgQueueInit : queue ?? for",
space->externId);
goto ERROR;
}
printf("ok.\n");
@ -192,6 +195,3 @@ msgSpace * msgSpaceCreate(
ERROR:
return NULL;
}

8
src/spaceDelete.c
View file

@ -4,10 +4,11 @@
/* 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 msgPoolDataTabSemIdIntern(msgPoolSemId destSemId,
const msgSpaceId externId);
int msgSpaceDelete(msgSpaceId externId){
int msgSpaceDelete(msgSpaceId externId)
{
//int shmId;
msgSpaceId nzgId;
msgSpace *space;
@ -64,4 +65,3 @@ int msgSpaceDelete(msgSpaceId externId){
ERROR:
return -1;
}

3
src/spaceListAdd.c
View file

@ -3,7 +3,8 @@
// 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){
int msgSpaceListAdd(msgSpaceListElemId newElemId)
{
msgSpaceListElem *listOldTailElem;
msgSpaceListElem *listNewTailElem;
msgSpaceList *list;

3
src/spaceListClose.c
View file

@ -1,7 +1,8 @@
#include "libnazgul.h"
#include "ids.h"
int msgSpaceListClose(msgSpaceList * list){
int msgSpaceListClose(msgSpaceList * list)
{
msgSpaceListId spaceListId;
strcpy(spaceListId, DEFAULT_MSGSPACELISTID);

8
src/spaceListElemCreate.c
View file

@ -2,9 +2,7 @@
#include "ids.h"
// cree un nouvel elemen
int msgSpaceListElemCreate(
msgSpaceListElemId listElemId,
msgSpace * space)
int msgSpaceListElemCreate(msgSpaceListElemId listElemId, msgSpace * space)
{
int listElemFd;
@ -35,9 +33,7 @@ int msgSpaceListElemCreate(
strcpy(listElem->next, listElemId);
strcpy(listElem->spaceId, space->id);
printf("[ ListElem : id %s,next: %s, Sid: %s ]\n",
listElem->id,
listElem->next,
listElem->spaceId);
listElem->id, listElem->next, listElem->spaceId);
if (msgSpaceListElemClose(listElem) < 0) {
NZG_ERROR("msgSpaceListElemClose", listElemId);
}

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

9
src/spaceListElemOpen.c
View file

@ -2,7 +2,8 @@
#include "ids.h"
// cree un nouvel elemen
void * msgSpaceListElemOpen(msgSpaceListElemId listElemId){
void *msgSpaceListElemOpen(msgSpaceListElemId listElemId)
{
int listElemFd;
void *listElemAddr;
@ -14,10 +15,7 @@ void * msgSpaceListElemOpen(msgSpaceListElemId listElemId){
listElemAddr = mmap(NULL,
sizeof(msgQueueElem),
PROT_READ|PROT_WRITE,
MAP_SHARED,
listElemFd,
0);
PROT_READ | PROT_WRITE, MAP_SHARED, listElemFd, 0);
if (listElemAddr == MAP_FAILED) {
NZG_ERROR("mmap", listElemId);
@ -29,5 +27,4 @@ void * msgSpaceListElemOpen(msgSpaceListElemId listElemId){
ERROR:
return NULL;
};

20
src/spaceListFindId.c
View file

@ -2,7 +2,8 @@
#define DEBUG 1
int msgSpaceListFindId(msgSpaceId externId){
int msgSpaceListFindId(msgSpaceId externId)
{
msgSpaceList *list;
msgSpaceId spaceId;
msgSpaceListElemId listHeadElemId;
@ -15,15 +16,21 @@ int msgSpaceListFindId(msgSpaceId externId){
NZG_ERROR("msgSpaceListOpen", "");
goto ERROR;
}
if (DEBUG) { printf("Before ListStrCpy\n"); }
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 (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"); }
if (DEBUG) {
printf("SpaceList : vide\n");
}
return 1;
} else {
return msgSpaceListElemFindId(listHeadElemId, spaceId);
@ -37,7 +44,8 @@ ERROR:
return -1;
}
int msgSpaceListElemFindId(msgSpaceListElemId elemId,msgSpaceId spaceId){
int msgSpaceListElemFindId(msgSpaceListElemId elemId, msgSpaceId spaceId)
{
msgSpaceListElem *listElem;
msgSpaceListElemId listElemIdNext;
msgSpaceId currentElemSpaceId;
@ -75,5 +83,3 @@ int msgSpaceListElemFindId(msgSpaceListElemId elemId,msgSpaceId spaceId){
ERROR:
return -1;
}

9
src/spaceListInit.c
View file

@ -1,7 +1,8 @@
#include "libnazgul.h"
#include "ids.h"
int msgSpaceListInit(){
int msgSpaceListInit()
{
int spaceListFd;
sem_t *spaceListSemFd;
msgSpaceList *list;
@ -22,12 +23,9 @@ int msgSpaceListInit(){
}
}
/*Fait un segment de memoir partager sur espace de listelement */
spaceListFd = shm_open(spaceListId,
O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
0666);
O_RDWR | O_CREAT | O_EXCL | O_TRUNC, 0666);
if (spaceListFd == -1) {
spaceListFd = shm_open(spaceListId, O_RDWR, 0666);
if (spaceListFd == -1) {
@ -73,4 +71,3 @@ EXISTING:
return 0;
};

12
src/spaceListLocking.c
View file

@ -1,9 +1,9 @@
#include "libnazgul.h"
// verouille le semaphore de la liste
int msgSpaceListLock(){
int msgSpaceListLock()
{
sem_t *msgSpaceListSemFd;
msgSpaceListSemId spaceListSemId;
strcpy(spaceListSemId, DEFAULT_MSGSPACELISTSEMID);
@ -33,14 +33,13 @@ ERROR:
return -1;
}
// deverouille le semaphore de la liste
int msgSpaceListUnlock(){
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) {
@ -48,14 +47,12 @@ int msgSpaceListUnlock(){
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);
@ -66,4 +63,3 @@ int msgSpaceListUnlock(){
ERROR:
return -1;
};

8
src/spaceListOpen.c
View file

@ -1,7 +1,8 @@
#include "libnazgul.h"
#include "ids.h"
void * msgSpaceListOpen(){
void *msgSpaceListOpen()
{
int listFd;
void *listAddr;
@ -16,10 +17,7 @@ void * msgSpaceListOpen(){
listAddr = mmap(NULL,
sizeof(msgSpaceList),
PROT_READ|PROT_WRITE,
MAP_SHARED,
listFd,
0);
PROT_READ | PROT_WRITE, MAP_SHARED, listFd, 0);
if (listAddr == MAP_FAILED) {
NZG_ERROR("mmap", spaceListId);
goto ERROR;

46
src/spaceListRem.c
View file

@ -2,7 +2,8 @@
#define DEBUG 1
int msgSpaceListRem(msgSpaceId spaceId){
int msgSpaceListRem(msgSpaceId spaceId)
{
msgSpaceList *list;
msgSpaceListElemId listHeadElemId;
msgSpaceListElemId listTailElemId;
@ -21,14 +22,20 @@ int msgSpaceListRem(msgSpaceId spaceId){
NZG_ERROR("msgSpaceListOpen", "");
goto ERROR;
}
if (DEBUG) { printf("Before ListStrCpy\n"); }
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 (DEBUG) {
printf("After ListStrCpy\n");
}
if ((strcmp(listHeadElemId, listId) == 0)
&& strcmp(listTailElemId, listId) == 0) {
if (DEBUG) { printf("SpaceList : vide\n"); }
if (DEBUG) {
printf("SpaceList : vide\n");
}
return 1;
} else {
bool found = false;
@ -67,22 +74,34 @@ int msgSpaceListRem(msgSpaceId spaceId){
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);
strcpy(list->headId,
nextElemId);
} else {
if (strcmp(currElemId,nextElemId)==0){
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);
strcpy(list->tailId,
prevElemId);
// - on fait pointer le précédent sur lui-meme
prevElem=msgSpaceListElemOpen(prevElemId);
strcpy(prevElem->next,prevElemId);
msgSpaceListElemClose(prevElem);
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);
prevElem =
msgSpaceListElemOpen
(prevElemId);
strcpy(prevElem->next,
nextElemId);
msgSpaceListElemClose
(prevElem);
}
}
// - on détruit l'actuel
@ -107,4 +126,3 @@ int msgSpaceListRem(msgSpaceId spaceId){
ERROR:
return -1;
}

13
src/spaceOpen.c
View file

@ -5,8 +5,8 @@
int msgSpaceIdIntern(msgSpaceId dest, const msgSpaceId src);
int msgPoolDataIdIntern(msgSpaceId dest, const msgSpaceId src);
msgSpace * msgSpaceOpen(msgSpaceId externId){
msgSpace *msgSpaceOpen(msgSpaceId externId)
{
int shmFd;
msgSpaceId nzgId;
msgSpace *mSAddr;
@ -17,10 +17,11 @@ msgSpace * msgSpaceOpen(msgSpaceId externId){
perror("shm_open");
return NULL;
}
mSAddr=mmap(NULL,sizeof(msgSpace),PROT_READ|PROT_WRITE,MAP_SHARED,shmFd,(off_t)0);
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());
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"

5
test/test_create_delete.c
View file

@ -6,7 +6,8 @@
#include "libnazgul.h"
int main(void) {
int main(void)
{
// msgSpace mS=0;
pid_t pid;
@ -35,8 +36,6 @@ int main(void) {
pid = fork();
if (pid == 0) {
mSPAC = msgSpaceOpen(testId);
sleep(5);

35
test/test_msgSpaceState.c
View file

@ -6,11 +6,13 @@
#include "libnazgul.h"
void usage(char * myname){
void usage(char *myname)
{
printf("Usage: %s [--all | msgSpaceId1 msgSpaceId2 ... ]\n", myname);
}
int about(char * spaceId){
int about(char *spaceId)
{
msgPoolDataTabSemId ressourceSemId;
sem_t *ressourceSemFd;
int i;
@ -33,27 +35,35 @@ int about(char * 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);
msgPoolSemIdIntern(ressourceSemId,
space->externId, i);
ressourceSemFd =
sem_open(ressourceSemId, O_CREAT,
SEM_DEFAULT_MODE, 0);
if (ressourceSemFd == SEM_FAILED) {
NZG_ERROR("sem_open",ressourceSemId);
NZG_ERROR("sem_open",
ressourceSemId);
goto ERROR;
}
if (sem_getvalue(ressourceSemFd, &ressourceSemVal) < 0){
NZG_ERROR("sem_getvalue",ressourceSemId);
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",
printf
("- %d/%d free buffers in pool #%d\n",
ressourceSemVal,
poolDataTab[i].bufferNb,
i);
poolDataTab[i].bufferNb, i);
msgPoolDataTabClose(space, poolDataTab);
msgPoolDataTabUnlock(space);
if (sem_close(ressourceSemFd) < 0) {
NZG_ERROR("sem_getvalue",ressourceSemId);
NZG_ERROR("sem_getvalue",
ressourceSemId);
goto ERROR;
}
// pour chaque buffer, dire s'il est libre ou pas
@ -74,7 +84,8 @@ ERROR:
return -1;
}
int main(int argc,char **argv){
int main(int argc, char **argv)
{
printf("Args %d\n", argc);
if (argc < 2) {
usage(argv[0]);

10
test/test_put_get_mono.c
View file

@ -6,7 +6,8 @@
#include "libnazgul.h"
int main(void) {
int main(void)
{
// msgSpace mS=0;
msgSpaceId testId;
@ -38,12 +39,13 @@ int main(void) {
montext = msgAllocate(mSPAC, 1, 280, 0);
*montext = 42;
printf("### test Valeur0 %d ###\n", (int)*montext);
printf("Put..."); fflush(stdout);
printf("Put...");
fflush(stdout);
msgPut(mSPAC, 0, montext);
printf("put-ok\n");
printf("Get..."); fflush(stdout);
printf("Get...");
fflush(stdout);
montext = msgGet(mSPAC, 0, 0);
printf("get-ok\n");
printf("### test Reception %d ###\n", (int)*montext);

9
test/test_put_get_multi.c
View file

@ -6,7 +6,8 @@
#include "libnazgul.h"
int main(void) {
int main(void)
{
// msgSpace mS=0;
msgSpaceId testId;
@ -38,12 +39,14 @@ if (pid==0){
montext = msgAllocate(mSPAC, 1, 280, 0);
*montext = 42;
printf("### test Valeur0 %d ###\n", (int)*montext);
printf("Put1..."); fflush(stdout);
printf("Put1...");
fflush(stdout);
msgPut(mSPAC, 0, montext);
printf("put1-ok\n");
} else {
mSPAC = msgSpaceOpen(testId);
printf("Get..."); fflush(stdout);
printf("Get...");
fflush(stdout);
montext = msgGet(mSPAC, 0, 0);
printf("get-ok\n");
printf("### test Reception %d ###\n", (int)*montext);