Processus Linux. Structure, états et attributs d'un processus Linux. Structure. Etats d un processus Linux

Transcription

1 1 Processus Linux La structure d un système tel que Linux repose sur le fait que tout processus Linux peut créer un autre processus. Le processus créateur est qualifié de père tandis que le processus créé est qualifié de fils. Nous décrivons ci-dessous la structure d un processus Linux ainsi que les opérations permettant de créer et détruire un tel processus, et les relations entre processus créateur (père) et processus créé (fils). Structure, états et attributs d'un processus Linux Structure Chaque processus Linux est représenté par un bloc de contrôle (structure task_struct définie dans le fichier linux/sched.h) alloué dynamiquement par le système au moment de la création du processus. Le bloc de contrôle contient tous les attributs permettant de qualifier et de gérer le processus. L'ensemble des blocs de contrôle est repéré depuis une table des processus (structure task[0..nrtask] définie dans le fichier kernel/sched.c), chaque entrée contenant un pointeur vers un bloc de contrôle. Par ailleurs, l'ensemble des blocs de contrôle est également inclus dans une liste doublement chaînée. Le premier élément du tableau task, qui représente également la tête de la liste doublement chaînée, correspond toujours au premier processus créé par le système au moment du boot. Ce processus ne s'exécute que lorsque aucun autre processus n'est prêt. Les informations contenues dans le bloc de contrôle concernent: l état du processus ainsi que les informations d ordonnancement (quanta d exécutions, priorités et chaînage dans les files d ordonnancement); l identifiant du processus encore appelé PID; l identifiant du père du processus (PPID) (c est-à-dire le processus à partir duquel le processus a été créé); les outils de communication utilisés par le processus tels que les sémaphores et les signaux; le contexte mémoire du processus; le contexte processeur du processus; les temps d exécutions du processus en mode utilisateur et en mode superviseur ainsi que ceux de ses fils. Etats d un processus Linux Un processus Linux évolue entre deux modes au cours de son exécution: le mode utilisateur qui est le mode classique d'exécution et le mode noyau qui est le mode dans lequel se trouve un processus élu passé en mode superviseur, un processus prêt ou un processus bloqué (endormi). Plus précisément, un processus Linux peut passer par les états suivants : TASK_RUNNING: le processus est dans l'état prêt ou dans l'état élu;

2 2 TASK_INTERRUPTIBLE et TASK_UNINTERRUPTIBLE: le processus est dans l'état bloqué; TASK_ZOMBIE: le processus a terminé son exécution mais son bloc de contrôle existe toujours car son père n a pas pris en compte sa terminaison. Principaux attributs Chaque processus Linux est caractérisé par un numéro unique appelé PID (entier non signé de 32 bits) qui lui est attribué par le système au moment de sa création. Chaque nouveau processus reçoit comme valeur de PID, la dernière valeur attribuée lors de l opération de création précédente augmentée de 1. Par ailleurs, chaque processus Linux pouvant créer lui-même un autre processus, chaque processus est également caractérisé par l'identifiant du processus qui l'a créé (son père), appelé PPID. Les primitives données ci-dessous permettent à un processus respectivement de connaître la valeur de son PID, du PID de son père. #include <unistd.h> pid_t getpid(); retourne le PID du processus appelant. pid_t getppid(); retourne le PPID du processus appelant. Exemple : pid_t ret ; -- déclaration variable ret de type pid_t ret = getpid() ; Création d'un processus Linux Sous le système Linux, tout processus peut créer un nouveau processus qui est une exacte copie de lui-même. Le processus créateur est appelé «le père» et le processus créé est appelé «le fils». Il découle de cette possibilité la formation d une arborescence de processus, reliés entre eux par des liens de filiation. La primitive fork() permet la création dynamique d'un nouveau processus qui s'exécute de manière concurrente avec le processus qui l'a créé. Tout processus Linux hormis le processus 0 est créé à l'aide de cette primitive. Le processus créateur (le père) par un appel à la primitive fork() crée un processus fils qui est une copie exacte de luimême (code et données). Le prototype de la fonction est le suivant: #include <unistd.h> pid_t fork (); Lors de l'exécution de la primitive fork(), si les ressources noyaux sont disponibles, le système effectue les opérations suivantes (primitive do_fork du noyau): le système alloue un bloc de contrôle pour le nouveau processus et trouve une entrée libre dans la table des processus pour ce nouveau bloc de contrôle; le système copie les informations contenues dans le bloc de contrôle du père dans celui du fils sauf les informations concernant le PID, le PPID; le système alloue un PID unique au nouveau processus;

