Вы находитесь на странице: 1из 10

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE UNIVERSITE DE BEJAIA FACULTE DES SCIENCES EXACTES DEPARTEMENT D INFORMATIQUE

Expos en Systme d Exploitation II

Thme :

Synchronisation & Exclusion Mutuelle Sous LINUX

Ralis par :

Propos par : - Mr. ALLEM

 BOUAZZA Belkacem  MEDJANI Larbi

2010/2011

S O M M A I R E

Introduction L'exclusion mutuelle Les Processus du point de vu de linux Cration d un processus - fork() Synchronisation Les signaux sous UNIX Le traitement des signaux Exemple pratique sous Linux

Introduction
Un processus est un programme en cours d excution. Il faut d emble faire la diffrence entre un programme qui est un chier inerte regroupant des instructions pour le CPU et un processus qui un lment actif (on parle donc de programme en cours d excution pour un processus). Un processus n est pas continuellement en train de s excuter. Si la machine comporte n processeurs identiques, un instant donn il y a au maximum n processus actifs (c est--dire en cours d excution). Figeons un processus pour en observer ses composantes. Nous trouvons : y Des donnes (variables globales, etc.) stockes dans une zone dela mmoire qui a t alloue au processus ; y La valeur des registres du processeur lors de l excution ; y les ressources qui lui ont t alloues par le systme d exploitation (mmoire principale, chiers ouverts, priphriques utiliss, etc.). L ensemble de ces composantes forme le conte xte d excution d un processus ou plus simplement le contexte. En fait, parmi tous les processus qui sont susceptibles de s excuter, seulement un petit nombre s excutent rellement. L allocation du processeur aux processus qui le rclament est appele l ordonnancement du processeur. L tat oprationnel d un processus est un moyen de reprsenter les diffrentes tapes de ce processus telles qu elles sont gres par le systme d exploitation. Le schma suivant montre les divers tats dans lesquels, dans une premire approche intuitive, peut se trouver un processus.

Un processus est caractris dans le systme par :


un identi cateur ou numro (par exemple le PID, pour Process IDenti cation, dans le systme UNIX) ; un tat oprationnel (l un des cinq vus prc demment) ; un contexte ; des informations comme les priorits, la date de dmarrage, la liation ; des statistiques calcules par l O.S. telles que le temps d excution cumul, le nombre d oprations d E/S, etc.

