Discussion :

[TuxThePenguin]

Bonjour,

Décidément en ce moment, je me tourne beaucoup vers vous. Je suis en train de découvrir la partie création de processus avec fork et je dois dans un exercice réaliser un programme manipulant les processus en les faisant passé dans les état zombie ou orphelin selon certaines conditions.

Voilà l'énoncé :

Écrire un programme qui engendre trois fils. Un fils rentrera dans l’état zombi et puis deviendra orphelin. Un deuxième fils deviendra orphelin avant rentrer dans l’état zombi. Un troisième fils deviendra zombi et il ne sera jamais orphelin.
.

Pour l'instant, mon code s’arrête à la boucle for me permettant de créer 3 processus. Je ne parviens cependant pas à trouver comment faire ce qui m'est demandé.
Je ne vois pas comment passer un processus dans son état zombi ou dans son état orphelin.
Pour le processus orphelin, je visualise plus ou moins ce que c'est. C'est le moment ou ce processus fils est toujours en cours d’exécution, mais n'a plus de pères.
Pour ce qui est du processus zombi, je n'arrive pas à visualiser ce que c'est malgré mettre renseigner dessus.

Pourriez-vous donc m'éclaircir sur ces processus zombie et orphelin. Dans quels cas, un processus se retrouve dans un de ces états et comment peut-on les obtenir ?

