CH 2 INF2610 Hiv 19

Noyau d'un système d'exploitation
INF2610
Chapitre 2 : Processus
Département de génie informatique et génie logiciel
Hiver 2019
Chapitre 2 - Processus
●  Qu’est ce qu’un processus ?
●  États d’un processus
●  Hiérarchie des processus
●  Processus UNIX-Linux
–  Création de processus
–  Remplacement d’espace d’adressage
–  Attente de la fin d’un processus fils
–  Terminaison de processus
–  Partage de fichiers entre processus
Génie informatique et génie logiciel

Noyau d'un système d'exploitation Chapitre 2 - 2
Ecole Polytechnique de Montréal
Qu’est ce qu’un processus ?
●  Le concept processus est le plus important dans un système
d’exploitation. Tout le logiciel d’un ordinateur est organisé en un
certain nombre de processus (système et utilisateur).
●  Un processus est un programme en cours d’exécution. Il est

caractérisé par (son contexte) :
–  un numéro d’identification unique (PID),
–  un espace d’adressage (code, données, piles d’exécution),
–  les fichiers ouverts, les espaces mémoire alloués, les périphériques,
–  les signaux à capter, à masquer, à ignorer, en attente et les actions
associées,
–  le processus père, les processus fils, le groupe, les variables
d’environnement, les statistiques, les limites d’utilisation des
ressources,
–  un état principal (prêt, en cours d’exécution, bloqué, etc.),
–  une priorité,
–  les valeurs des registres lors de la dernière suspension (CO,
PSW, Sommet de Pile, etc.) è contexte d’exécution,
–  etc.
Qu’est ce qu’un processus ? (2)
Table des processus
•  Le système d’exploitation maintient dans une table appelée «table des
processus» les informations sur tous les processus créés (une entrée
par processus : Bloc de Contrôle de Processus PCB).
Un PCB est une
structure de données qui
représente un processus
au niveau du système
d’exploitation
Tannenbaum

Table des processus : Changement de contexte
Processus A Mode kernel

Processus B
Mode utilisateur
Mode utilisateur
exécution
interruption Sauvegarder état dans PCB A
exécution
Charger état du PCB B
Sauvegarder état dans PCB B

interruption
exécution Charger état du PCB A
Tannenbaum

Table des processus
•  Dans le cas de Linux, le PCB est une structure task_struct et la

table des processus est une liste doublement chainée.
Accès (direct/indirect) à
partir d’un processeur,
via un registre, au PCB de
la tâche en cours
d’exécution.

Espace d’adressage virtuel
Fichier exécutable ELF (Executable and Linkable Format)
Program header table
!
http://flint.cs.yale.edu/cs422/doc/ELF_Format.pdf
Le fichier exécutable permet au noyau de
construire un processus (table des pages de son
espace d’adressage, adresse de la première
instruction
Ecole à de
Polytechnique exécuter,
Montréal etc.). Chapitre 2 - 7 !
Espace d’adressage virtuel
cat /proc/’’pid’’/maps
man 5 proc
Table des pages : indique pour

chaque page de l’espace
d’adressage d’un processus, son
emplacement en mémoire ou sur le
disque, son code de protection, etc.
Tannenbaum

États d’un processus
Expiration
Attente d’admission File des prêts Fin d’exécution

Process eur
Processeur
File des bloqués Attente d’événement
Tannenbaum
Élection
Admission Terminaison
Nouveau Prêt Exécution Fin
Suspension
Arrivée de Attente d'un

l’événement événement
Bloqué

États d’un processus (2) : Unix
fork
Création
Préemption
Retour Mémoire
Mémoire
à usager insuffisante
suffisante
Exécution
suspension
Mode Hors mémoire
user Retour Prêt en Prêt hors
Élection mémoire mémoire
En mémoire
Interruption ou
Appel système Exécution
Mode
noyau Mise en attente
d’un evt
Arrivée de l’evt Arrivée de l’evt
terminaison
attente Hors mémoire Attente

Zombie en hors
mémoire mémoire

