Comment créer un démon sous Linux

Les démons sont des processus qui ne s'exécutent pas directement sous le contrôle de l'utilisateur mais servent en arrière-plan. Habituellement, ils démarrent au démarrage du système et s'exécutent en continu jusqu'à ce que le système s'arrête. La seule différence entre ces processus et les processus normaux est qu'ils n'envoient en aucun cas des messages à la console ou à l'écran.

Voici comment vous pouvez créer un démon sur une machine Linux.

Une brève introduction à la création des démons

De nombreux démons s'exécutent sur le système et quelques exemples de démons familiers sont les suivants :

• Crond: Exécute les commandes à l'heure spécifiée
• sshd: Permet de se connecter au système à partir de machines distantes
• httpd: dessert des pages Web
• nfsd: Autorise le partage de fichiers sur le réseau

De plus, les processus démons sont généralement nommés pour se terminer par la lettre ré, même si ce n'est pas obligatoire.

Pour qu'un processus s'exécute en tant que démon, le chemin suivant est suivi :

• Les opérations initiales, telles que la lecture des fichiers de configuration ou l'obtention des ressources système nécessaires, doivent être effectuées avant que le processus ne devienne un démon. De cette façon, le système peut signaler les erreurs reçues à l'utilisateur et le processus se terminera avec un code d'erreur approprié.
• Un processus exécuté en arrière-plan est créé avec init comme processus parent. Dans ce but, un sous-processus est d'abord dérivé du processus init, puis le processus supérieur se termine par exit.
• Une nouvelle session devrait s'ouvrir en appelant la fonction setsid, et le processus devrait être déconnecté du terminal.
• Tous les descripteurs de fichiers ouverts hérités du processus parent sont fermés.
• Entrée, sortie standard, et les messages d'erreur sont redirigés vers /dev/null.
• Le répertoire de travail du processus doit changer.

Que sont les sessions démon ?

Après s'être connecté au système via un terminal, les utilisateurs peuvent exécuter de nombreuses applications via le programme shell. Ces processus doivent se fermer lorsque l'utilisateur quitte le système. Le système d'exploitation regroupe ces processus en groupes de sessions et de processus.

Chaque session se compose de groupes de processus. Vous pouvez décrire cette situation comme suit :

Le terminal où les processus reçoivent leurs entrées et envoient leurs sorties est appelé le terminal de contrôle. Un terminal de contrôle est associé à une seule session à la fois.

Une session et les groupes de processus qu'elle contient ont des numéros d'identification (ID); ces numéros d'identification sont les numéros d'identification de processus (PID) des responsables de groupe de session et de processus. Un processus enfant partage le même groupe que son processus parent. Lorsque plusieurs processus sont communiquant avec le mécanisme de tuyau, le premier processus devient le leader du groupe de processus.

Création d'un processus démon sous Linux

Ici, vous verrez comment vous pouvez créer une fonction démon. Pour cela, vous allez créer une fonction nommée _démon. Vous pouvez commencer par nommer le code de l'application qui s'exécutera en tant que démon comme test.c, et le code que vous allez créer la fonction démon en tant que démon.c.

//test.c
#inclure <stdio.h>
entier_démon(entier, entier);
entierprincipale()
{
	getchar();
	_démon (0, 0);
	getchar();
retourner0;
}

//daemon.c
#inclure <sys/types.h>
#inclure <sys/stat.h>
#inclure <stdlib.h>
#inclure <stdio.h>
#inclure <fcntl.h>
#inclure <unistd.h>
#inclure <linux/fs.h>
#inclure <linux/limits.h>
entier_démon(entier nochdir, entier nonfermé){
 pid_t pid ;
 pid = fourche(); // Débranche le processus parent
 si (pid < 0) {
sortie(EXIT_FAILURE);
 }
 si (pid > 0) {
sortie(EXIT_SUCCESS);
 }
retourner0;
}

Pour créer un démon, vous avez besoin d'un processus d'arrière-plan dont le processus parent est init. Dans le code ci-dessus, _démon crée un processus enfant puis tue le processus parent. Dans ce cas, votre nouveau processus sera un sous-processus d'init et continuera à s'exécuter en arrière-plan.

Compilez maintenant l'application avec la commande suivante et examinez l'état du processus avant et après _deamon est appelé:

gcc-otesttest.cdémon.c

Exécutez l'application et passez à un autre terminal sans appuyer sur aucune autre touche :

./test

Vous pouvez voir que les valeurs liées à votre processus sont les suivantes. Ici, vous devrez utiliser la commande ps pour obtenir des informations relatives au processus. Dans ce cas, le _démon la fonction n'a pas encore été appelée.

ps-C test -o "pid ppid pgid si tty statistiquecommande"
# Production
PID PPID PGID SID TT STAT COMMANDE
10296 5119 10296 5117 points/2 S+ ./test

Quand tu regardes le STAT, vous voyez que votre processus est en cours d'exécution mais attend qu'un événement hors planification se produise, ce qui entraînera son exécution au premier plan.

Vous pouvez voir que le processus parent de votre application est le shell comme prévu.

ps-jp 5119 
# Production 
PID PGID SID TTY HEURE CMD
5119 5119 5117 pts/2 00:00:02 zsh

Retournez maintenant au terminal où vous exécutez votre application et appuyez sur Entrer invoquer le _démon une fonction. Ensuite, regardez à nouveau les informations de processus sur l'autre terminal.

