Première version
This commit is contained in:
smas
commit
991dc2df52
BIN
doc/libshmem.doc
Normal file
BIN
doc/libshmem.doc
Normal file
Binary file not shown.
588
doc/man3/libshmem.3
Normal file
588
doc/man3/libshmem.3
Normal file
@ -0,0 +1,588 @@
|
||||
'\" t
|
||||
.\" @(#)LIBSM.3 99/10/27 SMA;
|
||||
.TH LIBSM 3 "27 Oct 1999"
|
||||
.SH NOM
|
||||
LIBSM (librairie de memoires partagees)
|
||||
.SH SYNOPSIS
|
||||
.LP
|
||||
.BI "cc [flag ...] file ... -lver -ldl -lnode -lshmem [library ...]"
|
||||
.LP
|
||||
.BI "#include <shmem.h>"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Open ( int " Instance ", const char * " Context_Name ", SMT_Flags " Open_Mode " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Instance_Get ( int * " Instance " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Context_Set ( char * " Context_Name " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Context_Get ( char ** " Context_Name " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Close ( SMT_Flags " Close_Mode " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Stderr_Set ( FILE * " Out " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Exist ( char * " Heap_Name " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Open ( char * " Heap_Name ", SMT_Heap ** " Heap ", size_t " Seg_Size " , SMT_Flags " Open_Flags ", int * " Locked " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Close ( SMT_Heap * " Heap " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_End ( char * " Heap_Name " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Compress ( SMT_Heap * " Heap ", size_t * " Size " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Check ( SMT_Heap * " Heap ", int * " Nb_Detected " , int * " Nb_Corrected ", FILE * " Out " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Lock ( SMT_Heap * " Heap ", SMT_Flags " Lock_Flags ", int * " Locked " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Unlock ( SMT_Heap * " Heap " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Config ( SMT_Heap * " Heap ", SMT_Tag " Tag ", ... );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Chunk_Alloc ( SMT_Heap * " Heap ", void ** " Ptr ", size_t " Size " );"
|
||||
.LP
|
||||
.BI "SMT_Status SM_Chunk_Free ( SMT_Heap * " Heap ", void * " Ptr " );"
|
||||
.LP
|
||||
.SH GENERALITES
|
||||
.LP
|
||||
La librairie LIBSM permet de gerer des espaces de memoire partagee.
|
||||
Ces espaces de memoire partagee (notion de 'heap') sont references dans une base geree par la librairie.
|
||||
.LP
|
||||
La librairie permet de gerer plusieurs instances, chacune ayant une base qui lui est propre.
|
||||
Pour chaque instance, des contextes d'utilisation pourront etre definis.
|
||||
.LP
|
||||
Les heaps sont constitues de blocs memoire (notion de 'chunk') qui pourront etre alloues et desalloues par les programmes y accedant de maniere concurrente.
|
||||
.LP
|
||||
Chaque heap presente la particularite d'etre :
|
||||
.LP
|
||||
.RS 3
|
||||
- identifie par un nom unique dans la base
|
||||
.LP
|
||||
- securise : les acces concurrents sont geres par l'utilisation de semaphores
|
||||
.RS -3
|
||||
.LP
|
||||
La librairie propose des fonctions de gestion :
|
||||
.LP
|
||||
.RS 3
|
||||
- de la base de la librairie (initialisation, ouverture, fermeture, destruction).
|
||||
.LP
|
||||
- des heaps (creation, ouverture, verrouillage, compression, deverrouillage, fermeture, destruction)
|
||||
.LP
|
||||
- des chunks (allocation, desallocation)
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "BASE DE HEAPS"
|
||||
.LP
|
||||
La base constitue l'espace commun a tous les utilisateurs d'une instance de la librairie.
|
||||
.LP
|
||||
Cette base est initialisee une premiere fois et reference la liste de tous les heaps de l'instance.
|
||||
.LP
|
||||
Cette base est protegee par un systeme de verrou permettant de gerer les acces concurrents aux differents heaps.
|
||||
.LP
|
||||
.I NB
|
||||
: la base contient un heap 'systeme' qui gere les ressources des autres heaps (dits heaps 'utilisateur').
|
||||
Ce heap 'systeme' est un heap prive qui ne devra pas etre accede directement par les utilisateurs de la librairie.
|
||||
.LP
|
||||
.BI "NOTION DE HEAP"
|
||||
.LP
|
||||
Un heap est un espace de memoire partagee reference dans la base.
|
||||
Il y est identifie de maniere unique par son nom.
|
||||
.LP
|
||||
La notion de contexte d'utilisation permet de distinguer des heaps en prefixant leur nom par ce contexte.
|
||||
.LP
|
||||
Les acces concurrents aux ressources d'un heap sont geres par un systeme de verrou qui autorise :
|
||||
.LP
|
||||
.RS 3
|
||||
- plusieurs acces en lecture simultanes (verrous partages)
|
||||
.LP
|
||||
- un seul acces en ecriture (verrou exclusif)
|
||||
.RS -3
|
||||
.LP
|
||||
.I NB
|
||||
: un verrouillage est opere en mode 'wait', ce qui signifie que les processus desirant verrouiller une ressource non disponible sera mis en attente jusqu'a sa mise en disponibilite.
|
||||
.LP
|
||||
.BI "NOTION DE CHUNK"
|
||||
.LP
|
||||
Un chunk est un bloc d'allocation memoire au sein d'un heap.
|
||||
.LP
|
||||
Un chunk appartient necessairement a une liste de chunks alloues au sein du heap (ACR) ou bien a celle de ses chunks libres (FCR).
|
||||
.LP
|
||||
.SH TYPES
|
||||
.LP
|
||||
La librairie met a la disposition des utilisateurs les types suivants :
|
||||
.LP
|
||||
.BI "SMT_Flags
|
||||
.LP
|
||||
.RS 3
|
||||
Ce type d'indicateur permet de preciser le mode d'ouverture d'une instance/d'un heap de la librairie.
|
||||
.LP
|
||||
.RS 3
|
||||
-
|
||||
.B SMD_OPEN
|
||||
: pour ouvrir une instance/un heap existante/existant
|
||||
.LP
|
||||
-
|
||||
.B SMD_CREAT
|
||||
: pour creer l'instance/le heap si elle/il n'existe pas
|
||||
.LP
|
||||
.RS -3
|
||||
.LP
|
||||
Pour l'ouverture de la librairie, il permet en outre de preciser le mode de debugging :
|
||||
.LP
|
||||
.RS 3
|
||||
-
|
||||
.B SM_DEBUG_NONE
|
||||
: aucun message d'erreur n'est affiche
|
||||
.LP
|
||||
-
|
||||
.B SM_DEBUG
|
||||
: les messages d'erreur generes par la librairie LIBSHMEM sont affiches sur la sortie standard d'erreur
|
||||
.LP
|
||||
-
|
||||
.B SM_DEBUG_ALL
|
||||
: les messages d'erreur generes par toutes les librairies sous-jacentes a la LIBSHMEM sont affiches sur la sortie standard d'erreur
|
||||
.RS -3
|
||||
.LP
|
||||
Pour l'ouverture d'un heap, il permet de preciser son type de verrouillage :
|
||||
.LP
|
||||
.RS 3
|
||||
-
|
||||
.B SMD_WRITE
|
||||
: acces en ecriture (pose d'un verrou exclusif )
|
||||
.LP
|
||||
-
|
||||
.B SMD_READ
|
||||
: acces en lecture (pose d'un verrou partage)
|
||||
.LP
|
||||
-
|
||||
.B SMD_UNDEF
|
||||
: aucun verrou.
|
||||
.LP
|
||||
.RS -3
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Heap
|
||||
.LP
|
||||
.RS 3
|
||||
Ce type permet de designer un heap ouvert par le processus courant.
|
||||
.LP
|
||||
C'est le seul type concernant les heaps qui sera manipule par les utilisateurs a travers les API de la librairie.
|
||||
.RS -3
|
||||
.LP
|
||||
.SH FONCTIONS
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Open ( int " Instance ", const char * " Context_Name ", SMT_Flags " Open_Mode " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet d'acceder aux ressources partagees d'une instance de la librairie (base de heap, heap 'systeme').
|
||||
Elle devra necessairement etre appelee par tout programme utilisant la librairie.
|
||||
.LP
|
||||
Cette fonction attend les parametres suivants :
|
||||
.LP
|
||||
.RS 3
|
||||
* (In)
|
||||
.I Instance
|
||||
: numéro de l'instance a ouvrir.
|
||||
.LP
|
||||
.I NB
|
||||
: si cet argument vaut 0, alors c'est la variable d'environnement $INSTANCE qui definira le numéro de l'instance (1000 sinon).
|
||||
.LP
|
||||
* (In)
|
||||
.I Context
|
||||
: nom du contexte a utiliser.
|
||||
.LP
|
||||
.I NB
|
||||
: si cet argument est NULL, alors c'est la variable d'environnement $CONTEXT qui definira le nom du contexte, ("CTX" sinon).
|
||||
.LP
|
||||
* (In)
|
||||
.I Open_Mode
|
||||
: le mode d'ouverture de l'instance (
|
||||
.B SMD_CREATE
|
||||
pour la creation de l'instance, ou
|
||||
.B SMD_OPEN
|
||||
pour une ouverture simple)
|
||||
.LP
|
||||
.I NB
|
||||
: cette valeur pourra etre combinee avec un mode de debugging (
|
||||
.B SMD_DEBUG_NONE
|
||||
,
|
||||
.B SMD_DEBUG
|
||||
ou
|
||||
.B SMD_DEBUG_ALL
|
||||
)
|
||||
.LP
|
||||
.RS -3
|
||||
Outre l'acces aux ressources de l'instance, cette fonction provoque le verrouillage de la base en lecture.
|
||||
L'utilisateur de la librairie est ainsi assure de l'existence de ces ressources tout au long de leur utilisation.
|
||||
.LP
|
||||
.I NB
|
||||
: le mode d'ouverture
|
||||
.B SMD_CREATE
|
||||
est reserve aux administrateurs.
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Instance_Get ( int * " Instance " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de recuperer dans l'argument
|
||||
.I Instance
|
||||
le numéro de l'instance utilisee.
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Context_Set ( char * " Context_Name " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de definir
|
||||
.I Context_Name
|
||||
comme etant le nom du nouveau contexte d'utilisation de l'instance de la librairie LIBSHMEM.
|
||||
.LP
|
||||
.I NB
|
||||
: specifier un contexte implique que tous les heaps manipules seront prefixes par le nom de ce contexte.
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Context_Get ( char ** " Context_Name " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de recuperer dans l'argument
|
||||
.I Context_Name
|
||||
le nom du contexte utilise.
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Close ( SMT_Flags " Close_Flags " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de fermer l'instance de la librairie LIBSM.
|
||||
Elle libere egalement le verrou en lecture qui avait ete pose sur la base lors de l'ouverture de l'instance.
|
||||
Cette fonction doit donc etre systematiquement appelee a la fin de chaque programme utilisant la librairie.
|
||||
.LP
|
||||
L'argument
|
||||
.I Close_Flags
|
||||
est le mode de fermeture de l'instance :
|
||||
.LP
|
||||
.RS 3
|
||||
-
|
||||
.B SMD_CLOSE
|
||||
pour fermer simplement l'instance
|
||||
.LP
|
||||
-
|
||||
.B SMD_DESTROY
|
||||
pour detruire en outre toutes les ressources de l'instance
|
||||
.LP
|
||||
.RS -3
|
||||
.LP
|
||||
.I NB
|
||||
: le mode de fermeture
|
||||
.B SMD_DESTROY
|
||||
est reserve aux administrateurs.
|
||||
.LP
|
||||
Bien entendu, la destruction des ressouces de l'instance ne sera pas possible tant qu'il existera d'autres processus utilisant la meme instance.
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Library_Stderr_Set ( FILE * " Out " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de definir
|
||||
.I Out
|
||||
comme la sortie standard des messages d'erreur generes par la librarie.
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Exist ( char * " Heap_Name " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de tester si un heap existe deja dans la base.
|
||||
.LP
|
||||
L'argument
|
||||
.I Heap_Name
|
||||
est le nom du heap a tester.
|
||||
.LP
|
||||
.RS -3
|
||||
.BI "SMT_Status SM_Heap_Open ( char * " Heap_Name ", SMT_Heap ** " Heap ", size_t " Seg_Size ", SMT_Flags " Open_Flags ", int * " Locked " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet d'ouvrir ou de creer un heap 'utilisateur' dans la base.
|
||||
.LP
|
||||
Elle doit recevoir les arguments suivants :
|
||||
.LP
|
||||
.RS 3
|
||||
* (In)
|
||||
.I Heap_Name
|
||||
: le nom du heap
|
||||
.LP
|
||||
* (Out)
|
||||
.I Heap
|
||||
: l'adresse d'un pointeur sur le heap a ouvrir
|
||||
.LP
|
||||
* (In)
|
||||
.I Seg_Size
|
||||
: la taille des segments qui composeront le heap (une fois le heap cree, cette taille peut etre modifiee via la fonction SM_Heap_Config).
|
||||
.LP
|
||||
.I NB
|
||||
: si cet argument est nul, la taille sera par defaut de 102400 octets.
|
||||
.LP
|
||||
* (In)
|
||||
.I Open_Flags
|
||||
: le mode d'acces qui determine d'une part l'ouverture ou la creation du heap et d'autre part son type de verrouillage.
|
||||
.LP
|
||||
.I NB
|
||||
: les deux valeurs
|
||||
.B SMD_OPEN
|
||||
et
|
||||
.B SMD_CREATE
|
||||
peuvent etre combinees.
|
||||
.LP
|
||||
* (In)
|
||||
.I Locked
|
||||
: un pointeur sur un indicateur de verrouillage : il indique si le verrou a effectivement ete pose ou si le heap etait deja verrouille dans ce mode
|
||||
.RS -3
|
||||
.LP
|
||||
.I NB
|
||||
: le heap cree est constitue d'un seul segment de donnees et contient un unique chunk libre correspondant a ce premier segment de donnees.
|
||||
.LP
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Close ( SMT_Heap * " Heap ");"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de fermer un heap ouvert.
|
||||
.LP
|
||||
Elle permet non seulement de detacher les ressources du heap du processus appelant, mais elle permet aussi de liberer le verrou pose lors de l'ouverture du heap.
|
||||
.LP
|
||||
L'argument
|
||||
.I Heap
|
||||
est un pointeur sur un heap ouvert.
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_End ( char * " Heap_Name " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de detruire un heap.
|
||||
.LP
|
||||
L'argument
|
||||
.I Heap_Name
|
||||
designe le nom du heap a detruire.
|
||||
.LP
|
||||
.RS -3
|
||||
.BI "SMT_Status SM_Heap_Compress ( SMT_Heap * " Heap ", size_t * " Size " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de compresser un heap, ce qui consiste a fusionner les chunks libres dont les adresses se suivent.
|
||||
.LP
|
||||
Elle doit recevoir les arguments suivants :
|
||||
.LP
|
||||
.RS 3
|
||||
* (In)
|
||||
.I Heap
|
||||
: un pointeur sur un heap ouvert
|
||||
.LP
|
||||
* (Out)
|
||||
.I Size
|
||||
: un pointeur sur la taille gagnee par compression
|
||||
.RS -3
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Check ( SMT_Heap * " Heap ", int * " Nb_Detected " , int * " Nb_Corrected ", FILE * " Out " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de corriger les structures qui constituent un heap dans le cas ou celles-ci contiendraient des incoherences.
|
||||
.LP
|
||||
Un rapport complet de toutes les erreurs detectees et corrigees sur chacune des structures du heap est affiche.
|
||||
.LP
|
||||
Elle doit recevoir les arguments suivants :
|
||||
.RS 3
|
||||
.LP
|
||||
* (In)
|
||||
.I Heap
|
||||
: un pointeur sur un heap ouvert
|
||||
.LP
|
||||
* (Out)
|
||||
.I Nb_Detected
|
||||
: un pointeur sur le nombre d'erreurs detectees
|
||||
.LP
|
||||
* (Out)
|
||||
.I Nb_Corrected
|
||||
: un pointeur sur le nombre d'erreurs corrigees
|
||||
.LP
|
||||
* (In)
|
||||
.I Out
|
||||
: un pointeur sur le flux de sortie du rapport
|
||||
.LP
|
||||
.RS -3
|
||||
.I NB
|
||||
: cette fonction est automatiquement activee lors de l'ouverture d'un heap qui est dans un etat invalide (c.a.d un heap dont une mise a jour n'a pas ete a son terme).
|
||||
.LP
|
||||
Si toutes les erreurs detectees n'ont pas pu etre corrigees, le heap est declare corrompu et ne sera plus accessible par personne.
|
||||
.LP
|
||||
.RS -3
|
||||
.BI "SMT_Status SM_Heap_Lock ( SMT_Heap * " Heap ", SMT_Flags " Lock_Flags ", int * " Locked " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de poser un verrou sur un heap.
|
||||
.LP
|
||||
Elle doit recevoir les arguments suivants :
|
||||
.LP
|
||||
.RS 3
|
||||
* (In)
|
||||
.I Heap
|
||||
: un pointeur sur un heap ouvert
|
||||
.LP
|
||||
* (In)
|
||||
.I Lock_Flags
|
||||
: le mode de verrouillage
|
||||
.LP
|
||||
* (Out)
|
||||
.I Locked
|
||||
: un pointeur sur un indicateur de verrouillage qui indique si le verrou a effectivement ete pose ou si le heap etait deja verrouille dans ce mode
|
||||
.LP
|
||||
.RS -3
|
||||
.I NB
|
||||
: si le heap est deja verrouille avec le mode demande, alors l'indicateur de verrouillage sera valorise a FALSE.
|
||||
.LP
|
||||
Si le heap est deja verrouille avec un autre type de verrou, alors la fonction retournera
|
||||
.B SMS_KO
|
||||
.
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Unlock ( SMT_Heap * " Heap " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet d'oter le verrou qui a ete pose sur un heap.
|
||||
.LP
|
||||
L'argument
|
||||
.I Heap
|
||||
est un pointeur sur le heap a deverrouiller.
|
||||
.RS -3
|
||||
.LP
|
||||
.BI "SMT_Status SM_Heap_Config ( SMT_Heap * " Heap ", SMT_Tag " Tag ", ... );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de configurer certain aspects d'un heap.
|
||||
.LP
|
||||
Elle doit recevoir les aruments suivants :
|
||||
.LP
|
||||
.RS 3
|
||||
* (In)
|
||||
.I Heap
|
||||
: un pointeur sur le heap a configurer.
|
||||
.LP
|
||||
* (In)
|
||||
.I Tag
|
||||
: le type de configuration
|
||||
.LP
|
||||
.RS 3
|
||||
-
|
||||
.B SMD_SEGMENT_SIZE
|
||||
: definition de la taille (en octets) des nouveaux segments de donnees qui composeront le heap (par defaut, les heaps sont composes de segments de 102 400 octets).
|
||||
.LP
|
||||
-
|
||||
.B SMD_HEAP_LIMIT
|
||||
: limitation de la taille totale des segments de donnees qui composent le heap (par defaut, un heap n'est pas limite en taille).
|
||||
.LP
|
||||
-
|
||||
.B SMD_AUTO_COMPRESS
|
||||
: nombre de chunks libres a partir duquel le heap est automatiquement compresse (la valeur SMD_NO_AUTO_COMPRESS permet de desactiver cette procedure automatique).
|
||||
.LP
|
||||
NB : cette limite est fixee par defaut a 1 000 chunks.
|
||||
.LP
|
||||
.RS -3
|
||||
.RS -3
|
||||
.RS -3
|
||||
.BI "SMT_Status SM_Chunk_Alloc ( SMT_Heap * " Heap ", void ** " Ptr ", size_t " Size " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de reserver de la memoire dans un heap.
|
||||
.LP
|
||||
Elle doit recevoir les arguments suivants :
|
||||
.LP
|
||||
.RS 3
|
||||
* (In)
|
||||
.I Heap
|
||||
: un pointeur sur un heap ouvert
|
||||
.LP
|
||||
* (In)
|
||||
.I Size
|
||||
: la taille du chunk (en octets)
|
||||
.LP
|
||||
* (Out)
|
||||
.I Ptr
|
||||
: l'adresse du pointeur de chunk
|
||||
.RS -3
|
||||
.LP
|
||||
.RS -3
|
||||
.BI "SMT_Status SM_Chunk_Free ( SMT_Heap * " Heap ", void * " Ptr " );"
|
||||
.LP
|
||||
.RS 3
|
||||
Cette fonction permet de liberer de la memoire dans un heap.
|
||||
.LP
|
||||
Elle doit recevoir les arguments suivants :
|
||||
.LP
|
||||
.RS 3
|
||||
* (In)
|
||||
.I Heap
|
||||
: un pointeur sur un heap ouvert
|
||||
.LP
|
||||
* (In)
|
||||
.I Ptr
|
||||
: un pointeur de chunk
|
||||
.RS -3
|
||||
.RS -3
|
||||
.LP
|
||||
.SH CODE RETOUR
|
||||
.LP
|
||||
Toutes les fonctions constituant l'API de la librairie retourne une valeur de type
|
||||
.B SMT_Status
|
||||
:
|
||||
.LP
|
||||
.RS 3
|
||||
-
|
||||
.B SMS_OK
|
||||
: la fonction s'est correctement executee et a produit un resultat
|
||||
.LP
|
||||
-
|
||||
.B SMS_KO
|
||||
: la fonction s'est correctement executee mais n'a pas produit de resultat
|
||||
.LP
|
||||
-
|
||||
.B SMS_ERRAPI
|
||||
: la fonction a ete appelee avec des arguments de valeur incorrecte
|
||||
.LP
|
||||
-
|
||||
.B SMS_ERRMEM
|
||||
: la fonction ne s'est pas correctement executee pour un probleme d'allocation memoire
|
||||
.LP
|
||||
-
|
||||
.B SMS_ERRSHM
|
||||
: la fonction ne s'est pas correctement executee pour un probleme relatif a la memoire partagee
|
||||
.LP
|
||||
-
|
||||
.B SMS_ERRSIG
|
||||
: une operation sur semaphore a ete interrompue par un signal
|
||||
.LP
|
||||
-
|
||||
.B SMS_ERRSEM
|
||||
: la fonction ne s'est pas correctement executee pour un probleme relatif a l'utilisation des semaphores
|
||||
.LP
|
||||
.RS -3
|
||||
.I NB
|
||||
: la macro
|
||||
.B SM_ERROR()
|
||||
permet de tester si un code retour correspond a une erreur.
|
||||
.LP
|
||||
En cas d'erreur, la variable
|
||||
.B SM_Error_Msg
|
||||
contient un message du type :
|
||||
.LP
|
||||
.RS 3
|
||||
Error <Nom fonction> : <message d'erreur>
|
||||
.RS -3
|
||||
.LP
|
||||
.I NB
|
||||
: dans la mesure du possible, la librairie tente en cas de probleme de revenir a la situation precedant l'appel a la fonction.
|
||||
.LP
|
||||
Toutefois, pour les cas plus difficiles, la librairie propose une procedure de verification et de correction (
|
||||
.B SM_Heap_Check
|
||||
) qui permet de corriger des incoherences sur les structures de donnees constituant un heap.
|
||||
.RS -3
|
||||
.LP
|
||||
.SH VOIR AUSSI
|
||||
.B libnode
|
||||
(3)
|
||||
388
include/shmem.h
Normal file
388
include/shmem.h
Normal file
@ -0,0 +1,388 @@
|
||||
#ifndef _LIBSM
|
||||
#define _LIBSM
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <sys/types.h>
|
||||
#include <node.h>
|
||||
|
||||
/* Code retour des fonctions constituant l'API */
|
||||
|
||||
typedef long SMT_Status;
|
||||
|
||||
#define SMS_OK NDS_OK /* La fonction s'est correctement exécutée et a produit un résultat */
|
||||
#define SMS_KO NDS_KO /* La fonction s'est correctement exécutée mais n'a pas produit de résultat */
|
||||
#define SMS_NO_WAIT 2 /* Opération sur sémaphore en mode IPC_NOWAIT qui n'a pas pu aboutir */
|
||||
|
||||
#define SMS_YES SMS_OK /* Résultat booléen positif */
|
||||
#define SMS_NO SMS_KO /* Résultat booléen négatif */
|
||||
|
||||
#define SMS_ERRMEM NDS_ERRMEM /* Problème d'allocation mémoire */
|
||||
#define SMS_ERRAPI NDS_ERRAPI /* Utilisation incorrecte des API */
|
||||
#define SMS_ERRSHM -3 /* Problème relatif aux segments de mémoire partagée */
|
||||
#define SMS_ERRSEM -4 /* Problème relatif à l'utilisation des sémaphores */
|
||||
#define SMS_ERRSIG -5 /* Opération sur sémaphore interrompue par un signal */
|
||||
|
||||
#define SM_ERROR(s) ((s) < 0) /* Tous les codes retour négatifs correspondent à des erreurs */
|
||||
|
||||
typedef int SMT_Flags;
|
||||
|
||||
#define SMD_UNDEF 0
|
||||
|
||||
/* Flags d'ouverture d'un heap ou d'une instance de la librairie */
|
||||
|
||||
#define SMD_CREATE 0x01 /* Création */
|
||||
#define SMD_OPEN 0x02 /* Ouverture simple */
|
||||
#define SMD_DESTROY 0x04 /* Destruction */
|
||||
#define SMD_CLOSE 0x08 /* Fermeture simple */
|
||||
|
||||
/* NB : pour l'ouverture de la librairie, les valeurs SMD_OPEN et SMD_CREATE sont mutuellement exclusives */
|
||||
|
||||
/* Flags de verrouillage */
|
||||
|
||||
#define SMD_READ 0x04 /* verrou partagé */
|
||||
#define SMD_WRITE 0x08 /* verrou exclusif */
|
||||
#define SMD_NO_LOCK 0x00 /* aucun verrou */
|
||||
|
||||
#define SMD_LOCK_MSK(a) ((a) & (SMD_READ|SMD_WRITE))
|
||||
|
||||
/* Mode de debug sur l'ouverture de la librairie */
|
||||
|
||||
#define SMD_DEBUG_NONE 0x00 /* pour n'afficher aucun message généré par les diverses librairies */
|
||||
#define SMD_DEBUG 0x10 /* pour afficher les messages générés par la librairie */
|
||||
#define SMD_DEBUG_ALL 0x20 /* pour afficher les messages générés par toutes les librairies sous-jacentes */
|
||||
|
||||
#define SMD_DEBUG_MSK(a) ((a) & (SMD_DEBUG|SMD_DEBUG_ALL))
|
||||
|
||||
/* Différentes types de configuration d'un heap */
|
||||
|
||||
typedef int SMT_Config;
|
||||
|
||||
#define SMD_SEGMENT_SIZE 1 /* Définir la taille des segments */
|
||||
#define SMD_HEAP_LIMIT 2 /* Définir la taille maximale */
|
||||
#define SMD_AUTO_COMPRESS 3 /* Définir la taille d'un FCR à partir de laquelle
|
||||
la compression du heap est autmatiquement activée */
|
||||
|
||||
#define SMD_DEFAULT_COMPRESS 1000 /* si + de 1000 chunks libres, alors compression du heap */
|
||||
|
||||
/* Différentes valeurs de configuration */
|
||||
|
||||
#define SMD_UNLIMITED 0
|
||||
#define SMD_NO_AUTO_COMPRESS 0
|
||||
|
||||
/* Nom du heap système */
|
||||
|
||||
#define HEAP_SYSTEM "system"
|
||||
|
||||
#ifndef FALSE
|
||||
#define FALSE 0
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE 1
|
||||
#endif
|
||||
|
||||
char SM_Error_Msg [512];
|
||||
|
||||
#ifndef SM_MODE
|
||||
#define SM_MODE 0
|
||||
#endif
|
||||
|
||||
#if SM_MODE == 1 /* API sans vérification des arguments */
|
||||
|
||||
#define SM_Library_Open SM_Library_Open_I
|
||||
#define SM_Library_Instance_Get SM_Library_Instance_Get_I
|
||||
#define SM_Library_Context_Set SM_Library_Context_Set_I
|
||||
#define SM_Library_Context_Get SM_Library_Context_Get_I
|
||||
#define SM_Library_Close SM_Library_Close_I
|
||||
#define SM_Library_Dump SM_Library_Dump_I
|
||||
#define SM_Library_Unlock SM_Library_Unlock_I
|
||||
#define SM_Library_Stderr_Set SM_Library_Stderr_Set_I
|
||||
#define SM_Heap_Exist SM_Heap_Exist_I
|
||||
#define SM_Heap_Open SM_Heap_Open_I
|
||||
#define SM_Heap_IsOpen SM_Heap_IsOpen_I
|
||||
#define SM_Heap_Close SM_Heap_Close_I
|
||||
#define SM_Heap_End SM_Heap_End_I
|
||||
#define SM_Heap_Compress SM_Heap_Compress_I
|
||||
#define SM_Heap_Config SM_Heap_Config_I
|
||||
#define SM_Heap_Check SM_Heap_Check_I
|
||||
#define SM_Heap_Lock SM_Heap_Lock_I
|
||||
#define SM_Heap_Unlock SM_Heap_Unlock_I
|
||||
#define SM_Chunk_Alloc SM_Chunk_Alloc_I
|
||||
#define SM_Chunk_Free SM_Chunk_Free_I
|
||||
|
||||
#else /* API avec vérification des arguments */
|
||||
|
||||
#define SM_Library_Open SM_Library_Open_C
|
||||
#define SM_Library_Instance_Get SM_Library_Instance_Get_C
|
||||
#define SM_Library_Context_Set SM_Library_Context_Set_C
|
||||
#define SM_Library_Context_Get SM_Library_Context_Get_C
|
||||
#define SM_Library_Close SM_Library_Close_C
|
||||
#define SM_Library_Dump SM_Library_Dump_C
|
||||
#define SM_Library_Unlock SM_Library_Unlock_C
|
||||
#define SM_Library_Stderr_Set SM_Library_Stderr_Set_C
|
||||
#define SM_Heap_Exist SM_Heap_Exist_C
|
||||
#define SM_Heap_Open SM_Heap_Open_C
|
||||
#define SM_Heap_IsOpen SM_Heap_IsOpen_C
|
||||
#define SM_Heap_Close SM_Heap_Close_C
|
||||
#define SM_Heap_End SM_Heap_End_C
|
||||
#define SM_Heap_Compress SM_Heap_Compress_C
|
||||
#define SM_Heap_Config SM_Heap_Config_C
|
||||
#define SM_Heap_Check SM_Heap_Check_C
|
||||
#define SM_Heap_Lock SM_Heap_Lock_C
|
||||
#define SM_Heap_Unlock SM_Heap_Unlock_C
|
||||
#define SM_Chunk_Alloc SM_Chunk_Alloc_C
|
||||
#define SM_Chunk_Free SM_Chunk_Free_C
|
||||
|
||||
#endif
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Structure de la base de heaps */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct {
|
||||
int SysMemID; /* ID de la 1ère zone de mémoire partagée de la base */
|
||||
int DataMemID; /* ID de la 2ème zone de mémoire partagée de la base */
|
||||
size_t Size; /* Taille de la zone de mémoire partagée */
|
||||
int SemID; /* ID du sémaphore pour la gestion des verrous */
|
||||
NDT_Root * MHR; /* Memory Heap Root : racine de la liste de heap */
|
||||
pid_t Creator; /* ID du processus créateur de la base */
|
||||
pid_t Writer; /* ID du dernier processus ayant accédé en écriture à la base */
|
||||
void * Free; /* Pointeur sur la première zone libre de la base */
|
||||
void * Attach; /* Adresse du dernier attachement */
|
||||
size_t Segment_Size; /* Taille par défaut des segments qui composeront les heaps */
|
||||
} SMT_Base;
|
||||
|
||||
/* Référence sur la base de heaps */
|
||||
|
||||
SMT_Base * SM_Base;
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Structure d'un MHH (Memory Heap Header) */
|
||||
/* Rappel : un MHH est une valeur attachée à un MHN (Memory Heap Node) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct {
|
||||
char Name [256]; /* Nom du heap */
|
||||
int SemID; /* ID du sémaphore pour la gestion des verrous */
|
||||
NDT_Root * DSR; /* Data Segment Root */
|
||||
NDT_Root * ACR; /* Allocated Chunks Root */
|
||||
NDT_Root * FCR; /* Free Chunks Root */
|
||||
pid_t Writer; /* ID du processus ayant accédé en dernier au MHH en écriture */
|
||||
int State; /* Etat d'un heap (valide, non validé ou corrompu) */
|
||||
size_t Segment_Size; /* Taille des segments de mémoire composant le heap */
|
||||
size_t Limit_Size; /* Taille limite du heap (par défaut : pas de limite) */
|
||||
int Auto_Compress; /* Nombre de chunks libres à partir duquel le heap est automatiquement compressé */
|
||||
} SMT_MHH;
|
||||
|
||||
/* Heap ouvert */
|
||||
|
||||
typedef struct {
|
||||
char * Name;
|
||||
SMT_MHH * MHH;
|
||||
SMT_Flags Lock_Mode; /* Mode dans lequel le heap est verrouillé */
|
||||
int Nb_Seg; /* Nombre de segments du heap lors de son ouverture */
|
||||
} SMT_Heap;
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Structure d'un DSH (Data Segment Header) */
|
||||
/* Rappel : un DSH est une valeur attachée à un DSN (noeud de DSR) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct {
|
||||
int MemID; /* ID de la zone de mémoire partagée */
|
||||
size_t Size; /* Taille de la zone de mémoire partagée */
|
||||
void * Start; /* Adresse de début de la zone de mémoire partagée */
|
||||
} SMT_DSH;
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Structure d'un chunk */
|
||||
/* Rappel : un chunk est la valeur attachée à un noeud de ACR ou FCR */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct {
|
||||
size_t Size; /* Taille allouée au chunk */
|
||||
void * Data; /* Adresse de la zone de données du chunk */
|
||||
} SMT_Chunk;
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Ouverture d'une instance de la librairie */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Instance : numéro d'instance de la librairie */
|
||||
/* (I) Context : nom du nouveau contexte */
|
||||
/* (I) Flags : indicateur création/ouverture + mode d'affichage des erreurs */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Library_Open_I ( int Instance, const char * Context, SMT_Flags Flags );
|
||||
SMT_Status SM_Library_Open_C ( int Instance, const char * Context, SMT_Flags Flags );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Récupération du numéro de l'instance utilisée */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (O) Instance : adresse du numéro de l'instance utilisée */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Library_Instance_Get_I ( int * Instance);
|
||||
SMT_Status SM_Library_Instance_Get_C ( int * Instance);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Changement de contexte d'utilisation de la librairie */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Context : nom du nouveau contexte */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Library_Context_Set_I ( const char * Context );
|
||||
SMT_Status SM_Library_Context_Set_C ( const char * Context );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Récupération du nom du contexte utilisé */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (O) Context : adresse du nom du contexte utilisé */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Library_Context_Get_I ( char ** Context );
|
||||
SMT_Status SM_Library_Context_Get_C ( char ** Context );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Fermeture de l'instance de la librairie */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Flags : mode de fermeture (destruction ou fermeture simple) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Library_Close_I ( SMT_Flags Flags );
|
||||
SMT_Status SM_Library_Close_C ( SMT_Flags Flags );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Affichage des informations de la base de mémoires partagées */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Out : pointeur sur le flux de sortie */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Library_Dump_I ( FILE * Out );
|
||||
SMT_Status SM_Library_Dump_C ( FILE * Out );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Libération de tous les verrous (base, heap) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Library_Unlock_I ( void );
|
||||
SMT_Status SM_Library_Unlock_C ( void );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Définition de la sortie standard des messages d'erreur de la librairie */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Library_Stderr_Set_I ( FILE * Out );
|
||||
SMT_Status SM_Library_Stderr_Set_C ( FILE * Out );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Test d'existence d'un heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap_Name : nom du heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Exist_I ( const char * Heap_Name );
|
||||
SMT_Status SM_Heap_Exist_C ( const char * Heap_Name );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Ouverture/création d'un heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap_Name : nom du heap */
|
||||
/* (O) Heap : pointeur sur le heap ouvert / créé */
|
||||
/* (I) Seg_Size : taille des segments du heap */
|
||||
/* (I) Flags : mode d'ouverture du heap */
|
||||
/* (O) Locked : verrou effectif (TRUE ou FALSE) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Open_I ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked );
|
||||
SMT_Status SM_Heap_Open_C ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Teste si un heap a déjà été ouvert par le processus courant */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap_Name : nom du heap */
|
||||
/* (O) Heap : adresse du pointeur sur le heap ouvert */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_IsOpen_I ( const char * Heap_Name, SMT_Heap ** Heap );
|
||||
SMT_Status SM_Heap_IsOpen_C ( const char * Heap_Name, SMT_Heap ** Heap );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Fermeture d'un heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap : pointeur sur un heap ouvert */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Close_I ( SMT_Heap * Heap );
|
||||
SMT_Status SM_Heap_Close_C ( SMT_Heap * Heap );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Destruction d'un heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap_Name : nom du heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_End_I ( const char * Heap_Name );
|
||||
SMT_Status SM_Heap_End_C ( const char * Heap_Name );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Compression d'un heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap : pointeur sur un heap ouvert */
|
||||
/* (O) Compress : pointeur sur la taille mémoire gagnée */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Compress_I ( SMT_Heap * Heap, size_t * Compress );
|
||||
SMT_Status SM_Heap_Compress_C ( SMT_Heap * Heap, size_t * Compress );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Configuration d'un heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap : pointeur sur un heap ouvert */
|
||||
/* (I) Tag : type de configuration */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Config_I ( SMT_Heap * Heap, SMT_Config Tag, ... );
|
||||
SMT_Status SM_Heap_Config_C ( SMT_Heap * Heap, SMT_Config Tag, ... );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Vérification/correction des structures d'un heap : */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap : pointeur sur un heap ouvert */
|
||||
/* (O) Nb_Detected : pointeur sur le nombre d'erreurs détectées */
|
||||
/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */
|
||||
/* (I) Out : pointeur sur le flux de sortie du rapport */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Check_I ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out);
|
||||
SMT_Status SM_Heap_Check_C ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Pose d'un verrou sur un heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap : pointeur sur un heap ouvert */
|
||||
/* (I) Flags : mode de verrouillage (SMD_READ ou SMD_WRITE) */
|
||||
/* (O) Locked : verrouillage effectué (TRUE ou FALSE) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Lock_I ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked );
|
||||
SMT_Status SM_Heap_Lock_C ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Libération d'un verrou sur un heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap : pointeur sur un heap ouvert */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Unlock_I ( SMT_Heap * Heap );
|
||||
SMT_Status SM_Heap_Unlock_C ( SMT_Heap * Heap );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Allocation d'un chunk dans un heap */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap : pointeur sur un heap ouvert */
|
||||
/* (I) Size : taille du chunk */
|
||||
/* (O) Ptr : pointeur sur la zone de données allouée */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Chunk_Alloc_I ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
|
||||
SMT_Status SM_Chunk_Alloc_C ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Désallocation d'un chunk */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* (I) Heap : pointeur sur un heap ouvert */
|
||||
/* (I) Ptr : adresse de la zone de données du chunk à désallouer */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Chunk_Free_I ( SMT_Heap * Heap, void * Ptr );
|
||||
SMT_Status SM_Chunk_Free_C ( SMT_Heap * Heap, void * Ptr );
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
3847
lib/libshmem.c
Normal file
3847
lib/libshmem.c
Normal file
File diff suppressed because it is too large
Load Diff
263
lib/libshmem.h
Normal file
263
lib/libshmem.h
Normal file
@ -0,0 +1,263 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <stdarg.h>
|
||||
#include <sys/sem.h>
|
||||
#include <sys/shm.h>
|
||||
#include <sys/ipc.h>
|
||||
#include <ver.h>
|
||||
#include <shmem.h>
|
||||
|
||||
/* Compteur d'ouverture de la librairie */
|
||||
|
||||
unsigned int SM_Open_Counter = 0;
|
||||
|
||||
/* Flux de sortie des messages d'erreur générés par la librairie */
|
||||
|
||||
FILE * SM_stderr;
|
||||
|
||||
extern char * strdup (const char *);
|
||||
|
||||
#define max(A,B) ((A < B) ? B : A)
|
||||
|
||||
/* Limite supérieure d'adressage */
|
||||
|
||||
#define MEM_LIMIT 1000000000
|
||||
|
||||
/* Taille d'un segment = 100 Ko par défaut */
|
||||
|
||||
#define K 1024
|
||||
#define NB_BLOCS 100
|
||||
#define SEGMENT_DEFAULT_SIZE NB_BLOCS * K
|
||||
|
||||
char Info_Msg [256];
|
||||
|
||||
/* Etats possibles pour un heap */
|
||||
|
||||
#define SMD_STATE_VALID 0
|
||||
#define SMD_STATE_UNVALIDATED 1
|
||||
#define SMD_STATE_CORRUPTED 2
|
||||
|
||||
/* Référence sur le heap système */
|
||||
|
||||
SMT_Heap * System_Heap;
|
||||
|
||||
/* Liste des heaps ouverts par le processus courant */
|
||||
|
||||
NDT_Root * Opened_Heap_List;
|
||||
|
||||
/*
|
||||
Taille par défaut des chunks alloués dans le heap système :
|
||||
Cette taille est fixée à la taille maximale des chunks pouvant
|
||||
y être alloué (de type NDT_Node, NDT_Root, SMT_MHH ou SMT_DSH)
|
||||
*/
|
||||
|
||||
#define DEFAULT_CHUNK_SIZE max(max(sizeof(NDT_Root), sizeof(NDT_Node)), max(sizeof(SMT_MHH), sizeof(SMT_DSH)))
|
||||
|
||||
/*
|
||||
Nombre de chunk libre minimum avant extension du heap système par un
|
||||
nouveau segment de données (fixé à 3 car l'ajout d'un nouveau segment
|
||||
nécessite l'allocation de 2 chunks (un noeud et une entête de segment).
|
||||
*/
|
||||
|
||||
#define FREE_CHUNK_LIMIT 3
|
||||
|
||||
int SM_Instance;
|
||||
char * SM_Context;
|
||||
|
||||
/* Contexte et instance d'utilisation de la librairie */
|
||||
|
||||
#define DEFAULT_INSTANCE 1000
|
||||
#define INSTANCE_ENV_VAR "INSTANCE"
|
||||
|
||||
#define DEFAULT_CONTEXT "CTX"
|
||||
#define CONTEXT_ENV_VAR "CONTEXT"
|
||||
|
||||
/*
|
||||
Variable globale permettant d'indiquer que l'on est en train
|
||||
d'étendre le heap système par ajout d'un nouveau segment.
|
||||
*/
|
||||
|
||||
unsigned int Adding_Segment = FALSE;
|
||||
|
||||
SMT_Chunk * Tmp_Chunk;
|
||||
SMT_MHH * Tmp_MHH;
|
||||
|
||||
/*
|
||||
Définition des opérations de verouillage et de déverrouillage
|
||||
NB : la valeur 1 d'un sémaphore correspond à l'état non verrouillé
|
||||
*/
|
||||
|
||||
/* Pose d'un verrou en lecture : 2 opérations : ( -1 puis +2 ) */
|
||||
|
||||
struct sembuf SM_SemOp_SSL [2] = { {0, -1, SEM_UNDO}, {0, 2, SEM_UNDO} };
|
||||
|
||||
/* Libération d'un verrou en lecture : 2 opérations ( -2 puis +1 ) */
|
||||
|
||||
struct sembuf SM_SemOp_RSL [2] = { {0, -2, SEM_UNDO|IPC_NOWAIT}, {0, 1, SEM_UNDO|IPC_NOWAIT} };
|
||||
|
||||
/* Pose d'un verrou en écriture : 2 opérations ( -1 puis 0 ) */
|
||||
|
||||
struct sembuf SM_SemOp_SEL [2] = { {0, -1, SEM_UNDO}, {0, 0, SEM_UNDO} };
|
||||
|
||||
/* Libération d'un verrou en écriture : 2 opérations ( 0 puis +1 ) */
|
||||
|
||||
struct sembuf SM_SemOp_REL [2] = { {0, 0, SEM_UNDO|IPC_NOWAIT}, {0, 1, SEM_UNDO|IPC_NOWAIT} };
|
||||
|
||||
/* Transformation d'un verrou en écriture en un verrou en lecture : 2 opérations ( 0 puis +2 ) */
|
||||
|
||||
struct sembuf SM_SemOp_TSL [2] = { {0, 0, SEM_UNDO|IPC_NOWAIT}, {0, 2, SEM_UNDO|IPC_NOWAIT} };
|
||||
|
||||
typedef union semun
|
||||
{
|
||||
int val;
|
||||
struct semid_ds * buf;
|
||||
unsigned short int * array;
|
||||
} semun;
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Allocation de mémoire dans la base */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Base_Alloc (size_t, void **, void *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Désallocation de mémoire dans la base */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Base_Free (void *, void *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Allocation de mémoire dans le heap système */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_System_Alloc (size_t, void **, void *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Désallocation de mémoire dans le heap système */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_System_Free (void *, void *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Initialisation de la base */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Base_Init (void);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Terminaison de la base */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Base_End (void);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Ouverture de la base */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Base_Open (void);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Fermeture de la base */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Base_Close (void);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Pose d'un verrou sur la base : */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Base_Lock (SMT_Flags);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Libération d'un verrou sur la base : */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Base_Unlock (SMT_Flags);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Fonction manager de la liste des heaps ouverts */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
NDT_Status SM_Opened_Heap_List_Manager (va_list);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Fonction manager du MHR (Memory Heap Root) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
NDT_Status MHR_Manager (va_list);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Destruction d'un MHH (Memory Heap Header) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_MHH_End (SMT_MHH *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Fonction manager pour un DSR (Data Segment Root) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
NDT_Status SM_DSR_Manager (va_list);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Initialisation d'un nouveau segment de données (noeud du DSR) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_DSH *SM_DataSegment_Init (SMT_MHH *, size_t);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Terminaison d'un segment de données */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_DataSegment_End (NDT_Root *, SMT_DSH *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Ouverture d'un segment de données */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_DataSegment_Open (SMT_DSH *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Fermeture d'un segment de données */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_DataSegment_Close (SMT_DSH *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Compression d'un segment de données */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
size_t SM_DataSegment_Compress (SMT_DSH *, NDT_Root *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Fonction manager pour un ACR (Allocated Chunk Root) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
NDT_Status SM_ACR_Manager (va_list);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Fonction manager pour un FCR (Free Chunk Root) */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
NDT_Status SM_FCR_Manager(va_list);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Pose d'un verrou sur un heap : */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Lock_Set (SMT_MHH *, SMT_Flags);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Changement d'un verrou sur un heap : */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Lock_Change (SMT_MHH *, SMT_Flags);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Libération d'un verrou sur un heap : */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Heap_Lock_Release (SMT_MHH *, SMT_Flags);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Opération sur un sémaphore */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
SMT_Status SM_Semaphore_Operate (int, struct sembuf *, unsigned int);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Récupère sous forme explicite l'état d'un verrou */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
char * SM_Lock_Status_Get (const char *, void *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Récupère sous forme explicite la description d'une racine de structure */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
char * SM_Root_Description_Get (const char *, NDT_Root *);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Routine d'affichage d'un message d'erreur */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
void SM_Error_Print (void);
|
||||
|
||||
/*------------------------------------------------------------------------------*/
|
||||
/* Pour préfixer un nom de heap avec le nom de l'instance utilisée */
|
||||
/*------------------------------------------------------------------------------*/
|
||||
static char * SM_Name_Prefix (const char *);
|
||||
341
util/smadmin.c
Normal file
341
util/smadmin.c
Normal file
@ -0,0 +1,341 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdarg.h>
|
||||
#include <node.h>
|
||||
#define SM_MODE 0 /* Utilisation des API sécurisés */
|
||||
#include <shmem.h>
|
||||
|
||||
VER_INFO_EXPORT (smadmin, "$Revision: 1.1 $", "$Name: $", __FILE__, "$Author: smas $")
|
||||
|
||||
#define USAGE "Usage : %s [ --help | --version [-v] | --create | --destroy ]\n"
|
||||
|
||||
#define QUIT 0
|
||||
#define BASE_INIT 1
|
||||
#define BASE_OPEN 2
|
||||
#define BASE_INFO 3
|
||||
#define BASE_CLOSE 4
|
||||
#define BASE_END 5
|
||||
#define MHH_INIT 6
|
||||
#define MHH_OPEN 7
|
||||
#define MHH_CHECK 8
|
||||
#define MHH_COMPRESS 9
|
||||
#define MHH_CLOSE 10
|
||||
#define MHH_END 11
|
||||
#define ALLOC_CHUNK 12
|
||||
#define WRITE_CHUNK 13
|
||||
#define READ_CHUNK 14
|
||||
#define FREE_CHUNK 15
|
||||
#define DSR_DUMP 16
|
||||
#define ACR_DUMP 17
|
||||
#define FCR_DUMP 18
|
||||
|
||||
char menu [1000];
|
||||
char tmp [100];
|
||||
|
||||
void init_menu (void);
|
||||
int print_menu (void);
|
||||
|
||||
int main (int argc, char ** argv)
|
||||
{
|
||||
int choice;
|
||||
char name [100];
|
||||
int Mode, Locked;
|
||||
void * ptr;
|
||||
char answer [10];
|
||||
SMT_Heap * Heap;
|
||||
int Nb_Detected, Nb_Corrected;
|
||||
size_t size;
|
||||
|
||||
/* Lancement de commande d'administration */
|
||||
|
||||
if (argc >= 2)
|
||||
{
|
||||
if (!strcmp (argv[1], "--help"))
|
||||
{
|
||||
fprintf (stderr, USAGE, argv[0]);
|
||||
return -1;
|
||||
}
|
||||
else if (!strcmp (argv[1], "--version"))
|
||||
{
|
||||
if (argc >= 3 && !strcmp (argv[2], "-v"))
|
||||
return VER_Object_Print (stdout, VERD_VERBOSE);
|
||||
else
|
||||
return VER_Object_Print (stdout, VERD_MINIMAL);
|
||||
}
|
||||
else if (!strcmp (argv[1], "--create"))
|
||||
{
|
||||
if (SM_Library_Open (0, NULL, SMD_CREATE | SMD_DEBUG_ALL) != SMS_OK)
|
||||
{
|
||||
fprintf (stderr, "=> Impossible de créer l'instance de la librairie LIBSHMEM\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
else if (!strcmp (argv[1], "--destroy"))
|
||||
{
|
||||
if (SM_Library_Open (0, NULL, SMD_OPEN | SMD_DEBUG_ALL) != SMS_OK || SM_Library_Close (SMD_DESTROY) != SMS_OK)
|
||||
{
|
||||
fprintf (stderr, "=> Impossible de détruire l'instance de la librairie LIBSHMEM\n");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf (stderr, USAGE, argv[0]);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/* Lancement du menu intercatif */
|
||||
|
||||
init_menu ();
|
||||
|
||||
choice = print_menu ();
|
||||
|
||||
while (choice != QUIT)
|
||||
{
|
||||
strcpy (answer, "yes");
|
||||
|
||||
switch (choice)
|
||||
{
|
||||
case BASE_INIT:
|
||||
fprintf (stdout, "\nReturn code = %s\n", \
|
||||
SM_Library_Open (0, NULL, SMD_CREATE | SMD_DEBUG_ALL) == SMS_OK ? "OK" : "NOK" );
|
||||
break;
|
||||
|
||||
case BASE_OPEN:
|
||||
fprintf (stdout, "\nReturn code = %s\n", \
|
||||
SM_Library_Open (0, NULL, SMD_OPEN | SMD_DEBUG_ALL) == SMS_OK ? "OK" : "NOK" );
|
||||
break;
|
||||
|
||||
case BASE_END:
|
||||
fprintf (stdout, "\nReturn code = %s\n", \
|
||||
SM_Library_Close (SMD_DESTROY) == SMS_OK ? "OK" : "NOK" );
|
||||
break;
|
||||
|
||||
case BASE_CLOSE:
|
||||
fprintf (stdout, "\nReturn code = %s\n", \
|
||||
SM_Library_Close (SMD_CLOSE) == SMS_OK ? "OK" : "NOK" );
|
||||
break;
|
||||
|
||||
case BASE_INFO:
|
||||
SM_Library_Dump (stderr);
|
||||
break;
|
||||
|
||||
case MHH_INIT:
|
||||
fprintf (stdout, "\nNew heap name ? ");
|
||||
gets (name);
|
||||
fprintf (stdout, "\nHeap segment size ? ");
|
||||
gets (tmp);
|
||||
size = atoi (tmp);
|
||||
fprintf (stdout, "\nReturn code = %s\n", \
|
||||
SM_Heap_Open (name, &Heap, size, \
|
||||
SMD_CREATE, &Locked) == SMS_OK ? "OK" : "NOK" );
|
||||
break;
|
||||
|
||||
case MHH_OPEN:
|
||||
fprintf (stdout, "\nHeap name to open ? ");
|
||||
gets (name);
|
||||
fprintf (stdout, "\nOpening mode (read=1 write=2) ? ");
|
||||
gets (tmp);
|
||||
if (tmp[0] == '1') Mode = SMD_READ;
|
||||
else Mode = SMD_WRITE;
|
||||
if (!strcmp (name, HEAP_SYSTEM))
|
||||
{
|
||||
fprintf (stdout, \
|
||||
"\n*** Warning : you can not make this operation on the system heap ***\n");
|
||||
break;
|
||||
}
|
||||
|
||||
fprintf (stdout, "\nReturn code = %s\n", SM_Heap_Open (name, \
|
||||
&Heap, 0, SMD_OPEN | Mode, &Locked) == SMS_OK ? "OK" : "NOK" );
|
||||
|
||||
break;
|
||||
|
||||
case MHH_COMPRESS:
|
||||
fprintf (stdout, "\nHeap name à compresser ? ");
|
||||
gets (name);
|
||||
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_WRITE, &Locked) == SMS_OK)
|
||||
{
|
||||
size_t Compress;
|
||||
SM_Heap_Compress (Heap, &Compress);
|
||||
fprintf (stdout, "\nCompression size = %d byte(s)\n", (int)Compress);
|
||||
if (Locked == TRUE) SM_Heap_Unlock (Heap);
|
||||
}
|
||||
break;
|
||||
|
||||
case MHH_END:
|
||||
fprintf (stdout, "\nHeap name to remove ? ");
|
||||
gets (name);
|
||||
if (!strcmp (name, HEAP_SYSTEM))
|
||||
{
|
||||
fprintf (stdout, \
|
||||
"\n*** Warning : you can not make this operation on the system heap ***\n");
|
||||
break;
|
||||
}
|
||||
|
||||
fprintf (stdout, "\nReturn code = %s\n", \
|
||||
SM_Heap_End (name) == SMS_OK ? "OK" : "NOK" );
|
||||
|
||||
break;
|
||||
|
||||
case MHH_CLOSE:
|
||||
fprintf (stdout, "\nHeap name to close ? ");
|
||||
gets (name);
|
||||
if (!strcmp (name, HEAP_SYSTEM))
|
||||
{
|
||||
fprintf (stdout, \
|
||||
"\n*** Warning : you can not make this operation on the system heap ***\n");
|
||||
break;
|
||||
}
|
||||
if (SM_Heap_IsOpen (name, &Heap) == SMS_OK)
|
||||
fprintf (stdout, "\nReturn code = %s\n", \
|
||||
SM_Heap_Close (Heap) == SMS_OK ? "OK" : "NOK" );
|
||||
else
|
||||
fprintf (stdout, "\nHeap %s is not opened\n", name);
|
||||
|
||||
break;
|
||||
|
||||
case MHH_CHECK:
|
||||
fprintf (stdout, "\nHeap name to check/recover ? ");
|
||||
gets (name);
|
||||
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_WRITE, &Locked) == SMS_OK)
|
||||
{
|
||||
Nb_Detected = Nb_Corrected = 0;
|
||||
SM_Heap_Check (Heap, &Nb_Detected, &Nb_Corrected, stderr);
|
||||
if (Locked == TRUE) SM_Heap_Unlock (Heap);
|
||||
}
|
||||
break;
|
||||
|
||||
case ALLOC_CHUNK:
|
||||
fprintf (stdout, "\nHeap name ? ");
|
||||
gets (name);
|
||||
fprintf (stdout, "\nAllocation size ? ");
|
||||
gets (tmp);
|
||||
size = atoi (tmp);
|
||||
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_WRITE, &Locked) == SMS_OK)
|
||||
{
|
||||
SM_Chunk_Alloc (Heap, size, &ptr);
|
||||
if (Locked == TRUE) SM_Heap_Unlock (Heap);
|
||||
}
|
||||
fprintf (stdout, "\nAddress = 0x%p (%d)\n", ptr, (unsigned int)ptr);
|
||||
break;
|
||||
|
||||
case WRITE_CHUNK:
|
||||
fprintf (stdout, "\nAddress ? ");
|
||||
gets (tmp);
|
||||
ptr = (void *)atoi (tmp);
|
||||
fprintf (stdout, "\nString to put in ? ");
|
||||
gets (tmp);
|
||||
strcpy ( (char *)ptr, tmp);
|
||||
fprintf (stdout, "\nOK\n");
|
||||
break;
|
||||
|
||||
case READ_CHUNK:
|
||||
fprintf (stdout, "\nAddress ? ");
|
||||
gets (tmp);
|
||||
ptr = (void *)atoi (tmp);
|
||||
fprintf (stdout, "\nValeur du pointeur = %s\n", (char *)ptr);
|
||||
break;
|
||||
|
||||
case FREE_CHUNK:
|
||||
fprintf (stdout, "\nHeap name ? ");
|
||||
gets (name);
|
||||
fprintf (stdout, "\nAddress ? ");
|
||||
gets (tmp);
|
||||
ptr = (void *)atoi (tmp);
|
||||
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_WRITE, &Locked) == SMS_OK)
|
||||
{
|
||||
fprintf (stdout, "\nReturn code = %s\n", \
|
||||
SM_Chunk_Free (Heap, ptr) == SMS_OK ? "OK" : "NOK" );
|
||||
if (Locked == TRUE) SM_Heap_Unlock (Heap);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case DSR_DUMP:
|
||||
fprintf (stdout, "\nHeap name ? ");
|
||||
gets (name);
|
||||
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_READ, &Locked) == SMS_OK)
|
||||
{
|
||||
ND_DataStruct_Info_Print (Heap->MHH->DSR, stdout);
|
||||
ND_DataStruct_Print (Heap->MHH->DSR, stdout);
|
||||
if (Locked == TRUE) SM_Heap_Unlock (Heap);
|
||||
}
|
||||
break;
|
||||
|
||||
case ACR_DUMP:
|
||||
fprintf (stdout, "\nHeap name ? ");
|
||||
gets (name);
|
||||
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_READ, &Locked) == SMS_OK)
|
||||
{
|
||||
ND_DataStruct_Info_Print (Heap->MHH->ACR, stdout);
|
||||
ND_DataStruct_Print (Heap->MHH->ACR, stdout);
|
||||
if (Locked == TRUE) SM_Heap_Unlock (Heap);
|
||||
}
|
||||
break;
|
||||
|
||||
case FCR_DUMP:
|
||||
fprintf (stdout, "\nHeap name ? ");
|
||||
gets (name);
|
||||
if (SM_Heap_Open (name, &Heap, 0, SMD_OPEN | SMD_READ, &Locked) == SMS_OK)
|
||||
{
|
||||
ND_DataStruct_Info_Print (Heap->MHH->FCR, stdout);
|
||||
ND_DataStruct_Print (Heap->MHH->FCR, stdout);
|
||||
if (Locked == TRUE) SM_Heap_Unlock (Heap);
|
||||
}
|
||||
break;
|
||||
|
||||
case QUIT:
|
||||
fprintf (stdout, "\nExiting program ...\n");
|
||||
break;
|
||||
|
||||
default:
|
||||
fprintf (stdout, "\nUndefined choice %d\n", choice);
|
||||
}
|
||||
choice = print_menu ();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void init_menu (void)
|
||||
{
|
||||
sprintf (menu, "Menu :\n");
|
||||
sprintf (tmp, " - %2d) %-18s\n", QUIT, "Quit"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", BASE_INIT, "Init library"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", BASE_OPEN, "Open library"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s\n", BASE_INFO, "Info library"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", BASE_CLOSE, "Close library"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", BASE_END, "End library"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s\n", MHH_INIT, "Init heap"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", MHH_OPEN, "Open heap"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", MHH_CHECK, "Check/recover heap"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s\n", MHH_COMPRESS, "Compress heap"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", MHH_CLOSE, "Close heap"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", MHH_END, "End heap"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s\n", ALLOC_CHUNK, "Allocate chunk"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", WRITE_CHUNK, "Write chunk"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", READ_CHUNK, "Read chunk"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s\n", FREE_CHUNK, "Free chunk"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", DSR_DUMP, "Dump DSR"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s", ACR_DUMP, "Dump ACR"); strcat (menu, tmp);
|
||||
sprintf (tmp, " - %2d) %-18s\n", FCR_DUMP, "Dump FCR"); strcat (menu, tmp);
|
||||
}
|
||||
|
||||
int print_menu (void)
|
||||
{
|
||||
fprintf (stdout, "------------------------------------------------------\n%s", menu);
|
||||
|
||||
tmp[0] = '\0';
|
||||
while (tmp[0] == '\0')
|
||||
{
|
||||
printf ("\nChoice ? ");
|
||||
gets (tmp);
|
||||
}
|
||||
|
||||
return atoi (tmp);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user