États d’un processus (3) : Linux
…
http://www.informit.com/articles/article.aspx?p=368650
États : R à Task_Running,
S (sleeping) à Task_Interruptible,
D à Task_Uninterruptible,
T (being traced or stopped) à Task_Stopped,
Z à Task_Zombie.
États d’un processus (4) : Windows
Exécutable
Veille
Changement
Élection de contexte
Préemption
Prêt Exécution
Ressource Ressource Attente

disponible disponible ressource Terminaison
Dormance Bloqué Fin

Éviction
Non-exécutable

Hiérarchie des processus
●  Le système d’exploitation fournit un ensemble d’appels système qui
permettent la création, la destruction, la communication et la
synchronisation des processus.
●  Les processus sont créés et détruits dynamiquement.
●  Un processus peut créer un ou plusieurs processus qui, à leur tour,

peuvent en créer d’autres.
●  Dans certains systèmes (MS-DOS), lorsqu’un processus crée un autre

processus, l’exécution du processus créateur est suspendue jusqu’à
la terminaison du processus créé (exécution séquentielle).
●  Sous Linux/Unix/Windows, les processus créateurs et créés

s’exécutent en concurrence et sont de même niveau (exécution
asynchrone). Chaque processus a un parent et éventuellement un ou
plusieurs fils.
Hiérarchie des processus (2) :
●  Windows ne gère pas de relation hiérarchique entre processus :

-  Chaque processus a un pointeur vers le processus parent
(processus créateur).
-  Si ce parent se termine, il n’y a pas d’actualisation de cette
information. Un processus peut pointer vers un parent
inexistant. Cela ne cause aucun problème puisque rien ne
dépend de cette information de parenté.
●  Linux/Unix gère dynamiquement la relation hiérarchique entre

processus :
-  Chaque processus a un pointeur vers le processus parent
(processus créateur).
-  Si ce parent se termine, il est adopté par un autre processus
vivant (processus init de numéro 1).

Hiérarchie des processus (3) : Linux/UNIX
•  BIOS (Basic Input/Output System dans la carte mère) exécute des
opérations de vérification de l'intégrité du système, charge et lance
l’exécution du programme d'amorçage MBR (Master Boot Record).
•  MBR charge une partie du système d’exploitation puis lance son exécution.
Cette partie détermine les caractéristiques du matériel, effectue un certain
nombre d’initialisations et crée le processus 0.
•  Le processus 0 réalise d’autres initialisations (ex. le système de fichier)

puis crée deux processus : init de PID 1 et démon des pages de PID 2.
Ensuite, d’autres processus sont crées à partir du processus init.

http://www.ibm.com/developerworks/linux/library/l-linuxboot/
Processus UNIX – Linux
●  Chaque processus a un numéro d’identification unique (PID). L’appel
système getpid() permet de récupérer le PID du processus.
●  Chaque processus a un père (structure arborescente). Le processus init

est l’ancêtre de tous les processus utilisateur. L’appel système getppid()
permet de récupérer le PID de son processus père.
●  La création de processus est réalisée par duplication de l’espace

d’adressage et de certaines tables du processus créateur (l’appel
système fork).
●  La duplication facilite la création et le partage de ressources. Le fils

hérite les résultats des traitements déjà réalisés par le père.
●  Un processus peut remplacer son code exécutable par un autre (appel

système exec).
●  Un processus père peut stopper/repartir/détruire (appel système kill) ou

attendre la terminaison (appel système wait) de ses fils mais ne peut
pas les renier.
Création de processus : fork
●  L’appel système fork :

–  associe un numéro d’identification unique (le PID du processus);
–  ajoute puis initialise une entrée dans la table des processus
(PCB). Certaines entités comme le répertoire de travail courant,
la valeur d’umask, les limites des ressources sont copiées du
processus parent, etc;
–  duplique l’espace d’adressage du processus effectuant l’appel à
fork (code+pile+données) à Principe « Copy-on-write »
partage en lecture, duplication en cas d’écriture.
–  duplique la table des descripteurs de fichiers….
●  La valeur de retour est :

–  0 pour le processus créé (fils).
–  le PID du processus fils pour le processus créateur (père).
–  négative si la création de processus a échoué (manque d’espace
mémoire ou le nombre maximal de créations autorisées est
atteint).
Création de processus (2) : fork
●  Au retour de la fonction fork, l’exécution des processus père et fils se

