Ce document décrit le fonctionnement des processus sous Linux, notamment la fonction fork() qui permet de dupliquer un processus père en un processus fils. Il explique comment le père et le fils coexistent de manière concurrente après le fork, et les mécanismes de synchronisation entre eux comme la fonction wait().
0 évaluation0% ont trouvé ce document utile (0 vote)
66 vues7 pages
Ce document décrit le fonctionnement des processus sous Linux, notamment la fonction fork() qui permet de dupliquer un processus père en un processus fils. Il explique comment le père et le fils coexistent de manière concurrente après le fork, et les mécanismes de synchronisation entre eux comme la fonction wait().
Ce document décrit le fonctionnement des processus sous Linux, notamment la fonction fork() qui permet de dupliquer un processus père en un processus fils. Il explique comment le père et le fils coexistent de manière concurrente après le fork, et les mécanismes de synchronisation entre eux comme la fonction wait().
Ce document décrit le fonctionnement des processus sous Linux, notamment la fonction fork() qui permet de dupliquer un processus père en un processus fils. Il explique comment le père et le fils coexistent de manière concurrente après le fork, et les mécanismes de synchronisation entre eux comme la fonction wait().
Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
Télécharger au format pdf ou txt
Vous êtes sur la page 1/ 7
Comprendre les processus en C sous linux
Programmation Système - Fork
Introduction Un fork est une fonctionnalité sous les systèmes Unix ou Linux qui permet de dupliquer un processus. Pour expliquer son fonctionnement, on va partir d'un processus qu'on appellera avec affection "Le Papa". Ce processus va simplement se dupliquer et les deux processus (le père et le fils) affichent chacun leur statut (père ou fils).
Lancement du père Nous allons partir d'un processus père. Afin de bien déterminer les enjeux du fork, on va également observer ses descripteurs de fichiers, ou plutôt l'un des plus importants: celui du flux de sortie (stdout) c'est-à-dire l'écran. On va aussi lui mettre une petite variable globale qui servira plus tard pour l'affichage du statut du processus (père ou fils).
Voici à quoi va ressembler notre processus de départ:
La flèche rouge pointe vers la prochaine instruction à exécuter.
Comme on n'a encore rien exécuté, on en est au début du main. On va donc exécuter les deux premières instructions:
On peut voir en rouge les instructions qui ont été exécutées, ainsi que les données qui ont été modifiées par la dernière instruction. Jusqu'ici tout va bien, on a changé la valeur de quisuisje pour lui attribuer l'identité du père. Passons à l'instruction suivante.
Le fork La prochaine instruction est la plus délicate à comprendre, exécutons-la et regardons ce qui se passe. Le père a appelé fork et il s'est dupliqué. Cela implique plusieurs choses:
● Un nouveau processus a été créé, il est considéré comme le fils du processus qui a appelé fork() ● Ce processus est une copie conforme de son père. D'ailleurs, la prochaine instruction à exécuter sera la même pour les deux : la condition if. ● La fonction fork() ne retourne pas la même chose pour les deux processus. Pour le fils, il retournera 0. Pour le père, il retourne le pid du fils (son numéro de processus). ● Cette duplication implique certaines choses concernant les variables et les descripteurs de fichiers. Nous allons y venir.
Passons à l'instruction suivante
pour les deux.
Maîtriser le fil d'exécution du
père et celui du fils
Les deux processus viennent de
vérifier la condition if. Etant donné que chez le père, la variable pid est différente de 0, il continuera dans le else. Par contre, le fils entrera dans le bloc du if car, pour lui, pid est égal à 0.
Important: C'est donc ainsi qu'on
maîtrise le fil d'exécution du père et celui du fils: en vérifiant la valeur de la variable pid qui est différente pour les deux.
On continue. Les variables et les descripteurs de fichiers
Attention ici c'est un point à ne pas
manquer!
-Le fils a changé la valeur de sa variable
quisuisje. Ceci a changé la valeur de sa propre variable quisuisje, mais pas celle du père. Voici donc notre première conclusion: les variables du père et celles du fils sont totalement distinctes ; même si elles portent le même nom, il ne s'agit pas des mêmes variables. En revanche, vous aurez remarqué qu'au moment du fork, le fils avait hérité des valeurs de toutes les variables de son père.
-Le père vient de faire un printf et a donc
écrit "Je suis Le pere" sur le flux de sortie standard (stdout). Donc, après cette écriture, le pointeur du fichier stdout a avancé de 15 caractères (la longueur de la phrase affichée). Avez-vous remarqué qu'il en était de même chez le fils? En effet, si le père et le fils ont des variables distinctes, en revanche, leur descripteurs de fichiers sont les mêmes. Donc, si l'un des deux processus modifie son pointeur de position dans un fichier, ça se répercutera également chez l'autre. Attention, cela ne vaut que pour les descripteurs de fichiers hérités durant le fork. Si le père ou le fils ouvre d'autres fichiers après le fork, ces descripteurs ne seront pas partagés entre eux deux. De même, si le fils ferme un descripteur de fichier hérité du père, le descripteur de fichier du père ne sera par contre pas fermé (même chose dans le sens inverse).
La synchronisation ● Côté fils: un printf a été fait, cette fois pour afficher "Je suis Le fils". Le pointeur de fichier a donc avancé de 15 chez le fils, ce qui se répercute chez le père. ● Côté père: le père a exécuté la fonction wait(). Cette fonction permet la synchronisation entre le père et tous ses fils. Cela signifie que le père va arrêter de s'exécuter (dans ce cas on dit qu'il dort) jusqu'à ce que son fils se termine complètement.
La fin
Le fils vient d'exécuter sa dernière instruction ; à présent, il n'existe plus. Pendant ce temps-là, le père était encore en attente, mais il va bientôt se réveiller puisque le fils est terminé. Enfin, le père se terminera lui aussi.
Création d'un Processus
Règle d'Or : tout processus UNIX peut créer un ou plusieurs processus. Donc pour créer un processus nouveau, il en faut déjà un existant ... qui va être cloné, puis spécialisé. Il y a donc une filiation entre les processus ! Primitives
PID Courant : pid_t getpid(void); Retourne le pid du processus courant (appelant)
PID du Père pid_t getppid(void); Retourne le pid du père du processus courant (appelant)
Suspension : int sleep (int nb_sec); sleep endort le processus jusqu'à ce que nb_sec secondes se soient écoulées, ou jusqu'à ce qu'un signal non-ignoré soit reçu.
int usleep (int nb_msec);usleep endort le processus jusqu'à ce que nb_msec
micro-secondes se soient écoulées, ou jusqu'à ce qu'un signal non-ignoré soit reçu.
Création de processus : pid_t fork(void); Permet la création dynamique d’un nouveau
processus (fils). par duplication du processus courant (père). Le processus fils ne diffère du processus père que par les pid et ppid. Les 2 processus (père et fils) s’exécutent de manière concurrente !
Retourne un entier : En cas de succès: 0 dans le fils et pid du fils dans le père En cas d’échec : -1 dans le père et le fils n’est pas créé La valeur retournée par fork permet donc de faire la distinction entre le père et le fils !
Bibliothèques :
#include <sys/types.h>
#include <unistd.h> Exemple basique int main(void) { pid_t pid; pid = fork(); if (pid == 0) printf(" Je suis le FILS "); else printf(" Je suis le PERE "); return 0; }
Après fork : ● allocation d’une entée dans la table des processus au nouveau processus ● allocation d ’un pid au nouveau processus ● duplication du contexte du processus père (données, pile…) ● retour du pid du processus fils à son père et 0 au processus fils
Synchronisation (les Primitives)
Exit : void exit(int status);
– termine le processus appelant. – transmet la valeur de status (le mot d’état) au processus père – ferme les descripteurs de fichiers ouverts – un signal SIGCHLD est envoyé au processus père.
Wait pid_t wait(int *status);
– attend la terminaison ou l'arrêt d'un processus fils (fils quelconque). – retourne le PID d'un processus terminé, -1 en cas d’erreur (si tous sont déjà terminés). – stocke la valeur transmise par le fils (exit) dans l'entier pointé par status. Exemple complet
Dans le ==père== (PID supposé : 1234) : Dans le ==fils== (PID supposé : 2345):
int main(void) int main(void)
{ int pid, status; { int pid, status; pid = fork(); pid = fork(); if (pid == 0) { if (pid == 0) { printf(" Je suis le fils"); printf(" Je suis le fils"); exit(3); exit(3); } else { } else { printf(" Je suis le pere "); printf(" Je suis le pere "); printf(" j ’attends la fin printf(" j ’attends la fin de de mon fils); mon fils); wait(&status); wait(&status); printf(" status = %d printf(" status = %d ",status>>8); ",status>>8); } } return 0; return 0; } }
Affichages :
Je suis le fils Je suis le pere j ’attends la fin de mon fils status = 3
On ne peut pas prédire l'ordre des 3 premiers printf. Par contre on sait forcément que l'affichage du status se fera en dernier !
● Lorsqu’un processus se termine (exit), le système détruit son contexte, sauf son entrée de la table des processus ● Le procesus est alors dit dans un état ZOMBI (momentané si bien codé) ● Le processus père récupère la mort de son fils (wait), et détruit son entrée de la table des processus. ● Le fils disparaît complètement du système (n’est plus zombi).
La communication entre le fils zombi et le père s ’effectue par le biais d ’un signal transmis du fils vers le père (signal SIGCHLD : la mort du fils). Un processus fils défunt reste zombie jusqu’à ce que son père ait pris connaissance de sa mort (wait).
