Vous êtes sur la page 1sur 27

Programmation systeme en C sous UNIX

Manuel des Ionctions utiles




1. Processus ....................................................................................................................................................... 2
1.1. Creation de processus........................................................................................................................... 2
1.2. Terminaison de processus .................................................................................................................... 2
1.3. Numero de processus ........................................................................................................................... 2
1.4. Mise en attente de processus................................................................................................................ 2
1.5. Attente de processus ............................................................................................................................ 3
1.6. Surcharge de processus ........................................................................................................................ 3
2. Threads .......................................................................................................................................................... 5
2.1. Creation de thread................................................................................................................................ 5
2.2. Attributs de thread................................................................................................................................ 5
2.3. Terminaison de thread.......................................................................................................................... 7
2.4. Detachement de thread......................................................................................................................... 8
2.5. Attente de terminaison de thread.......................................................................................................... 8
2.6. Thread et Mutex................................................................................................................................... 9
2.7. Attributs de Mutex ............................................................................................................................. 10
3. Semaphores ................................................................................................................................................. 11
3.1. Creation d'un groupe de semaphores.................................................................................................. 11
3.2. Manipulation de semaphores ............................................................................................................. 12
3.3. Contrle de semaphores..................................................................................................................... 13
3.4. Creation de cles.................................................................................................................................. 15
4. Signaux........................................................................................................................................................ 15
4.1. Prise en compte de signaux................................................................................................................ 15
4.2. Gestion des signaux ........................................................................................................................... 16
4.3. Generation de signaux........................................................................................................................ 18
4.4. Generation retardee de signal............................................................................................................. 18
5. Pipes ............................................................................................................................................................ 19
5.1. Creation.............................................................................................................................................. 19
5.2. Fermeture........................................................................................................................................... 19
5.3. Lecture et ecriture .............................................................................................................................. 19
6. Messages ..................................................................................................................................................... 20
6.1. Creation.............................................................................................................................................. 20
6.2. Operations sur les messages............................................................................................................... 21
6.3. Contrle de messages......................................................................................................................... 23
7. Memoire ...................................................................................................................................................... 23
7.1. Memoire non partagee ....................................................................................................................... 23
7.2. Memoire partagee .............................................................................................................................. 24