poursuit, en temps partagé, à partir de l’instruction qui suit l’appel à
fork.
●  Le père et le fils ont chacun un espace d’adressage privé.

Exemple 1 : Création d’un processus fils
(chaque processus a son espace d’adressage
(privé))

Création de processus (3) : Exemple 1
1 // programme tfork.c : appel système fork()
2 #include <sys/types.h> /* typedef pid_t */
3 #include <unistd.h> /* fork() */
4 #include <stdio.h> /* pour perror, printf */
5 int a=20;
6 int main( ) {
7 pid_t x;
8 // création d’un fils
9 switch (x = fork()) {
10 case -1: /* le fork a échoué */
11 perror("le fork a échoué !");
12 break;
13 case 0: /* seul le processus fils exécute ce « case »*/
14 printf("ici processus fils, le PID %d.\n ", getpid());
15 a += 10;
16 break;
17 default: /* seul le processus père exécute ce « case »*/
18 printf("ici processus père, le PID %d.\n", getpid());
19 a += 100;
20 }
21 // les deux processus exécutent ce qui suit :
22 printf("Fin du Process %d. avec a = %d\n", getpid(), a);
23 return 0;
24 }
a du fils
jupiter% gcc -o tfork tfork.c
jupiter% ./tfork
ici processus père, le PID 12339.
ici processus fils, le PID 12340.
Fin du Process 12340 avec a = 30. a du père
Fin du Process 12339 avec a = 120.
jupiter% ./tfork a du père

ici processus père, le PID 15301.
ici processus fils, le PID 15302.
jupiter% a du fils

Exemple 2 : Création de plusieurs processus
-  strace permet de construire l’arbre des processus créés.

-  Orphelins adoptés par le processus init de pid 1.

1 // programme tree.c : appel système fork()

2 #include <sys/types.h>
3 #include <unistd.h>
4 #include <stdio.h>
5 int main( ) {
6 pid_t p;
7 int i, n=5;
8 for (i=1; i<n; i++) {
9 p = fork();
10 if (p > 0)
11 break ;
12 sleep(1);
13 printf(" Processus %d de père %d. \n", getpid(), getppid());
14 }
15 sleep(2);
16 return 0;
17 }

shell Processus
23706
Comment utiliser strace pour déterminer
Processus l’arborescence des processus créés ?
i=1
fork() 23707
sleep(2) sleep(1)
return 0 printf(..) Processus
i=2 23708
fork()
sleep(2) sleep(1)
return 0 printf(..)
i=3 Processus
fork() 23709
sleep(2)
return 0 sleep(1)
printf(..)
jupiter% gcc –o tree tree.c i=4 Processus
jupiter% ./tree fork() 23710
Processus 23707 de pere 23706 sleep(2)
return 0
Processus 23709 de pere 23708 printf(..)
i=5
Noyau d'un système d'exploitation return 0 Chapitre 2 - 24
jupiter$ strace -f -e trace=clone -o stree.txt ./tree
Processus 26770 de père 26769.
Processus 26771 de père 26770.
Processus 26773 de père 26771. Comment utiliser strace pour déterminer
Processus 26774 de père 26773. l’arborescence des processus ?
jupiter$ cat stree.txt
26769 clone(child_stack=NULL, flags=CLONE_CHILD_CLEARTID|
CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ffb6cbbc790) = 26770
26769 +++ exited with 0 +++
26770 +++ exited with 0 +++
26771 clone(child_stack=NULL, flags=CLONE_CHILD_CLEARTID
|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ffb6cbbc790) = 26773
26771 +++ exited with 0 +++
26773 +++ exited with 0 +++
26774 +++ exited with 0 +++
Création de processus (8) : Exemple 2 sans «sleep(2)»
shell Processus jupiter% gcc –o tree tree.c
23706 jupiter% ./tree
jupiter% Processus 23707 de pere 1
Processus Processus 23708. de pere 1
i=1
fork() 23707 Processus 23709 de pere 1
sleep(1)
Processus 23710 de pere 1
terminaison printf(..)
i=2 Processus
fork() 23708
terminaison sleep(1)
printf(..)
i=3 Processus
fork()
terminaison 23709
sleep(1)
printf(..)
i=4 Processus
Les fils qui deviennent
fork()
orphelins sont adoptés 23710
par le processus init terminaison
sleep(1)
de PID 1 printf(..)
i=5
Génie informatique et génie logiciel terminaison
Ecole Polytechnique de Montréal Chapitre 2 - 26
Terminaison de processus
●  Un processus se termine par une demande d’arrêt volontaire (exit)

