Quelle est la raison de l'exécution d'une double fourche lors de la création d'un démon?

Je suis en train de créer un démon en python. J'ai trouvé la question suivante, qui a quelques bonnes ressources et dans lequel je suis actuellement, mais je suis curieux de savoir pourquoi une double fourche est nécessaire. J'ai gratté autour de google, et trouvé beaucoup de ressources de déclarer que l'on est nécessaire, mais pourquoi pas.

Certains mentionner que c'est pour empêcher le démon de l'acquisition d'un terminal de contrôle. Comment serait-il le faire sans la deuxième fourche? Quelles sont les répercussions?

stackoverflow.com/questions/10932592/why-fork-twice/...
Une difficulté à faire un double fourche, c'est que les parents ne peuvent facilement obtenir le PID de l'enfant (le fork() appel renvoie l'enfant PID pour le parent, de sorte qu'il est facile d'obtenir le PID du processus fils, mais pas si facile d'obtenir le PID du petit-processus).

InformationsquelleAutor Shabbyrobe | 2009-05-19

102

En regardant le code référencé dans la question, la justification est:
```
# Fork a second child and exit immediately to prevent zombies.  This
# causes the second child process to be orphaned, making the init
# process responsible for its cleanup.  And, since the first child is
# a session leader without a controlling terminal, it's possible for
# it to acquire one by opening a terminal in the future (System V-
# based systems).  This second fork guarantees that the child is no
# longer a session leader, preventing the daemon from ever acquiring
# a controlling terminal.
```
De sorte qu'il est de s'assurer que le démon est re-apparenté sur init (juste au cas où le processus de coups de pied hors du démon est de longue durée), et enlève toute chance de le démon de réacquérir un contrôle de l'ats. Donc, si aucun de ces cas s'appliquent, puis une fourchette devrait être suffisant. "Unix Programmation Réseau - Stevens" a un bon article sur ce.
- Ce n'est pas tout à fait correct. La méthode standard pour créer un démon est simplement pour ne p=fork(); if(p) exit(); setsid(). Dans ce cas, le parent quitte et le premier processus enfant est à nouveau apparentés. Le double-fourche magie est que nécessaire pour empêcher le démon de l'acquisition d'un ats.
- Donc, si je comprends bien, si mon programme commence et forks un child processus, ce premier processus enfant sera un session leader et sera en mesure d'ouvrir un terminal TTY. Mais si j'ai de la fourche à partir de cet enfant et de mettre fin à ce premier enfant, le deuxième fourche enfant ne sera pas un session leader et ne sera pas en mesure d'ouvrir un terminal TTY. Est cette déclaration correcte?
- simplement un fork de ne pas créer un animateur de la séance. Ce qui est fait par setsid(). Ainsi, la première fourche processus devient un leader de session, après l'appel de setsid() et puis nous fourche à nouveau de sorte que la finale, double-fourches processus n'est plus un animateur de la séance. Autres que l'exigence de setsid() à être un animateur de la séance, vous êtes sur place.
InformationsquelleAutor Beano
157

J'essaye de comprendre le double fourche et je suis tombé sur cette question ici. Après beaucoup de recherche, c'est ce que j'ai compris. Espérons que cela va aider à clarifier les choses le mieux pour quelqu'un qui a la même question.

Dans Unix tous les processus qui appartient à un groupe qui, à son tour, appartient à une session. Voici la hiérarchie...

Session (SID) → Groupe de Processus (PGID) → Processus (PID)

Le premier processus dans le processus de groupe devient le processus de chef de groupe et le premier dans le processus de la session devient le leader de la session. Chaque session peut avoir un numéro associé. Seulement un leader de session peut prendre le contrôle d'un ATS. Pour qu'un processus soit véritablement automatiquement (a couru dans le fond), nous devons nous assurer que le leader de la session est tué alors qu'il n'y a pas de possibilité de la session jamais prendre le contrôle de l'ATS.