Programmation systeme en C 2 M. Dalmau IUT de Bayonne
Preambule : La plupart des Ionctions decrites dans ce document retournent une valeur particuliere en cas
d'erreur. TouteIois il est possible d'avoir plus de details sur la cause de l'erreur en consultant la variable systeme
errno. Il Iaut pour cela inclure le Iichier error.h~ qui deIinit toutes les constantes citees pour chaque Ionction a
la rubrique 'Erreurs'.
1. Processus
1.1. Cration de processus
#include unistd.h~
pidt Iork(void);
1.1.1. Description
fork cree un processus Iils qui diIIere du processus parent uniquement par ses valeurs PID et PPID et par le Iait
que toutes les statistiques d'utilisation des ressources sont remises a zero. Les verrouillages de Iichiers. et les
signaux en attente ne sont pas herites.
1.1.2. VaIeur Renvoye
En cas de succes. le PID du Iils est renvoye au processus parent. et 0 est renvoye au processus Iils. En cas
d'echec -1 est renvoye dans le contexte du parent. aucun processus Iils n'est cree. et errno contient le code
d'erreur.
1.1.3. Erreurs
ENOMEM : Impossible d'allouer assez de memoire pour une structure de tche pour le Iils.
EAGAIN : Impossible de trouver un emplacement vide dans la table des processus.
1.2. Terminaison de processus
#include stdlib.h~
void exit (int status);
1.2.1. Description
exit termine normalement le programme en cours. La valeur status (0 a 255) est renvoyee au processus parent.
les constantes EXITFAILURE et EXITSUCCESS deIinies dans stdlib.h peuvent tre utilisees. Les Ilux
ouverts sont vides et Iermes.
1.3. Numro de processus
#include sys/types.h~
#include unistd.h~
pidt getpid(void);
pidt getppid(void);
1.3.1. Description
getpid retourne l'ID du processus actiI.
getppid retourne le PID du processus parent de celui en cours. Elle est souvent utilisee apres un fork pour
etablir la communication entre les deux processus issus du mme programme.
1.4. Mise en attente de processus
#includeunistd.h~
int pause(void);
unsigned int sleep (unsigned int nbsec);
Programmation systeme en C 3 M. Dalmau IUT de Bayonne
1.4.1. Description
Un appel a pause endort le processus appelant iusqu'a ce qu'il recoive un signal.
sleep endort le processus iusqu'a ce que nbsec secondes se soient ecoulees. ou iusqu'a ce qu'un signal non
ignore soit recu.
1.4.2. VaIeur Renvoye
pause renvoie touiours -1. et errno est positionne a la valeur EINTR.
sleep() renvoie zero si le temps prevu s'est ecoule. ou le nombre de secondes restantes si un signal a reveille le
processus.
1.5. Attente de processus
#include sys/types.h~
#include sys/wait.h~
pidt wait(int *status)
pidt waitpid(pidt pid. int *status. int options);
1.5.1. Description
wait suspend l'execution du processus courant iusqu'a ce qu'un enIant se termine. ou iusqu'a ce qu'un signal a
intercepter arrive. Si un processus Iils s'est deia termine au moment de l'appel (il est devenu "zombie"). la
Ionction revient immediatement. Toutes les ressources utilisees par le Iils sont liberees.
waitpid suspend l'execution du processus courant iusqu'a ce que le processus Iils de numero pid se termine. ou
iusqu'a ce qu'un signal a intercepter arrive. Si le Iils mentionne par pid s'est deia termine au moment de l'appel (il
est devenu "zombie"). la Ionction revient immediatement. Toutes les ressources utilisees par le Iils sont liberees.
La valeur de pid peut egalement tre l'une des suivantes :
-1 attendre la Iin de n'importe quel Iils. C'est le mme comportement que wait.
0 attendre la Iin de n'importe quel processus Iils du mme groupe que l'appelant.
~ 0 attendre la Iin du processus numero pid.
La valeur de l'argument option options est un OU binaire (operateur ' ) entre les constantes suivantes :
WNOHANG : ne pas bloquer si aucun Iils ne s'est termine.
WUNTRACED : recevoir l'inIormation concernant egalement les Iils bloques si on ne l'a pas encore recue.
Si status est non NULL. wait et waitpid y stockent l'inIormation sur la terminaison du Iils.
1.5.2. VaIeur Renvoye
En cas de reussite. le PID du Iils qui s'est termine est renvoye. en cas d'echec -1 est renvoye et errno contient le
code d'erreur.
1.5.3. Erreurs
ECHILD : Le processus indique par pid n'existe pas. ou n'est pas un Iils du processus appelant. (Ceci peut
arriver pour son propre Iils si le signal SIGCHLD est ignore).
EINVAL : L'argument options est invalide.
1.6. Surcharge de processus
#include unistd.h~
extern char **environ;
Programmation systeme en C 4 M. Dalmau IUT de Bayonne
int execl (const char *path. const char *arg. ...);
int execlp (const char *file. const char *arg. ...);
int execle (const char *path. const char *arg . .... char * const envp||);
int execv (const char *path. char *const argv||);
int execvp (const char *file. char *const argv||);
1.6.1. Description
La Iamille de Ionctions exec remplace l'image memoire du processus en cours par un nouveau processus.
L'argument initial de toutes ces Ionctions est le chemin d'acces du Iichier a executer.
Les arguments const char *arg ainsi que les points de suspension des Ionctions execl. execlp. et execle peuvent
tre vues comme des arg0. arg1. .... argn. Ils constituent une liste de pointeurs sur des chanes de caracteres
terminees par le caractere nul ('\0'). et constituent les arguments du programme a executer. Par convention le
premier argument doit pointer sur le nom du Iichier associe au programme a executer. La liste des arguments
doit se terminer par un pointeur NULL.
Les Ionctions execv et execvp utilisent un tableau de pointeurs plutt qu'une liste de pointeurs pour les
arguments du programme a executer.
La Ionction execle peut egalement indiquer l'environnement du processus a executer en Iaisant suivre le pointeur
NULL qui termine la liste d'arguments. ou le pointeur NULL de la table par un parametre supplementaire. Ce
parametre est un tableau de pointeurs sur des chanes de caracteres terminees par des caracteres nuls. qui doit se
terminer par un pointeur NULL. Les autres Ionctions Iournissent au nouveau processus l'environnement
constitue par la variable externe environ.
Les Ionctions execlp et execvp agiront comme le shell dans la recherche du Iichier executable si le nom Iourni
ne contient pas de slash (/). Le chemin de recherche est speciIie dans la variable d'environnement PATH. Si
cette variable n'est pas deIinie. le chemin par deIaut sera ``/bin:/usr/bin:''. De plus certaines erreurs sont traitees
de maniere speciIique.
Si la permission d'acces au Iichier est reIusee. ces Ionctions continueront a parcourir le reste du chemin de
recherche. Si aucun Iichier n'est trouve. elles reviendront. et errno contiendra le code d'erreur EACCES.
Si l'en-tte d'un Iichier n'est pas reconnu. ces Ionctions executeront un shell avec le chemin d'acces au Iichier en
tant que premier argument. Si ceci echoue. aucune recherche supplementaire n'est eIIectuee.
1.6.2. VaIeur Renvoye
Si l'une quelconque des Ionctions exec revient a l'appelant. c'est qu'une erreur a eu lieu. La valeur de retour est -
1. et errno contient le code d'erreur.
1.6.3. Erreurs
Toutes ces Ionctions peuvent echouer et positionner errno comme suit:
EACCES : Le fichier n'est pas un Iichier regulier ou l'autorisation d'execution est reIusee
EPERM : Le systeme de Iichiers est monte avec l'attribut noexec.
E2BIG : La liste d'arguments est trop grande.
ENOEXEC : Le Iichier executable n'est pas dans le bon Iormat. ou est destine a une autre architecture.
EFAULT : L'argument fichier pointe en dehors de l'espace d'adressage accessible.
ENAMETOOLONG : La chane de caracteres fichier est trop longue.
ENOENT : Le fichier n'existe pas.
ENOMEM : Pas assez de memoire pour le noyau.
ENOTDIR : Un element du chemin d'acces n'est pas un repertoire.
ELOOP : Le chemin d'acces au fichier contient une reIerence circulaire (a travers un lien symbolique)
ETXTBSY : Le fichier executable a ete ouvert en ecriture par un ou plusieurs processus.
EIO : Une erreur d'entree/sortie de bas niveau s'est produite.
ENFILE : Le nombre maximal de Iichiers ouverts sur le systeme est atteint
EMFILE : Le nombre maximal de Iichiers ouverts par processus est atteint.
Programmation systeme en C 5 M. Dalmau IUT de Bayonne
2. Threads
2.1. Cration de thread
#include pthread.h~
int pthreadcreate(pthreadt * thread. pthreadattrt * attr. void * (*startroutine)(void *). void * arg);
2.1.1. Description
pthreadcreate cree un nouveau thread s'executant concurremment avec le thread appelant. Le nouveau thread
execute la Ionction startroutine en lui passant arg comme premier argument. Le nouveau thread s'acheve soit
explicitement en appelant pthreadexit() . ou implicitement lorsque la Ionction startroutine s'acheve. Ce
dernier cas est equivalent a appeler pthreadexit() avec la valeur renvoyee par startroutine comme code de
sortie.
L'argument attr indique les attributs du nouveau thread. Voir pthreadattrinit() pour une liste complete des
attributs. L'argument attr peut tre NULL. auquel cas. les attributs par deIaut sont utilises: le thread cree est
ioignable (non detache) et utilise la politique d'ordonnancement usuelle.
2.1.2. VaIeur Renvoye
En cas de succes. l'identiIiant du nouveau thread est stocke a l'emplacement memoire pointe par l'argument
thread. et 0 est renvoye. En cas d'erreur. un code d'erreur non nul est renvoye.
2.1.3. Erreurs
EAGAIN : pas assez de ressources systeme pour creer un processus pour le nouveau thread.
2.2. Attributs de thread
#include pthread.h~
int pthreadattrinit(pthreadattrt *attr);
int pthreadattrdestroy(pthreadattrt *attr);
int pthreadattrsetdetachstate(pthreadattrt *attr. int detachstate);
int pthreadattrgetdetachstate(const pthreadattrt *attr. int *detachstate);
int pthreadattrsetschedpolicy(pthreadattrt *attr. int policv);
int pthreadattrgetschedpolicy(const pthreadattrt *attr. int *policv);
int pthreadattrsetschedparam(pthreadattrt *attr. const struct schedparam *param);
int pthreadattrgetschedparam(const pthreadattrt *attr. struct schedparam *param);
int pthreadattrsetinheritsched(pthreadattrt *attr. int inherit);
int pthreadattrgetinheritsched(const pthreadattrt *attr. int *inherit);
int pthreadattrsetscope(pthreadattrt *attr. int scope);
int pthreadattrgetscope(const pthreadattrt *attr. int *scope);
2.2.1. Description
ModiIier les attributs des threads revient a remplir la structure des attributs de threads attr qui est du type
pthreadattrt. puis a la passer en tant que second argument a pthreadcreate() . Un parametre egal a NULL
revient a choisir les parametres par deIaut pour tous les attributs.
pthreadattrinit initialise la structure d'attributs de thread attr et la remplit avec les valeurs par deIaut pour
tous les attributs (ces valeurs par deIaut sont deIinies plus bas).
Chaque attribut attrname (voir plus bas pour une liste de tous les attributs) peut tre individuellement modiIie en
utilisant la Ionction pthreadattrsetattrname et recupere a l'aide de la Ionction pthreadattrgetattrname.
pthreadattrdestroy detruit un obiet attributdethread. qui ne doit plus iamais tre reutilise iusqu'a ce qu'il
soit reinitialise.
Programmation systeme en C 6 M. Dalmau IUT de Bayonne
Les structures d'attributs ne sont consultees que lors de la creation d'un nouveau thread. La mme structure
d'attributs peut tre reutilisee pour creer plusieurs threads. ModiIier une structure d'attributs apres un appel a
pthreadcreate ne modiIie pas les attributs du thread precedemment cree.
Les attributs de thread suivants sont supportes:
detachstate
Contrle si le thread cree est dans l'etat ioignable (valeur PTHREADCREATE1OINABLE) ou dans l'etat
detache (PTHREADCREATEDETACHED).
Valeur par deIaut: PTHREADCREATE1OINABLE.
Dans l'etat ioignable. un autre thread peut se synchroniser avec la Iin du thread et reprendre son execution a la
Iin du thread en utilisant pthreadjoin() . mais certaines ressources du thread resteront allouees apres sa Iin et ne
seront liberees que lorsqu'un autre thread appellera pthreadjoin() sur ce thread.
Dans l'etat detache. les ressources du thread sont immediatement liberees quand il se termine. mais
pthreadjoin() ne peut tre utilise pour se synchroniser sur la Iin du thread.
Un thread cree dans l'etat ioignable peut ensuite tre mis dans l'etat detache en utilisant pthreaddetach() .
schedpolicy
Change la politique et les parametres d'ordonnancement pour le thread pour l'une parmi SCHEDOTHER
(processus normal. non temps reel). SCHEDRR (temps reel. round-robin) ou SCHEDFIFO (temps reel.
premier dans la liste. premier execute).
Valeur par deIaut: SCHEDOTHER.
Les politiques d'ordonnancement temps reel SCHEDRR et SCHEDFIFO ne sont disponibles que pour les
processus possedant les privileges du super-utilisateur.
La politique d'ordonnancement d'un thread peut tre modiIiee apres sa creation avec pthreadsetschedparam() .
schedparam
Contient la politique d'ordonnancement (essentiellement. la priorite d'ordonnancement) pour le thread.
Valeur par deIaut: priorite a 0.
Cet attribut est sans signiIication si la politique d'ordonnancement est SCHEDOTHER; il n'a d'importance que
pour les polices temps reel SCHEDRR et SCHEDFIFO.
La priorite d'ordonnancement d'un thread peut tre modiIiee apres sa creation avec pthreadsetschedparam() .
inheritsched
Indique si la politique et les parametres d'ordonnancement pour le nouveau thread sont determines par les valeurs
des attributs schedpolicv et schedparam (valeur PTHREADEXPLICITSCHED) ou sont heritees du thread
parent (valeur PTHREADINHERITSCHED).
Valeur par deIaut: PTHREADEXPLICITSCHED.
Programmation systeme en C 7 M. Dalmau IUT de Bayonne
scope
DeIinit comment sont interpretes les parametres d'ordonnancement pour le nouveau thread.
PTHREADSCOPESYSTEM. signiIie que tous les threads sont en competition avec tous les processus en
cours d'execution pour le temps processeur. En particulier. les priorites de threads sont interpretees relativement
aux priorites de tous les autres processus sur la machine.
PTHREADSCOPEPROCESS. signiIie que les threads ne sont en competition qu'avec les autres threads du
mme processus: les priorites de threads sont interpretees relativement a celles des autres threads du processus.
quelle que soit la priorite des autres processus.
Valeur par deIaut: PTHREADSCOPESYSTEM.
2.2.2. VaIeur Renvoye
Toutes ces Ionctions renvoient 0 en cas de succes et un code d'erreur non nul en cas d'erreur. En cas de succes.
les Ionctions pthreadattrgetattrname sauvegardent egalement la valeur courante de l'attribut attrname a
l'emplacement pointe par leur second argument.
2.2.3. Erreurs
La Ionction pthreadattrsetdetachstate renvoie. en cas de probleme. le code d'erreur EINVAL si l'argument
detachstate speciIie n'est ni PTHREADCREATE1OINABLE ni PTHREADCREATEDETACHED.
La Ionction pthreadattrsetschedparam renvoie en cas de probleme. le code d'erreur EINVAL si la priorite
indiquee par param n'est pas dans l'intervalle autorise pour la politique d'ordonnancement courante dans attr (1 a
99 pour SCHEDFIFO et SCHEDRR; 0 pour SCHEDOTHER).
La Ionction pthreadattrsetschedpolicy renvoie l'un des codes d'erreur suivants en cas de probleme:
EINVAL : l'argument policv speciIie n'est ni SCHEDOTHER. ni SCHEDFIFO. ni SCHEDRR.
ENOTSUP : policv est SCHEDFIFO ou SCHEDRR. et l'utilisateur eIIectiI du processus appelant n'est pas
le super utilisateur.
La Ionction pthreadattrsetinheritsched renvoie en cas de probleme. le code d'erreur EINVAL si l'argument
inherit speciIie n'est ni PTHREADINHERITSCHED ni PTHREADEXPLICITSCHED.
La Ionction pthreadattrsetscope renvoie l'un des codes d'erreur suivants en cas de probleme:
EINVAL : l'argument scope speciIie n'est ni PTHREADSCOPESYSTEM ni
PTHREADSCOPEPROCESS.
ENOTSUP : l'argument scope speciIie est PTHREADSCOPEPROCESS qui n'est pas supporte pas cette
version d'UNIX.
2.3. Terminaison de thread
#include <pthread.h>
void pthreadexit(void `retval);
2.3.1. Description
pthreadexit termine l'execution d'un thread.
L'argument retval est la valeur de retour du thread. Il peut tre consulte par un autre thread en utilisant
pthreadjoin() .
Programmation systeme en C 8 M. Dalmau IUT de Bayonne
2.4. Dtachement de thread
#include pthread.h~
int pthreaddetach(pthreadt th);
2.4.1. Description
pthreaddetach place le thread th dans l'etat detache. Cela garantit que les ressources memoire consommees par
th seront immediatement liberees lorsque l'execution de th s'achevera. Cependant. cela empche les autres
threads de se synchroniser sur la mort de th en utilisant pthreadjoin.
Un thread peut tre cree initialement dans l'etat detache. en utilisant l'attribut detachstate dans l'appel de
pthreadcreate() . Par opposition. pthreaddetach ne s'applique qu'aux threads crees dans l'etat ioignable. et
necessitant d'tre mis dans l'etat detache plus tard.
Des que pthreaddetach rend la main. tout appel ulterieur a pthreadjoin sur th echouera. Si un autre thread a
deia ioint le thread th lorsque pthreaddetach est appelee. pthreaddetach ne Iait rien. et laisse th dans l'etat
ioignable.
2.4.2. VaIeur Renvoye
En cas de succes. 0 est renvoye. En cas d'erreur. un code d'erreur non nul est renvoye.
2.4.3. Erreurs
ESRCH : aucun thread ne correspond a celui indique par th
EINVAL : le thread th est deia dans l'etat detache.
2.5. Attente de terminaison de thread
#include pthread.h~
int pthreadioin(pthreadt th. void **threadreturn);
2.5.1. Description
pthreadjoin suspend l'execution du thread appelant iusqu'a ce que le thread identiIie par th acheve son
execution. soit en appelant pthreadexit() soit apres avoir ete annule.
Si threadreturn ne vaut pas NULL. la valeur renvoyee par th y sera enregistree. Cette valeur sera soit
l'argument passe a pthreadexit() . soit PTHREADCANCELED si le thread th a ete annule.
Le thread ioint th doit tre dans l'etat ioignable: il ne doit pas avoir ete detache par pthreaddetach() ou par
l'attribut PTHREADCREATEDETACHED lors de sa creation par pthreadcreate() .
Quand l'execution d'un thread ioignable s'acheve. ses ressources memoire (descripteur de thread et pile) ne sont
pas desallouees iusqu'a ce qu'un autre thread le ioigne en utilisant pthreadjoin. Aussi. pthreadjoin doit tre
appelee une Iois pour chaque thread ioignable pour eviter des "Iuites" de memoire.
Au plus un seul thread peut attendre la mort d'un thread donne. Appeler pthreadjoin sur un thread th dont un
autre thread attend deia la Iin renvoie une erreur.
2.5.2. VaIeur Renvoye
En cas de succes. le code renvoye par th est enregistre a l'emplacement pointe par threadreturn. et 0 est
renvoye. En cas d'erreur. un code d'erreur non nul est renvoye.
2.5.3. Erreurs
ESRCH : Aucun thread correspondant a th n'a pu tre trouve.
Programmation systeme en C 9 M. Dalmau IUT de Bayonne
EINVAL : Le thread th a ete detache.
EINVAL : Un autre thread attend deia la mort de th.
EDEADLK : L'argument th represente le thread appelant.
2.6. Thread et Mutex
#include <pthread.h>
pthreadmutext fastmutex PTHREADMUTEXINITIALIZER;
pthreadmutext recmutex PTHREADRECURSIVEMUTEXINITIALIZERNP;
pthreadmutext errchkmutex PTHREADERREURCHECKMUTEXINITIALIZERNP;

int pthreadmutexinit(pthreadmutext *mutex. const pthreadmutexattrt *mutexattr);
int pthreadmutexlock(pthreadmutext *mutex));
int pthreadmutextrylock(pthreadmutext *mutex);
int pthreadmutexunlock(pthreadmutext *mutex);
int pthreadmutexdestroy(pthreadmutext *mutex);
2.6.1. Description
Un mutex est un obiet d'exclusion mutuelle (MUTual EXclusion device). et est tres pratique pour proteger des
donnees partagees de modiIications concurrentes et pour implementer des sections critiques.
Un mutex peut tre dans deux etats : deverrouille ou verrouille. Un thread qui tente de verrouiller un mutex deia
verrouille est suspendu iusqu'a ce que le mutex soit deverrouille.
pthreadmutexinit initialise le mutex pointe par mutex selon les attributs de mutex speciIie par mutexattr. Si
mutexattr vaut NULL. les parametres par deIaut sont utilises.
Les variables de type pthreadmutext peuvent aussi tre initialisees de maniere statique. en utilisant les
constantes PTHREADMUTEXINITIALIZER (pour les mutex rapides).
PTHREADRECURSIVEMUTEXINITIALIZERNP (pour les mutex recursiIs). et
PTHREADERREURCHECKMUTEXINITIALIZERNP (pour les mutex a veriIication d'erreur).
Comme le suIIixe NP l'indique. les deux derniers sont des extensions non-portables aux standard POSIX et ne
devraient donc iamais tre employes dans un programme portable.
pthreadmutexlock verrouille le mutex. Si le mutex est deverrouille. il devient verrouille et est possede par le
thread appelant; et pthreadmutexlock rend la main immediatement. Si le mutex est deia verrouille par un
autre thread. pthreadmutexlock suspend le thread appellant iusqu'a ce que le mutex soit deverrouille.
Si le mutex est deia verrouille par le thread appelant. le comportement de pthreadmutexlock depend du type
de mutex. Si ce dernier est de type "rapide''. le thread appelant est suspendu iusqu'a ce que le mutex soit
deverrouille. Si le mutex est de type "a veriIication d'erreur''. pthreadmutexlock rend la main immediatement
avec le code d'erreur EDEADLK. Si le mutex est de type "recursiI''. pthreadmutexlock rend la main
immediatement avec un code de retour indiquant le succes. enregistrant le nombre de Iois ou le thread appelant a
verrouille le mutex. Un nombre egal d'appels a pthreadmutexunlock doit tre realise avant que le mutex ne
retourne a l'etat deverrouille.
pthreadmutextrylock se comporte de la mme maniere que pthreadmutexlock. excepte qu'elle ne bloque
pas le thread appelant si le mutex est deia verrouille par un autre thread (ou par le thread appelant dans le cas
d'un mutex "rapide''). Au contraire. pthreadmutextrylock rend la main immediatement avec le code d'erreur
EBUSY.
pthreadmutexunlock deverrouille le mutex. Si le mutex est de type "rapide''. pthreadmutexunlock le
reinitialise touiours a l'etat deverrouille. S'il est de type "recursiI''. son compteur de verrouillage est decremente
(nombre d'operations pthreadmutexlock realisees sur le mutex par le thread appelant). et deverrouille
seulement quand ce compteur atteint 0.
Programmation systeme en C 10 M. Dalmau IUT de Bayonne
Sur les mutex "veriIicationd d'erreur''. pthreadmutexunlock veriIie lors de l'execution que le mutex est
verrouille en entrant. et qu'il est verrouille par le mme thread que celui appelant pthreadmutexunlock. Si ces
conditions ne sont pas reunies. un code d'erreur est renvoye et le mutex n'est pas modiIie. Les mutex "rapides'' et
"recursiIs'' ne realisent pas de tels tests. permettant a un mutex verrouille d'tre deverrouille par un thread autre
que celui l'ayant verrouille. Ce comportement n'est pas portable et l'on ne doit pas compter dessus.
pthreadmutexdestroy detruit un mutex. liberant les ressources qu'il detient. Le mutex doit tre deverrouille.
2.6.2. VaIeur Renvoye
pthreadmutexinit retourne touiours 0. Les autres Ionctions renvoient 0 en cas de succes et un code d'erreur
non nul en cas de probleme.
2.6.3. Erreurs
La Ionction pthreadmutexlock renvoie l'un des codes d'erreur suivants en cas de probleme:
EINVAL : le mutex n'a pas ete initialise.
EDEADLK : le mutex est deia verrouille par un thread autre que l'appelant (mutex a veriIication d'erreur
seulement).
La Ionction pthreadmutextrylock renvoie l'un des codes d'erreur suivants en cas de probleme:
EBUSY : le mutex ne peut tre verrouille car il l'est deia.
EINVAL : le mutex n'a pas ete initialise.
La Ionction pthreadmutexunlock renvoie le code d'erreur suivant en cas de probleme:
EINVAL : le mutex n'a pas ete initialise.
EPERM : le thread appelant ne possede pas le mutex (mutex a veriIication d'erreur seulement).
La Ionction pthreadmutexdestroy renvoie. en cas de probleme. le code d'erreur EBUSY si le mutex est deia
verrouille.
2.7. Attributs de Mutex
#include pthread.h~
int pthreadmutexattrinit(pthreadmutexattrt *attr);
int pthreadmutexattrdestroy(pthreadmutexattrt *attr);
int pthreadmutexattrsettypenp(pthreadmutexattrt *attr. int tvpe);
int pthreadmutexattrgettypenp(const pthreadmutexattrt *attr. int *tvpe);
2.7.1. Description
Les attributs de creation de mutex peuvent tre speciIies lors de leur creation en les passant en tant que second
argument a pthreadmutexinit() . NULL est equivalent a demander les attributs par deIaut.

pthreadmutexattrinit initialise l'obiet attributsdemutex attr et le remplit avec les valeurs par deIaut.
pthreadmutexattrdestroy detruit un obiet attributsdemutex qui ne doit plus iamais tre utilise.
Le type de mutex peut tre soit PTHREADMUTEXFASTNP pour des mutex rapides. soit
PTHREADMUTEXRECURSIVENP pour des mutex recursiIs. soit
PTHREADMUTEXERREURCHECKNP pour des mutex avec veriIication d'erreur. Comme le suIIixe NP
l'indique. ce sont des extensions non-portables aux standard POSIX et ne devraient donc iamais tre employes
dans un programme portable.
Programmation systeme en C 11 M. Dalmau IUT de Bayonne
Le type de mutex determine ce qui se passe si un thread essaye de verrouiller un mutex deia verrouille par
pthreadmutexlock() . Si le mutex est de type rapide; pthreadmutexlock() suspend simplement le thread
appelant. Si le mutex est de type "avec veriIication d'erreur". pthreadmutexlock() rend la main
immediatement avec le code d'erreur EDEADLK. Si le mutex est de type recursiI. l'appel a
pthreadmutexlock() rend la main immediatement avec un code de retour de succes. Le nombre de
verrouillage par le thread possedant le mutex est enregistre dans le mutex. Le thread possedant le mutex doit
appeler pthreadmutexunlock() le mme nombre de Iois aIin que le mutex passe a l'etat deverrouille.
Le type de mutex par deIaut est rapide. c'est-a-dire PTHREADMUTEXFASTNP.
pthreadmutexattrsettypenp modiIie l'attribut typedemutex dans attr a la valeur speciIiee par tvpe.
pthreadmutexattrgettypenp recupere la valeur courante de l'attribut typedemutex dans attr et l'enregistre
a l'emplacement pointe par tvpe.
2.7.2. VaIeur Renvoye
pthreadmutexattrinit. pthreadmutexattrdestroy et pthreadmutexattrgettypenp retournent touiours
0.
pthreadmutexattrsettypenp retournent 0 en cas de succes et un code d'erreur non nul en cas d'erreur.
2.7.3. Erreurs
En cas d'erreur. pthreadmutexattrsettypenp renvoie le code d'erreur EINVAL si type n'est ni
PTHREADMUTEXFASTNP ni PTHREADMUTEXRECURSIVENP ni
PTHREADMUTEXERREURCHECKNP
3. Smaphores
3.1. Cration d'un groupe de smaphores
# include sys/types.h~
# include sys/ipc.h~
# include sys/sem.h~
int semget ( keyt kev. int nsems. int semflg )
3.1.1. Description
Cette Ionction retourne l'identiIicateur de l'ensemble de semaphores associe a la valeur de cle kev. Un nouvel
ensemble contenant nsems semaphores est cree si kev a la valeur IPCPRIVATE ou si aucun ensemble n'est
associe a kev. et si l'option IPCCREAT est presente dans semflg.
Pendant la creation. les 9 bits de poids Iaibles de l'argument semflg deIinissent les permissions d'acces (pour le
proprietaire. le groupe et les autres) au ieu de semaphores. en utilisant le mme Iormat et la mme signiIication
que les droits d'acces des Iichiers (rwxrwxrwx). Les permissions d'execution ne sont pas utilisees par le systeme
pour un ieu de semaphores. l'autorisation d'ecriture signiIie autorisation de modiIication. C'est pourquoi on peut
se contenter d'utiliser les constantes SEMA (permission de modiIication) et SEMR (permission de lecture).
L'argument nsems doit tre inIerieur ou egal au nombre maximal de semaphores par ensemble. (SEMMSL).
Si le ieu de semaphores existe deia. les permissions d'acces sont contrlees. et l'on veriIie si l'ensemble est sur le
point d'tre detruit.
3.1.2. VaIeur Renvoye
Si l'appel reussit. il renvoie l'identiIicateur de l'ensemble (un entier positiI). sinon il renvoie -1 et errno contient
le code d'erreur.
Programmation systeme en C 12 M. Dalmau IUT de Bayonne
3.1.3. Erreurs
EACCES : Le ieu de semaphore associe a kev existe. mais le processus n'a aucun droit d'acces sur lui
EEXIST : Le ieu de semaphore associe a kev existe mais l'argument semflg precise a la Iois IPCCREAT et
IPCEXCL.
EIDRM : le ieu de semaphores est prt a tre detruit
ENOENT : Aucun ieu de semaphore associe a kev n'existe et l'argument semflg ne precise pas IPCCREAT.
ENOMEM : Pas assez de memoire pour creer les structures necessaires.
ENOSPC : Le nombre maximal de ieux de semaphores sur le systeme (SEMMNI) est atteint. ou le nombre
maximal de semaphores sur le systeme est atteint (SEMMNS).
3.2. Manipulation de smaphores
# include sys/types.h~
# include sys/ipc.h~
# include sys/sem.h~
int semop ( int semid. struct sembuf `sops. unsigned nsops )
3.2.1. Description
Cette Ionction eIIectue des operations sur les membres selectionnes de l'ensemble de semaphores identiIie par
semid. Chacun des nsops elements dans le tableau pointe par sops indique une operation a eIIectuer sur un
semaphore en utilisant une structure deIinie comme suit:
struct sembuf ]
short semnum; /* Numero du semaphore (0premier) */
short semop; /* Operation sur le semaphore */
short semIlg; /* Options pour l'operation */
}
Les options possibles pour semflg sont IPCNOWAIT et SEMUNDO. Si une operation indique l'option
SEMUNDO. elle sera annulee lorsque le processus se terminera.
La semantique de cet appel systeme assure qu'un appel systeme ne sera eIIectue que si toutes ses operations
reussissent. Chaque operation est eIIectuee sur le semnum-ieme semaphore de l'ensemble. Le premier
semaphore est le numero 0. Pour chaque semaphore l'operation est l'une des trois decrites ci-dessous.
1) Si l'argument semop est un entier positiI. la Ionction aioute cette valeur a semval. De plus si SEMUNDO
est demande. le systeme met a iour le compteur "undo" du semaphore. Cette operation n'est iamais bloquante. Le
processus appelant doit avoir l'autorisation de modiIication sur le ieu de semaphores.
2) Si semop vaut zero le processus attend que semval soit nul. Plusieurs cas sont possibles :
Si semval vaut zero. l'appel systeme continue immediatement
Sinon. si l'on a reclame IPCNOWAIT dans semflg. l'appel systeme echoue (en annulant les actions
precedentes) et errno contient le code d'erreur EAGAIN.
Autrement semzcnt est incremente de 1 et le processus s'endort iusqu'a ce que l'un des evenements suivants
se produise :
- semval devient egal a 0. semzcnt est alors decremente et l'appel systeme continue
- Le ieu de semaphores est supprime. L'appel systeme echoue et errno contient le code d'erreur
EIDRM.
- Le processus recoit un signal a intercepter. la valeur de semzcnt est decrementee et l'appel systeme
echoue avec errno contenant le code d'erreur EINTR.
Le processus appelant doit avoir l'autorisation de lecture sur le ieu de semaphores.

