Comment faire mourir le processus de l'enfant après la sortie des parents?

Supposons que j'ai un processus qui engendre exactement un processus enfant. Maintenant, lorsque le processus parent se termine pour une raison quelconque (normalement ou anormalement, par kill, ^ C, affirmer l'échec ou toute autre chose), je veux que le processus enfant meure. Comment faire ça correctement?

Une question similaire sur stackoverflow:

• (demandé plus tôt) Comment puis-je provoquer la fermeture d'un processus enfant lorsque le parent le fait?
• (demandé plus tard) Les processus enfants créés avec fork () sont-ils automatiquement supprimés lorsque le parent est tué?

Une question similaire sur stackoverflow pour Windows :

• Comment détruire automatiquement les processus enfants dans Windows?
• Tuer le processus enfant lorsque le processus parent est tué

L'enfant peut demander au noyau de fournir SIGHUP(ou un autre signal) lorsque le parent décède en spécifiant l'option PR_SET_PDEATHSIGdans prctl()syscall comme ceci:

prctl(PR_SET_PDEATHSIG, SIGHUP);

Voir man 2 prctlpour plus de détails.

Edit: Ceci est uniquement Linux

J'essaie de résoudre le même problème, et puisque mon programme doit fonctionner sur OS X, la solution Linux uniquement ne fonctionnait pas pour moi.

Je suis arrivé à la même conclusion que les autres personnes sur cette page - il n'y a pas de moyen compatible POSIX d'avertir un enfant quand un parent décède. J'ai donc jeté un coup d'œil à la prochaine meilleure chose - avoir le sondage des enfants.

Lorsqu'un processus parent meurt (pour une raison quelconque), le processus parent de l'enfant devient le processus 1. Si l'enfant interroge simplement périodiquement, il peut vérifier si son parent est 1. Si tel est le cas, l'enfant doit quitter.

Ce n'est pas génial, mais cela fonctionne, et c'est plus facile que les solutions d'interrogation de socket / fichier de verrouillage TCP suggérées ailleurs sur cette page.

J'ai réalisé cela dans le passé en exécutant le code "original" dans "l'enfant" et le code "engendré" dans le "parent" (c'est-à-dire: vous inversez le sens habituel du test après fork()). Puis piéger SIGCHLD dans le code "engendré" ...

Peut-être pas possible dans votre cas, mais mignon quand cela fonctionne.

Si vous ne parvenez pas à modifier le processus enfant, vous pouvez essayer quelque chose comme ceci:

int pipes[2];
pipe(pipes)
if (fork() == 0) {
    close(pipes[1]); /* Close the writer end in the child*/
    dup2(0, pipes[0]); /* Use reader end as stdin */
    exec("sh -c 'set -o monitor; child_process & read dummy; kill %1'")
}

close(pipes[0]); /* Close the reader end in the parent */

Cela exécute l'enfant à partir d'un processus shell avec le contrôle des travaux activé. Le processus enfant est généré en arrière-plan. Le shell attend une nouvelle ligne (ou un EOF) puis tue l'enfant.

Lorsque le parent décède - quelle qu'en soit la raison - il ferme son extrémité du tuyau. Le shell enfant obtiendra un EOF de la lecture et procédera à la suppression du processus enfant en arrière-plan.

Sous Linux, vous pouvez installer un signal de mort parentale chez l'enfant, par exemple:

#include <sys/prctl.h> // prctl(), PR_SET_PDEATHSIG
#include <signal.h> // signals
#include <unistd.h> // fork()
#include <stdio.h>  // perror()

// ...