J'ai couru Sander Maréchal de python exemple daemon programme de ce site sur mon Ubuntu. Voici les résultats avec mes commentaires.
```
1. `Parent`    = PID: 28084, PGID: 28084, SID: 28046
2. `Fork#1`    = PID: 28085, PGID: 28084, SID: 28046
3. `Decouple#1`= PID: 28085, PGID: 28085, SID: 28085
4. `Fork#2`    = PID: 28086, PGID: 28085, SID: 28085
```
De noter que le processus est le leader de la session après Decouple#1, parce que c'est PID = SID. Il pourrait encore prendre le contrôle d'un ATS.

Noter que Fork#2 n'est plus le leader de la session PID != SID. Ce processus ne peut jamais prendre le contrôle d'un ATS. Vraiment automatiquement.

Personnellement, je trouve la terminologie de la fourchette à deux reprises pour être source de confusion. Une meilleure idiome peut-être à la fourchette découpler-fourche.

Autres liens d'intérêt:
- Unix processus - http://www.win.tue.nl/~aeb/linux/lk/lk-10.html
- Bifurquer à deux reprises empêche également la création des zombies lors de parent processus est exécuté pendant plus de temps et pour quelque raison retrait gestionnaire par défaut pour le signal informant que le processus de mort.
- Mais la deuxième pour pouvez également appeler découpler et de devenir leader de session, et puis d'acquérir le terminal.
- Ce n'est pas vrai. La première fork() déjà empêche de créer des zombies, à condition de fermer le parent.
- Un exemple minimal pour produire de la ci-dessus cité résultats: gist.github.com/cannium/7aa58f13c834920bb32c
- En serait-il bon d'appel setsid() avant un seul fork()? En fait, je suppose que les réponses de cette question vous répondre.
InformationsquelleAutor Praveen Gollakota
101

Strictement parlant, le double-fourche n'a rien à voir avec la ré-parenting le démon comme un enfant de init. Tout ce qui est nécessaire pour re-parent de l'enfant que le parent doit quitter. Cela peut être fait avec une seule fourche. Aussi, en faisant un double-fourche par lui-même n'a pas re-parent le processus de démon à init; le démon du parent doit sortie. En d'autres termes, le parent se ferme lorsque la fourche d'un bon démon, afin que le démon est re-apparenté à init.

Alors pourquoi la double fourche? POSIX.1-2008 date de Section 11.1.3, "Le Terminal De Contrôle", a la réponse (italiques ajoutés):

Le terminal de contrôle d'une séance est alloués par le leader de la session la mise en œuvre définis. Si un leader de session n'a pas de terminal de contrôle, et ouvre un terminal de fichier qui n'est pas déjà associé à une session sans l'aide de la O_NOCTTY option (voir open()), elle est mise en œuvre-définir si le terminal devient le terminal de contrôle de l'animateur de la séance. Si un processus qui est pas un leader de session ouvre un terminal, ou les O_NOCTTY option est utilisée sur open(), alors que le terminal ne doit pas devenir le terminal de contrôle du processus appelant.

Cela nous dit que si un processus démon fait quelque chose comme ça ...
```
int fd = open("/dev/console", O_RDWR);
```
... puis le démon pourrait acquérir /dev/console que son terminal de contrôle, selon que le démon est un leader de session, et en fonction de la mise en œuvre du système. Le programme peut garantie que l'appel ci-dessus ne seront pas acquérir un terminal de contrôle si le programme s'assure d'abord qu'il n'est pas un animateur de la séance.

Normalement, lors du lancement d'un démon, setsid est appelé (à partir du processus enfant après l'appel de fork) de dissocier le démon de son terminal de contrôle. Toutefois, l'appel de setsid signifie également que le processus appelant sera le leader de la session de la nouvelle session, ce qui laisse ouverte la possibilité que le démon pourrait acquérir un terminal de contrôle. Le double-fourche technique permet de s'assurer que le processus de démon n'est pas le leader de la session, ce qui garantit ensuite, un appel à open, comme dans l'exemple ci-dessus, n'entraînera pas dans le processus de démon de réacquérir un terminal de contrôle.

La double fourche technique est un peu paranoïaque. Il peut ne pas être nécessaire si vous savoir que le démon ne jamais ouvrir un terminal de fichier. Aussi, sur certains systèmes, il peut ne pas être nécessaire, même si le démon n'ouvrez un terminal de fichier de périphérique, depuis que le comportement de la mise en œuvre est définie. Cependant, une chose qui n'est pas mise en œuvre définies est que seul un leader de session peut affecter le terminal de contrôle. Si un processus n'est pas un leader de session, il ne peut pas allouer un terminal de contrôle. Par conséquent, si vous voulez être paranoïaque et être certain que le démon ne peut pas, par inadvertance, d'acquérir un terminal de contrôle, indépendamment de toute mise en œuvre définies par les détails, puis le double-fourche technique est essentielle.
- +1 dommage que cette réponse est venue ~quatre ans après que la question a été posée.
- Mais ça n'explique toujours pas pourquoi il est extrêmement important qu'un démon ne peut pas acquérir un terminal de contrôle
- Le mot clé est "par inadvertance" acquérir un terminal de contrôle. Si le processus se passe pour ouvrir un terminal, et il devient le processus terminal de contrôle, que si quelqu'un émet un ^C à partir de ce terminal, il pourrait mettre fin au processus. Donc ça peut être sympa pour protéger un processus de avoir qui se produisent à elle par inadvertance. Personnellement, je vais m'en tenir à une seule fourche et setsid() pour le code que j'ai écris que je sais ne pas être l'ouverture de bornes.
- Une chose à noter, toutefois, est que l'ouverture d'un terminal de fichier de périphérique est mais d'une façon qu'un processus peut acquérir un terminal de contrôle. "Le terminal de contrôle pour une session est attribué par le chef de session à la mise en œuvre manière définie.", cela signifie Que les implémentations pourrait fournir d'autres moyens qu'un animateur de la séance peut acquérir un terminal de contrôle. Je ne suis pas paranoïaque, mais quand je le suis, je daemonize mon processus avec soin 🙂
- comment cela pourrait-il arriver "par inadvertance"? Un processus ne sera pas seulement de bon gré mal gré, de la fin d'ouverture des bornes, si ce n'est pas écrit à le faire. Peut-être à double fourche est utile si vous le programmeur ne connaissez pas le code et je ne sais pas si elle pourrait ouvrir un terminal.
- Imaginez ce qui pourrait arriver si vous ajoutez une ligne comme ceci à votre fichier de configuration du démon: LogFile=/dev/console. Les programmes n'ont pas toujours le temps de compilation de contrôle sur les fichiers qu'ils pourraient ouvrir 😉
- Merci, c'est un bon point!
- oui on a toujours besoin de l'efp vos entrées. Si vous avez un fichier de configuration qui contrôlent ce que vous êtes d'ouverture, ceci peut être important. C'est un cas de vous le programmeur ne sachant pas ce qu'elle pourrait ouvrir. Mais si les fichiers que vous ouvrez ne sont pas spécifiés par l'utilisateur/admin entrée, c'est tout simplement bâclée de programmation. Il me rappelle les jours, les gens l'habitude de taper "sync" deux fois avant de s'éteindre d'un système. En fait, le seul but de la seconde synchronisation servi a un retard de sorte que la première async vider sur le disque pourrait avoir le temps de remplir.
- FWIW, vous avez droit à double fourche n'est pas nécessaire pour reparent à init lors de la diaboliser, mais la partie est nécessaire quand un démon veut à la fourchette et reparent un enfant et de continuer à fonctionner: stackoverflow.com/q/10932592/53974 (bien sûr, dans ce cas, vous pouvez éviter reparenting et de faire vos propres récolter, mais il peut être compliqué).
InformationsquelleAutor Dan Moulding
11

Prises de Mauvais CTK:

"Sur certaines saveurs de Unix, vous êtes obligé de faire un double-fourche au démarrage, afin d'entrer en mode démon. C'est parce que seule la fourche n'est pas garanti de se détacher du terminal de contrôle."
- Comment peut seule fourche de ne pas se détacher du terminal de contrôle, mais à double fourchette à le faire? Ce que les unix cela se produit-il sur?
- Un démon doit fermer l'entrée et la sortie des descripteurs de fichiers (fds), sinon, il serait encore attaché à la borne il a été lancé. Un fork du processus hérite de ceux de la mère. Apparemment, le premier enfant ferme la fds mais qui ne nettoie pas tout. Sur la deuxième fourche, les fds n'existe pas, donc le deuxième enfant ne peut pas être connecté à quelque chose de plus.
- Sys V, je crois...
- Non, un démon correctement "détache" de lui-même à partir de son terminal de contrôle en appelant setsid après une première fourche. Il veille ensuite à ce qu'il reste détaché à partir d'un terminal de contrôle par bifurquer à nouveau et d'avoir le leader de la session (le processus qui a appelé setsid) de sortie.
- Ce n'est pas fork qui se détache du terminal de contrôle. C'est setsid qui le fait. Mais setsid échouera si elle est appelée à partir d'un processus de chef de groupe. Ainsi une première fork doit être fait avant setsid pour s'assurer que setsid est appelé à partir d'un processus qui n'est pas un processus de chef de groupe. La deuxième fork assure que le processus final (celui qui va être le démon) n'est pas un animateur de la séance. Seuls les animateurs de la séance peut acquérir un terminal de contrôle, de sorte que cette deuxième fourche garantit que le démon ne sera pas, par inadvertance, acquérir un terminal de contrôle. Cela est vrai de toute POSIX OS.
- Ce n'est pas la garantie que le deuxième enfant de ne pas acquérir le contrôle terminal car il peut appeler setsid et de devenir leader de session, puis acquérir le contrôle terminal.
- Cette réponse est mauvaise, mais finit par être la bonne, parce que le commentaire de @bdonlan
InformationsquelleAutor Stefan Thyberg
7

Selon "Advanced Programming in the Unix Environment", par Stephens et Rago, la deuxième fourche est plus une recommandation, et il est fait pour garantir que le démon ne pas acquérir un terminal de contrôle sur le Système V-systèmes.

InformationsquelleAutor Paolo Tedesco
3

Une des raisons est que le processus parent peut immédiatement wait_pid() pour l'enfant, et puis l'oublier. Lorsque le grand-enfant meurt, c'est le parent est de l'init, et il faudra attendre () - et de l'état zombie.

Le résultat est que le processus parent n'a pas besoin d'être conscient de la fourche enfants, et il rend aussi possible la fourche long processus en cours d'exécution à partir de libs etc.

InformationsquelleAutor KarlP
2

Le démon() l'appel de la mère d'appel _exit() si elle réussit. La motivation initiale peut avoir été de permettre au parent de faire un travail supplémentaire alors que l'enfant est daemonizing.

Il peut également être basée sur une croyance erronée qu'il est nécessaire afin d'assurer le démon n'a pas de parent, et il est à nouveau apparentés à init - mais ce sera de toute façon une fois que le parent décède dans l'unique fourche cas.

Donc je suppose que tout cela se résume juste en bas de la tradition de la fin - une seule fourche est suffisante tant que le parent meurt en peu de temps de toute façon.

InformationsquelleAutor bdonlan
2

Un décent discussion à ce sujet semblent être à http://www.developerweb.net/forum/showthread.php?t=3025

Citant mlampkin à partir de là:

...pensez à la setsid( ) appeler la "nouvelle" façon de faire de la chose (dissocier du terminal) et de la [deuxième] appel fork( ) après que la redondance de traiter avec le SVr4...
- Sauf que mlampkin est faux. Uzume est juste, cependant.
InformationsquelleAutor Stobor
-1

Il pourrait être plus facile à comprendre de cette façon:
- La première fourche et setsid permettra de créer une nouvelle session (mais le processus ID == ID de session).
- La deuxième fourche permet de s'assurer que le processus d'ID != l'ID de session.
InformationsquelleAutor pandy.song

Vous devez vous connecter pour publier un commentaire.