Discussion :

[Baradhur]

Bonjour a tous!

Je suis en train d'essayer de mettre sur pied un programme qui me permettra de lancer d'autres programmes, et de contrôler leur terminaisons. Tout ca dans le but de contrôler leurs exécutions, et de pouvoir les relancer si jamais ils plantent. Et je me demande comment faire ca efficacement.

Concrètement, j'ai mon programme principale (appeler le watchdog) qui va faire 3 fork suivi de 3 exec pour lancer 3 programmes indépendants les un des autres. Jusque la, rien de bien compliquer.

Par contre, je ce que j'aimerais maintenant, c'est d'avoir une gestion des retours de mes fork une fois qu'ils se terminent (avec des waitpid etc). En sachant qu'ils ne sont pas censés se terminer tant qu'on leur dit pas.
Et je voudrais donc, au final, que mon watchdog puissent savoir lequel de ces fork s'est terminer, pour savoir exactement quel fork/exec je dois rappeler pour relancer la partie qui a planter.

Le but est de pouvoir tenir le programme (qui contient 3 processus) actif le plus longtemps possible, et de relancer les processus qu'il faut quand ils plantent.

Comment faire pour pouvoir avoir cette gestion sélective des retour de fork? Faire dormir ce processus sans consommer de ressource, mais pouvoir relancer le plus rapidement possible le bon fork qui contient le bon exec des qu'il y a un probleme.

Je sais qu'il y quelquechose a faire avec waitpid(), mais comment faire pour que le pere puisse lancer ces 3 fils avant d'etre bloquer sur un wait? Et consommer le moin de ressource possible?


Merci d'avance pour vos reponses!

[piemur2000]

Je pense que ton idée de base est bonne. Faire des fork et des waitpid après coup. Dès que le processus fils se termine waitpid va retourner et la tu peux faire le traitement que tu veux = relancer le processus qui a planté.
Pour attendre le retour de n'importe quel fils il faut utiliser:

Code :

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

waitpid(-1, &status, 0);

ou plus simplement:

Code :

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

wait(&status);

http://linux.die.net/man/2/waitpid

[Baradhur]

Le probleme que j'ai avec ca, c'est que le waitpid met le processus pere en attente. Et donc je me retrouve avec un pere en attente de la fin du 1er (qui est pense pour ne pas s'arreter) et le 2eme ou 3eme processus par encore lancer. Il faut que je sois sur que les 3 fork soit bien executes, et que je puisse les identifier a leur retour.

Ca donnerait quelque choe comme ca:

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
24
25
26
27
28
29
30
31
32
int lancerlexec1()
{
int pid1 = fork();
if (pid1 == 0)
      exec(..);
else
  return pid1;
}
 
int lancerlexec2()
{
int pid2 = fork();
if (pid2 == 0);
     exec(...);
else
  return pid2;
}
 
int main()
{
int pid1 = lancerfork1();
int pid2 = lancerfork2();
 
while ( 42)
{
waitpid(pid1, ...);
if (retour du pid1)
  pid1 = lancerlexec1();
waitpid(pid2, ...);
if (retour du pid2)
   pid2 = lancerlexec2();
}

Ce serait un truc dans ce gout auquel j'aimerais arrive. Mais je suis pas sur de bien savoir comment y arriver!

[piemur2000]

Comme j'ai dit précédemment il faut utiliser wait(&status); qui attends la fin de l’exécution de n'importe lequel des processus fils.

Ca donnerait quelque chose comme ca:

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
24
25
26
 
....
 
int main()
{
    int status;
    int pid1 = lancerfork1();
    int pid2 = lancerfork2();
 
    while (true)
    {
        int crashedPid = wait(&status);
        if (crashedPid == pid1)
        {
            pid1 = lancerlexec1();
        }
        else if (crashedPid == pid2)
        {
            pid2 = lancerlexec2();
        }
        else 
        {
            // Gestion d'erreur
        }
    }
}

Tu peux en plus essayer de comprendre pourquoi ton processus s'est arrêté grâce au status remplit par wait. Je t'ai donné le manpage des fonction wait et waitpid dans mon message précédent, tout est détaillé et tu as même des exemples d'utilisation.

[Baradhur]

Ha we, c'est pas bete comme ca! J'ai deja utilise plusieurs fois le remplissage du status pour debugger de programmes, donc ca pas de soucis. Mais faire ca avec un simple wait comme ca, je pensais pas que ca pourrais passer aussi simplement.


Juste pour etre sur, une derniere petite question:

Est ce que le fait de mettre un wait comme ca, ca peut creer un conflit dans le cas ou le pere arrive sur le wait avant d'avoir fini de lancer correctement les fork? Je ne voudrais pas me retrouver avec un resultats aleatoire sur les exec que j'aurais eu le temps de faire avant de mettre le pere en wait.

Merci de tes reponses tres clair en tout cas!

[piemur2000]

Non, aucun problème avec les fork. La fonction ne retourne qu'une fois que le processus fils est créé. Du coup aucun problème avec wait.

Par contre si tu veux faire un watchdog je te conseil de t'inspirer de la manière dont fonctionne les watchdog hardware. En effet un processus peut etre bloqué dans un état non correct sans pour autant se terminer. La meilleure solution est d'envoyer régulièrement un message au watchdog pour signaler que tout se passe bien. Si le watchdog ne reçoit pas de message le watchdog peut arrêter le processus et le redémarrer. Bien sur cela implique d'avoir un contrôle sur les processus que tu lance.

[Baradhur]

Comment est ce que je peux envoyer un signal a mon processus pere a partir de mon processus que j'ai exec? Sinon, c'est effectivement une remarque pertinente!

[Emmanuel Deloget]

Comment est ce que je peux envoyer un signal a mon processus pere a partir de mon processus que j'ai exec? Sinon, c'est effectivement une remarque pertinente!

man 2 kill

kill(pid, sig) te permets d'envoyer un signal quelconque au processus choisi.

[Baradhur]

Hum on est obliger de passer par kill? Y'a pas quelque chose de plus specifique pour la communication entre processus pere/fils?

Sinon, merci beaucoup pour toute l'aide que tu m'apporte, je t'en suis reconnaissant!

[Emmanuel Deloget]

Hum on est obliger de passer par kill? Y'a pas quelque chose de plus specifique pour la communication entre processus pere/fils?

Sinon, merci beaucoup pour toute l'aide que tu m'apporte, je t'en suis reconnaissant!

Le processus fils est un processus comme les autres ; il ne crée par de canal particulier avec son père qui permettrait de lui passer des informations.

Maintenant, si tu as un contrôle complet sur le code source du processus fils, tu peux tenter d'utiliser les sémaphores POSIX ou tout autre mécanisme de communication inter-process.

[Baradhur]

Ok tres bien! Je vais utiliser des messages queue alors. Merci pour toutes ces informations Ca m'a bien aide!

[piemur2000]

La solution dont je parlais suppose en effet que tu puisse modifier le code du processus fils. A partir de ce moment il est possible d'utiliser un pipe (par exemple) pour envoyer des messages du fils au père.

La commande kill permet simplement d'envoyer un signal à un processus. Par défaut cette commande envoie le signal SIG_KILL qui "tue" le processus mais elle peut être utilisé pour envoyer beaucoup d'autres signaux.

Man page de la commande: http://linux.die.net/man/2/kill
Liste des signaux: http://www.linuxplusvalue.be/mylpv.php?id=185

Mais de toute façon, si tu ne peux pas modifier le code des processus fils, il tu ne peux rien faire de plus que le wait et de relancer les processus qui se terminent.