ou par un arrêt forcé provoqué par un autre processus (appel
système kill) ou une erreur.
void exit(int vstatus);
•  Lorsqu’un processus fils se termine :

–  son état de terminaison est enregistré dans son PCB,
–  la plupart des autres ressources allouées au processus sont
libérées,
–  le processus passe à l’état zombie (<defunct>).
•  Son PCB et son PID sont conservés jusqu’à ce que son processus
père ait récupéré cet état de terminaison. Il est alors détruit.
•  Les appels système wait(&status) et waitpid(pid, &status, option)

permettent au processus père de récupérer, dans status, cet état de
terminaison.

Attente et terminaison de processus
●  Un processus peut attendre ou vérifier la terminaison d’un de ses fils :

–  pid_t wait (int * pstatus); // attendre un fils
–  pid_t waitpid(int pid, int*pstatus, int options); //attendre le fils
spécifié.
●  wait(&status) et waitpid(pid, &status, options) retournent :

–  le PID du fils qui s’est terminé,
–  -1 en cas d’erreur (le processus n’a pas de fils), et
–  dans status des informations sur l’état de terminaison. Ces
informations peuvent être récupérées au moyen de macros telles
que :
•  WIFEXITED(status) : fin normale avec exit,
•  WIFSIGNALED(status) : tué par un signal,
•  WIFSTOPPED(status) : stoppé temporairement,
•  WEXITSTATUS(status) : valeur de retour du processus fils
( exit(valeur)).
●  waitpid(pid, &status, WNOHANG) vérifie seulement la terminaison pas

d’attente. Il retourne 0 si l’exécution du processus n’est pas terminée.
Exemple 3 : État de terminaison d’un processus
(rôles de wait et exit)

Exemple 3 : wait & exit
// programme deuxfils.c
#include <sys/wait.h> jupiter% gcc -o deuxfils deuxfils.c
#include <stdio.h> jupiter% deuxfils
#include <unistd.h>
fin du fils1
void fils(int i);
fin du fils2
int main() {
int status; jupiter% deuxfils
if (fork()==0) { // premier fils fin du fils2
fils(1); fin du fils1
} else if (fork()==0) { // second fils
fils(2);
} else { if (wait(&status) > 0)
printf("fin du fils%d\n", WEXITSTATUS(status));
if (wait(&status) > 0)
printf("fin du fils%d\n", WEXITSTATUS(status));
}
return 0;
}
void fils(int i) {
sleep(2);
_exit(i);
}
Remplacement de l’espace d’adressage
●  Le système UNIX/Linux offre une famille d’appels système exec qui permettent
à un processus de remplacer son code exécutable par un autre spécifié par path
ou file :
#include <unistd.h>
extern char **environ;
int execl(const char *path, const char *arg, …, /* (char *) NULL */);
int execlp(const char *file, const char *arg, …, /* (char *) NULL */);
int execle(const char *path, const char *arg, …, /*, (char *) NULL, char * const envp[]*/);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);
●  Après un exec, le processus conserve, notamment, son PID, l’espace mémoire

alloué, sa table de descripteurs de fichiers et ses liens parentaux (processus fils
et père).
●  En cas de succès de l’appel système exec, l’exécution de l’ancien code est

abandonnée au profit du nouveau.
●  En cas d’échec, le processus poursuit l’exécution de son code à partir de

l’instruction qui suit l’appel (il n’y a pas eu de remplacement de code).
Exemple 4 : shell simplifié
(faire exécuter une commande par son processus fils)

Exemple 4 : shell simplifié (execvp)
// programme test de execvp : texecvp.c