pid_t ppid_before_fork = getpid();
pid_t pid = fork();
if (pid == -1) { perror(0); exit(1); }
if (pid) {
    ; // continue parent execution
} else {
    int r = prctl(PR_SET_PDEATHSIG, SIGTERM);
    if (r == -1) { perror(0); exit(1); }
    // test in case the original parent exited just
    // before the prctl() call
    if (getppid() != ppid_before_fork)
        exit(1);
    // continue child execution ...

Notez que le stockage de l'ID de processus parent avant le fork et le test dans l'enfant après prctl()élimine une condition de concurrence entre prctl()et la sortie du processus qui a appelé l'enfant.

Notez également que le signal de décès des parents de l'enfant est effacé chez les enfants nouvellement créés. Il n'est pas affecté par un execve().

Ce test peut être simplifié si nous sommes certains que le processus système chargé de l'adoption de tous les orphelins a le PID 1:

pid_t pid = fork();
if (pid == -1) { perror(0); exit(1); }
if (pid) {
    ; // continue parent execution
} else {
    int r = prctl(PR_SET_PDEATHSIG, SIGTERM);
    if (r == -1) { perror(0); exit(1); }
    // test in case the original parent exited just
    // before the prctl() call
    if (getppid() == 1)
        exit(1);
    // continue child execution ...

S'appuyer sur ce processus système étant initet ayant PID 1 n'est pas portable, cependant. POSIX.1-2008 spécifie :

L'ID de processus parent de tous les processus enfants et processus zombies existants du processus appelant doit être défini sur l'ID de processus d'un processus système défini par l'implémentation. Autrement dit, ces processus doivent être hérités par un processus système spécial.

Traditionnellement, le processus système adoptant tous les orphelins est PID 1, c'est-à-dire init - qui est l'ancêtre de tous les processus.

Sur les systèmes modernes comme Linux ou FreeBSD, un autre processus pourrait avoir ce rôle. Par exemple, sous Linux, un processus peut appeler prctl(PR_SET_CHILD_SUBREAPER, 1)pour s'établir comme processus système qui hérite de tous les orphelins de l'un de ses descendants (cf. un exemple sur Fedora 25).

Par souci d'exhaustivité. Sur macOS, vous pouvez utiliser kqueue:

void noteProcDeath(
    CFFileDescriptorRef fdref, 
    CFOptionFlags callBackTypes, 
    void* info) 
{
    // LOG_DEBUG(@"noteProcDeath... ");

    struct kevent kev;
    int fd = CFFileDescriptorGetNativeDescriptor(fdref);
    kevent(fd, NULL, 0, &kev, 1, NULL);
    // take action on death of process here
    unsigned int dead_pid = (unsigned int)kev.ident;

    CFFileDescriptorInvalidate(fdref);
    CFRelease(fdref); // the CFFileDescriptorRef is no longer of any use in this example

    int our_pid = getpid();
    // when our parent dies we die as well.. 
    LOG_INFO(@"exit! parent process (pid %u) died. no need for us (pid %i) to stick around", dead_pid, our_pid);
    exit(EXIT_SUCCESS);
}


void suicide_if_we_become_a_zombie(int parent_pid) {
    // int parent_pid = getppid();
    // int our_pid = getpid();
    // LOG_ERROR(@"suicide_if_we_become_a_zombie(). parent process (pid %u) that we monitor. our pid %i", parent_pid, our_pid);

    int fd = kqueue();
    struct kevent kev;
    EV_SET(&kev, parent_pid, EVFILT_PROC, EV_ADD|EV_ENABLE, NOTE_EXIT, 0, NULL);
    kevent(fd, &kev, 1, NULL, 0, NULL);
    CFFileDescriptorRef fdref = CFFileDescriptorCreate(kCFAllocatorDefault, fd, true, noteProcDeath, NULL);
    CFFileDescriptorEnableCallBacks(fdref, kCFFileDescriptorReadCallBack);
    CFRunLoopSourceRef source = CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, fdref, 0);
    CFRunLoopAddSource(CFRunLoopGetMain(), source, kCFRunLoopDefaultMode);
    CFRelease(source);
}

Le processus enfant a-t-il un canal vers / depuis le processus parent? Si c'est le cas, vous recevrez un SIGPIPE si vous écrivez, ou vous obtiendrez EOF lors de la lecture - ces conditions pourraient être détectées.

Inspiré par une autre réponse ici, j'ai trouvé la solution tout-POSIX suivante. L'idée générale est de créer un processus intermédiaire entre le parent et l'enfant, qui a un seul but: remarquer quand le parent meurt et tuer explicitement l'enfant.

Ce type de solution est utile lorsque le code de l'enfant ne peut pas être modifié.

int p[2];
pipe(p);
pid_t child = fork();
if (child == 0) {
    close(p[1]); // close write end of pipe
    setpgid(0, 0); // prevent ^C in parent from stopping this process
    child = fork();
    if (child == 0) {
        close(p[0]); // close read end of pipe (don't need it here)
        exec(...child process here...);
        exit(1);
    }
    read(p[0], 1); // returns when parent exits for any reason
    kill(child, 9);
    exit(1);
}

Il y a deux petites mises en garde avec cette méthode:

• Si vous tuez délibérément le processus intermédiaire, l'enfant ne sera pas tué lorsque le parent décède.
• Si l'enfant quitte avant le parent, le processus intermédiaire essaiera de tuer le pid enfant d'origine, qui pourrait maintenant faire référence à un processus différent. (Cela pourrait être corrigé avec plus de code dans le processus intermédiaire.)

En passant, le code que j'utilise est en Python. Le voici pour être complet:

def run(*args):
    (r, w) = os.pipe()
    child = os.fork()
    if child == 0:
        os.close(w)
        os.setpgid(0, 0)
        child = os.fork()
        if child == 0:
            os.close(r)
            os.execl(args[0], *args)
            os._exit(1)
        os.read(r, 1)
        os.kill(child, 9)
        os._exit(1)
    os.close(r)

Je ne pense pas qu'il soit possible de garantir que l'utilisation uniquement des appels POSIX standard. Comme dans la vraie vie, une fois qu'un enfant est né, il a sa propre vie.

Il est possible que le processus parent intercepte la plupart des événements de terminaison possibles et tente de tuer le processus enfant à ce stade, mais il y en a toujours qui ne peuvent pas être interceptés.

Par exemple, aucun processus ne peut attraper a SIGKILL. Lorsque le noyau gère ce signal, il va tuer le processus spécifié sans aucune notification à ce processus.

Pour étendre l'analogie - la seule autre façon standard de le faire est de se suicider lorsque l'enfant découvre qu'il n'a plus de parent.

Il existe une façon de faire uniquement avec Linux prctl(2)- voir d'autres réponses.

Comme d'autres personnes l'ont souligné, s'appuyer sur le pid parent pour devenir 1 lorsque le parent sort n'est pas portable. Au lieu d'attendre un ID de processus parent spécifique, attendez simplement que l'ID change:

pit_t pid = getpid();
switch (fork())
{
    case -1:
    {
        abort(); /* or whatever... */
    }
    default:
    {
        /* parent */
        exit(0);
    }
    case 0:
    {
        /* child */
        /* ... */
    }
}

/* Wait for parent to exit */
while (getppid() != pid)
    ;

Ajoutez un micro-sommeil comme vous le souhaitez si vous ne souhaitez pas interroger à pleine vitesse.

Cette option me semble plus simple que d'utiliser un tuyau ou de s'appuyer sur des signaux.

Installez un gestionnaire de pièges pour attraper SIGINT, ce qui tue votre processus enfant s'il est encore en vie, bien que d'autres affiches soient correctes pour qu'il n'attrape pas SIGKILL.

Ouvrez un .lockfile avec un accès exclusif et demandez au sondage enfant d'essayer de l'ouvrir - si l'ouverture réussit, le processus enfant devrait quitter

Cette solution a fonctionné pour moi:

• Passez le canal stdin à l'enfant - vous n'avez pas à écrire de données dans le flux.
• L'enfant lit indéfiniment de stdin jusqu'à EOF. Un EOF signale que le parent est parti.
• C'est un moyen infaillible et portable pour détecter quand le parent est parti. Même si le parent plante, le système d'exploitation fermera le tuyau.

Il s'agissait d'un processus de type travailleur dont l'existence n'avait de sens que lorsque le parent était vivant.

Je pense qu'un moyen rapide et sale est de créer un tuyau entre l'enfant et le parent. À la sortie du parent, les enfants recevront un SIGPIPE.

Certaines affiches ont déjà mentionné les pipes et kqueue. En fait, vous pouvez également créer une paire de sockets de domaine Unix connectés par l' socketpair()appel. Le type de socket doit êtreSOCK_STREAM .

Supposons que vous ayez les deux descripteurs de fichier socket fd1, fd2. Maintenant, fork()pour créer le processus enfant, qui héritera des fds. Dans le parent, vous fermez fd2 et chez l'enfant, vous fermez fd1. Maintenant, chaque processus peut poll()ouvrir le fd restant de sa propre extrémité pour l' POLLINévénement. Tant que chaque côté n'a pas explicitement close()son fd pendant la durée de vie normale, vous pouvez être assez sûr qu'un POLLHUPindicateur doit indiquer la terminaison de l'autre (que ce soit propre ou non). Dès notification de cet événement, l'enfant peut décider quoi faire (par exemple mourir).

#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <poll.h>
#include <stdio.h>

int main(int argc, char ** argv)
{
    int sv[2];        /* sv[0] for parent, sv[1] for child */
    socketpair(AF_UNIX, SOCK_STREAM, 0, sv);

    pid_t pid = fork();

    if ( pid > 0 ) {  /* parent */
        close(sv[1]);
        fprintf(stderr, "parent: pid = %d\n", getpid());
        sleep(100);
        exit(0);

    } else {          /* child */
        close(sv[0]);
        fprintf(stderr, "child: pid = %d\n", getpid());

        struct pollfd mon;
        mon.fd = sv[1];
        mon.events = POLLIN;

        poll(&mon, 1, -1);
        if ( mon.revents & POLLHUP )
            fprintf(stderr, "child: parent hung up\n");
        exit(0);
    }
}

Vous pouvez essayer de compiler le code de validation de principe ci-dessus et l'exécuter dans un terminal comme ./a.out & . Vous avez environ 100 secondes pour expérimenter la destruction du PID parent par divers signaux, ou il se fermera simplement. Dans les deux cas, vous devriez voir le message "enfant: parent raccroché".

Par rapport à la méthode utilisant le SIGPIPEgestionnaire, cette méthode ne nécessite pas d'essayer l' write()appel.

Cette méthode est également symétrique , c'est-à-dire que les processus peuvent utiliser le même canal pour surveiller leur existence mutuelle.

Cette solution appelle uniquement les fonctions POSIX. J'ai essayé cela sous Linux et FreeBSD. Je pense que cela devrait fonctionner sur d'autres Unix, mais je n'ai pas vraiment testé.

Voir également:

• unix(7)des pages de manuel Linux, unix(4)FreeBSD, poll(2), socketpair(2), socket(7)sous Linux.

Sous Posix , les exit(), _exit()et les _Exit()fonctions sont définies à:

• Si le processus est un processus de contrôle, le signal SIGHUP doit être envoyé à chaque processus du groupe de processus de premier plan du terminal de contrôle appartenant au processus appelant.

Ainsi, si vous vous arrêtez pour que le processus parent soit un processus de contrôle pour son groupe de processus, l'enfant doit recevoir un signal SIGHUP lorsque le parent quitte. Je ne suis pas absolument sûr que cela se produise lorsque le parent se bloque, mais je pense que oui. Certes, pour les cas non-crash, cela devrait fonctionner correctement.

Notez que vous devrez peut-être lire beaucoup de petits caractères - y compris la section Définitions de base (définitions), ainsi que les informations sur les services système pour exit()et setsid()et setpgrp()- pour obtenir l'image complète. (Moi aussi!)

Si vous envoyez un signal au pid 0, en utilisant par exemple

kill(0, 2); /* SIGINT */

ce signal est envoyé à l'ensemble du groupe de traitement, tuant ainsi efficacement l'enfant.

Vous pouvez le tester facilement avec quelque chose comme:

(cat && kill 0) | python

Si vous appuyez ensuite sur ^ D, vous verrez le texte "Terminated"comme une indication que l'interpréteur Python a bien été tué, au lieu d'être simplement quitté à cause de la fermeture de stdin.

Dans le cas où cela est pertinent pour quelqu'un d'autre, lorsque je génère des instances JVM dans des processus enfants bifurqués à partir de C ++, la seule façon dont je pouvais obtenir que les instances JVM se terminent correctement après la fin du processus parent était de faire ce qui suit. J'espère que quelqu'un pourra fournir des commentaires dans les commentaires si ce n'était pas la meilleure façon de le faire.

1) Appelez prctl(PR_SET_PDEATHSIG, SIGHUP)le processus enfant forké comme suggéré avant de lancer l'application Java via execv, et

