programmation orientée système cours 11: la gestion des...

Programmation Orientee Systeme

Cours 11: La Gestion des Processus

Francesco Belardinelli

Laboratoire IBISC

3 avril 2018

Cours 11 : La Gestion des Processus

Capitre 13 de Unix : Programmation et Communication

1. Caracteristiques des Processus

2. Creation des Processus

3. Processus Zombies

4. Mecanismes de Synchronisation

Gestion des Processus : rappels

• Un processus correspond a l’execution d’un programme

• il s’agit d’un objet dynamique qui se modifie dans le temps

• caracterise par son espace d’adressage : ensemble des instructions et des donnees

• selon les objets auxquels il accede, il peut s’executer enI mode utilisateur (acces aux objets de son espace d’adressage)

ouI mode noyau (acces aux objets externes a son espace d’adressage, notamment les tables

de systeme)

• le passage d’un mode a l’autre se fait par des interruptions

Caracteristiques des Processus

• Fonctions pour obtenir l’identifiant d’un processus et de son pere :

#include <sys/types.h>

#include <unistd.h>

pid_t getpid();

pid_t getppid();

• pid_t est un type entier

• exemple pid.c :


#include <unistd.h>

#include <stdio.h>

int main(){

pid_t pid;

pid = getpid();

printf("le pid du processus est %d.\n", pid);

pid = getppid();

printf("le pid du processus pere est %d.\n", pid);

return 0;

}

• comparez avec echo $$ ou ps (Cours 10)


• Fonctions pour obtenir le proprietaire reel et effectif d’un processus :

uid_t getuid();

uid_t geteuid();

Example 1 (uid.c)


#include <unistd.h>

#include <stdio.h>

int main(){

uid_t uid;

uid = getuid();

printf("l’id de l’utilisateur reel est %d.\n", uid);

uid = geteuid();

printf("l’id de l’utilisateur effectif est %d.\n", uid);

return 0;

}

Identifiants Reels et Effectifs

• Au niveau du OS, le noyau, les utilisateurs et les groupes ne sont pas identifiespar des noms, mais par des nombres

• chaque nom d’utilisateur et le nom du groupe est associe a un numero uniquenon signe, appele ID utilisateur et ID groupe, ou uid et gid

• cette association est faite via les fichiers /etc/group et /etc/passwd

• l’utilisateur et le groupe d’ID 0 sont normalement appeles root (racine)

• chaque processus Unix possede un ID utilisateur et un ID de groupe qui lui estassocie

• ces identifiants constituent les privileges effectifs du processus, car ils determinentce que le processus peut faire et ce qu’il ne peut pas

• ces identifiants sont designes comme uid et gid effectifs

• quand-meme, lorsqu’on appelle un utilitaire de systeme, tel que passwd, l’uideffectif du processus est regle sur 0 (c.a.d., l’uid de la root)

• en tant qu’utilisateur normal, vous etes autorises a modifier seulement le mot depasse de votre propre compte

• donc, cela pose la question : comment savoir qui a invoque passwd ?

• tout processus a une autre paire de ID utilisateur et groupe, appele les uid et gidreels

• on peut comparer l’ID utilisateurs reels a des badges qu’on porte, et l’uid effectifa l’ensemble des cles qu’on a recu

• la plupart du temps, l’ID effectif du processus est le meme que l’ID reels


• Fonctions pour obtenir l’id du groupe proprietaire reel et effectif :

uid_t getgid(void);

uid_t getegid(void);

• fonctions pour modifier l’id du groupe proprietaire reel et effectif :

int setgid(gid_t gid)

int setegid(gid_t gid)

• exemple gid.c :#include <sys/types.h>

#include <unistd.h>

#include <stdio.h>

int main(){

uid_t gid;

printf("l’id du group de l’utilisateur reel est %d.\n", getgid());

printf("l’id du group de l’utilisateur effectif est %d.\n", getegid());

if(setgid(500)== -1)

perror("permission insuffisante");

else printf("l’id du group de l’utilisateur reel est %d.\n", getgid());

if(setegid(500)== -1)

perror("permission insuffisante");

else printf("l’id du group de l’utilisateur effectif est %d.\n", getegid());

return 0;

}

• comparez les executions en mode utilisateur et noyau


• utilisateur et groupe du processus

• session a laquelle le processus appartient

• date de creation : nombre de secondes depuis le 01/01/1970

• temps CPU consommes dans les 2 modes (utilisateur et noyau) :

struct tms {clock_t tms_utime; /*temps CPU pour l’execution d’instructions de l’utilisateur*/clock_t tms_stime; /*temps CPU pour l’execution d’instructions du systeme */clock_t tms_cutime; /*somme de tms_utime et tms_cutime du processus fils */clock_t tms_cstime; /*somme de tms_stime et tms_cstime du processus fils */};