#include <unistd.h> jupiter% gcc –o texecvp
#include <stdio.h> texecvp.c
#include <sys/wait.h> jupiter% ./texecvp date
int main (int argc , char * argv[]) { Mon Sep 3 19:17:00 EDT 2018
if (fork() == 0) { // il s'agit du fils fin du fils avec 0
// exécute un autre programme
execvp(argv[1], &argv[1]) ;
fprintf(stderr, "invalide %s\n ", argv[1]);
jupiter% ./texecvp ugg+kjù
_exit(1);
} invalide ugg+kjù
int status; fin du fils avec 1
if(wait(&status) > 0)
printf("fin du fils avec %d\n", jupiter% ./texecvp ./deuxfils
WEXITSTATUS(status)); fin du fils1
return 0; fin du fils2
} fin du fils avec 0

Exemple 5 : execv et execl
(passage de paramètres)

Exemple 5 : execv & execl
jupiter$ gcc forkExec.c –o ./forkExec
// programme forkExec.c jupiter$ ./forkExec
#include <sys/wait.h> /usagers4/p302161/codesINF2610/codesExecINF2610
#include <stdio.h> fin du fils 26168 avec 0
#include <unistd.h> total 36
#include <stdlib.h> // pour exit -rwx------ 1 p302161 gigl 8496 Sep 3 15:48 deuxfils
-rwx------ 1 p302161 gigl 8568 Sep 3 17:34 forkExec
int main( ) { -rwx------ 1 p302161 gigl 8472 Sep 3 15:49 tree
if (fork()==0) { // premier fils fin du fils 26167 axec 0
char* args[]={"ls","-l", NULL};
execv("/bin/ls",args); jupiter$ pwd
printf("echec de execv de ls \n"); /usagers4/p302161/codesINF2610/codesExecINF2610
jupiter$ ls -l
exit(1); total 36
} else if (fork()==0) { // second fils -rwx------ 1 p302161 gigl 8496 Sep 3 15:48 deuxfils
execl("/bin/pwd","pwd",NULL); -rwx------ 1 p302161 gigl 8568 Sep 3 17:34 forkExec
-rwx------ 1 p302161 gigl 8472 Sep 3 15:49 tree
printf("echec de execl de pwd \n");
exit(1);
} else { int pid, status;
pid=wait(&status);
printf("fin du fils %d avec %d\n", pid, WEXITSTATUS(status));
pid=wait(&status);
printf("fin du fils %d axec %d\n", pid, WEXITSTATUS(status));
}
return 0;
} Noyau d'un système d'exploitation Ecole Polytechnique de Montréal Chapitre 2 - 35
Exemple 6 : execve
(passage de paramètres)

Exemple 6 : execve
// programme forkExecve.c // programme fils.c
#include <sys/wait.h> #include <stdio.h>
#include <stdio.h> #include <unistd.h>
#include <unistd.h> #include <stdlib.h> // pour exit
#include <stdlib.h> // pour exit int main(int argc, char* argv[], char*env[]) {
int main( ) { printf(" argc = %d \n", argc);
if (fork()==0) { // fils int i;
char* args[]={"fils", NULL}; for(i=0; i<argc;i++)
char* env[]={"PWD=../",NULL}; printf(" argv[%d]=%s \n", i, argv[i]);
execve("./fils", args, env); for(i=0;env[i]!=NULL;i++)
printf("echec de execve \n"); printf(" env[%d]=%s \n", i, env[i]);
exit(1); printf(" getenv(PWD)=%s\n" , getenv("PWD"));
} // père exit(0);
int pid, status; }
pid=wait(&status);
printf("fin du fils %d avec %d\n", pid, WEXITSTATUS(status));
return 0;
jupiter$ gcc forkExecve.c –o forkExecve
} jupiter$ gcc fils.c -o fils
jupiter$ ./forkExecve
argc = 1
argv[0]=fils
env[0]=PWD=../
getenv(PWD)=../
fin du filsde9276
Ecole Polytechnique avec 0
Montréal Chapitre 2 - 37
Partage de fichiers entre processus père et fils
•  Le fork duplique la table des descripteurs de fichiers du processus père.
Le fils hérite les descripteurs de fichiers