2) Ajoutez un hook d'arrêt à l'application Java qui interroge jusqu'à ce que son PID parent soit égal à 1, puis faites un effort Runtime.getRuntime().halt(0). L'interrogation se fait en lançant un shell séparé qui exécute la pscommande (Voir: Comment trouver mon PID en Java ou JRuby sous Linux? ).

EDIT 130118:

Il semble que ce n'était pas une solution solide. Je lutte toujours un peu pour comprendre les nuances de ce qui se passe, mais je recevais parfois des processus JVM orphelins lors de l'exécution de ces applications dans des sessions écran / SSH.

Au lieu d'interroger le PPID dans l'application Java, j'ai simplement demandé au hook d'arrêt d'effectuer un nettoyage suivi d'un arrêt brutal comme ci-dessus. Ensuite, j'ai veillé à invoquer waitpiddans l'application parent C ++ sur le processus enfant généré lorsqu'il était temps de tout terminer. Cela semble être une solution plus robuste, car le processus enfant s'assure qu'il se termine, tandis que le parent utilise les références existantes pour s'assurer que ses enfants se terminent. Comparez cela à la solution précédente qui avait mis fin au processus parent chaque fois qu'il le souhaitait, et avait demandé aux enfants de déterminer s'ils étaient orphelins avant de terminer.

Une autre façon de faire cela qui est spécifique à Linux est de créer le parent dans un nouvel espace de noms PID. Ce sera alors PID 1 dans cet espace de noms, et quand il le quittera, tous ses enfants seront immédiatement tués avec SIGKILL.

Malheureusement, pour créer un nouvel espace de noms PID, vous devez avoir CAP_SYS_ADMIN. Mais, cette méthode est très efficace et ne nécessite aucun changement réel pour le parent ou les enfants au-delà du lancement initial du parent.

Voir clone (2) , pid_namespaces (7) et unshare (2) .

Si le parent décède, le PPID des orphelins passe à 1 - il vous suffit de vérifier votre propre PPID. D'une certaine manière, c'est un sondage, mentionné ci-dessus. voici une pièce de coquille pour ça:

check_parent () {
      parent=`ps -f|awk '$2=='$PID'{print $3 }'`
      echo "parent:$parent"
      let parent=$parent+0
      if [[ $parent -eq 1 ]]; then
        echo "parent is dead, exiting"
        exit;
      fi
}


PID=$$
cnt=0
while [[ 1 = 1 ]]; do
  check_parent
  ... something
done

J'ai trouvé 2 solutions, toutes deux pas parfaites.

1.Tuez tous les enfants en les tuant (-pid) lorsqu'ils reçoivent le signal SIGTERM.
Évidemment, cette solution ne peut pas gérer "kill -9", mais elle fonctionne dans la plupart des cas et est très simple car elle n'a pas besoin de se souvenir de tous les processus enfants.

    var childProc = require('child_process').spawn('tail', ['-f', '/dev/null'], {stdio:'ignore'});

    var counter=0;
    setInterval(function(){
      console.log('c  '+(++counter));
    },1000);

    if (process.platform.slice(0,3) != 'win') {
      function killMeAndChildren() {
        /*
        * On Linux/Unix(Include Mac OS X), kill (-pid) will kill process group, usually
        * the process itself and children.
        * On Windows, an JOB object has been applied to current process and children,
        * so all children will be terminated if current process dies by anyway.
        */
        console.log('kill process group');
        process.kill(-process.pid, 'SIGKILL');
      }

      /*
      * When you use "kill pid_of_this_process", this callback will be called
      */
      process.on('SIGTERM', function(err){
        console.log('SIGTERM');
        killMeAndChildren();
      });
    }

De la même manière, vous pouvez installer le gestionnaire 'exit' comme ci-dessus si vous appelez process.exit quelque part. Remarque: Ctrl + C et un crash soudain ont été automatiquement traités par OS pour tuer le groupe de processus, donc plus ici.

2.Utilisez chjj / pty.js pour lancer votre processus avec le terminal de contrôle connecté.
Lorsque vous tuez le processus en cours de toute façon même par -9, tous les processus enfants seront également automatiquement tués (par le système d'exploitation?). Je suppose que parce que le processus actuel tient un autre côté du terminal, donc si le processus actuel meurt, le processus enfant obtiendra SIGPIPE donc meurt.

    var pty = require('pty.js');

    //var term =
    pty.spawn('any_child_process', [/*any arguments*/], {
      name: 'xterm-color',
      cols: 80,
      rows: 30,
      cwd: process.cwd(),
      env: process.env
    });
    /*optionally you can install data handler
    term.on('data', function(data) {
      process.stdout.write(data);
    });
    term.write(.....);
    */

J'ai réussi à faire une solution portable, sans polling avec 3 processus en abusant du contrôle du terminal et des sessions. C'est de la masturbation mentale, mais ça marche.

L'astuce est:

• le processus A est démarré
• le processus A crée un tuyau P (et ne le lit jamais)
• le processus A se transforme en processus B
• le processus B crée une nouvelle session
• le processus B alloue un terminal virtuel pour cette nouvelle session
• le processus B installe le gestionnaire SIGCHLD pour qu'il meure à la sortie de l'enfant
• le processus B définit un gestionnaire SIGPIPE
• le processus B se transforme en processus C
• le processus C fait tout ce dont il a besoin (par exemple, exec () s le binaire non modifié ou exécute la logique)
• le processus B écrit dans le tuyau P (et bloque de cette façon)
• le processus A attend le processus B et se termine lorsqu'il meurt

De cette façon:

• si le processus A meurt: le processus B obtient un SIGPIPE et meurt
• si le processus B meurt: le processus A attend () revient et meurt, le processus C obtient un SIGHUP (car lorsque le chef de session d'une session avec un terminal attaché meurt, tous les processus du groupe de processus de premier plan obtiennent un SIGHUP)
• si le processus C meurt: le processus B obtient un SIGCHLD et meurt, donc le processus A meurt

Lacunes:

• le processus C ne peut pas gérer SIGHUP
• le processus C sera exécuté dans une session différente
• le processus C ne peut pas utiliser l'API de session / groupe de processus car cela rompra la configuration fragile
• créer un terminal pour chacune de ces opérations n'est pas la meilleure idée qui soit

Même si 7 ans se sont écoulés, je viens de rencontrer ce problème car j'exécute l'application SpringBoot qui doit démarrer webpack-dev-server pendant le développement et doit le tuer lorsque le processus backend s'arrête.

J'essaie d'utiliser Runtime.getRuntime().addShutdownHookmais cela a fonctionné sur Windows 10 mais pas sur Windows 7.

Je l'ai changé pour utiliser un thread dédié qui attend la fin du processus ou InterruptedExceptionqui semble fonctionner correctement sur les deux versions de Windows.

private void startWebpackDevServer() {
    String cmd = isWindows() ? "cmd /c gradlew webPackStart" : "gradlew webPackStart";
    logger.info("webpack dev-server " + cmd);

    Thread thread = new Thread(() -> {

        ProcessBuilder pb = new ProcessBuilder(cmd.split(" "));
        pb.redirectOutput(ProcessBuilder.Redirect.INHERIT);
        pb.redirectError(ProcessBuilder.Redirect.INHERIT);
        pb.directory(new File("."));

        Process process = null;
        try {
            // Start the node process
            process = pb.start();

            // Wait for the node process to quit (blocking)
            process.waitFor();

            // Ensure the node process is killed
            process.destroyForcibly();
            System.setProperty(WEBPACK_SERVER_PROPERTY, "true");
        } catch (InterruptedException | IOException e) {
            // Ensure the node process is killed.
            // InterruptedException is thrown when the main process exit.
            logger.info("killing webpack dev-server", e);
            if (process != null) {
                process.destroyForcibly();
            }
        }

    });

    thread.start();
}

Historiquement, à partir d'UNIX v7, le système de processus a détecté l'orphelinité des processus en vérifiant l'ID parent d'un processus. Comme je l'ai dit, historiquement, le init(8)processus système est un processus spécial pour une seule raison: il ne peut pas mourir. Il ne peut pas mourir car l'algorithme du noyau pour gérer l'attribution d'un nouvel identifiant de processus parent dépend de ce fait. lorsqu'un processus exécute son processus, le processus est devenu orphelin avant l'appel système.exit(2) appel (au moyen d'un appel système de processus ou par une tâche externe comme lui envoyant un signal ou similaire), le noyau réaffecte à tous les enfants de ce processus l'ID du processus init en tant qu'ID de processus parent. Cela conduit au test le plus simple et au moyen le plus portable de savoir si un processus est devenu orphelin. Vérifiez simplement le résultat dugetppid(2) appel système et s'il s'agit de l'ID de processus duinit(2)

Deux problèmes émergent de cette approche qui peuvent conduire à des problèmes:

• tout d'abord, nous avons la possibilité de changer le initprocessus en n'importe quel processus utilisateur, alors comment pouvons-nous garantir que le processus init sera toujours le parent de tous les processus orphelins? Eh bien, dans le exitcode d'appel système, il y a une vérification explicite pour voir si le processus exécutant l'appel est le processus init (le processus avec pid égal à 1) et si c'est le cas, le noyau panique (il ne devrait plus être en mesure de maintenir hiérarchie des processus), il n'est donc pas permis au processus init de passer un exit(2)appel.
• deuxièmement, il y a une condition de concurrence dans le test de base exposé ci-dessus. L'id du processus d'initialisation est supposé être historiquement 1, mais cela n'est pas garanti par l'approche POSIX, qui déclare (comme exposé dans d'autres réponses) que seul l'ID de processus d'un système est réservé à cette fin. Presque aucune implémentation posix ne fait cela, et vous pouvez supposer dans les systèmes dérivés Unix d'origine 1que la réponse à l' getppid(2)appel système suffit pour supposer que le processus est orphelin. Une autre façon de vérifier est de faire getppid(2)juste après le fork et de comparer cette valeur avec le résultat d'un nouvel appel. Cela ne fonctionne tout simplement pas dans tous les cas, car les deux appels ne sont pas atomiques ensemble, et le processus parent peut mourir après fork(2)et avant le premier getppid(2)appel système. La parent id only changes once, when its parent does ansortie de processus (2)call, so this should be enough to check if the getppid (2)result changed between calls to see that parent process has exit. This test is not valid for the actual children of the init process, because they are always children ofinit (8) `, mais vous pouvez supposer en toute sécurité ces processus comme n'ayant aucun parent non plus (sauf lorsque vous remplacez dans un système le processus init)

J'ai transmis le pid parent en utilisant l'environnement à l'enfant, puis vérifié périodiquement si / proc / $ ppid existe à partir de l'enfant.