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

Update documentation & fix POSIX-related issues

Browse source
This commit is contained in:
glenux 2004-02-26 11:36:30 +00:00 committed by Glenn Y. Rolland
parent fc1cb56d19
commit 198cf8fe78
32 changed files with 223 additions and 145 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
doc/rapport/arbo.tex
View file

@ -8,19 +8,18 @@ Libnazgul/
|-- Makefile // Règles de compilation
|-- doc/
| |-- ennonce // Enoncé du projet en format postscript
| |-- rapport/ // Rapport Latex
| `-- rapport/ // Rapport Latex
| |-- Makefile // Règles de compilation
| |-- ...
| `-- ...
|
|--test
| |-- Makefile // Règles de compilation
| |-- create_delete // Le main de la fonction
| |-- put_get_mono // Test avec un seul processus
| |-- put_get_multi // Test avec plusieurs processus
| |-- create_delete // Le main de la fonction
| `-- *.c // Programmes de test
|
|
|-- src/ // Sources de la bibliothèque
`-- src/ // Sources de la bibliothèque
|-- Makefile // Règles de compilation
|-- ...
|-- *.h // En-têtes pour l'utilisation de Libnazgul
`-- *.c // Sources de Libnazgul
\end{verbatim}

26
doc/rapport/avenir.tex
View file

@ -1,12 +1,16 @@
\chapter{A venir}
\chapter{Conclusion}
\par Bien que nous ayons fini le projet, il se peut qu'il ne soit pas
sans défauts. C'est pourquoi dans l'avenir, il faudrai corriger les
bogues éventuels que tous nos tests n'auraient pas fait appara{\^i}tre.
Mais il n'y a pas que cela; le ``code'' pourrai {\^e}tre amélioré et
allégé. Nous pourrions également faire plus ``subtil'' par endroits.
Nous devrions aussi vérifier tous les codes d'erreurs renvoyés par les
fonctions après leur appel. Il serai également possible de faire en sorte
d'utiliser moins de mémoire en réduisant le nombre de {\em shm}; pour
cela il faudrai changer de structure de donnée. Nous aimerions également
finir l'outil d'analyse {\em msgSpaceState} des {\em msgSpace}.
\par Nous avons fini le projet, mais il n'est certainement pas exempt
de bugs et d'autres défauts.
C'est pourquoi dans l'avenir, il faudrai corriger les bogues éventuels que
tous nos tests n'auraient pas fait appara{\^i}tre. Le ``code'' lui-même pourrait {\^e}tre grandement amélioré et allégé car des choses plus ``subtiles'' auraient pu être écrite à certains endroits (nécessitant malheureusement un peu plus de temps).
\par De même la gestion des codes d'erreurs renvoyés par les fonctions pourrait être améliorée et la facilité de débuggage augmentée.
\par Il serait également possible de faire en sorte d'utiliser moins de
mémoire en réduisant le nombre de segment de mémoire partagée, mais pour
cela il faudrai changer de structures de données.
\par De plus nous aimerions (d'ici la soutenance) rendre les outils de test et d'analyse des espaces de messages plus complet.
\par Enfin nous tenons à remercier M. Rifflet pour le cours (et son livre) ainsi que M. Bertier pour leurs nombreuses explications (si précieuses) qu'ils nous tout deux apportés.

125
doc/rapport/devel.tex
View file

@ -5,7 +5,9 @@
\subsection{Travail collaboratif}
\par Nous avons travaillé ensemble gr{\^a}ce à CVS (Concurrent Versions System). Notre projet est hébergé chez Sourceforge\footnote{\url{http://www.sourceforge.net}}.
Le CVS permet la modification du code du projet en m{\^e}me temps par plusieurs personnes. Les modifications et les mises à jour de chacun des membres du projet sont diffusées instantanément, avec un risque minimisé de conflits lors des modifications du m{\^e}me code.
Le CVS permet la modification du code du projet en m{\^e}me temps par plusieurs
personnes. Les modifications et les mises à jour de chacun des membres du projet peuvent
ainsi être diffusées instantanément, avec un risque minimisé de conflits lors des modifications du m{\^e}me code.
\subsection{Moyens techniques}
@ -13,10 +15,8 @@ Le CVS permet la modification du code du projet en m{\^e}me temps par plusieurs
\par Chacun selon nos préférences, nous avons utilisés des machines sous GNU/Linux ou Microsoft Windows et codé avec Vim.
La personne sous Microsoft Windows avait une session graphique sur un serveur GNU/Linux, appartenant a un autre membre du projet,
gr{\^a}ce à l'utilisation de VNC\footnote{\url{http://www.realvnc.com}} (Virtual Network Computing).
Cela afin de permettre à l'utilisateur de Microsoft Windows de pouvoir
tester la bibliothèque dans les meilleures conditions, car sous
Microsoft Windows l'utilisateur n'est pas prévenu des
{\em segmentation fault} et autres erreurs système.
Cela afin de permettre à l'utilisateur de Microsoft Windows de pouvoir compiler et tester
la bibliothèque dans de meilleurs conditions que sous son système initial\ldots
\section{Programmation}
@ -28,48 +28,63 @@ utilis
des fonctions dans le fichier \\``\verb+/src/proto.h+'', avec en
commentaire le fichier d'où il est issu. Par contre pour les fonctions
qui génèrent les {\em ids}, leur prototype est dans le fichier ``\verb+/src/ids.h+'', généré par ``\verb+/src/ids.c+''.
Le fichier ``\verb+/src/proto.h+'' est connu des logiciels qui utilisent
\par Le fichier ``\verb+/src/proto.h+'' est connu des logiciels qui utilisent
notre bibliothèque, tandis que ``\verb+/src/ids.h+'' non.
Nous allons donc vous décrire nos différentes fonctions en les classant
par famille.
\newline
\par Nous avons quatre grandes {\em familles} de fonctions.
\begin{description}
\item{\sc msgBuffer*} Ce sont toutes les fonctions qui concernent les
buffers : comment on les créés, les ``attachent'' aux processus.
\item{\sc msgPool*} Ce sont les fonctions qui permettent de créer ou de
\item[msgBuffer*]{Ce sont toutes les fonctions qui concernent les
buffers : création, attachement aux processus\ldots}
\item[msgPool*]{Ce sont les fonctions qui permettent de créer ou de
détruire une {\em pool}, de l'ouvrir ou encore de poser un ``verrou''.
\begin{description}
\item{\sc msgPool*} Fonctions servant à gérer une {\em pool}, qui
correspond à un ensemble de {\em buffers}.
\item{\sc msgPoolDataTab*} Fonctions utiles pour la gestion des
\item[msgPool*]{Fonctions servant à gérer une {\em pool}, qui
correspond à un ensemble de {\em buffers}.}
\item[msgPoolDataTab*]{Fonctions utiles pour la gestion des
informations d'une {\em pool} telles que la taille des {\em buffers},
leur nombre\dots
leur nombre\dots}
\end{description}
\item{\sc msgQueue*} Toutes les fonctions gérant les ``queues'', {\em
files de maessages}. On y
trouve celle qui en créé une, celles qui vérifient si elle est
disponible ou pas, celles qui ajoutent un élément ou au contraire en
enlève un.
}
\item[msgQueue*]{Toutes les fonctions gérant les ``queues'', {\em
files de messages}. On y trouve celle qui en créé une, celles i
qui vérifient si elle est disponible ou pas, celles qui ajoutent
un élément ou au contraire en enlève un.
\begin{description}
\item{\sc msgQueue*} Rassemble toutes les fonctions servant à la gestion
des files de messages.
\item{\sc msgQueueElem*} Les fonctions utiles pour gérer un élément
d'une file de messages.
\item{\sc msgQueue(Prot/Read)*} Fonctions servant à protéger une file.
\item[msgQueue*]{ Rassemble toutes les fonctions servant à la gestion
des files de messages.}
\item[msgQueueElem*]{ Les fonctions utiles pour gérer un élément
d'une file de messages.}
\item[msgQueue(Prot|Read)*]{Fonctions servant à protéger une file
({\em read} indique la disponibilité d'une ressource en lecture,
{\em Prot} la protection contre les modification).}
\end{description}
\item{\sc msgSpace*} Ensemble de fonctions qui gèrent les espaces de
}
\item[msgSpace*]{Ensemble de fonctions qui gèrent les espaces de
messages : création, ouverture, listes\ldots
\begin{description}
\item{\sc msgSpace*} Fonctions pour la création, ``ouverture'', ``fermeture''\dots d'un espace de messages.
\item{\sc msgSpaceList*} Ce sont toutes les fonctions utiles pour la
gestion de la liste cha{\^i}née des {\em msgSpace} existants.
\item{\sc msgSpaceListElem*} Fonctions correspondant à la gestion d'un
élément de la {\em msgSpaceList}.
\item[msgSpace*]{Fonctions pour la création, ``ouverture'', ``fermeture''\dots d'un espace de messages.}
\item[msgSpaceList*]{Ce sont toutes les fonctions utiles pour la
gestion de la liste cha{\^i}née des {\em msgSpace} existants.}
\item[msgSpaceListElem*]{ Fonctions correspondant à la gestion d'un
élément de la {\em msgSpaceList}.}
\end{description}
}
\end{description}
\subsection{Détails sur certaines fonctions}
\par Nous détaillerons ici quelques fonctions qui peuvent ne pas
@ -110,43 +125,45 @@ espace de messages {\em msgSpace *}, un num
l'adresse d'un buffer {\em void *}. Elle insère le buffer dans le numéro
de file de messages de l'espace de messages. Lorsque l'on appelle cette
fonction, à la fin, on ``délocke'' le sémaphore sur la {\em queue}.
\item{\sc msgSpaceState(\dots)} Cette fonction prend en argument, un
``id'' d'espace de message, {\em msgSpaceId}, et permet de conna{\^i}tre
l'état de l'espace de message dont l'``id'' est donnée en argument.
\end{itemize}
\newpage
\section{Difficultés rencontrées}
\par Nous n'avons pas eu de grosses difficultés à proprement parlé.
\subsection{Restrictions}
\par Nous n'avons pas eu de grosses difficultés à proprement parler.
Nous avions juste quelques restrictions, comme le fait de ne pas
pouvoir utiliser de pointeurs absolus, car l'espace d'adressage entre
les différents processus n'est pas forcément le m{\^e}me. Ils ont
seulement un segment de mémoire partagée en commun. Il a donc
fallu utiliser les différentes {\em id} des espaces de messages {\em msgSpace}, ou
encore des {\em pools} pour pouvoir faire en sorte que les processus peuvent
bien accéder aux {\em buffers} situés dans la mémoire partagée.
seulement un segment de mémoire partagée en commun.
\par Il a donc fallu utiliser les différentes {\em id} (c'est à dire les identifiants POSIX) des espaces de messages {\em msgSpace}, des {\em pools}
et autres types de données stockées en mémoire partagée pour pouvoir permettre a tous les processus d'accéder correctement aux données.
\subsection{Libertés d'implémentations de POSIX\ldots}
\par Le choix des identifiants ne fut pas simple non plus, car il
fallait en changer en fonction des différentes implémentations. Par
exemple nous pouvions avoir des identifiants du type ``\verb+/tmp/identifiant+'',
qui ne marchaient que sur un type de machines. Sur les autres il
fallait en avoir un du type ``\verb+/identifiant+''. Cela nous a amener
à faire une distinction de cas et générer un identifiant différent
selon que l'on soit sur une machine de type {\em HP-UX}, {\em SunOS}
ou {\em Linux}.
fallait en changer en fonction des différentes implémentations de POSIX.
En effet la norme POSIX précise que l'identifiant doit commencer par un ``\verb+/+'' et si possible ne pas en comporter d'autres.
\par Si cela est vrai sur certains systèmes (comme GNU/Linux) d'autres
systemes (HP-UX, SunOS) requièrent que cet identifiant corresponde
au chemin absolu (dans l'arborescence UNIX) d'un fichier sur lequel
on possède des droits\ldots
\par Nous avons donc choisi les identifiants du type
``\verb+/tmp/identifiant+'', qui pour les systèmes avec la restrictions précédente et ``\verb+/identifiant+'' sur les autres. i
Cela nous a également conduit à faire une distinction dans le \verb+Makefile+
entre les options de compilation pour {\em HP-UX}, {\em SunOS} ou {\em Linux}.
\par Malheureusement le fait de travailler sur plusieurs types de
machines n'était pas seulement g{\^e}nant pour les identifiants,
mais également pour créer la bibliothèque. En effet, il faut ajouter
plus ou moins d'options à la compilation: soit il faut ajouter \verb+-lrt+, dans un cas ou \verb+-lrt -lpthread+ dans l'autre. Ceci afin
d'inclure les bonnes librairies pour que notre bibliothèque puisse
fonctionner convenablement.
\par Ces distinctions se font dans les {\em Makefile}, \verb+/src/Makefile+ et \verb+/test/Makefile+.
\par Encore une autre difficulté d{\^u}e à Posix, est la
projection de fichier ou {\em mapping} avec {\em mmap}. L'offset
peut {\^e}tre aligné sur les pages mémoires sur
certains systèmes. Or ceci est emb{\^e}tant lorsque l'on veut
accéder à un fichier qui commence n'importe où dans le bloc mémoire.
Pour remédier à cela, nous {\em mappons} jusqu'à ``juste derrière le
buffer''. Nous autorisons le buffer en lecture/écriture et nous déplaçons
l'adresse obtenue au début du buffer.
compiler et fonctionner convenablement.
\par La seconde difficulté liée à POSIX, est la projection de fichier
ou {\em mapping} avec {\em mmap}. Selon l'implémentation, l'offset (décalage par rapport au début de l'addresse mémoire du fichier) peut éventuellement {\^e}tre aligné sur la taille des pages mémoires\ldots
\par Ceci est assez génant lorsque l'on veut accéder à bloc de donnée
qui peut commencer n'importe où dans la zone de mémoire partagée.
Pour remédier à cela, nous {\em mappons} du début de la zone mémoire partagée jusqu'à ``juste derrière'' le bloc de donnée qui nous intéresse.
\par Puis nous changeons les droits d'acces (\verb+mprotect+) pour nous autoriser la modifiction uniquement sur le bloc de données qui nous intéresse.
\par Enfin nous opérons le décalage d'addresse ``à la main'' et renvoyons l'addresse qui correspond au début du bloc de données demandé.

11
doc/rapport/intro.tex
View file

@ -1,6 +1,6 @@
\chapter{À propos du projet}
\section{Condition d'utilisiation}
\section{Conditions d'utilisation}
\par Ce programme est un logiciel libre; vous pouvez le redistribuer et/ou
le modifier conformément aux dispositions de la Licence Publique Générale GNU,
telle que publiée par la Free Software Foundation; version 2 de la licence, ou encore toute version ultérieure.
@ -13,10 +13,11 @@ telle que publi
\section{Les objectifs}
\par L'objectif de ce projet est de réaliser une bibliothèque permettant
à plusieurs processus d'un m{\^e}me sytème de communiquer entre eux via des messages, sans
faire la recopie de ces messages dans l'espace d'adressage du noyau.
à plusieurs processus d'un m{\^e}me sytème de communiquer entre eux via des files de messages, sans faire la recopie de ces messages dans l'espace
d'adressage du noyau.
\par Nous devions donc mettre en oeuvre les techniques de la programmation
système ainsi que la création d'une bibliothèque de fonctions. Nous avons utilisés les mécanismes de mémoire partagée et de synchronisation version Posix.
système ainsi que la création d'une bibliothèque de fonctions.
Pour ce faire, nous avons utilisés les mécanismes de mémoire partagée et de synchronisation à la norme POSIX.
\section{Obtenir l'archive du projet}
@ -38,6 +39,6 @@ et son adresse est :
\newline
{\url{http://www.sourceforge.net/projects/libnazgul/}}.
\par Ce site vous permettra de télécharger le projet, d'en avoir
une description et également d'y contribuer.
une description et éventuellement d'y contribuer.
\newpage

31
doc/rapport/manuel.tex
View file

@ -1,17 +1,30 @@
\chapter{Manuel d'utilisation}
\section{Que faire de nos sources? \ldots les compiler}
\section{Que faire de nos sources?}
%\subsection{Les compiler}
\par Pour pouvoir utiliser notre bibliotèque, il faut commencer par la
créer. Pour cela placez-vous dans le répertoire de l'archive (noté ici
\verb+/+) ou dans le sous-répertoire \verb+src/+ et tapez ``\verb+make+''.
compiler. Pour cela placez-vous dans le répertoire racine de l'archive (noté ici
\verb+/+) ou dans son sous-répertoire \verb+src/+
et tapez ``\verb+make+''. Cela compilera la bibliothèque
(fichier \verb+libnazgul.a+) ainsi que les divers programmes de test dans
l'archive.
\section{Que faire ensuite? \ldots inclure notre bibliothèque}
%\subsection{Inclure notre bibliothèque dans un programme}
\section{Comment utiliser Libnazgul ?}
\par Dans votre programme, si vous voulez utiliser notre bibliothèque
il vous suffit de l'inclure. Au début de votre programme tapez ``\verb+#include ''libnazgul.h``+''.
\par Une fois notre bibliothèque incluse, vous pourrez sans problèmes
appeler les fonctions contenues à l'intérieur : {\it msgSpaceCreate(\ldots), msgPut(\ldots), msgFree(\ldots) etc\dots}
\par Une fois le projet compilé (voir ci-dessus), vous il vous est possible
d'utiliser {\sc Libnazgul}.
Il vous faudra pendant l'écriture de vos programmes C/C++,
mettre \verb+#include libnazgul.h+ au début des fichiers utilisant la bibliothèque.
\par De même il faudra prendre bien soin, à la compilation de vos programme de :
\begin{itemize}
\item{spécifier (option \verb+-I+) le répertoire où se trouvent les
en-têtes (fichiers *.h) de la bibliothèque {\sc Libnazgul},}
\item{indiquer (option \verb+-L+) le chemin vers le fichier \verb+libnazgul.a+,}
\item{renseigner le compilateur (option \verb+-l+) sur les bibliotheques nécessaires pour utiliser les fonctions de {\sc Libnazgul} : nazgul, rt, et pthreads.}
\end{itemize}
\par Vous pourrez ainsi sans problèmes appeler toutes les fonctions fournis
par {\sc Libnazgul} : {\it msgSpaceCreate(\ldots), msgPut(\ldots), msgFree(\ldots),
etc\dots}

2
doc/rapport/rapport.tex
View file

@ -17,7 +17,7 @@
%--------------------------------------------------------------
\pagestyle{fancy}
\rhead[\sc{LIBNAZGUL is Not Another Zero G User Library}]{\sc{LIBNAZGUL is Not Another Zero G User Library}}
\rhead[{\small\sc{LIBnazgul is Not Another Zero-share Great or Ultimate Library}}]{{\small \sc{LIBnazgul is Not Another Zero-share Great or Ultimate Library}}}
\lhead[\it{}]{\it{}}
%\rhead[\it{Projet de Système.}]{\it{Projet de Système.}}

3
src/Makefile
View file

@ -33,10 +33,11 @@ CFILES := $(shell ls *.c)
OFILES := $(patsubst %.c,%.o,$(CFILES))
DESTFILE=libnazgul.a
INCLUDES=-I /usr/lib/ -I /usr/local/lib/
DEFINES:=
ifeq "SunOS" "${OS}"
DEFINES:=-D_NZG_REALFILEID
DEFINES:=-D_NZG_REALFILEID -D_NZG_SUNOS
endif
ifeq "HP-UX" "${OS}"

2
src/allocate.c
View file

@ -15,6 +15,7 @@ void * msgAllocate(msgSpace *space,
int option
){
void * resultAddr=NULL;
int bufferFreeSize;
int i;
msgPoolId resultPoolId;
/* tableau des valeurs des semPoolCoef/pool pour identifier le pool
@ -183,7 +184,6 @@ if (mSPoolDataTabAddr==NULL){
/* mapper le buffer libre dans l'esp addr du proc */
strcpy(resultPoolId,mSPoolDataTabAddr[selectedPoolIndex].poolId);
int bufferFreeSize;
bufferFreeSize=mSPoolDataTabAddr[selectedPoolIndex].bufferSize;
printf("BufferSize : %d\n", bufferFreeSize);

3
src/bufferGetProcAttach.c
View file

@ -14,6 +14,7 @@ int msgBufferGetProcAttach(
bool found=false;
int pIdx=0;
int bIdx;
while ((!found) && (pIdx < poolNb)){
/* Pour chaque pool */
//récuperer l'ID du BufferInfoTab;
@ -29,7 +30,7 @@ int msgBufferGetProcAttach(
PROT_READ,MAP_SHARED,bufferInfoTabFd,(off_t)0);
/* on cherche dans chacun des buffers */
int bIdx=0;
bIdx=0;
while((!found) && bIdx<bufferInfoNb){
if (bufferInfoTabAddr[bIdx].addr == addr){
found=true;

23
src/free.c
View file

@ -1,14 +1,18 @@
#include "libnazgul.h"
int msgFree(msgSpace * space, void * addr){
printf("[ FREE 0x%08x ]\n",(int)addr);
int poolIndex;
int bufferIndex;
msgPoolData * poolDataTabAddr;
sem_t * ressourceSemFd;
msgPoolDataTabSemId ressourceSemId;
/* on acquiert le droit de modifier les infos sur la ressource */
msgPoolDataTabSemId ressourceSemId;
int err;
int bufferNb;
int bufferSize;
void * realAddr;
printf("[ FREE 0x%08x ]\n",(int)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);
@ -20,7 +24,6 @@ int msgFree(msgSpace * space, void * addr){
poolDataTabAddr = msgPoolDataTabOpen(space);
// TODO: verouiller semaphore DataInfo ??
int err;
poolIndex=-1; bufferIndex=-1;
err=msgBufferGetProcAttach(
@ -36,17 +39,17 @@ int msgFree(msgSpace * space, void * addr){
msgBufferDetachProc(poolDataTabAddr,poolIndex,bufferIndex,addr);
/* unmapper le buffer */
void * realAddr=addr;
int bufferSize=poolDataTabAddr[poolIndex].bufferSize;
int bufferNb=poolDataTabAddr[poolIndex].bufferNb;
realAddr=addr;
bufferSize=poolDataTabAddr[poolIndex].bufferSize;
bufferNb=poolDataTabAddr[poolIndex].bufferNb;
realAddr=realAddr-poolIndex*bufferSize;
munmap(realAddr,bufferSize*bufferNb);
msgPoolDataTabClose(space,poolDataTabAddr);
// deverouiller semaphore DataInfo
msgPoolDataTabUnlock(space);
msgPoolDataTabUnlock(space);
// deverouiller semaphore ressource.
msgPoolSemIdIntern(ressourceSemId,space->externId,poolIndex);
ressourceSemFd = sem_open(ressourceSemId,O_CREAT,SEM_DEFAULT_MODE,0);

2
src/get.c
View file

@ -8,6 +8,7 @@ void * msgGet(msgSpace * space,int queueIndex,int option){
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){
@ -39,7 +40,6 @@ void * msgGet(msgSpace * space,int queueIndex,int option){
goto ERROR;
}
/* on récupere la taille des buffer dans la pool du buffer */
msgPoolData * poolDataTab;
poolDataTab=msgPoolDataTabOpen(space);
// mapper le buffer dans l'espace mémoire du processus
resultAddr=msgBufferMap(poolDataTab,oldElem->poolIndex,oldElem->bufferIndex);

5
src/global.h
View file

@ -26,6 +26,11 @@
#endif
#ifndef MAP_FAILED
#define MAP_FAILED ((void *)-1)
#endif
#ifdef _NZG_REALFILEID
#define DEFAULT_MSGSPACELISTID "/tmp/nzgSpaceList"
#else

12
src/poolDataTabLock.c
View file

@ -4,10 +4,12 @@
#define DEBUG 0
int msgPoolDataTabLock(msgSpace * space){
int semval;
sem_t * poolDataTabSemFd;
if (DEBUG) {printf("Locking %s\n",space->poolDataTabSemId);}
semval=0;
if (DEBUG) {printf("Locking %s\n",space->poolDataTabSemId);}
poolDataTabSemFd=sem_open(
poolDataTabSemFd=sem_open(
space->poolDataTabSemId
,O_CREAT,
SEM_DEFAULT_MODE,
@ -21,9 +23,9 @@ if (DEBUG) {printf("Locking %s\n",space->poolDataTabSemId);}
NZG_ERROR("sem_wait",space->poolDataTabSemId);
goto ERROR;
}
int semval=0;
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);

4
src/poolDataTabUnlock.c
View file

@ -4,6 +4,7 @@
#define DEBUG 0
int msgPoolDataTabUnlock(msgSpace * space){
int semval;
sem_t * poolDataTabSemFd;
if (DEBUG) { printf("Unlocking %s\n",space->poolDataTabSemId); }
poolDataTabSemFd=sem_open(
@ -20,7 +21,8 @@ int msgPoolDataTabUnlock(msgSpace * space){
NZG_ERROR("sem_post",space->poolDataTabSemId);
goto ERROR;
}
int semval=0;
semval=0;
sem_getvalue(poolDataTabSemFd,&semval);
if (DEBUG) { printf("(AfternValue:%d)\n",semval); }

12
src/put.c
View file

@ -6,8 +6,10 @@ int msgPut(msgSpace * space,int queueIndex, void * addr){
int poolIndex;
int bufferIndex;
int err;
msgQueueElemId newElemId;
msgQueueElemId newElemId;
msgQueueElem * queueElem;
msgQueueId queueId;
msgQueue * queue;
msgPoolDataTabLock(space);
poolDataTabAddr=msgPoolDataTabOpen(space);
@ -24,15 +26,13 @@ int msgPut(msgSpace * space,int queueIndex, void * addr){
);
// ouvrir la queue avec le bon index
msgQueueId queueId;
msgQueue * queue;
msgQueueIdIntern(queueId,space->externId,queueIndex);
msgQueueProtLock(space->externId,queueIndex);
queue = msgQueueOpen(queueId);
// creer un element vide
msgQueueElemCreate(newElemId,queueId,queue->elemCounter);
// ouvrir l'element
queueElem=msgQueueElemOpen(newElemId);
@ -40,7 +40,7 @@ int msgPut(msgSpace * space,int queueIndex, void * addr){
// modifier les index pour retrouver le buffer
queueElem->poolIndex=poolIndex;
queueElem->bufferIndex=bufferIndex;
// fermer l'element
if (msgQueueElemClose(queueElem) <0 ){
NZG_ERROR("msgQueueElemClose","");

4
src/queueDelete.c
View file

@ -3,6 +3,8 @@
int msgQueueDelete(msgQueueId externId,int queueIdx){
msgQueue * queue;
msgQueueId queueId;
msgQueueSemId queueProtLockSemId;
msgQueueSemId queueReadLockSemId;
msgQueueIdIntern(queueId,externId,queueIdx);
queue = msgQueueOpen(queueId);
@ -15,8 +17,6 @@ int msgQueueDelete(msgQueueId externId,int queueIdx){
}
}
msgQueueSemId queueProtLockSemId;
msgQueueSemId queueReadLockSemId;
msgQueueProtSemIdIntern(queueProtLockSemId,externId,queueIdx);
msgQueueReadSemIdIntern(queueReadLockSemId,externId,queueIdx);
sem_unlink(queueProtLockSemId);

2
src/queueElemCreate.c
View file

@ -6,11 +6,11 @@ int msgQueueElemCreate(
msgQueueId queueId,
int counter){
msgQueueElemId queueElemId;
int queueElemFd;
msgQueueElemIdIntern(queueElemId,queueId,counter);
strcpy(finalQueueElemId,queueElemId);
int queueElemFd;
queueElemFd=shm_open(queueElemId,
O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
SHM_DEFAULT_MODE);

5
src/queueProtLock.c
View file

@ -3,6 +3,7 @@
#define DEBUG 0
int msgQueueProtLock(msgSpaceId externId,int queueIdx){
int semval;
sem_t * queueSemFd;
msgQueueSemId queueSemId;
@ -18,13 +19,11 @@ int msgQueueProtLock(msgSpaceId externId,int queueIdx){
NZG_ERROR("sem_wait",queueSemId);
goto ERROR;
}
int semval=0;
semval=0;
sem_getvalue(queueSemFd,&semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
sem_close(queueSemFd);
sem_close(queueSemFd);
return 0;

3
src/queueProtUnlock.c
View file

@ -4,6 +4,7 @@
#define DEBUG 0
int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){
int semval;
sem_t * queueSemFd;
msgQueueSemId queueSemId;
@ -20,7 +21,7 @@ int msgQueueProtUnlock(msgSpaceId externId,int queueIdx){
NZG_ERROR("sem_post",queueSemId);
goto ERROR;
}
int semval=0;
semval=0;
sem_getvalue(queueSemFd,&semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }

3
src/queueReadLock.c
View file

@ -4,6 +4,7 @@
#define DEBUG 0
int msgQueueReadLock(msgSpaceId externId,int queueIdx){
int semval;
sem_t * queueSemFd;
msgQueueSemId queueSemId;
@ -19,7 +20,7 @@ int msgQueueReadLock(msgSpaceId externId,int queueIdx){
NZG_ERROR("sem_wait",queueSemId);
goto ERROR;
}
int semval=0;
semval=0;
sem_getvalue(queueSemFd,&semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }

7
src/queueReadTryLock.c
View file

@ -4,6 +4,7 @@
#define DEBUG 0
int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){
int semval;
sem_t * queueSemFd;
msgQueueSemId queueSemId;
@ -19,9 +20,9 @@ int msgQueueReadTryLock(msgSpaceId externId,int queueIdx){
goto ERROR;
}
if (DEBUG) { printf("Locking %s\n",queueSemId); }
int semval=0;
sem_getvalue(queueSemFd,&semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
semval=0;
sem_getvalue(queueSemFd,&semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
sem_close(queueSemFd);

11
src/queueReadUnlock.c
View file

@ -4,12 +4,13 @@
#define DEBUG 0
int msgQueueReadUnlock(msgSpaceId externId,int queueIdx){
sem_t * queueSemFd;
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);
queueSemFd=sem_open(queueSemId,O_CREAT,SEM_DEFAULT_MODE,1);
if(queueSemFd==SEM_FAILED){
NZG_ERROR("sem_open",queueSemId);
goto ERROR;
@ -19,9 +20,9 @@ int msgQueueReadUnlock(msgSpaceId externId,int queueIdx){
NZG_ERROR("sem_post",queueSemId);
goto ERROR;
}
int semval=0;
sem_getvalue(queueSemFd,&semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
semval=0;
sem_getvalue(queueSemFd,&semval);
if (DEBUG) { printf("(AfterValue:%d)\n",semval); }
sem_close(queueSemFd);

4
src/spaceCreate.c
View file

@ -22,8 +22,10 @@ msgSpace * msgSpaceCreate(
/* msgSpaceList mSList; */
int mSFd; // shm file descriptor
int i;
int err;
static int mSIdNum=-1;
msgSpace * space;
msgSpaceListElemId listElemId;
msgPoolDataTabId poolDataTabId;
msgPoolData * poolDataTabAddr;
@ -50,7 +52,6 @@ msgSpace * msgSpaceCreate(
NZG_ERROR("msgSpaceListLock","");
goto ERROR;
}
int err;
if ((err=msgSpaceListFindId(externId)) < 1){
if (err==0){
// soit le msgSpace existe deja
@ -173,7 +174,6 @@ msgSpace * msgSpaceCreate(
}
msgPoolDataTabClose(space,poolDataTabAddr);
/* on ajoute spaceId a la liste des msgSpace connus */
msgSpaceListElemId listElemId;
printf("spaceListInit...\n");
printf("ok\n");

2
src/spaceDelete.c
View file

@ -8,11 +8,11 @@ int msgPoolDataTabSemIdIntern(
msgPoolSemId destSemId,const msgSpaceId externId);
int msgSpaceDelete(msgSpaceId externId){
fprintf(stderr,"Deleting msgSpace with id : %s\n",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;

4
src/spaceListElemCreate.c
View file

@ -7,8 +7,9 @@ int msgSpaceListElemCreate(
msgSpace * space)
{
msgSpaceListElemIdIntern(listElemId,space->externId);
int listElemFd;
msgSpaceListElem * listElem;
msgSpaceListElemIdIntern(listElemId,space->externId);
listElemFd=shm_open(listElemId,
O_RDWR|O_CREAT|O_EXCL|O_TRUNC,
@ -25,7 +26,6 @@ int msgSpaceListElemCreate(
}
close(listElemFd);
msgSpaceListElem * listElem;
listElem=msgSpaceListElemOpen(listElemId);
if (listElem ==NULL){
NZG_ERROR("msgSpaceListElemOpen",listElemId);

4
src/spaceListFindId.c
View file

@ -5,11 +5,11 @@
int msgSpaceListFindId(msgSpaceId externId){
msgSpaceList * list;
msgSpaceId spaceId;
msgSpaceIdIntern(spaceId,externId);
msgSpaceListElemId listHeadElemId;
msgSpaceListElemId listTailElemId;
msgSpaceListId listId;
msgSpaceIdIntern(spaceId,externId);
list=msgSpaceListOpen();
if (list==NULL){
NZG_ERROR("msgSpaceListOpen","");

5
src/spaceListInit.c
View file

@ -4,9 +4,11 @@
int msgSpaceListInit(){
int spaceListFd;
sem_t * spaceListSemFd;
msgSpaceList *list;
msgSpaceListSemId spaceListSemId;
msgSpaceListId spaceListId;
strcpy(spaceListSemId,DEFAULT_MSGSPACELISTSEMID);
strcpy(spaceListId,DEFAULT_MSGSPACELISTID);
@ -42,7 +44,6 @@ int msgSpaceListInit(){
}
close(spaceListFd);
msgSpaceList *list;
list=msgSpaceListOpen();
if (list == NULL){
NZG_ERROR("msgSpaceListOpen","");
@ -65,7 +66,7 @@ int msgSpaceListInit(){
ERROR:
return -1;
EXISTING:
if (msgSpaceListUnlock() < 0){
if (msgSpaceListUnlock() < 0){
NZG_ERROR("msgSpaceListUnlock","");
goto ERROR;
}

9
test/Makefile
View file

@ -24,21 +24,26 @@ CC=gcc
CFLAGS=-Wall -O2 -ggdb
#-O2 -ggdb
INCLUDES=-I /usr/include -I ../src/
INCLUDES=-I /usr/include/ -I ../src/
LIBINC=-L /usr/lib -L ../src
BASELIBS=-lnazgul
LIBS=$(BASELIBS)
DEFS=
ifeq "HP-UX" "${OS}"
DEFS=-D_NZG_HPUX
LIBS=$(BASELIBS) -lpthread -lrt
endif
ifeq "SunOS" "${OS}"
DEFS=-D_NZG_SUNOS
LIBS=$(BASELIBS) -lrt
endif
ifeq "Linux" "${OS}"
DEFS=-D_NZG_LINUX
LIBS=$(BASELIBS) -lrt -lpthread
endif
@ -61,5 +66,5 @@ clean:
@rm -f $(FILES)
% : %.c
$(CC) -o $* $< $(INCLUDES) $(LIBINC) $(LIBS) $(CFLAGS)
$(CC) -o $* $< $(INCLUDES) $(LIBINC) $(LIBS) $(CFLAGS) $(DEFS)

10
test/create_delete.c
View file

@ -1,9 +1,15 @@
#ifdef _NZG_HPUX
#include <sys/wait.h>
#else
#include <wait.h>
#endif
#include "libnazgul.h"
int main(void) {
// msgSpace mS=0;
pid_t pid;
msgSpaceId testId;
msgSpace * mSPAC;
msgPool poolInfos[3];
@ -20,14 +26,14 @@ int main(void) {
sprintf(testId,"test%d",(int)getuid());
printf("RequestedId: %s\n",testId);
printf("Void size: %d\n",sizeof(void));
printf("Void size: %d\n",(int)sizeof(void));
mSPAC=msgSpaceCreate(testId,0,3,poolInfos);
if (mSPAC ==NULL) {
NZG_ERROR("msgSpaceCreate",testId);
exit(0);
}
pid_t pid=fork();
pid=fork();

5
test/msgSpaceState.c
View file

@ -1,4 +1,9 @@
#ifdef _NZG_HPUX
#include <sys/wait.h>
#else
#include <wait.h>
#endif
#include "libnazgul.h"
void usage(char * myname){

7
test/put_get_mono.c
View file

@ -1,4 +1,9 @@
#ifdef _NZG_HPUX
#include <sys/wait.h>
#else
#include <wait.h>
#endif
#include "libnazgul.h"
int main(void) {
@ -17,7 +22,7 @@ int main(void) {
sprintf(testId,"test%d",(int)getuid());
printf("RequestedId: %s\n",testId);
printf("Void size: %d\n",sizeof(void));
printf("Void size: %d\n",(int)sizeof(void));
//creation de l'espace de messages
mSPAC=msgSpaceCreate(testId,1,2,poolInfos);
if (mSPAC ==NULL) {

7
test/put_get_multi.c
View file

@ -1,4 +1,9 @@
#ifdef _NZG_HPUX
#include <sys/wait.h>
#else
#include <wait.h>
#endif
#include "libnazgul.h"
int main(void) {
@ -17,7 +22,7 @@ int main(void) {
sprintf(testId,"test%d",(int)getuid());
printf("RequestedId: %s\n",testId);
printf("Void size: %d\n",sizeof(void));
printf("Void size: %d\n",(int)sizeof(void));
//creation de l'espace de messages
mSPAC=msgSpaceCreate(testId,1,2,poolInfos);
if (mSPAC ==NULL) {