ouverts (avec leurs buffers pour par
exemple printf) è il faut donc vider les
buffers par fflush avant d’appeler le fork.
http://processors.wiki.ti.com/index.php/Tips_for_using_printf#Buffered_I.2FO

Exemple 7 : printf avant fork
#include <unistd.h> /* pour write et fork */

#include <stdio.h> /* pour printf */
int main( ) {
printf(" ici 1er printf de %d ", getpid());

write(1," ici 1er write ",16);
printf(" ici 2eme printf de %d ", getpid());
fork();
write(1," ici 2eme write ", 17);
printf("end of line printf de %d\n", getpid());
write(1, " ici 3eme write \n",17);
return 0;
}
jupiter%./printfwrite
ici 1er write ici 2eme write ici 1er printf de 11243 ici 2eme printf de 11243 end of line printf de
11243
ici 3eme write
ici 2eme write ici 1er printf de 11243 ici 2eme printf de 11243 end of line printf de 11244
ici 3eme write Génie informatique et génie logiciel
jupiter% Chapitre 2 - 39
Exemple 7’ : printf avant fork (2)
#include <unistd.h> /* pour write */

#include <stdio.h> /* pour printf et fflush*/
int main( ) {
printf(" ici 1er printf de %d ", getpid());

write(1," ici 1er write ",16);
Que fait fclose(stdout) ?
printf(" ici 2eme printf de %d ", getpid());
fflush(stdout);
fork();
write(1," ici 2eme write ", 17);
printf("end of line printf de %d\n", getpid());
write(1, " ici 3eme write \n",17);
return 0;
}
jupiter%./printfwrite
ici 1er write ici 1er printf de 11258 ici 2eme printf de 11258 ici 2eme write end of line printf de 11258
ici 3eme write
ici 2eme write end of line printf de 11259
ici 3eme write
jupiter%
Exercice 1
Donnez l'arborescence de processus créés par ce programme ainsi que l'ordre
de l'affichage des messages.
// chaine_fork_wait.c
int main()
{ int i, n=2;
pid_t fils_pid;
for(i=0; i<n;i++)
{ fils_pid = fork();
if (fils_pid > 0)
{ wait(NULL);
break;
}
}
printf(“Processus %d de pere %d\n”, getpid(), getppid());
return 0;
}
Exercice 2
Donnez, sous forme d'un arbre, les différents ordres possibles d'affichage
de messages (chaque chemin de l'arbre correspond à un ordre possible).
int main()
{ printf(“message0\n”);
if (fork())
{ printf(“message1\n”);
if (fork())
printf(“message2\n”);
else exit(0);
} else printf(“message3\n”);
return 0;
}
Ajouter une ligne de code pour forcer l'ordre d'affichage suivant :

message0; message3; message1;message2

Exercice 3
1- Donnez un code qui crée l’arbre de

processus suivant :
- PP est le processus principal (qui exécute le
code).
- Après avoir créé ses éventuels fils, chaque
processus affiche à l’écran son nom et son
pid puis se termine.
2 – Complétez le code pour que chaque père

attende la fin de ses fils avant de se terminer.
3 – Complétez le code pour que les processus

feuilles F4, F5, F6 et F7 se transforment
respectivement en : date, ls, ps et cat
fich.txt. La transformation de chaque
processus feuille est lancée juste après
l’affichage de son nom et son pid.
Annexe
Passage de paramètres à un programme
int main(int argc, const char *argv[]);
int main(int argc, const char *argv[], const char *envp[]);
Via une ligne de commande :

●  argc: nombre de paramètres sur la ligne de commande (y compris
le nom de l’exécutable lui-même)
●  argv: tableau de chaînes de caractères contenant les paramètres

de la ligne de commande.
●  envp: tableau de chaînes de caractères contenant les variables

d’environnement au moment de l’appel, sous la forme
variable=valeur

Annexe
Passage de paramètres à un programme (2)
●  int main(int argc, const char*argv[])
Via « execv » ou « execp »
●  int execv (const char* path, const char* com[])
argv ß com
●  int execl (const char* path, const char* com0,

const char* com1,…, )
argv [0] ß com0 , argv [1] ß com1, ….,

Annexe
Exemple 8 : Terminaison de processus
Les liens père /fils

Après le fork, le père
// programme exec_wait.c remplace son espace sont maintenus
#include <unistd.h> d’adressage par celui du // programme wait_child.c
#include <stdio.h> programme wait_child.c #include <unistd.h>
#include <sys/types.h> #include <stdio.h>
#include <stdlib.h> #include <stlib.h>
int main() { #include <sys/types.h>
pid_t p = fork(); #include <sys/wait.h>
if (p != 0) { int main() {
execlp("./wait_child", "./wait_child", NULL); printf("J'attends le fils\n");
printf("execlp a échoué\n"); wait(NULL);
exit(-1); printf("Le fils a terminé \n");
} else { exit(0);
sleep(5); }
printf("Je suis le fils\n");
exit(0); jupiter$ ./exec_wait
} J’attends le fils…
} Je suis le fils
Le fils a terminé
Annexe
Exemple 9 : Attente de la fin d’un processus fils
// programme parent.c // programme fils.c
#include <unistd.h> #include <stdio.h>
#include <sys/wait.h> #include <unistd.h>
#include <stdio.h> int main() {
#include <stdlib.h> printf("fils [%d]\n", getpid());
int main( ) { return 0;
int p, child, status; }
p = fork(); Le père attend
if (p == -1) la fin du fils
return -1; jupiter% gcc fils.c
if(p > 0) { /* parent */ jupiter% gcc -o parent parent.c
printf ("père[%d], fils[%d]\n", getpid(), p); jupiter% parent
if ((child=wait(NULL)) > 0) père[10524], fils[10525]
printf("père[%d], Fin du fils[%d]\n", getpid(), child); fils [10525]
printf("Le père[%d] se termine \n", getpid()); père[10524] Fin du fils[10525]
} else { /* enfant */ Le père[10524] se termine
if ((status=execl("/home/user/a.out", "a.out", NULL)) == -1) jupiter%
printf("le programme n'existe pas : %d\n",status);
else
printf("cette instruction n’est jamais exécutée\n");
Le fils change de
}
code exécutable
return 0;
} Noyau d'un système d'exploitation Ecole Polytechnique de Montréal Chapitre 2 - 47
Annexe
Exemple 10 : Remplacement d’espace d’adressage
(et errno)
1 // programme test_exec.c
2 #include <unistd.h>
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <string.h>
6 #include <errno.h>
7 int main ()
8 { char* arg[] = {"ps", "-f", NULL};
9 printf("Bonjour\n");
10 execvp("ps", arg);
11 printf("Echec de execvp\n");
12 printf("Erreur %s\n",strerror(errno));
13 return 0;
14 }

