Quelle est la raison pour effectuer une double fourchette lors de la création d'un démon?

https://stackoverflow.com/questions/881388

22-08-2019
|

Question

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

Certains mention qu'il est d'empêcher le démon de l'acquisition d'un terminal de contrôle. Comment serait-il le faire sans la seconde fourche? Quelles sont les répercussions?

La solution

En regardant le code mentionné 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.

Il est donc de faire en sorte que le démon est à nouveau parented sur init (juste au cas où le processus le coup d'envoi du démon est longue durée de vie), et enlève toute chance du démon réacquérir un terminal de contrôle. Donc, si aucun de ces cas appliquer, puis une fourchette devrait être suffisante. " Unix réseau Programmation - Stevens " a une bonne section sur ce

Autres conseils

Je suis en train de comprendre la fourche double et sommes tombés sur cette question ici. Après beaucoup de recherche ce que je compris. Espérons que cela aidera à clarifier les choses pour toute personne qui a la même question.

Dans tous les processus Unix 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 groupe de processus devient le leader du groupe de processus et le premier processus de la session devient le leader de la session. Chaque session peut avoir un ATS associé. Seul un chef de session peut prendre le contrôle d'un ATS. Pour un processus pour être vraiment daemon (RAN en arrière-plan), nous devons veiller à ce que le chef de session est tué afin qu'il n'y ait pas de possibilité de la session jamais prendre le contrôle de l'ATS.

J'ai couru le programme démon exemple python de Sander Marechal 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

Notez que le processus est le leader de la session après Decouple#1, parce qu'il est PID = SID. Il pourrait encore prendre le contrôle d'un ATS.

Notez 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 daemon.

Je trouve personnellement deux fois la fourchette de terminologie pour être source de confusion. Une meilleure expression pourrait être fourche découpler fourche.

Liens supplémentaires d'intérêt:

processus Unix - http://www.win .tue.nl / ~ AEB / linux / lk / lk-10.html

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

Alors pourquoi la double fourchette? POSIX.1-2008 Section 11.1.3, " le terminal de contrôle », a la réponse (italique ajouté):

Le terminal de contrôle d'une session est alloué par le chef de la session d'une manière définie par l'implémentation. Si un chef de session n'a pas de terminal de contrôle, et ouvre un fichier de terminal qui est pas déjà associée à une session sans utiliser l'option O_NOCTTY (voir open()), il est défini par l'implémentation si le terminal est le terminal de contrôle du chef de session. Si un processus qui est pas un chef de file de la session ouvre un fichier terminal, ou l'option O_NOCTTY est utilisé sur open(), alors que le terminal ne doit pas devenir le terminal de contrôle du processus d'appel .

Cela nous dit que si un démon fait quelque chose comme ça ...

int fd = open("/dev/console", O_RDWR);

... alors le processus démon peut acquérir /dev/console comme terminal de contrôle, selon que le processus démon est un leader de la session, et en fonction de la mise en œuvre du système. Le programme peut garantie que l'appel ci-dessus ne peut acquérir un terminal de contrôle si le programme assure d'abord qu'il ne soit pas un chef de session.

Normalement, lors du lancement d'un démon, setsid est appelé (du processus de l'enfant après avoir appelé fork) à dissocier le démon de son terminal de contrôle. Toutefois, l'appel setsid signifie également que le processus d'appel sera le leader de la session de la nouvelle session, ce qui laisse ouverte la possibilité que le démon pourrait réacquérir un terminal de contrôle. La technique de double fourche assure que le processus démon est pas le chef de la session, ce qui garantit alors qu'un appel à open, comme dans l'exemple ci-dessus, ne donnera pas lieu dans le processus démon réacquérir un terminal de contrôle.

La technique de double fourche est un peu paranoïaque. Il peut ne pas être nécessaire si vous connaissez que le démon ne sera jamais ouvrir un fichier terminal. En outre, sur certains systèmes, il peut ne pas être nécessaire, même si le démon ne s'ouvre un fichier terminal, puisque ce comportement est défini par l'implémentation. Cependant, une chose qui n'est pas définie par l'implémentation est que seul un chef de session peut affecter le terminal de contrôle. Si un processus est pas un chef 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 processus démon ne peut pas acquérir, par inadvertance, un terminal de contrôle, quel que soit les détails de mise en œuvre définis, alors la technique de double fourche est essentielle.

Bad CTK :

« Sur certaines versions d'Unix, vous êtes obligé de faire une double fourche au démarrage, afin de passer en mode démon. En effet, seul fork n'est pas garanti à se détacher du terminal de contrôle. »

Selon « Programmation avancée dans l'environnement Unix », par Stephens et Rago, la seconde fourche est plus une recommandation, et il est fait pour garantir que le démon n'acquiert un terminal de contrôle sur les systèmes à base de V système.

L'une des raisons est que le processus parent peut immédiatement wait_pid () pour l'enfant, puis l'oublier. Quand donc grand-enfant meurt, il est parent est init, et il attendra () pour - et le sortir de l'état de zombie.

Le résultat est que le processus parent n'a pas besoin d'être au courant des enfants en forme de fourche, et il permet également de fourche longs processus de fonctionnement de libs etc.

Le démon () appel a le _exit d'appel parent () si elle réussit. La motivation originale peut-être pour permettre aux parents de faire un travail supplémentaire alors que l'enfant est daemonizing.

Il peut également se fonder sur une croyance erronée selon laquelle il est nécessaire afin d'assurer le démon n'a pas de processus parent et est reparented init -. Mais cela se produira de toute façon une fois que le parent meurt dans le seul cas fourchette

Je suppose que tout se résume juste en bas de la tradition à la fin -. Une seule fourche est suffisante tant que le parent meurt en bref ordre de toute façon

Une bonne discussion de ce semble être http: // www. developerweb.net/forum/showthread.php?t=3025

mlampkin de là citant:

... penser à l'appel setsid () comme la « nouvelle » façon de faire des choses (dissocier du terminal) et la [deuxième] appel fork () après que la redondance pour faire face à la SVr4 ...

Il est peut-être plus facile à comprendre ainsi:

La première fourche et setsid va créer une nouvelle session (mais l'ID de processus == ID de session).
La seconde fourche fait que l'ID de processus! = ID de session.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow