Bonjour à tous,

Je suis en train de créer un programme sous Linux qui crée notamment des processus fils pour des traitements spécifiques.
J'ai donc un processus parent et ses fils. Je voudrais, quand un fils meurt, qu'il soit automatiquement relancé par le père. Pour cela, je comptais utiliser les signaux UNIX : à la réception de SIGCHLD, le père, via une fonction de signal handler, fait un wait et relance le processus fils via un fork.

Un truc du genre :

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
void funcHandler(int signal)
{
	if (signal == SIGCHLD)
	{
		pid_t fils = wait(NULL);
 
		if (fils == pidPremierFils)
		{
			if ((pidPremierFils = fork()) == 0)
			{
				PremierFils();
			}
		}
         }
}
Je me pose du coup ces questions :

1. A-t-on le "droit" de faire un fork dans un signal handler ? Pour le processus fils, ça change quelque chose ?
2. Si on a un premier signal (mort du premier fils), on va dans le signal handler. Par malchance, pendant ce temps, un deuxième signal arrive (mort du deuxième fils) : n'est-ce pas dangereux ? Notamment si le programme est en train de faire le fork ?
3. Du coup, pendant qu'on est dans le signal handler, vaut-il mieux bloquer les autres signaux ? Dans ce cas, les signaux seront-ils "supprimés" ou bien retardés à la fin de traitement du signal handler et donc bien capturés ?

D'une manière générale, est-ce la bonne manière de faire ? Ou alors quelle est la manière de gérer la relance de processus fils sous Linux ?

Merci d'avance.