• on peut recuperer ces infos avec la fonction times :

#include <sys/times.h>

clock_t times(struct tms *buf);

• exemple : le programme times.c affiche ses temps d’execution


• Le masque de creation des fichiers : cela permet de modifier les droits des fichierscrees par le processus (droits du masque enleves a la creation)


#include <sys/stat.h>

mode_t umask(mode_t mask)

• La table des descripteurs : nombre limite par OPEN_MAX de limits.h

• L’etat du processus :I etat transitoire a sa creation ou au cours de la creation d’un filsI etat pret (eligible par l’ordonnaceur)I etat actifI etat en sommeil (processus en attente d’evenements)I etat suspenduI etat zombie (processus termine mais son pere ne le sait pas encore)

schema au tableau des differents etats.

Creation des Processus

• Permet de creer dynamiquement un nouveau processus s’executant en paralleledu processus qui l’a cree

• tout processus, excepte l’originel (de PID 1), est cree par un appel a la fonctionfork :


#include <unistd.h>

pid_t fork(void)

• un appel a fork par un processus (pere) entraıne, si possible, la creation d’unnouveau processus (fils), c.a.d., l’attribution d’un bloc de controle et soninitialisation

• processus fils = copie exacte du processus pere (enfin presque . . . ) : il execute lememe programme que le pere sur une copie des donnees de celui-ci (au momentde l’appel a fork)

Creation des Processus

• processus fils = copie exacte du processus pere (enfin presque . . . )⇒ copie des donnees + copie de la pile d’execution

• a la reprise de l’execution, les deux processus repartent du meme point

• comme le programme execute par les 2 processus est le meme et les donnees sontidentiques, il faut, pour que leur comportement soit different dans la suite del’execution, pouvoir les distinguer

• code de retour different dans le pere et dans le fils :I -1 en cas d’echec (trop grand nombre de processus ouverts)I 0 dans le processus filsI le PID du fils dans le processus pere

Creation des Processus : exemple

Programme ex1.c qui cree un processus fils et affiche les valeurs du pid et ppid pourles deux processus.


#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

int main(){

pid_t pid;

pid = fork();

switch (pid){

case (-1): /* Echec de la creation. */

perror("Creation");

exit(1);

case (0): /* Creation du fils. */

printf("valeur fork = %d.\n", pid);

printf("fils %d de pere %d.\n", getpid(), getppid());

printf("fin du fils.\n");

exit(0);

default: /* Creation du pere. */


printf("pere %d de pere %d.\n", getpid(), getppid());

printf("fin du pere.\n");

}

return 0;

}

on obtient le meme resultat avec une instruction if...then

Creation des Processus : a savoir

• Les 2 processus (pere et fils) partagent le meme code physique

• le processus fils travaille sur une copie des donnees de son pere

• ainsi, toute modification des donnees par l’un des processus n’est pas visible del’autre

• processus executes en parallele

• non-determinisme du resultat car evenements exterieurs

• mecanismes de synchronisation disponibles (wait)

Creation de Processus

Exemples d’execution du programme precedent.

• fils termine avant l’election du pere

• le processus shell reveille a la terminaison du pere.

$ echo $$7469 /* identite du processus shell */$ ./a.outvaleur fork = 0.fils 12364 de pere 12363.fin du fils.valeur fork = 12364.fils 12363 de pere 7469.fin du pere.$


Exemples d’execution du programme precedent

• pere termine avant le fils

• processus shell reveille apres la terminaison du fils

$ ./a.outvaleur fork = 0.fils 12364 de pere 12363.valeur fork = 12364.fils 12363 de pere 7469.fin du pere.fin du fils.$


Exemples d’execution du programme precedent.

• pere termine avant election du fils

• fils orphelin adopte par le processus init

$ ./a.outvaleur fork = 12364.fils 12363 de pere 7469.fin du pere.valeur fork = 0.fils 12364 de pere 1.fin du fils.$

• exemple async.c : variables copiees


Attributs que le fils n’herite pas du pere :

• son identification unique (attribuee par le systeme)

• l’identification de son pere

• les temps d’execution (initialises a la valeur nulle)

• les signaux pendants

• la priorite du processus fils (initialisee a une valeur standard)

• les verrous sur les fichiers detenus par le processus pere

Example 2

• heritage.c : heritage des attributs

• heritageDesc.c : heritage des descripteurs de fichiers

• boucle.c : meme gestion des signaux

• forkDonnees : copie des donnees

Processus zombies

• Tout processus se terminant passe dans l’etat zombie

• il y reste tant que son pere n’a pas pris connaissance de sa terminaison

• pourquoi un tel etat ? tout processus se terminant possede une valeur de retour alaquelle son pere peut acceder

• le systeme fournit un moyen a un processus d’acceder aux codes de retour de sesfils

• un fils qui se termine envoie le signal SIGCHLD a son pere