3 3 le système duplique pour le processus fils le contexte mémoire du processus parent c est-à-dire le code, les données, et la pile; l état du nouveau processus est mis à la valeur TASK_RUNNING; le système retourne au processus père le PID du processus créé et au nouveau processus (le fils) la valeur 0. Lors de cette création le processus fils hérite de tous les attributs de son père sauf: l'identificateur de son père; son propre identificateur; les temps d'exécution du nouveau processus sont à nuls. A l'issue de l'exécution de la primitive fork(), chaque processus, le père et le fils, reprend son exécution après le fork(). Le code et les données étant strictement identiques, il est nécessaire de disposer d'un mécanisme pour différencier le comportement des deux processus après le fork(). On utilise pour cela le code retour du fork qui est différent chez le fils (toujours 0) et le père (PID du fils créé). Ainsi, dans le programme donné ci-dessous, le processus n est le processus père. Le processus n est le processus fils créé par le processus n à l'issue de l'appel à la primitive fork(). Une fois la primitive fork() exécutée par le père, les deux processus (le père et le fils) reprennent leur exécution de manière concurrente. Le processus fils a pour retour de la primitive fork() la valeur 0. Il va donc exécuter la partie de l'alternative pour laquelle (if pid == 0) est vrai (code en jaune). Le processus père au contraire a pour retour de la primitive fork() la valeur du PID du processus créé c'est-à-dire une valeur positive (code en bleu). Il va donc exécuter l'autre partie de l'alternative. Les traces générées par cette exécution sont par exemple 1 : je suis le fils; mon pid est je suis le père; mon pid est pid de mon fils, pid de mon père, /*******************************************************/ /* Création d'un processus fils */ /*******************************************************/ #include <stdio.h> #include <stdlib.h> #include <unistd.h> main () { pid_t ret; ret = fork(); if (ret == 0) { -- code exécuté par le fils affiche(" je suis le fils; mon pid est", getpid()); affiche ("pid de mon père,", getppid()); else { -- code exécuté par le père 1 L ordre des traces dépend de l ordonnancement réalisé par le système et de l ordre d exécution des deux processus père et fils.