L'exclusion mutuelle :
Exemple simple : 1. Rservation() { 2. 3. 4 5. 6. } if (nbplace > 0) { // Rserver une place . nbplace = nbplace } 1;

Le programme Rservation() peut s'excuter de manire concurrente Sans prcaution, la variable nbplace peut atteindre une valeur infrieure 0 P1 excute le test de la ligne 2, trouve 1>0, puis est prempt par P2. P2 dmarre, excute la ligne 2, trouve galement 1>0, dcrmente nbplace puis se termine. P1 reprend ligne 3, dcrmente nbplace puis se termine. nbplace=-1 !

Pour remdier ce problme : Ralisation matrielle d'une section critique (masquage/dmasquage ; Test and set ; Swap) Ralisation entirement logicielle d'une section critique (Verrou, Smaph ore)

Les Processus du point de vu de linux :


Aprs avoir tudi les processus au sein des systmes d exploitation quelconques, on s intresse maintenant leurs incarnations dans les O.S. de la famille Unix (GNU/Linux, SUN-Solaris, Minix, XINU, Mac OS S, HP-UX, Windows SFU Services For Unix ). La programmation systme se fera en effet en langage C sous Linux. Il faut donc connatre la faon de les manipuler l aide du langage C. Un processus est un ensemble d octets (crits en langage machine) en cours d excution, en d autres termes, c est l excution d un programme. Un processus UNIX se dcompose en : 1 un espace d adressage (visible par l utilisateur/programmeur) ; 2 Le bloc de contrle du processus (PCB en anglais) lui -mme dcompos en : une entre dans la table des processus du noyau struct proc d nie dans la librairie <sys/proc.h>. une structure struct user appele zone u d nie dans <sys/user.h>.

Les processus sous Unix apportent : La multiplicit des excutions. En effet, plusieurs processus peuvent tre l excution d un mme programme. La protection des excutions. Un processus ne peut excuter que ses instructions propres et ce de faon squentielle ; il ne peut pas excuter des instructions appartenant un autre processus. Les processus so us UNIX communiquent entre eux et avec le reste du monde grce aux appels systme. C est ce systme de communication entre processus sous Unix qui constitue le l conducteur du reste de l xpos

Cration d un processus - fork()


Sous UNIX la cration de processus est ralise en langage C par l appel systme : pid_t fork(void) ; Tous les processus - sauf le processus d identi cation 0 (le main), sont crs par un appel systme fork. Le processus qui appelle le fork est appel processus pre. Le nouveau processus cr par un fork est appel processus ls. Tout processus a un seul processus pre. Tout processus peut avoir zro ou plusieurs processus ls. PID : Chaque processus est identi de faon unique par un numro : son PID (Process IDenti cation). Le processus de PID=0 est cr au dmarrage de la machine. Ce processus a toujours un rle spcial pour le systme (surtout pour la gestion de la mmoire). Le processus zro cre, grce un appel de fork, le processus init dont le PID est gal 1. Ce processus de PID=1 est l anctre de tous les autres processus (le processus 0 ne ralisant plus defork()) et c est lui qui accueille tous les processus orphelins de pre (ceci a n de collecter les information la mort de chaque processus). Tous les processus sont associs une entre dans la table des processus qui est interne au noyau. De plus, le noyau alloue pour chaque processus une structure appele zone u , qui contient des donnes prives du processus, uniquement manipulables par le noyau. La table des p rocessus nous permet d accder la table des rgions. Les structures de rgions de la table des rgions contiennent des informations sur le type, les droits d accs et la localisation (adresses en mmoire ou adresses sur disque) de la rgion. Seule la zon e u du processus courant est manipulable par le noyau, les autres sont inaccessibles.

Le contexte d un processus est l ensemble des donnes qui permettent de reprendre l excution d un processus qui a t interrompu. Le contexte d un processus est l ensemble de 1 son tat ; 2 son mot d tat : en particulier La valeur des registres actifs ; Le compteur ordinal. 3 les valeurs des variables globales statiques ou dynamiques ; 4 son entre dans la table des processus ; 5 sa zone u ; 6 sa pile ; 7 les zones de code et de donnes. Quand il y a changement de processus courant, il y a ralisation d une commutation de mot d tat et d un changement de contexte. Une interruption est un signal lectrique reu sur l une des bornes du processeur. Ce signal est la consquence d un vnement extrieur ou intrne. Une fois que le signal est dtect, il faut terminer la cause de l interruption. Pour cela on utilise un indicateur, pour les diffrentes causes : on parle alors de vecteur d interruptions. Il existe trois grands types d interruptions : externes (indpendantes du processus) telles que les interventions de l oprateur, pannes, etc ; Droutements : erreur interne du processeur, dbordement, division par zro, etc (causes qui entranent la ralisation d une sau vegarde sur disque de l image mmoire core dump ) ; Appels systme : une demande d entre -sortie par exemple.

Le pre a appel fork et il s'est dupliqu. Cela implique plusieurs choses:


y y y y

Un nouveau processus a t cr, il est considr comme le fils du processus qui a appel fork() Ce processus est une copie conforme de son pre. D'ailleurs, la prochaine instruction excuter sera la mme pour les deux : la condition if. La fonction fork() ne retourne pas la mme chose pour les deux processus. Pour le fils, il retournera 0. Pour le pre, il retournera le pid du fils (son numro de processus). Cette duplication implique certaines choses concernant les variables et les descripteurs de fichiers. Nous allons y venir.

Synchronisation
Il n y a pas de problme de synchronisation que si un des processus impliqus dans l accs en parallle la ressource partage la mod ifie ; si les processus en accs simultan sont tous en mode consultation, il n y a pas de problme de synchronisation puisque la ressource partage n est pas modifie.

Les signaux sous UNIX


Prsentation des signaux Sous UNIX, les processus peuvent s'envoyer des messages appels signaux. Ces derniers ont des origines diverses, ils peuvent tre : retransmis par le noyau : division par zro, overflow, instruction interdite, envoys depuis le clavier par l'utilisateur ( touches : CTRL+Z, CTRL+C,... ) mis par la commande kill depuis le shell ou depuis le C par l'appel la primitive kill. Pour voir la totalit des messages envoyables sous UNIX, faites: kill -l On peut remarquer que tous les signaux ont leur nom qui commence par ``SIG''. Descriptif de quelques signaux: SIGFPE : une erreur arithmtique est survenue. SIGKILL : signal de terminaison. Le processus qui reoit ce signal doit se terminer immdiatement. SIGINT : frappe du caractre int sur le clavier du terminal: (CTRL + C). SIGUSR1 et SIGUSR2 : signaux qui peuvent tre mis par un processus utilisateur. SIGSTP : frappe du caractre de suspension sur le clavier: (le fameux CTRL +Z). SIGCONT : signal de continuation d'un processus stopp: lorsque vous tapez bg aprs avoir fait un CTRL +Z SIGHUP : le processus leader de votre session est termin: typiquement, lorsque vous vous loggez, un processus vous concernant est cre; les autres

processus qui sont cres ensuite dpendent de celui -ci. Une fois que le processus leader de votre session est termin (par un logout par exemple), le message SIGHUP est envoy tous ses fils qui vont se terminer leur tour. L'envoi de signaux : En shell: kill -num_du_signal num_du_processus En langage C: #include <signal.h> int kill (pid_t pid, int sig); valeur de pid: si >0, le signal ira en direction du processus de numro pid (nous laisserons de ct ici les cas pid =0, pid<0...) retour du kill: renvoie 0: l'appel s'est bien droul renvoie -1: l'appel s'est bien droul valeur de sig: <0 ou >NSIG: valeur incorrecte 0: pas de signal envoy mais test d'erreur: sert tester l'existence d'un processus de numro pid par exemple sinon: signal de numro sig

Le traitement des signaux


Le destinataire du signal peut excuter une fonction la rception d'un signal donn. Ainsi, un appel signal(num_du_signal,fonction) rcupre un signal de numro num_du_signal. {Remarque: sur les UNIX de la famille Berkeley, par exemple Solaris de Sun, aprs excution de la fonction spcifique dfinie par l'utilisateur, l'option par dfaut est rtablie. Si on veut conserver l'option spcifique il faut rappeler signal(num_sig, fonction) dans fonction. Voici un exemple que vous pouvez tester en: lanant le programme puis en pressant sur (CTRL + C), supprimant la ligne : /* ligne 1 */ et retester le programme pour bien comprendre la remarque. #include <signal.h> void trait_sig_int () { printf("Bien reu SIGINT, mais je m'en moque \n"); signal (SIGINT,trait_sig_int); /* ligne 1 */ }

main () { signal (SIGINT,trait_sig_int); while (1); }

Exemple pratique sous Linux (Problme du coiffeur endormi)



Le coiffeur est dans son salon. Si il n a pas de client, il s endort dans sa chaise n chaises pour que les clients attendent Le premier client qui arrive doit veiller le coiffeur Les clients subsquents s assoient si il y a des chaises, sinon il quittent le salon Difficile de dvelopper une solution sans concurrence critique .

int nbClients = 0; sem_t clients, coiffeur; /* Initialiss 0 */ sem_t mutex; /* Initialis 1 */ void *threadClient(void *inutilise) { sem_wait(&mutex); /* Entrer dans la section critique */ if (nbClients == nbChaises + 1) { /* Si le sa lon est plein */ sem_post(&mutex); /* Sortir de la section critique */ return NULL; /* Sortir du salon */ } else { nbClients = nbClients + 1; /* Un client de plus */ } sem_post(&mutex); /* Sortir de la section critique */ sem_post(&clients); /* Se mettre dans la file */ sem_wait(&coiffeur); /* Attendre le coiffeur */ obtenirCoupe(); /* Se faire coiffer */ sem_wait(&mutex); nbClients = nbClients sem_post(&mutex); return NULL; /* Entrer dans la section critiqu e */ 1; /* Un client de moins */ /* Sortir de la section critique */

/* Sortir du salon */

} #define VRAI 1 void *threadCoiffeur(void *inutilise) { while (VRAI) { sem_wait(&clients);

sem_post(&coiffeur); coiffer(); } return NULL; /* Jamais atteint */ }

Conclusion :
La ralisation de cet expos nous a permis de nous familiariser avec les notions de base des systmes d exploitation (synchronisation et exclusion mutuelle). De la compilation l excution de programme sous linux en illus trant les notions de processus, thread, mmoire partage etc.

Вам также может понравиться