• les seules informations conservees dans le bloc de controle sont :I son code de retourI ses temps d’executionI ses temps d’execution dans les deux modesI son identite et celle de son pere

• exemple : prZombi.c

Mecanismes de Synchronisation

• Ces mecanismes permettent :I l’elimination des processus zombiesI la synchronisation d’un processus sur la terminaison de ses fils apres recuperation des

informations propres a ces terminaisons

• ces operations sont performees par la fonction wait :


#include <sys/wait.h>

pid_t wait(int *status)

• principe de fonctionnement :1. pas de fils, retourne -1 ;2. au moins un processus-fils zombie, retourne l’identite d’un des zombies et les

informations de ce zombie dans status (si 6= NULL).3. au moins un fils mais pas de zombie, il reste bloque jusqu’a ce que :

I l’un des fils devienne zombie (cas 2)I l’appel systeme soit interrompu par un signal “non mortel” (valeur de retour egale a -1)


Example 3 (wait2.c)Meme programme qu’auparavant, mais cette fois le fils execute le premier.


#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>


int main(int argc, char **argv){

pid_t pid, pid2;

int *status;

status = (int*)malloc(sizeof(int));

pid = fork();

if (pid == -1){

perror("Creation");

exit(1);

}

else{

pid2 = wait(status);


printf("fils %d de pere %d.\n", getpid(), getppid());

printf("avec fils %d de status %d.\n", pid2, *status);

}

free(status);

return 0;

}




pid_t waitpid(pid_t pid, int *status, int options)

• la fonction waitpid() permet :I de tester, en bloquant ou non le processus appelant, la terminaison d’un processus

particulier (ou dans un groupe de processus donne)I de recuperer les informations relatives a sa terminaison a l’adresse status

• le parametre pid permet de selectionner le processus attendu :< −1 n’importe quel processus fils dans le groupe |pid|−1 n’importe quel processus fils

0 n’importe quel processus fils du meme groupe que l’appelant> 0 n’importe quel processus fils d’identite pid





• le parametre options est une combinaison bit a bit des valeurs :I WNOHANG : le processus appelant n’est pas bloque si le processus attendu n’est pas

termineI WUNTRACED : si le processus attendu est stoppe, cette information est transmise, si elle

ne l’a pas encore eteI WCONTINUED : renvoie meme si un fils arrete a ete repris par SIGCONT

• la valeur de retour est :I -1 en cas d’erreurI 0 en cas d’echec en mode non bloquant (processus attendu existant mais ni termine ni

stoppe)I le numero du processus fils zombie attendu sinon





• l’interpretation du parametre resultant status se fait en utilisant les fonctionsmacro-definies suivantes :

I WIFEXITED : valeur non nulle si le processus attendu s’est termine normalementI WIFSIGNALED : valeur non nulle si le processus attendu s’est termine a la reception d’un

signalI WIFSTOPPED : valeur non nulle si le processus attendu est stoppe (waitpid() avec

WUNTRACED)I WEXITSTATUS : fournit le code de retour du processus attendi s’il s’est termine

normalementI WTERMSIG : fournit le numero du signal ayant provoque la terminaison du processus

attenduI WSTOPSIG : fournit le numero du signal ayant stoppe le processus attendu


• exemple : le programme waitpid.c cree un processus fils.

• si aucun argument de ligne de commande est fournie au programme, le filssuspend son execution en utilisant pause(), pour permettre a l’utilisateurd’envoyer des signaux au fils.

• sinon, si un argument de ligne de commande est fournie, le fils quitteimmediatement, en utilisant l’entier fourni sur la ligne de commande que l’etat desortie

• le processus parent execute une boucle qui surveille l’enfant a l’aide waitpid(), etutilise les macros W* () decrites ci-dessus pour analyser la valeur d’etat d’attente

$ ./a.out &Child PID is 32360[1] 32359$ kill -STOP 32360stopped by signal 19$ kill -CONT 32360continued$ kill -TERM 32360killed by signal 15[1]+ Done ./a.out$

Duplication des Descripteurs

• duplication des descripteurs : mechanisme fondamental pour realiser desredirections, c.a.d., modifier les associations entre descripteurs et fichiersphysiques

• un fils peut modifier le descripteur du pere

• la duplication permets a un processus d’acquerir un descripteur synonyme d’undescripteur qu’il possede deja

• #include <unistd.h>

int dup(int descripteur)

• exemple : duplication.c

• la primitive dup2 permet de choisir le synonyme

#include <unistd.h>

int dup2(int premier, int second)

Conclusions : La Gestion des Processus

1. Caracteristiques des ProcessusI pid, uid, gidI struct tmsI umask

2. Creation des Processus

3. Processus Zombies

4. Mecanismes de SynchronisationI wait, waitpid

programmation orientée système cours 11: la gestion des...

Documents