Lectures suggérées
2.1 PROCESSES et 10.3 PROCESSES IN LINUX

Modern operating Systems, 4nd edition, Andrew S. Tanenbaum, publié par
Pearson Education, Prentice-Hall, 2016. Livre disponible dans le dossier
Slides Aut 2018 du site moodle du cours.


CH 2 INF2610 Hiv 19

Transféré par

Droits d'auteur :

Formats disponibles

CH 2 INF2610 Hiv 19

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

CH 2 INF2610 Hiv 19

Transféré par

Droits d'auteur :

Formats disponibles

Noyau d'un système d'exploitation

Département de génie informatique et génie logiciel

● Qu’est ce qu’un processus ?

● États d’un processus

● Hiérarchie des processus

Génie informatique et génie logiciel

● Un processus est un programme en cours d’exécution. Il est

Génie informatique et génie logiciel

Processus A Mode kernel

interruption Sauvegarder état dans PCB A

Sauvegarder état dans PCB B

Génie informatique et génie logiciel

• Dans le cas de Linux, le PCB est une structure task_struct et la

Génie informatique et génie logiciel

Program header table

Table des pages : indique pour

Génie informatique et génie logiciel

Attente d’admission File des prêts Fin d’exécution

File des bloqués Attente d’événement

Arrivée de Attente d'un

Génie informatique et génie logiciel

attente Hors mémoire Attente

Génie informatique et génie logiciel

Ressource Ressource Attente

Dormance Bloqué Fin

Génie informatique et génie logiciel