3) Si semop est inIerieur a zero. le processus appelant doit avoir l'autorisation de modiIication sur le ieu de
semaphores. Si semval est superieur ou egal a la valeur absolue de semop. la valeur absolue de semop est
soustraite de semval. Si SEMUNDO est indique. le systeme met a iour le compteur "undo" du semaphore. Puis
l'appel systeme continue. Autrement si l'on a reclame IPCNOWAIT dans semflg. l'appel systeme echoue
(annulant les actions precedentes et errno contient le code d'erreur EAGAIN. Sinon semncnt est decremente de
un et le processus s'endort iusqu'a ce que l'un des evenements suivants se produise :
Programmation systeme en C 13 M. Dalmau IUT de Bayonne
- semval devient superieur ou egal a la valeur absolue de semop. alors la valeur semncnt est
decrementee. la valeur absolue de semop est soustraite de semval et si SEMUNDO est demande
le systeme met a iour le compteur "undo" du semaphore. Puis l'appel systeme continue.
- Le ieu de semaphores est supprime. L'appel systeme echoue et errno contient le code d'erreur
EIDRM.
- Le processus recoit un signal a intercepter. la valeur de semncnt est decrementee et l'appel systeme
echoue avec errno contenant le code d'erreur EINTR.
En cas de succes. le membre sempid de la structure sem de chacun des semaphores indiques dans le tableau
pointe par sops est rempli avec le PID du processus appelant. EnIin semotime et semctime sont Iixes a l'heure
actuelle.
3.2.2. VaIeur Renvoye
semop renvoie la valeur 0. s'il reussit et -1 s'il echoue auquel cas errno contient le code d'erreur.
3.2.3. Erreurs
E2BIG : l'argument nsops est superieur a SEMOPM. le nombre maximal d'operations par appel systeme.
EACCES : Le processus appelant n'a pas les permissions d'acces necessaires.
EAGAIN : Une operation a echoue et IPCNOWAIT a ete indique dans l'argument semflg.
EFAULT : sops pointe en dehors de l'espace d'adressage accessible.
EFBIG : La valeur de semnum est inIerieure a 0 ou superieure ou egale au nombre de semaphores dans
l'ensemble.
EIDRM : Le ieu de semaphores a ete supprime.
EINTR : Un signal a ete recu pendant l'attente.
EINVAL : L'ensemble de semaphores n'existe pas ou semid est inIerieur a zero. ou nsops n'a pas une valeur
positive.
ENOMEM : Pas assez de memoire pour allouer les structures necessaires.
ERANGE : semop + semval est superieur a SEMVMX.
3.3. Contrle de smaphores
# include sys/types.h~
# include sys/ipc.h~
# include sys/sem.h~
int semctl ( int semid. int semno. int cmd. union semun arg )
3.3.1. Description
semctl eIIectue l'operation de contrle indiquee par cmd sur l'ensemble de semaphores (ou sur le semno-ieme
semaphore de l'ensemble) identiIie par semid. Le premier semaphore de l'ensemble est identiIie par la valeur 0
dans l'argument semno.

Le type de l'argument arg est une union :
union semun
int val; /* utilise par SETVAL seulement */
struct semidds *buI; /* utilise par IPCSTAT et IPCSET */
ushort *array; /* utilise par GETALL et SETALL */
};

Les valeurs autorisees pour l'operation cmd sont :
IPCSTAT
Copier dans la structure pointee par arg.buf la structure de donnees concernant l'ensemble de
semaphores. L'argument semno est alors ignore. Le processus appelant doit avoir des privileges de
lecture sur le ieu de semaphores
IPCSET
Fixer la valeur de certains champs de la structure semidds pointee par arg.buf dans la structure de
contrle de l'ensemble de semaphores. en mettant a iour son membre semctime. Les champs de la
structure struct semidds Iournie dans arg.buf et copies dans la structure de l'ensemble sont :
Programmation systeme en C 14 M. Dalmau IUT de Bayonne
semperm.uid
semperm.gid
semperm.mode /* 9 bits poids Iaibles*/
L'UID eIIectiI du processus appelant doit tre soit celui du Super-User soit celui du createur ou du
proprietaire du ieu de semaphores. L'argument semno est ignore.
IPCRMID
Supprimer immediatement l'ensemble de semaphores en reveillant tous les processus en attente. Ils
obtiendront un code d'erreur. et errno aura la valeur EIDRM. L'UID eIIectiI du processus appelant doit
tre soit celui du Super-User soit celui du createur ou du proprietaire du ieu de semaphores. L'argument
semno est ignore.
GETALL
Renvoyer la valeur semval de chaque semaphore de l'ensemble dans le tableau arg.arrav. L'argument
semno est ignore. Le processus appelant doit avoir des privileges de lecture sur le ieu de semaphores.
GETNCNT
Renvoyer la valeur de semncnt pour le semno-ieme semaphore de l'ensemble (i.e. le nombre de
processus en attente d'une incrementation du champ semval du semno-ieme semaphore). Le processus
appelant doit avoir des privileges de lecture sur le ieu de semaphores.
GETPID
Renvoyer la valeur de sempid pour le semno-ieme semaphore de l'ensemble (i.e. le PID du processus
ayant execute le dernier appel systeme semop sur le semno-ieme semaphore). Le processus appelant
doit avoir des privileges de lecture sur le ieu de semaphores.
GETVAL
Renvoyer la valeur du champ semval du semno-ieme semaphore de l'ensemble Le processus appelant
doit avoir des privileges de lecture sur le ieu de semaphores.
GETZCNT
Renvoyer la valeur du champ semzcnt du semno-ieme semaphore de l'ensemble. (i.e. le nombre de
processus attendant que le champ semval du semno-ieme semaphore revienne a 0). Le processus
appelant doit avoir des privileges de lecture sur le ieu de semaphores.
SETALL
Positionner le champ semval de tous les semaphores de l'ensemble en utilisant le tableau arg.arrav . et
en mettant a iour le champ semctime de la structure semidds de contrle du ieu de semaphores. Les
processus en attente sont reveilles si semval devient 0 ou augmente. L'argument semno est ignore. Le
processus appelant doit avoir des privileges d'ecriture sur le ieu de semaphores.
SETVAL
Placer la valeur arg.val dans le champ semval du semno-ieme semaphore de l'ensemble en mettant a
iour le champ semctime dans la structure semidds associee au ieu de semaphores. Le processus
appelant doit avoir des privileges d'ecriture sur le ieu de semaphores Les processus en attente sont
reveilles si semval devient 0 ou augmente.
3.3.2. VaIeur Renvoye
En cas d'echec l'appel systeme renvoie -1 et errno contient le code d'erreur. Autrement. l'appel systeme renvoie
une valeur non negative dependant de l'argument cmd :
GETNCNT : la valeur de semncnt.
GETPID : La valeur sempid.
GETVAL : La valeur semval.
GETZCNT : La valeur semzcnt.
3.3.3. Erreurs
EACCES : Le processus appelant n'a pas les privileges necessaires pour executer la commande cmd.
EFAULT : arg.buf arg.arrav pointent en dehors de l'espace d'adressage accessible.
EIDRM : L'ensemble de semaphores a ete supprime.
EINVAL : cmd ou semid a une valeur illegale.
EPERM : L'argument cmd reclame les commandes IPCSET ou IPCRMID mais l'UID eIIectiI du processus
appelant n'a pas les privileges adequats.
ERANGE : l'argument cmd reclame les commandes SETALL ou SETVAL et la valeur de semval (pour
l'ensemble ou pour certains semaphores) est inIerieure a 0 ou superieur a la valeur SEMVMX.
Programmation systeme en C 15 M. Dalmau IUT de Bayonne
3.4. Cration de cls
# include sys/types.h~
# include sys/ipc.h~
keyt ftok (char `pathname. char proi )
3.4.1. Description
ftok convertit le nom et le chemin d'acces d'un Iichier existant. ainsi qu'un identiIicateur de proiet proi en une cle
IPC Systeme V de type keyt.
3.4.2. VaIeur Renvoye
Si elle reussit. la Ionction ftok renvoie une valeur de type keyt. sinon elle renvoie -1. et errno contient un code
d'erreur :
ENOENT : Un composant de pathname n'existe pas. ou il s'agit d'une chane vide.
ENOTDIR : Un composant du chemin d'acces n'est pas un repertoire.
ELOOP : Trop de liens symboliques rencontres dans le chemin d'acces.
EACCES : Autorisation reIusee.
ENOMEM : Pas assez de memoire pour le noyau.
ENAMETOOLONG : Nom de Iichier trop long
4. Signaux
4.1. Prise en compte de signaux
#include <signal.h>
void (`signal(int signum. void (`handler)(int)))(int);
4.1.1. Description
signal() installe un nouveau gestionnaire (2
eme
parametre) pour le signal numero signum. Le gestionnaire de
signal est handler qui peut tre soit une Ionction speciIique de l'utilisateur. soit l'une des constantes SIGIGN ou
SIGDFL.
Lors de l'arrivee d'un signal correspondant au numero signum. les evenements suivants se produisent : Si le
gestionnaire correspondant est conIigure avec SIGIGN. le signal est ignore. Si le gestionnaire vaut SIGDFL.
l'action par deIaut pour le signal est entreprise. Si le gestionnaire est dirige vers une Ionction handler(). alors
handler() est appele avec l'argument signum.
Utiliser d'une Ionction comme gestionnaire de signal est appele "intercepter ou capturer le signal". Les signaux
SIGKILL et SIGSTOP ne peuvent tre ni ignores ni interceptes.
4.1.2. VaIeur Renvoye
signal renvoie la valeur precedente du gestionnaire de signaux. ou SIGERR en cas d'erreur.
4.1.3. Les signaux de Ia norme POSIX
Le tableau ci-dessous decrit les principaux signaux deIinis par la norme POSIX ainsi que les actions qui leur sont
normalement associees (les signaux sont deIinis dans signal.h):
Signal Action Commentaire
SIGHUP T connexion avec le terminal Iermee. ou utilisateur deconnecte
SIGINT T Interruption au clavier (Ctrl C)
SIGQUIT D Quitter au clavier (Ctrl \)
SIGILL D Instruction inconnue
SIGABRT D Signal emis par la Ionction abort
SIGFPE D Erreur lors de calcul en reels
SIGKILL T * Tuer un processus (kill)
Programmation systeme en C 16 M. Dalmau IUT de Bayonne
SIGBUS D Erreur d'adressage sur le bus
SIGSEGV D Violation de protection memoire
SIGPIPE T Tube (pipe) casse: ecriture dans un tube sans lecteurs
SIGALRM T Signal de delai (timer) Ionction alarm
SIGTERM T Terminaison normale de processus
SIGUSR1 T Signal d'utilisateur 1
SIGUSR2 T Signal d'utilisateur 2
SIGCHLD I Processus Iils stoppe ou termine
SIGSTOP S * Stopper le processus
SIGTSTP S Stopper le processus au clavier (Ctrl Z)
SIGTTIN S Entree au clavier pour un processus en arriere plan
SIGTTOU S Sortie au clavier pour un processus en arriere plan
T : Terminer le processus
I : Ignorer le signal
D : Terminer le processus et Iaire une image de memoire (core dump)
S : Stopper le processus
* : Le signal ne peut ni tre ignore ni tre capture
4.2. Gestion des signaux
#include signal.h~
int sigaction(int signum. const struct sigaction *act. struct sigaction *oldact);
int sigprocmask(int how. const sigsett *set. sigsett *oldset);
int sigpending(sigsett *set);
int sigsuspend(const sigsett *mask);
4.2.1. Description
L'appel systeme sigaction sert a modiIier l'action eIIectuee par un processus a la reception d'un signal speciIique.
signum indique le signal concerne. a l'exception de SIGKILL et SIGSTOP.
Si act est non nul. la nouvelle action pour le signal signum est deIinie par act. Si oldact est non nul. l'ancienne
action est sauvegardee dans oldact.
La structure sigaction est deIinie par:
struct sigaction
void (* sahandler) (int);
void (* sasigaction) (int. siginIot *. void *);
sigsett samask;
int saIlags;
}
Remarque : Sur certaines architectures on emploie une union. il ne Iaut donc pas utiliser ou remplir
simultanement sahandler et sasigaction.
sahandler indique l'action aIIectee au signal signum. et peut tre SIGDFL pour l'action par deIaut. SIGIGN
pour ignorer le signal. ou un pointeur sur une Ionction de gestion de signaux.
samask Iournit un masque de signaux a bloquer pendant l'execution du gestionnaire. De plus le signal ayant
appele le gestionnaire est bloque a moins que les attributs SANODEFER ou SANOMASK soient precises.
saflags speciIie un ensemble d'attributs qui modiIient le comportement du gestionnaire de signaux. Il est Iorme
par un OU binaire ( ' ) entre les options suivantes :
Programmation systeme en C 17 M. Dalmau IUT de Bayonne
SANOCLDSTOP
Si signum vaut SIGCHLD. ne pas recevoir les signaux de notiIication d'arrt d'un processus Iils (quand
le Iils recoit un signal SIGSTOP. SIGTSTP. SIGTTIN ou SIGTTOU).
SAONESHOT ou SARESETHAND
Retablir l'action a son comportement par deIaut une Iois que le gestionnaire a ete appele (C'est le
comportement par deIaut avec la Ionction signal)
SARESTART
Fournir un comportement compatible avec la semantique BSD en redemarrant automatiquement les
appels systemes lents interrompus par l'arrivee du signal.
SANOMASK ou SANODEFER
Ne pas empcher un signal d'tre recu depuis l'interieur de son propre gestionnaire.
SASIGINFO
Le gestionnaire de signal recevra trois arguments. en non plus un seul. Dans ce cas. il Iaut utiliser le
membre sasigaction et non pas sahandler. (Le champ sasigaction est apparu dans les versions
ulterieures d'UNIX)
Le parametre siginfot de la routine sasigaction est une structure contenant les elements suivants :
siginIot
int sisigno; /* Numero de signal */
int sierrno; /* Numero d'erreur */
int sicode; /* Code du signal */
pidt sipid; /* PID de l'emetteur */
uidt siuid; /* UID reel de l'emetteur */
int sistatus; /* Valeur de sortie */
clockt siutime; /* Temps utilisateur ecoule */
clockt sistime; /* Temps systeme ecoule */
sigvalt sivalue; /* Valeur de signal */
int siint; /* Signal Posix.1b */
void * siptr; /* Signal Posix.1b */
void * siaddr; /* Emplacement d'erreur */
int siband; /* Band event */
int siId; /* Descripteur de Iichier */
}

Les champs sisigno. sierrno and sicode sont deIinis pour tous les signaux. Le reste de la structure peut tre
une union. et il ne Iaut donc tenir compte que des champs qui sont signiIicatiIs pour le signal recu. L'appel-
systeme kill. les signaux Posix.1b et SIGCHLD remplissent les champs sipid et siuid. SIGCHLD remplit aussi
sistatus. siutime et sistime. siint et siptr sont Iournis par l'emetteur d'un signal Posix.1b. SIGILL. SIGFPE.
SIGSEGV et SIGBUS remplissent siaddr avec l'adresse de l'erreur. SIGPOLL remplit siband et sifd.
sicode indique la raison pour laquelle le signal a ete emis. Il s'agit d'une valeur. pas d'un masque de bits.
L'appel sigprocmask est utilise pour changer la liste des signaux actuellement bloques. Son comportement est
dependant de la valeur de how. avec les conventions suivantes :
SIGBLOCK
L'ensemble des signaux bloques est l'union de l'ensemble actuel et de l'argument set.
SIGUNBLOCK
Les signaux dans l'ensemble set sont supprimes de la liste des signaux bloques. Il est possible de
debloquer un signal non bloque.
SIGSETMASK
L'ensemble des signaux bloques est egal a l'argument set.
Si oldset est non nul. la valeur precedente du masque de signaux est stockee dans oldset.
L'appel sigpending permet l'examen des signaux en attente (qui se sont declenches en etant bloques). Le masque
de signaux en attente est stocke dans set.
L'appel sigsuspend remplace temporairement le masque de signaux bloques par celui Iourni dans mask puis
endort le processus iusqu'a arrivee d'un signal.
Programmation systeme en C 18 M. Dalmau IUT de Bayonne
4.2.2. VaIeur Renvoye
sigaction. sigprocmask. sigpending et sigsuspend renvoient 0 s'ils reussissent. ou -1 s'ils echouent. auquel cas
errno contient le code d'erreur.
4.2.3. Erreurs
EINVAL : Un signal invalide est indique. Cette erreur se produit egalement si l'on tente de modiIier l'action
associee a SIGKILL ou SIGSTOP.
EFAULT : act. oldact. set ou oldset pointent en-dehors de l'espace d'adressage accessible.
EINTR : L'appel systeme a ete interrompu.
4.3. Gnration de signaux
#include signal.h~
int kill(pidt pid. int sig);
4.3.1. Description
kill peut tre utilise pour envoyer n'importe quel signal a n'importe quel processus ou groupe de processus.
Si pid est positiI. le signal sig est envoye au processus pid.
Si pid vaut zero. alors le signal sig est envoye a tous les processus appartenant au mme groupe que le processus
appelant.
Si pid vaut -1. alors le signal sig est envoye a tous les processus sauI le premier (init) dans l'ordre decroissant des
numeros dans la table des processus (par ex: shutdown envoie le signal SIGTERM a tous les processus).
Si pid est inIerieur a -1. alors le signal sig est envoye a tous les processus du groupe -pid.
4.3.2. VaIeur Renvoye
En cas de reussite 0 est renvoye. en cas d'echec -1 est renvoye et errno contient le code d'erreur.
4.3.3. Erreurs
EINVAL : Numero de signal invalide.
ESRCH : Le processus ou le groupe de processus n'existe pas. Un processus existant peut tre un zombie. c'est a
dire qu'il s'est deia termine mais que son pere n'a pas encore lu sa valeur de retour avec wait().
EPERM : Le processus appelant n'a pas l'autorisation d'envoyer un signal a l'un des processus concernes. Pour
qu'un processus ait le droit d'envoyer un signal a un autre processus pid il doit avoir des privileges de Super-
Utilisateur. ou avoir un UID reel ou eIIectiI egal a l'ID reel ou sauvegarde du processus recepteur.
4.4. Gnration retarde de signal
#include unistd.h~
unsigned int alarm(unsigned int nbsec);
4.4.1. Description
alarm programme une temporisation pour qu'elle envoie un signal SIGALRM au processus en cours dans
nbsec secondes. Si le signal n'est pas masque ou intercepte. sa reception terminera le processus.

Les programmations successives d'alarmes ne sont pas empilees. chaque appel de alarm annule l'eventuelle
programmation precedente.

Si nbsec vaut zero. aucune alarme n'est planiIiee. Ceci permet d'annuler une programmation anterieure.
Programmation systeme en C 19 M. Dalmau IUT de Bayonne
4.4.2. VaIeur renvoye
alarm renvoie le nombre de secondes qu'il restait de la programmation precedente (annulee). ou zero si
aucune alarme n'avait ete planiIiee auparavant.
5. Tubes
5.1. Cration
#include unistd.h~
int pipe(int filedes|2|);
5.1.1. Description
pipe cree une paire de descripteurs de Iichiers. pointant sur un i-noeud de tube. et les place dans un tableau
filedes. filedes|0| est utilise pour la lecture. et filedes|1| pour l'ecriture.
En general deux processus (crees par fork) vont se partager le tube. et utiliser les Ionctions read et write
pour se transmettre des donnees.
5.1.2. VaIeur renvoye
pipe renvoie 0 s'il reussit. ou -1 s'il echoue. auquel cas errno contient le code d'erreur.

5.1.3. Erreurs
EMFILE : Trop de descripteurs de Iichiers sont utilises par le processus.
ENFILE : La table systeme pour les tubes est pleine.
EFAULT : filedes est invalide.
5.2. Fermeture
#include unistd.h~
int close(int fd);
5.2.1. Description
close Ierme le descripteur fd. de maniere a ce qu'il ne reIerence plus aucun Iichier. et puisse tre reutilise.
Pour un tube on a deux descripteurs de Iichiers que l'on peut Iermer independamment l'un de l'autre. En general
l'un des processus Ierme le descripteur utilise en lecture tandis que l'autre Ierme celui utilise en ecriture.

Si fd est la derniere copie d'un descripteur de Iichier donne. les ressources qui lui sont associees sont
liberees.
5.2.2. VaIeur renvoye
close renvoie 0 s'il reussit. ou -1 en cas d'echec. auquel cas errno contient le code d'erreur.
5.2.3. Erreurs
EBADF : Le descripteur de Iichier fd est invalide
5.3. Lecture et criture
Elles Iont appel aux Ionctions read et write utilisees pour les Iichiers :
#include sys/types.h~
#include unistd.h~
Programmation systeme en C 20 M. Dalmau IUT de Bayonne

ssizet read(int fd. void *buI. sizet count);
ssizet write(int fd. const void *buI. sizet count);


5.3.1. Description
read lit iusqu'a count octets depuis le tube associe au descripteur fd dans le buIIer pointe par buf. Si count vaut
zero. read renvoie zero et n'a pas d'autres eIIet.
write ecrit iusqu'a count octets dans le tube associe au descripteur fd depuis le buIIer pointe par buf.
5.3.2. VaIeur renvoye
read renvoie -1 s'il echoue. auquel cas errno contient le code d'erreur.

Sinon. read renvoie le nombre d'octets lus. et avance la tte de lecture de ce nombre. Le Iait que le nombre
renvoye soit plus petit que le nombre demande n'est pas une erreur.
write renvoie le nombre d'octets ecrits (0 signiIiant aucune ecriture). ou -1 s'il echoue. auquel cas errno
contient le code d'erreur.
5.3.3. Erreurs
EINTR : read (resp write)a ete interrompu par un signal avant d'avoir eu le temps de lire (resp. ecrire) quoi que
ce soit.
EAGAIN : On utilise une lecture (resp. ecriture) non bloquante (attribut ONONBLOCK du descripteur de
Iichier) et aucune donnee n'etait disponible (resp. il n'y a plus de place dans le tube).
EBADF : fd n'est pas un descripteur valide. ou n'est pas ouvert en lecture (resp. ecriture).
EFAULT : buf pointe en dehors de l'espace d'adressage accessible.
EINVAL fd correspond a un obiet ne permettant pas l'ecriture.
EPIPE fd est connecte a un tube (pipe) dont l'autre extremite est Iermee. Quand ceci se produit. le processus
ecrivain recoit un signal SIGPIPE. S'il intercepte. bloque ou ignore ce signal. EPIPE est renvoye.
6. Messages
6.1. Cration
# include sys/types.h~
# include sys/ipc.h~
# include sys/msg.h~
int msgget ( keyt kev. int msgflg )
6.1.1. Description
msgget renvoie l'identiIicateur de la Iile de messages associee a la cle kev. Une nouvelle Iile de messages est
creee si kev a la valeur IPCPRIVATE ou si aucune Iile de message n'est associee a kev. et si la valeur
IPCCREAT a ete introduite dans msgflg (c'est a dire msgflg&IPCCREAT non nul). La Ionction msgget
echouera si msgflg indique a la Iois IPCCREAT et IPCEXCL et si une Iile de messages existe deia
associee a kev.

Lors de la creation. les 9 bits de poids Iaibles de l'argument msgflg deIinissent les permissions d'acces a la
Iile de message (pour le proprietaire. le groupe. et les autres) avec le mme Iormat et la mme signiIication
que les permissions d'acces dans les appels open() ou creat() (bien que la permission d'execution ne soit
pas utilisee). On peut le plus souvent se limiter a utiliser les constantes MSGR (lecture autorisee) et MSGW
(ecriture autorisee).

Pendant la creation. l'appel systeme initialise la structure systeme msqidds de la Iile de messages comme suit :
- msgperm.cuid et msgperm.uid sont remplis avec l'UID eIIectiI du processus appelant.
- msgperm.cgid et msgperm.gid sont remplis avec le GID eIIectiI du processus appelant.
- Les 9 bits de poids Iaibles de msgflg. sont copies dans les 9 bits de poids Iaibles de msgperm.mode
- msgqnum. msglspid. msglrpid. msgstime et msgrtime sont Iixes a 0.
Programmation systeme en C 21 M. Dalmau IUT de Bayonne
- msgctime est rempli avec l'heure actuelle.
- msgqbvtes est rempli avec la limite systeme MSGMNB.
6.1.2. VaIeur renvoye
msgget renvoie l'identiIicateur de la Iile de messages (un entier positiI). s'il reussit. En cas d'echec -1 est
renvoye et errno contient le code d'erreur.

6.1.3. Erreurs
EACCES : Une Iile de messages existe associee a la cle kev. mais le processus appelant n'a pas de permissions
sur cette Iile.
EEXIST : Une Iile de messages existe associee a la cle key et msgflg reclame a la Iois IPCCREAT et
IPCEXCL.
EIDRM : la Iile de messages est prte a tre supprimee.

ENOENT : Aucune Iile de messages n'existe associee a la cle kev et msgflg ne contient pas IPCCREAT.
ENOMEM : Pas assez de memoire pour les nouvelles structures de donnees.
ENOSPC : Le nombre maximum de Iiles de messages sur le systeme (MSGMNI) est atteint.
6.2. Oprations sur les messages
# include sys/types.h~
# include sys/ipc.h~
# include sys/msg.h~
int msgsnd (int msqid. struct msgbuI * msgp. sizet msgsz. int msgflg)
ssize msgrcv (int msqid. struct msgbuI * msgp. sizet msgsz. long msgtvp. int msgflg)

6.2.1. Description
Pour envoyer ou recevoir un message. le processus appelant alloue une structure comme celle-ci :

struct msgbuf
long mtype; /* type de message ( ~ 0 ) */
char mtext|msgsz|; /* contenu du message */
};

avec une table mtext de taille msgsz. valeur entiere non negative.

Le membre mtype doit avoir une valeur strictement positive qui puisse tre utilisee par le processus lecteur pour
la selection de messages (voir plus bas).

Le processus doit avoir une permission d'ecriture sur la Iile pour envoyer un message. et une permission de
lecture pour en recevoir un.

msgsnd insere une copie du message pointe par l'argument msgp dans la Iile dont l'identiIicateur est indique par
la valeur de l'argument msqid.

L'argument msgflg precise le comportement de l'appel systeme si l'insertion du nouveau message necessite
plus de msgqbvtes dans la Iile. En indiquant IPCNOWAIT le message ne sera pas envoye et l'appel
systeme echouera en retournant EAGAIN dans errno.

Sinon. le processus sera suspendu iusqu'a ce que la condition de blocage soit levee (auquel cas le message sera
envoye et l'appel systeme reussira). ou que la Iile soit supprimee (auquel cas l'appel systeme echouera et
errno contiendra EIDRM). ou que le processus recoive un signal a intercepter (auquel cas l'appel systeme
echouera et errno contiendra EINTR).

Si l'appel reussit. la structure de Iile de messages sera modiIiee comme suit :
Programmation systeme en C 22 M. Dalmau IUT de Bayonne
msgqnum est incremente de 1.
msgstime est rempli avec l'heure actuelle.

l'appel systeme msgrcv lit un message depuis la Iile indiquee par msqid dans la structure msgbuf pointee
par l'argument msgp. en extrayant le message en cas de reussite.

L'argument msgsz indique la taille maximale en octets du membre mtext de la structure pointee par l'argument
msgp. Si le contenu du message est plus long que msgsz octets. et si l'argument msgflg contient
MSGNOERROR. alors le message sera tronque (et la partie tronquee sera perdue). Sinon le message ne sera
pas extrait de la Iile. et l'appel systeme echouera en indiquant E2BIG dans errno.

L'argument msgtvp indique le type de message desire :
- Si msgtvp vaut 0. le premier message est lu.
- Si msgtvp est superieur a 0. alors le premier message de type msgtvp est extrait de la Iile. Si msgflg
contient MSGEXCEPT l'inverse est eIIectue. le premier message de type diIIerent de msgtvp est
extrait de la Iile.
- Si msgtvp est inIerieur a 0. le premier message de la Iile avec un type inIerieur ou egal a la valeur
absolue de msgtvp est extrait.

L'argument msgflg est compose d'un OU binaire ( ' ) avec les options suivantes :
IPCNOWAIT Si aucun message du type desire n'est present. l'appel systeme echoue et errno est Iixe a
ENOMSG.
MSGEXCEPT Utilise avec msgtvp superieur a 0 pour lire les messages de type diIIerent de msgtvp.
MSGNOERROR Tronque silencieusement les messages trop longs

Si aucun message du type requis n'est disponible et si on n'a pas demande IPCNOWAIT dans msgflg. Le
processus appelant est bloque iusqu'a l'occurrence d'un des evenements suivants.
- Un message du type desire arrive dans la Iile.
- Le processus appelant recoit un signal a intercepter. L'appel systeme echoue et errno contient
EINTR.

Si l'appel systeme reussit. la structure decrivant la Iile de messages est mise a iour comme suit :
- msglrpid est rempli avec le PID du processus appelant.
- msgqnum est decremente de 1
- msgrtime est rempli avec l'heure actuelle.

6.2.2. VaIeur renvoye
En cas d'echec les deux appels systemes renvoient -1 et errno contient le code d'erreur. Sinon msgsnd
renvoie 0 et msgrvc renvoie le nombre d'octets copies dans la table mtext.

6.2.3. Erreurs
msgsnd :

EAGAIN : Le message n'a pas pu tre envoye a cause de la limite msgqbvtes pour la Iile et de la requte
IPCNOWAIT dans mgsflg.
EACCES : le processus appelant n'a pas de permissions de lecture dans la Iile.
EFAULT : msgp pointe en dehors de l'espace d'adressage accessible.
EIDRM : La Iile de message a ete supprimee
EINTR : Un signal est arrive avant d'avoir pu ecrire quoi que ce soit.
EINVAL : msqid ou mtvpe ou msgsz sont invalides.
ENOMEM : pas assez de memoire pour le noyau.

msgrcv :

E2BIG : message trop long. et MSGNOERROR n'a pas ete requis.
EACCES : Le processus appelant n'a pas de permission de lecture dans la Iile.
EFAULT : msgp pointe en dehors de l'espace d'adressage
Programmation systeme en C 23 M. Dalmau IUT de Bayonne
EINTR : Un signal est arrive avant d'avoir pu lire quoi que ce soit.
EINVAL : msgqid ou msgsz invalides.
ENOMSG : IPCNOWAIT a ete requis et aucun message du type reclame n'existe dans la Iile.
6.3. Contrle de messages
# include sys/types.h~
# include sys/ipc.h~
# include sys/msg.h~
int msgctl ( int msqid. int cmd. struct msqidds *buf )

6.3.1. Description
msgctl permet d'eIIectuer l'operation indiquee par cmd sur la Iile de messages ayant l'identiIicateur msqid. Les
valeurs possibles de cmd sont :

IPCSTAT Copier les inIormations depuis la structure representant la Iile de messages dans la structure
pointee par buf. L'appelant doit avoir des privileges d'acces en lecture sur la Iile de messages.

IPCSET Ecrire la valeur de certains champs de la structure msqidds pointee par buf dans la structure
representant la Iile de messages. en mettant a iour le champ msgctime. Les champs a copier depuis la
structure struct msqidds pointee par buf sont :
msgperm.uid
msgperm.gid
msgperm.mode /* 9 bits poids Iaibles */
msgqbvtes
L'UID eIIectiI du processus appelant doit tre soit celui du Super-User soit celui du createur ou du
proprietaire de la Iile de messages. Seul le Super-User peut augmenter la valeur de msgqbvtes au-dessus
de la constante systeme MSGMNB.

IPCRMID EIIacer immediatement la Iile de messages et ses structures de donnees. en reveillant tous les
processus ecrivains et lecteurs en attente. Ils obtiendront un code d'erreur. et errno aura la valeur
EIDRM. L'UID eIIectiI du processus appelant doit tre soit celui du Super-User soit celui du createur
ou du proprietaire de la Iile de messages.
6.3.2. VaIeur renvoye
msgctl renvoie 0 s'il reussit. ou -1 s'il echoue. auquel cas errno contient le code d'erreur.
6.3.3. Erreurs
EACCES : L'argument cmd reclame l'operation IPCSTAT mais le processus appelant n'a pas d'acces en
lecture sur la Iile de messages msqid.
EFAULT : L'argument cmd reclame l'operation IPCSET ou IPCSTAT mais buf pointe en dehors de l'espace
d'adressage accessible.
EIDRM : La Iile de messages a deia ete supprimee.
EINVAL cmd ou msqid ont une valeur illegale.
EPERM L'argument cmd reclame l'operation IPCSET ou IPCRMID mais l'UID eIIectiI du processus
appelant n'a pas assez de privileges pour realiser la commande. C'est aussi le cas d'un processus non
Super-User tentant d'augmenter msgqbvtes au-dessus de la valeur MSGMNB.

7. Mmoire
7.1. Mmoire non partage
#include stdlib.h~
void *calloc (sizet nmemb. sizet size);
Programmation systeme en C 24 M. Dalmau IUT de Bayonne
void *malloc (sizet size);
void *realloc (void *ptr. sizet size);
void free (void *ptr);

7.1.1. Description
calloc alloue la memoire necessaire pour un tableau nmemb elements. chacun d'eux representant size octets. et
renvoie un pointeur vers la memoire allouee. Cette zone est remplie avec des zeros.
malloc alloue size octets. et renvoie un pointeur sur la memoire allouee. Le contenu de la zone de memoire n'est
pas initialise.
realloc modiIie la taille du bloc de memoire pointe par ptr pour l'amener a une taille de size octets. realloc
conserve le contenu de la zone memoire minimum entre la nouvelle et l'ancienne taille. Le contenu de la zone de
memoire nouvellement allouee n'est pas initialise. Si ptr est NULL. l'appel de realloc est equivalent a
malloc(size). Si size vaut zero. l'appel est equivalent a free(ptr). Si ptr n'est pas NULL. il doit avoir ete obtenu
par un appel anterieur a malloc. calloc ou realloc.
free libere l'espace memoire pointe par ptr. qui a ete obtenu lors d'un appel anterieur a malloc. calloc ou realloc.
Si le pointeur ptr n'a pas ete obtenu par l'un de ces appels. ou si il a deia ete libere avec free. le comportement est
indetermine. Si ptr est NULL. aucune tentative de liberation n'a lieu.
7.1.2. VaIeur Renvoye
Pour calloc et malloc. la valeur renvoyee est un pointeur sur la memoire allouee. qui est correctement alignee
pour n'importe quel type de variable. ou NULL si la demande echoue.
realloc renvoie un pointeur sur la memoire nouvellement allouee. qui est correctement alignee pour n'importe
quel type de variable. et qui peut tre diIIerent de ptr. ou NULL si la demande echoue. ou si size vaut zero. Si
realloc echoue. le bloc memoire original reste intact. il n'est ni libere ni deplace.
free ne renvoie pas de valeur.
7.2. Mmoire partage
Allouer un segment de mmoire partage
#include sys/ipc.h~
#include sys/shm.h~
int shmget(keyt cle. int size. int shmflg);

7.2.1. Description
shmget renvoie l'identiIicateur du segment de memoire partagee associe a la valeur de l'argument cle. Un
nouveau segment memoire. de taille size arrondie au multiple superieur de PAGESIZE. est cree si cle a la
valeur IPCPRIVATE ou si aucun segment de memoire partagee n'est associe a cle. et IPCCREAT est
present dans shmflg.
shmflg est compose de :
- IPCCREAT : pour creer un nouveau segment. Sinon shmget recherchera le segment associe a
cle. veriIiera que l'appelant a la permission de recevoir l'identiIiant shmid associe au segment. et
contrlera que le segment n'est pas detruit.
- IPCEXCL : est utilise avec IPCCREAT pour garantir l'echec si le segment existe deia.
- mode d'acces (les 9 bits de poids Iaibles) : indiquant les permissions pour le proprietaire. le groupe
et les autres. Actuellement la permission d'execution n'est pas utilisee par le systeme. On peut
utiliser les constantes SHMR (permission en lecture) et SHMW (permission en ecriture).

Programmation systeme en C 25 M. Dalmau IUT de Bayonne
Si un nouveau segment est cree. les permissions d'acces de shmflg sont copiees dans le membre shmperm de la
structure shmidds decrivant le segment. Cette structure est deIinie ainsi :
struct shmidds
struct ipcperm shmperm; /* Permissions d'acces */
int shmsegsz; /* Taille segment en octets */
timet shmatime; /* Heure dernier attachement */
timet shmdtime; /* Heure dernier detachement */
timet shmctime; /* Heure dernier changement */
unsigned short shmcpid; /* PID du createur */
unsigned short shmlpid; /* PID du dernier operateur */
short shmnattch; /* Nombre d'attachements */
/* ------------- Les champs suivants sont prives -------------- */
unsigned short shmnpages; /* Taille segment en pages */
unsigned long *shmpages; /* Taille d'une page (?) */

struct ipcperm

keyt key;
ushort uid; /* UID et GID eIIectiIs du proprietaire */
ushort gid;
ushort cuid; /* UID et GID eIIectiI du createur */
ushort cgid;
ushort mode; /* Mode d'acces sur 9 bits de poids Iaible */
ushort seq; /* Numero de sequence */
};

De plus. durant la creation. le systeme initialise la structure shmidds associee au segment comme suit :
- shmperm.cuid et shmperm.uid contiennent l'UID eIIectiI de l'appelant.
- shmperm.cgid et shmperm.gid contiennent le GID eIIectiI de l'appelant.
- Les 9 bits de poids Iaibles de shmperm.mode contiennent les 9 bits de poids Iaibles de shmflg.
- shmsegsz prend la valeur size.
- shmlpid. shmnattch. shmatime et shmdtime sont mis a 0.
- shmctime contient l'heure actuelle

Apres un fork le Iils herite des segments de memoire partagee.
Apres un exec tous les segments de memoire partagee sont detaches (pas detruits).
Lors d'un exit tous les segments de memoire partagee sont detaches (pas detruits).

7.2.2. VaIeur renvoye
Un identiIicateur de segment shmid valide est renvoye en cas de reussite. sinon -1 est renvoye et errno contient
le code d'erreur.
7.2.3. Erreurs
EINVAL : SHMMIN ~ size ou size ~ SHMMAX. ou size plus grand que la taille du segment.
EIDRM : Le segment est detruit.
ENOSPC : Tous les ID de memoire partagee sont utilises. ou l'allocation d'un segment partage de taille size
depasserait les limites de memoire partagee du systeme.
ENOENT : Aucun segment n'est associe a cle. et IPCCREAT n'etait pas indique.
EACCES : L'appelant n'a pas les autorisations d'acces au segment.
ENOMEM : Pas assez de memoire.
Oprations sur la mmoire partage
# include sys/types.h~
# include sys/ipc.h~
# include sys/shm.h~
char *shmat ( int shmid. char *shmaddr. int shmflg )
Programmation systeme en C 26 M. Dalmau IUT de Bayonne
int shmdt ( char *shmaddr)

7.2.4. Description
shmat attache le segment de memoire partagee identiIie par shmid au segment de donnees du processus
appelant. L'adresse d'attachement est indiquee par shmaddr avec les criteres suivants :
- Si shmaddr vaut NULL. le systeme essaye de trouver une zone libre.
- Si shmaddr n'est pas nulle et si SHMRND est indique dans shmflg. l'attachement a lieu a
l'adresse shmaddr arrondie au multiple inIerieur de SHMLBA. Si SHMRND n'est pas indique
shmaddr doit tre alignee sur une Irontiere de page. et l'attachement a lieu a cette adresse.

Si SHMRDONLY est indique dans shmflg. le segment est attache en lecture seulement. et le processus
doit disposer de la permission de lecture dessus (une tentative d'ecriture levera le signal SIGSEGV). Sinon le
segment est attache en lecture et ecriture et le processus doit disposer des deux permissions d'acces. Il n'y a
pas de notion d'ecriture seule pour les segments de memoire partagee.

Le segment est automatiquement detache quand le processus se termine. Le mme segment peut tre attache a la
Iois en lecture seule et en lecture/ecriture. Il peut egalement tre attache en plusieurs endroits de l'espace
d'adressage du processus.

Si shmat reussit. le membre shmatime de la structure shmidds associee au segment de memoire partagee
correspond a l'heure actuelle.

La Ionction shmdt detache le segment de memoire partagee situe a l'adresse indiquee par shmaddr. Le
segment doit tre eIIectivement attache. et l'adresse shmaddr doit tre celle renvoyee precedemment par shmat.

Quand shmdt reussit. les membres de la structure shmidds associee au segment de memoire partagee sont
mis a iour ainsi :
shmdtime correspond a l'heure actuelle.
shmlpid contient le PID de l'appelant.
shmnattch est decremente de 1. S'il devient nul. et si le segment est marque pour destruction. il est
eIIectivement detruit.

La region occupee de l'espace d'adressage du processus est liberee.
7.2.5. VaIeur renvoye
Les deux Ionctions renvoient -1 si elles echouent. auquel cas errno contient le code d'erreur. Sinon shmat
renvoie l'adresse d'attachement du segment de memoire partagee. et shmdt renvoie 0.

7.2.6. Erreurs
shmat:
EACCES : L'appelant n'a pas les permissions d'acces necessaires pour l'attachement.
EINVAL : shmid est invalide. shmaddr est mal alignee ou l'attachement a echoue sur brk.
ENOMEM : Pas assez de memoire pour le systeme.
EINVAL : Pas de segment attache a l'adresse shmaddr.
Contrle de la mmoire partage
#include sys/ipc.h~
#include sys/shm.h~
int shmctl(int shmid. int cmd. struct shmidds *buf);

Programmation systeme en C 27 M. Dalmau IUT de Bayonne
7.2.7. Description
shmctl permet a l'utilisateur d'obtenir des inIormations concernant un segment de memoire partagee. ainsi que
de Iixer le proprietaire le groupe et les permissions d'acces a ce segment. Cette Ionction permet egalement de
detruire un segment.

Les inIormations concernant le segment identiIie par shmid sont renvoyees dans une structure shmidds (voir
7.2.1).

Les commandes cmd suivantes sont disponibles :
- IPCSTAT : permet de recuperer dans le buIIer buf les inIormations concernant le segment de
memoire partagee. L'apellant doit avoir la permission d'utilisateur correspondant aux champs uid. gid.
ou mode de la structure shmperms. Seuls les 9 bits de poids Iaibles sont utilises dans mode. Le
membre shmctime est aussi mis a iour. L'appelant doit tre le createur du segment. son
proprietaire. ou le Super-User.
- IPCRMID : permet de considerer un segment comme prt pour la destruction. Il sera detruit
eIIectivement apres le dernier detachement (quand le membre shmnattch de la structure shmidds
associee vaudra zero.) L'appelant doit tre le createur du segment. son proprietaire. ou le Super-
User.

Attention. mme apres le dernier detachement. le contenu du segment n'est pas eIIace par le systeme. Un
processus realisant a nouveau un attachement recuperera son contenu. Il est a la charge du processus l'utilisateur
d'ecraser le contenu du segment s'il ne veut pas qu'il persiste.
7.2.8. VaIeur renvoye
shmctl renvoie 0 s'il reussit et -1 s'il echoue. auquel cas errno contient le code d'erreur.
EACCES : on demande IPCSTAT mais shmperm.modes ne permet pas la lecture du segment shmid.
EFAULT : cmd a la valeur IPCSET ou IPCSTAT mais buf pointe en-dehors de l'espace d'adressage
accessible.
EINVAL : shmid n'est pas un identiIicateur de segment valide. ou cmd n'est pas une commande reconnue.
EIDRM : shmid pointe sur un segment detruit.
EPERM : On reclame IPCSET ou IPCRMID mais l'appelant n'est ni le proprietaire du segment. ni son
createur. ni le Super-User.