ps-C test -o "pid ppid pgid si tty statistiquecommande"
# Production
PID PPID PGID SID TT STAT COMMANDE
22504 1 22481 5117 pts/2 S ./test

Tout d'abord, vous pouvez dire que le nouveau sous-processus s'exécute en arrière-plan puisque vous ne voyez pas le + personnage dans le STAT domaine. Examinez maintenant qui est le processus parent du processus à l'aide de la commande suivante :

ps-jp 1 
​​​​​​​# Production 
PID PGID SID TTY HEURE CMD
1 1 1? 00:00:01systemd

Vous pouvez maintenant voir que le processus parent de votre processus est le systemd processus. Il est mentionné ci-dessus que pour l'étape suivante, une nouvelle session devrait s'ouvrir et le processus devrait être déconnecté du terminal de contrôle. Pour cela, vous utilisez la fonction setsid. Ajoutez cet appel à votre _démon une fonction.

Le bout de code à ajouter est le suivant :

si (setsid() == -1) 
retourner-1;

Maintenant que vous avez inspecté l'état avant _démon appelé, vous pouvez maintenant supprimer le premier obtenir fonction dans le test.c code.

//test.c
#inclure <stdio.h>
entier_démon(entier, entier);
entierprincipale()
{
	_démon (0, 0);
	getchar();
retourner0;
}

Après avoir compilé et réexécuté l'application, rendez-vous sur le terminal où vous avez fait vos avis. Le nouveau statut de votre processus est le suivant :

ps-C test -o "pid ppid pgid si tty statistiquecommande"
​​​​​​​# Production
PID PPID PGID SID TT STAT COMMANDE
25494 1 25494 25494? Ss ./test

Le ? signer dans le TT indique que votre processus n'est plus connecté à un terminal. Remarquez que le PID, PGID, et SID les valeurs de votre processus sont les mêmes. Votre processus est maintenant un leader de session.

À l'étape suivante, remplacez le répertoire de travail par le répertoire racine en fonction de la valeur de l'argument que vous avez passé. Vous pouvez ajouter l'extrait suivant au _démon fonction pour cela:

si (!nochdir) {
 si (chdir("/") == -1)
retourner-1;
}

Maintenant, selon l'argument passé, tous les descripteurs de fichiers peuvent être fermés. Ajoutez le code suivant au _démon une fonction:

#définir NR_OPEN 1024
si (!noclose) {
 pour (i = 0; je < NR_OPEN; je++)
 fermer (je);
 ouvrir("/dev/nul", O_RDWR);
 dup (0);
 dup (0);
}

Une fois tous les descripteurs de fichiers fermés, les nouveaux fichiers ouverts par le démon seront affichés avec les descripteurs 0, 1 et 2 respectivement. Dans ce cas, par exemple, le printf commandes dans le code seront dirigées vers le deuxième fichier ouvert. Pour éviter cela, les trois premiers identifiants pointent vers le /dev/null appareil.

Dans ce cas, l'état final de la _démon fonction sera la suivante :

#inclure <sys/types.h>
#inclure <sys/stat.h>
#inclure <stdio.h>
#inclure <stdlib.h>
#inclure <fcntl.h>
#inclure <erreur.h>
#inclure <unistd.h>
#inclure <syslog.h>
#inclure <chaîne.h>
entier_démon(vide){
// PID: ID de processus
// SID: ID de session
 pid_t pid, sid;
 pid = fourche(); // Débranche le processus parent
 si (pid < 0) {
sortie(EXIT_FAILURE);
 }
 si (pid > 0) {
sortie(EXIT_SUCCESS);
 }
 // Créer un SIDpourenfant
 sid = setsid();
 si (sid < 0) {
// ÉCHOUER
sortie(EXIT_FAILURE);
 }
 si ((chdir("/")) < 0) {
// ÉCHOUER
sortie(EXIT_FAILURE);
 }
 fermer (STDIN_FILENO);
 fermer (STDOUT_FILENO);
 fermer (STDERR_FILENO);
pendant que (1) {
// Quelques tâches
 dormir (30);
 }
sortie(EXIT_SUCCESS);
}

Voici un exemple d'extrait de code qui exécute le sshd candidature en tant que démon:

...
if (!(debug_flag || inetd_flag || no_daemon_flag)) {
entier fd ;
 si (démon (0, 0) < 0)
 fatal("démon() a échoué: %.200s", strerror (errno));
/* Se déconnecte du tty de contrôle. */
 fd = ouvert (_PATH_TTY, O_RDWR | O_NOCTTY);
 si (fd >= 0) {
 (vide) ioctl (fd, TIOCNOTTY, NULL);
 fermer (fd);
 }
}
...

Les démons sont importants pour la programmation du système Linux

Les démons sont des programmes qui exécutent diverses actions d'une manière prédéfinie en réponse à certains événements. Ils s'exécutent en mode silencieux sur votre machine Linux. Ils ne sont pas sous le contrôle direct de l'utilisateur et chaque service exécuté en arrière-plan a son démon.

Il est important de maîtriser les démons pour apprendre la structure du noyau du système d'exploitation Linux et comprendre le fonctionnement des différentes architectures système.

Qu'est-ce qu'un démon ?

Lire la suite

A propos de l'auteur