Communications inter-processus
1. Signaux 2. S´emaphores 3. M´emoire partag´ee
Signaux
Signal = outil de base de la notification d’´ev`enement.
Fonctionnent sur un sch´ema essentiellement asynchrone.
PSA Noyau
process ou shell ex: kill clavier
C−c
De fa¸con simplifi´e, quand le signal arrive, le noyau interrompt le processus qui d´eclanche alors son gestionnaire de signaux (handler) pour r´eagir de fa¸con appropri´ee.
Cependant une primitive (sigpause) permet `a un processus de se mettre en attente d’un signal.
Signaux
Les signaux utilis´es initialement plutˆot pour la gestion d’erreurs ont vu leur rˆole s’´etendre dans les versions plus r´ecentes d’Unix. Ils ont n´eanmoins de s´erieuses limitations :
I Ils coˆutent cher : ils sont lanc´es par un appel syst`eme, le r´ecepteur est interrompu, sa pile `a l’ex´ecution est modifi´ee, le handler prend la main, la pile `a l’ex´ecution est restaur´ee.
I En nombre limit´e : de l’ordre de 20 `a 60, dont seulement deux signaux pour la programmation utilisateur (les autres signaux sont utilis´es par le syst`eme lui mˆeme).
I Ils sont strictement limit´es au rˆole de notification d’´ev`enement : ne peuvent pas apporter d’information compl´ementaire (au moins pour les signaux utilisateurs), ni mˆeme l’identit´e de l’´emetteur.
Les signaux sous Unix
Les signaux pr´ed´efinis sont identifi´es par un nom et un num´ero. Le nom est commun `a toutes les versions d’UNIX, le num´ero peut varier d’un syst`eme `a l’autre.
Chaque signal est associ´e `a un comportement par d´efaut (ce que doit faire le processus cible `a r´eception de ce signal) :
abortg´en´eration d’un fichier core et arrˆet du processus
exitterminaison du processus sans g´en´eration d’un fichier core ignorele signal est ignor´e
stopsuspension du processus
continuereprendre l’ex´ecution si le processus est suspendu (sinon le signal est ignor´e)
Principaux signaux
num nom comportement par d´efaut modifiable ?
1 SIGUP envoy´e lors de la d´econnexion non 2 SIGINT utilisation de la touche INTR (DEL) oui 3 SIGQUIT utilisation de la touche QUIT (CTR\) oui
4 SIGILL op´eration ill´egale non
5 SIGTRAP apr`es chaque instruction en mode trace non 8 SIGFPE erreur op´eration en virgule flottante non 9 SIGKILL destruction inconditionnelle du processus non 11 SIGSEGV violation de segment m´emoire non 12 SIGSYS erreur de param`etre dans un appel syst`eme non 13 SIGPIPE erreur dans un pipe (´ecriture sans lecteur) non
14 SIGALARM signal d horloge non
15 SIGTERM indicateur de fin normale d’un processus non 16 SIGUSR1 rien : `a disposition de l’utilisateur oui 17 SIGUSR2 rien : `a disposition de l’utilisateur oui Pour les programmes utilisateurs, on dispose des signaux SIGUSR1 et SIGUSR2.
Les signaux en shell
Pour la manipulation des signaux, on dispose des op´erations suivantes :
Envoi de signaux par
kill -s signal pidDestinataire
Pour modifier le comportement par d´efaut d’un signal on utilise la primitive :
trap ’instructions’ signaux
Les instructions de la liste sont s´epar´ees par des points virgules. Si la liste des instructions est vide, le signal est ignor´e. S’il n’y a pas de liste, on revient au comportement par d´efaut.
Exemple
P1
#!/bin/sh
trap ’echo fini;exit 1’ SIGUSR1 P2 $PID&
while : do
echo "ca boucle"
done P2
#!/bin/sh
kill -s SIGUSR1 $1
Remarque
La commandetrap -ldonne le liste des signaux auxquels peux r´epondre trap.
Pour bloquer un processus p`ere jusqu’`a la fin de l’un de ses fils :
wait pidDuFils
Sans param`etre, le wait fait attendre la fin de tous les fils.
Les signaux en C
Signaux non fiables et signaux fiables :Dans les versions
”anciennes” d’Unix le m´ecanisme des signaux ´etait non fiable `a cause de leur proc´edure de prise en compte :
arriv´ee du signal, r´einitialisation du m´ecanisme de capture des signaux puis appel du traitement.
Donc si un second signal arrive entre la r´einitialisation et l’appel, le premier signal est perdu. On parle de conflit d’ex´ecution.
La fonction signal(3) du C est consid´er´ee comme non fiable.
Un autre jeu de fonctions bas´e sur la fonction sigaction(2) a ´et´e propos´e pour rem´edier `a ce probl`eme.
L’interface des signaux non fiables (signal)
Le traitement en C des signaux non fiables repose sur deux fonctionssignaletkill (prototype danssignal.h).
Mise en place (et r´einitialisation) du gestionnaire :
signal(signal, *fonction a utiliser)
Envoi du signal :
kill(signal,pidDest)
Pointeurs pr´ed´efinis sur des fonctions de traitement de signaux : SIG IGNpour ignorer le signal etSIG DFLpour revenir au comportement par d´efaut.
L’interface des signaux fiables (sigaction)
Les signaux fiables reposent sur des jeux de signaux (d´efinis en C par le typesigset t). Un jeu de signaux est manipul´e par des fonctions (prototypes danssignal.h) qui permettent :
I d’initialiser le jeu de signaux (sigemptyset),
I de remplir le jeu avec autant de signaux que possible (sigefullset),
I d’ajouter un signal `a un jeu (sigaddset),
I de supprimer un signal d un jeu (sigdelset),
I v´erifier si un signal fait partie d un jeu (sigismember).
Action associ´ee `a un signal :
int sigaction(int signum, const struct sigaction
*act, struct sigaction *oldact)
Les tubes
Les tubes permettent de faire transiter des informations entre deux processus.
Sous Unix les tubes sont orient´es.
Assimil´es `a des fichiers s´equentiels de caract`eres :
I lecture n octets : bloquante si pas assez d’octets `a d´elivrer, sauf si fin de fichier
I ´ecriture de p octets : bloquante si manque de place
I fin de fichier quand plus aucun processus n’acc`ede au tube en
´ ecriture
Plusieurs types de tubes en C : tubes anonymes (popen, pipe), tubes nomm´es (mkfifo), tubes entre machines distantes sur le r´eseau (sockets).
Tubes anonymes popen
ouverture d’une communication avec un autre processus cr´e´e pour ex´ecuter une commande. Le processus appelant peut se positionner soit en lecture sur le tube (il r´ecup`ere alors les r´esultats de la commande), soit en ´ecriture (il envoie des donn´ees `a la commande).
Le descripteur renvoy´e est de typeFILE *. Lecture et ´ecriture avec freadet fwrite.
FILE *popen(char *command, char *type) ; int pclose(FILE *stream) ;
Tubes anonymes pipe
La fonctionpipepermet de cr´eer deux descripteurs d’acc´es `a un tube. Les descripteurs sont dans un tableau de deux entiers (le premier permet de lire, le second d’´ecrire).
Le prototype est dansunistd.h. Manipulations par read, write et close.
On utilise souvent pipe avant un fork pour permettre aux deux processus de communiquer.
int pipe(int filedes[2]) ;
Tubes nomm´ es mkfifo
La fonctionmkfifopermet de cr´eer un support de communication avec un autre processus quelconque en cr´eant un fichier sp´ecial qui pourra ˆetre ouvert par les deux processus ayant besoin de
communiquer (l’un ouvrant en lecture et l’autre en ´ecriture).
Manipulation par open, read, write, close.
mkfifo(char * chemin, int droit) ;
Exemple : l’instructionmkfifo("SR/PG/TESTmkfifo",0666) ; produit le fichier :
9 prw-r r 1 mnt root 0 Mar 26 10 :50 TESTmkfifo 14 15 4.49
Section critique
Probl`emes des Variables Partag´ees : lorsque plusieurs processus s’ex´ecutent sur un ordinateur monoprocesseur ou multiprocesseurs avec m´emoire commune, ils sont amen´es `a partager des espaces de donn´ees communs :
I soit volontairement s’ils coop`erent pour traiter un mˆeme probl`eme,
I soit involontairement parce qu’ils sont oblig´es de se partager les ressources de l’ordinateur.
⇒r´esultats impr´evisibles si pas de pr´ecaution.
Exemple : compte bancaire sauv´e sur disque
Section critique
Section critiqued’un code = partie du programme o`u se produit le conflit d’acc`es `a l’objet partag´e.
L’ex´ecution simultan´ee de deux sections critiques appartenant `a des ensembles diff´erents et ne partageant pas de variable ne pose pas de probl`eme.
Les sections critiques doivent ˆetre ex´ecut´ees en exclusion
mutuelle: avant d’ex´ecuter une section critique, un processus doit s’assurer qu’aucun autre processus n’est en train d’ex´ecuter une section critique du mˆeme ensemble.
Dans le cas contraire, il ne devra pas progresser plus avant tant que l’autre processus n’aura pas termin´e sa section critique.
Techniques d’exclusion mutuelle
Masquage des interruptions: avant d’entrer en section critique, puis restauration en sortie. Utilis´e par le syst`eme, mais interdit aux process utilisateur car dangereux.
Fichier verrou: Un fichier sert `a indiquer la pr´esence d’un processus en section critique.
Avant d’entrer en section critique : tentative d’ouverture du fichier avecopen(fic, O CREAT | O EXCL)
Fichier effac´e en fin de section critique par unlink(fic).
S´emaphores (Disjkstra 1965): variable enti`ere g´er´ee par le syst`eme + op´erations P (d´ecr´ementation : r´eservation de ressource) et V (incr´ementation : lib´eration de ressource).
S´ emaphores
S´emaphore S ; V(S) ⇔ S =S + 1
P(S) ⇔ si(S >0) S− −; sinon ps mis en attente V et P sont des op´erations atomiques indivisibles (on est sur qu’aucun autre process ne peut acc´eder `a un s´emaphore tant qu’une op´eration sur ce s´emaphore n’est pas termin´ee ou bloqu´ee).
S´ emaphores
Exclusion mutuelle : s´emaphore binaire
PS1 S=1
phase normale P(S)
phase critique V(S)
phase normale
PS2
phase normale P(S)
phase critique V(S)
phase normale
Exemple du producteur-consommateur
2 processus partagent un mˆeme tampon de taille fixe N. Le ps A remplit le tampon et le ps B vide le tampon.
Si m´emoire pleine, alors A doit attendre que B vide et inversement.
Solution avec 3 s´emaphores : plein=0 ; vide=N ; mutex=1 ;
IPC (Inter Process Communications) UNIX
I s´emaphores,
I segments de m´emoire partageables,
I messages.
Par nature un objet IPC est partageable par plusieurs processus et g´er´e de fa¸con globale par le syst`eme.
Principe identique pour les 3 ressources :
I cl´e IPC associ´ee `a la ressource (identifiant externe de type key t) et identifiant interne (entier) dans le processus pour manipulation,
I droits d’acc`es d´efinis `a la cr´eation,
I commandesipcs liste des ressources IPC allou´ees ipcrm lib´erer une ressource
primitiveftok()pour cr´eer une cl´e publique
S´ emaphores IPC
G´er´ees sous forme d’un tableau, on alloue un tableau de
s´emaphores et on effectue des op´erations sur les diff´erents ´el´ements du tableau :
I cr´eation du tableau : semget(...),
I manipulation : semctl(...),
I acc`es :semop(...)permet de r´eserver/lib´erer N unit´es de ressource `a la fois
M´ emoire partag´ ee
un segment de m´emoire peut ˆetre simultan´ement attach´e `a l’espace d’adressage virtuel de plusieurs processus ou plusieurs fois
`a des adresses diff´erentes d’un mˆeme processus.
I shmget(): cr´eation,
I shmctl(): modification des droits ou du propri´etaire, destruction,
I shmat() : attachement `a espace d’adressage virtuel, puis lecture/´ecriture si droits ok,
I shmdt() : d´etachement,
Verrouillage de fichier
Verrouillage de fichier par flock() (BSD) :Permet de mettre des verrous partag´es ou exclusifs sur les fichiers :
I verrou partag´e autorise l’acc`es `a plusieurs lecteurs simultan´es,
I verrou exclusif limite l’acc`es `a un seul ´ecrivain (ni lecteur ni autre ´ecrivain).
flcok()prend en param`etre le descripteur du fichier, mais le verrou porte sur le fichier, pas sur le descripteur donc si on duplique le descr (par dup()), le verrou reste actif sur le 2i`eme descr ; Verrouillage de r´egions par fcntl (POSIX) :permet de traiter non pas un fichier mais une partie du fichier appel´ee r´egion. Une r´egion est d´efinie par une taille en octets et une position de d´ebut dans le fichier. Utilise une structureflock.