● Les processus sont créés et détruits dynamiquement.

● Un processus peut créer un ou plusieurs processus qui, à leur tour,

● Dans certains systèmes (MS-DOS), lorsqu’un processus crée un autre

● Sous Linux/Unix/Windows, les processus créateurs et créés

● Windows ne gère pas de relation hiérarchique entre processus :

● Linux/Unix gère dynamiquement la relation hiérarchique entre

Génie informatique et génie logiciel

• Le processus 0 réalise d’autres initialisations (ex. le système de fichier)

Génie informatique et génie logiciel

● Chaque processus a un père (structure arborescente). Le processus init

● La création de processus est réalisée par duplication de l’espace

● La duplication facilite la création et le partage de ressources. Le fils

● Un processus peut remplacer son code exécutable par un autre (appel

● Un processus père peut stopper/repartir/détruire (appel système kill) ou

● L’appel système fork :

● La valeur de retour est :

● Au retour de la fonction fork, l’exécution des processus père et fils se

● Le père et le fils ont chacun un espace d’adressage privé.

Génie informatique et génie logiciel

Génie informatique et génie logiciel

jupiter% ./tfork a du père

Génie informatique et génie logiciel

- strace permet de construire l’arbre des processus créés.

Génie informatique et génie logiciel

1 // programme tree.c : appel système fork()

Génie informatique et génie logiciel

● Un processus se termine par une demande d’arrêt volontaire (exit)

• Lorsqu’un processus fils se termine :

• Les appels système wait(&status) et waitpid(pid, &status, option)

Génie informatique et génie logiciel

● Un processus peut attendre ou vérifier la terminaison d’un de ses fils :

● wait(&status) et waitpid(pid, &status, options) retournent :

● waitpid(pid, &status, WNOHANG) vérifie seulement la terminaison pas

●  Qu’est ce qu’un processus ?

●  États d’un processus

●  Hiérarchie des processus

●  Un processus est un programme en cours d’exécution. Il est

•  Dans le cas de Linux, le PCB est une structure task_struct et la

●  Les processus sont créés et détruits dynamiquement.

●  Un processus peut créer un ou plusieurs processus qui, à leur tour,

●  Dans certains systèmes (MS-DOS), lorsqu’un processus crée un autre

●  Sous Linux/Unix/Windows, les processus créateurs et créés

●  Windows ne gère pas de relation hiérarchique entre processus :

●  Linux/Unix gère dynamiquement la relation hiérarchique entre

•  Le processus 0 réalise d’autres initialisations (ex. le système de fichier)

●  Chaque processus a un père (structure arborescente). Le processus init

●  La création de processus est réalisée par duplication de l’espace

●  La duplication facilite la création et le partage de ressources. Le fils

●  Un processus peut remplacer son code exécutable par un autre (appel

●  Un processus père peut stopper/repartir/détruire (appel système kill) ou

●  L’appel système fork :

●  La valeur de retour est :

●  Au retour de la fonction fork, l’exécution des processus père et fils se

●  Le père et le fils ont chacun un espace d’adressage privé.

-  strace permet de construire l’arbre des processus créés.

●  Un processus se termine par une demande d’arrêt volontaire (exit)

•  Lorsqu’un processus fils se termine :

•  Les appels système wait(&status) et waitpid(pid, &status, option)

●  Un processus peut attendre ou vérifier la terminaison d’un de ses fils :

●  wait(&status) et waitpid(pid, &status, options) retournent :

●  waitpid(pid, &status, WNOHANG) vérifie seulement la terminaison pas

●  Après un exec, le processus conserve, notamment, son PID, l’espace mémoire

●  En cas de succès de l’appel système exec, l’exécution de l’ancien code est

●  En cas d’échec, le processus poursuit l’exécution de son code à partir de

•  Le fork duplique la table des descripteurs de fichiers du processus père.

int main(int argc, const char argv[], const char envp[]);

●  argv: tableau de chaînes de caractères contenant les paramètres

●  envp: tableau de chaînes de caractères contenant les variables

●  int main(int argc, const char*argv[])

●  int execv (const char* path, const char* com[])

●  int execl (const char* path, const char* com0,