La solution à ce problème se trouve sur internet (ça a l'air d'un exercice classique des TP de système d'exploitation), mais ceci ne m'a pas pour autant permis de comprendre et je préférerais le faire par moi-même à ma façon (car il y en a surement plusieurs) afin de bien comprendre.


Merci d'avance de votre aide.

[Christophe]

Ceci devrait t'aider :

http://mtodorovic.developpez.com/lin...page=page_3#L3

[Sve@r]

Pour le processus orphelin, je visualise plus ou moins ce que c'est. C'est le moment ou ce processus fils est toujours en cours d’exécution, mais n'a plus de pères.
Pour ce qui est du processus zombi, je n'arrive pas à visualiser ce que c'est malgré mettre renseigner dessus.
Pourriez-vous donc m'éclaircir sur ces processus zombie et orphelin. Dans quels cas, un processus se retrouve dans un de ces états et comment peut-on les obtenir ?

Bonjour

Pour l'orphelin c'est exact. Tout processus est toujours généré par un autre. Cela te donne alors tout un "arbre" de processus que tu peux voir avec la commande "ptree". Il peut arriver alors que le père d'un processus disparaisse. Comme un processus ne connait que son père, (et pas son grand père), il se retrouve alors "orphelin" ne sachant plus vers qui se rattacher.

A ce moment là, 2 cas possibles

1. a la mort du père, tous les fils reçoivent un signal "hup". A ce signal, ils meurent eux-aussi (et en récursif si eux-mêmes étaient père d'autres processus)
2. certains processus ayant été lancés via la commande "nohup" ne reçoivent pas ce "hup". Dans ce cas, à la mort de leur père ils restent en vie mais ne pouvant pas demeurer sans père, ils sont alors automatiquement adoptés par init (pid=1)

Sous Unix, le comportement par défaut est le 1. Sous Linux, c'est le 2. Sous Linux, donc, le nohup devient inutile.

Un procesuss zombie c'est plus simple: c'est un processus qui est mort mais où le père ne le sait pas encore. Quand tu programmes des père-fils via fork(), tu as ensuite à ta disposition wait(int *r) qui détecte la fin d'un fils et qui stocke la raison de cette fin dans le pointeur "r". Ben tant que le père n'a pas appelé wait(), il ne sait pas que son fils est mort et le fils est donc "zombie". Sous Linux ce terme morbide a un peu évolué en "defunct".

Ce programme crée un zombie

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h> 
#include <stdlib.h>
 
int main(int argc, char *argv[]) 
{ 
	int pid;
	int r;
	if ((pid=fork()) == 0)
	{
		// Fils
		sleep(1);
		printf("\tfils %d de %d\n", getpid(), getppid());
		sleep(30);
		printf("\tmort fils %d de %d\n", getpid(), getppid());
		exit(0);
	}
	// Père
	printf("\tpère %d de %d\n", getpid(), pid);
	sleep(100);
	wait(&r);
	printf("\tpère %d de %d mort (%d)\n", getpid(), pid, r);
	sleep(100);
}

A la création il y a un père et son fils. Le fils vit 30 secondes avant de mourir donc pendant 30 secondes, en utilisant intelligemment ps -edfl | grep tu les vois tous les deux. Ensuite le fils meurt mais le père continue à attendre 70 secondes durant lesquelles le ps te montrera encore le pid du fils à l'état de defunct/zombie (selon ton os). Ensuite le père se réveille en se demandant où est son fils et là, le district attorney lui dit qu'il est crevé alors il pleure encore 100 secondes durant lesquelles le ps ne te montre plus que lui. Puis il finit sa vie lamentable.

[TuxThePenguin]

Merci chrtophe pour ton lien où le cours est très bien fait et merci sve@r pour tes explications sur le processus zombi.

Si j'ai bien compris en reprenant la consigne de mon exercice, pour le premier processus qui doit passer à l’état zombi puis orphelin, il suffit de ne pas utiliser wait afin d'informer au père la mort du fils, mais de le tuer directement. Si je tue le père après le processus fils, ce dernier sera donc zombi puis orphelin, mais une fois le père mort, vus que wait ne sera pas utiliser, il sera encore zombi non ? Il apparaîtra donc toujours à la fin de la liste des processus sous l'état Z en faisant un ps aux.

Pour le cas du second processus, je ne comprends pas comment un processus peut devenir zombi alors qu'il est orphelin. Il faudrait tuer le père juste après avoir fait le wait non ? Mais dans ce cas-là le processus fils étant déjà terminé, il ne peut donc pas être orphelin.

Pour le troisième cas, c'est celui qui reprend l'exemple du processus zombi que sve@r a mit ou celui du cours posté par chrtophe.

Je vais donc déjà coder les cas du premier processus et du troisième que je visualise comment faire. Pour le second, je suis un peu bloqué par contre.

[Christophe]

Pour résumer :

L'arrêt d'un processus père va déclencher l'arrêt de ses fils. C'est le principe, car un programme bien fait devrait attendre la fin de tous ses fils pour s'arrêter. En cas de dérogation à cela voir le post de Sver.

Pourquoi un état de processus Zombie existe ? car il n'est pas à la charge d'un processus de s'auto-détruire, mais à son père. Quand un processus se termine, il passe en zombie. Il restera en zombie tant que :

- son père étant averti le détruise
- qu'il soit adopté par init car orphelin

En fonctionnement normal, un processus ne reste pas suffisamment longtemps zombie pour qu'on le voit. L'état de Zombie permet donc de gérer le deuil du père, que le système puisse gérer un problème de processus mort mais non normalement supprimé.

Remarque : un processus orphelin, c'est pas normal, cela vient soit d'un crash du père, soit d'une mauvaise gestion ou non utilisation de wait/waitpid.

La remarque de Sver sur la différence de comportement entre Unix et Linux est intéressante. Sous Linux, un processus orphelin continuera à fonctionner par défaut alors que sous Unix, c'est au choix. Les 2 cas de figures peuvent être un avantage ou un inconvénient selon la situation.

@Sver : petite question : c'est qu'un comportement par défaut ? Je suppose que sous Linux a également le choix ...

[Sve@r]

@Sver : petite question : c'est qu'un comportement par défaut ? Je suppose que sous Linux a également le choix ...

C'est ce que j'ai remarqué de nombreuses fois. Facile à vérifier d'ailleurs ; te suffit de lancer un sleep 5000 & puis de fermer le shell qui l'a lancé. Tu verras alors ensuite ton sleep rattaché au init.
C'est vrai que ce serait plus logique de pouvoir choisir le comportement à adopter mais je n'ai jamais ni cherché, ni trouvé l'option qui permette ça. Ceci dit il existe plein d'options bash. Par exemple en bash par défaut, une variable ne sort pas d'un sous-processus. Exemple i=0; cat /etc/passwd |while read lig; do i=$((i+1)); echo $i; done; echo $i. En bash normal, on aura 0 à la fin (le i a été incrémenté dans le pipe et il est perdu en fin de pipe) mais on peut demander une option spéciale (sais plus laquelle) qui fait que le i est actualisé en dehors du pipe. Peut-être qu'on peut aussi demander une option spéciale qui implémente l'envoi automatique du SIGHUP aux fils à la mort du père...

[Christophe]

Le truc m'ayant intrigué, j'ai cherché un peu sur le net.

Quand un processus se termine (je parle d'un arrêt normal), celui-ci appelle la fonction noyau exit_notify(), qui est chargé d'envoyer un signal au père, de transmettre les processus enfants à init, puis de se placer en TASK_ZOMBIE, puis appelle l’ordonnanceur.

D''après ce que j'ai compris, quand le père reçoit le signal de fin de process de son fils concerné,soit il le gère soit il notifie au noyau qu'il s'en fout. Je présumes donc que la task_struct n'est pas libérée si ce signal n'est pas traité et reste donc en zombie, occupant l'espace mémoire de la task_struct et probablement ses piles.Si le processus est orphelin, init devenant son père, c'est lui qui recevra la notification de passage en zombie et enverra le signal au noyau. Ces entrées zombie ont un sens pour gérer la fin des processus petit-fils si il y en a, car ceux-ci ne connaissent pas leur grand-pères.

@Sver :
Quand au signal SIGHUP, c'est un signal signifiant que le terminal contrôlant le processus est fermé.

Du coup, si il y a une différence entre Unix et Linux, je me demande si c'est pas plus lié à la gestion de signaux par le shell qu'au système lui-même. Donc l'esperluette détachant la commande du terminal, le signal SIGHUP ne doit pas être géré. Sais-tu si l'esperluette c'est valable pour tous les shells ? j'ai testé avec csh ça fonctionne.