4 4 affiche ("je suis le père; mon pid est ", getpid()); affcihe ("pid de mon fils, ", ret); Le schéma ci-dessous illustre l arborescence de processus créés avec le même code couleur pour identifier les parties de code exécutées par chaque processus. Terminaison d un processus et synchronisation avec son père Terminaison d'un processus Un processus termine normalement son exécution en achevant l exécution du code qui lui est associé. Cette terminaison s effectue par le biais d un appel à la primitive exit(). Le prototype de la fonction exit() est le suivant: #include <stdlib.h> void exit (); Lors de la terminaison d un processus, le système désalloue les ressources encore possédées par le processus mais ne détruit pas le bloc de contrôle de celui-ci, passe l état du processus à la valeur TASK_ZOMBIE puis avertit le processus père de la terminaison de son fils, Un processus fils défunt reste zombie jusqu'à ce que son père ait pris connaissance de sa mort. Un processus fils orphelin, suite au décès de son père (le processus père s'est terminé avant son fils) est toujours adopté par le processus numéro 1 (Init) et non par son grand-père. Synchronisation avec le père

5 5 Un processus père peut se mettre en attente de la mort de l un de ses fils, par le biais de la primitives wait(). Lorsque le processus père prend connaissance de la mort de l un de ses fils, il cumule les temps d exécution en mode utilisateur et en mode superviseur de ce fils avec ceux des fils précédemment décédés, puis il détruit le bloc de contrôle du processus fils. Le prototype de la fonction wait() est le suivant: #include <sys/wait.h> pid_t wait (); L exécution du processus père est suspendue jusqu à ce qu un processus fils se termine. Un exemple /*******************************************************/ /* Terminaison du processus fils et affichage de sa */ /* valeur de retour */ /*******************************************************/ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> main () { pid_t ret,fils_mort; int status; ret = fork(); -- creation du processus fils if (ret == 0) { -- code exécuté par le fils affiche(" je suis le fils; mon pid est ", getpid()); affiche ("pid de mon père", getppid()); exit(); -- le fils se termine else { -- code exécuté par le père affiche ("je suis le père; mon pid est", getpid()); affiche ("pid de mon fils", ret); fils_mort = wait(); -- le père attend la fin de son fils affiche ("je suis le père; le pid de mon fils mort est ", fils_mort); Les traces d exécution de ce programme exécutable de nom essai sont par exemple: bash > essai je suis le père; mon pid est 4243 je suis le fils; mon pid est 4244 pid de mon père, 4243 pid de mon fils, 4244

6 6 je suis le père; le pid de mon fils mort est 4244 La commande ps l permettant d afficher les caractéristiques de l ensemble des processus de l utilisateur donne les éléments suivants: F PID PPID CMD bash -- père de essai essai -- père essai essai -- fils essai ps Les champs PID, PPID et CMD codent respectivement la valeur du PID et du PPID pour le processus et le nom du programme exécuté. De cela on déduit le graphe de processus suivant : bash (interpréteur shell) de PID 580 est le père du processus essai père de PID 4243, lui-même père du processus fils essai de PID 4244.

7 7 Exercice BONUS Processus Linux Soit le programme essai.c suivant: #include <stdio.h> main() { int pid; pid = fork(); if (pid == 0) {for(;;) -- boucle infinie affiche ("je suis le fils\n"); else {for(;;) boucle infinie affiche("je suis le père\n"); Question 1 On compile ce programme pour générer un exécutable appelé essai dont on lance l exécution. La commande ps l permettant d afficher les caractéristiques de l ensemble des processus de l utilisateur donne les éléments suivants: F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD 100 S wait4 pts/1 00:00:00 bash 100 S wait4 pts/2 00:00:00 bash 000 S down_f pts/2 00:00:01 essai 040 S write_ pts/2 00:00:01 essai Les champs S, PID, PPID et CMD codent respectivement l'état du processus (S pour Stopped, R pour Running, Z pour Zombie), la valeur du PID et du PPID pour le processus et le nom du programme exécuté. A/ Donnez le graphe de filiation des processus listés par le commande ps. B/ On tape la commande kill qui entraîne la terminaison du processus dont le pid 593 est spécifié en argument. L exécution de la commande ps l donne à présent le résultat suivant. Quel est l état du processus 593. Pourquoi? F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD 100 S wait4 pts/1 00:00:00 bash 100 S wait4 pts/2 00:00:00 bash 000 S write_ pts/2 00:00:03 essai 444 Z do_exi pts/2 00:00:03 essai <zombie> 100 R pts/1 00:00:00 ps Question 2 On lance de nouveau l exécution du programme essai. La commande ps l permettant d afficher les caractéristiques de l ensemble des processus de l utilisateur donne les éléments suivants:

8 8 F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD 100 S wait4 pts/1 00:00:00 bash 100 S wait4 pts/2 00:00:00 bash 000 S write_ pts/2 00:00:00 essai 040 S down_f pts/2 00:00:00 essai 100 R pts/1 00:00:00 ps A/ Donnez le graphe de filiation des processus listés par le commande ps. Que remarquez vous sur les valeurs des PID? Comment l expliquez vous? B/. On tape la commande kill qui entraîne la terminaison du processus dont le pid 604 est spécifié en argument. L exécution de la commande ps l donne à présent le résultat suivant. Qui est le nouveau père du processus 605. Pourquoi? F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD 100 S read_c tty5 00:00:00 mingetty 100 S read_c tty6 00:00:00 mingetty 100 S read_c pts/0 00:00:00 cat 100 S wait4 pts/1 00:00:00 bash 100 S wait4 pts/2 00:00:00 bash 100 S read_c pts/2 00:00:00 bash 040 S write_ pts/2 00:00:02 essai 100 R pts/1 00:00:00 ps