So erstellen Sie einen Daemon unter Linux

Daemons sind Prozesse, die nicht direkt unter der Kontrolle des Benutzers laufen, sondern im Hintergrund dienen. Normalerweise starten sie beim Systemstart und laufen kontinuierlich, bis das System heruntergefahren wird. Der einzige Unterschied zwischen diesen und normalen Prozessen besteht darin, dass sie in keiner Weise Nachrichten an die Konsole oder den Bildschirm senden.

So erstellen Sie einen Daemon auf einem Linux-Rechner.

Eine kurze Einführung in die Erstellung von Daemons

Viele Daemons laufen auf dem System und einige bekannte Daemon-Beispiele sind wie folgt:

• Crond: Lässt Befehle zur angegebenen Zeit ausführen
• sshd: Ermöglicht die Anmeldung beim System von Remote-Computern
• httpd: Stellt Webseiten bereit
• nfsd: Ermöglicht die gemeinsame Nutzung von Dateien über das Netzwerk

Außerdem werden Daemon-Prozesse normalerweise so benannt, dass sie mit dem Buchstaben enden d, obwohl es keine Pflicht ist.

Damit ein Prozess als Daemon ausgeführt wird, wird dem folgenden Pfad gefolgt:

• Anfängliche Operationen, wie z. B. das Lesen von Konfigurationsdateien oder das Abrufen erforderlicher Systemressourcen, müssen durchgeführt werden, bevor der Prozess zu einem Daemon wird. Auf diese Weise kann das System die empfangenen Fehler an den Benutzer melden und der Vorgang wird mit einem entsprechenden Fehlercode beendet.
  instagram viewer
• Ein im Hintergrund laufender Prozess wird mit init als übergeordnetem Prozess erstellt. Dazu wird zunächst ein Unterprozess aus dem Init-Prozess herausgegabelt und dann der übergeordnete Prozess mit Exit beendet.
• Eine neue Sitzung sollte durch Aufrufen der setsid-Funktion geöffnet werden, und der Prozess sollte vom Terminal getrennt werden.
• Alle offenen Dateideskriptoren, die vom übergeordneten Prozess geerbt wurden, werden geschlossen.
• Standardeingabe, Ausgabe, und Fehlermeldungen werden umgeleitet /dev/null.
• Das Arbeitsverzeichnis des Prozesses muss geändert werden.

Was sind Daemon-Sitzungen?

Nach dem Einloggen in das System über ein Terminal können Benutzer viele Anwendungen über das Shell-Programm ausführen. Diese Prozesse sollten geschlossen werden, wenn der Benutzer das System verlässt. Das Betriebssystem gruppiert diese Prozesse in Sitzungs- und Prozessgruppen.

Jede Sitzung besteht aus Prozessgruppen. Sie können diese Situation wie folgt beschreiben:

Das Terminal, an dem die Prozesse ihre Eingaben empfangen und ihre Ausgaben senden, wird als steuerndes Terminal bezeichnet. Ein steuerndes Terminal ist jeweils nur einer Sitzung zugeordnet.

Eine Sitzung und die darin enthaltenen Prozessgruppen haben Identifikationsnummern (ID-Nummern); diese Identifikationsnummern sind die Prozessidentifikationsnummern (PID) der Sitzungs- und Prozessgruppenleiter. Ein untergeordneter Prozess teilt sich dieselbe Gruppe wie sein übergeordneter Prozess. Wenn mehrere Prozesse sind Kommunikation mit dem Rohrmechanismus, wird der erste Prozess zum Prozessgruppenleiter.

Erstellen eines Daemon-Prozesses unter Linux

Hier sehen Sie, wie Sie eine Daemon-Funktion erstellen können. Zu diesem Zweck erstellen Sie eine Funktion mit dem Namen _dämon. Sie können beginnen, indem Sie den Anwendungscode, der als Daemon ausgeführt wird, als benennen test.c, und den Code, als den Sie die Daemon-Funktion erstellen werden daemon.c.

//test.c
#enthalten <stdio.h>
int_dämon(int, int);
inthauptsächlich()
{
	getchar();
	_daemon (0, 0);
	getchar();
Rückkehr0;
}

//daemon.c
#enthalten <sys/types.h>
#enthalten <sys/stat.h>
#enthalten <stdlib.h>
#enthalten <stdio.h>
#enthalten <fcntl.h>
#enthalten <unistd.h>
#enthalten <linux/fs.h>
#enthalten <linux/limits.h>
int_dämon(int nochdir, int noclose){
 pid_t pid;
 pid = Gabel (); // Verzweige den übergeordneten Prozess
 wenn (pid < 0) {
Ausfahrt(EXIT_FAILURE);
 }
 wenn (pid > 0) {
Ausfahrt(EXIT_SUCCESS);
 }
Rückkehr0;
}

Um einen Daemon zu erstellen, benötigen Sie einen Hintergrundprozess, dessen übergeordneter Prozess init ist. Im obigen Code _dämon erstellt einen untergeordneten Prozess und beendet dann den übergeordneten Prozess. In diesem Fall ist Ihr neuer Prozess ein Unterprozess von init und wird weiterhin im Hintergrund ausgeführt.

Kompilieren Sie nun die Anwendung mit dem folgenden Befehl und untersuchen Sie den Status des Prozesses vorher und nachher _deamon wird genannt:

gcc-ÖPrüfungPrüfung.cDämon.c

Führen Sie die Anwendung aus und wechseln Sie zu einem anderen Terminal, ohne eine andere Taste zu drücken:

./Prüfung

Sie können sehen, dass die Werte in Bezug auf Ihren Prozess wie folgt sind. Hier müssen Sie verwenden den Befehl ps, um prozessbezogene Informationen abzurufen. In diesem Fall ist die _dämon Funktion wurde noch nicht aufgerufen.

ps-C Prüfung -o "pid ppid pgid sid tty StatBefehl"
# Ausgabe
PID PPID PGID SID TT STAT BEFEHL
10296 5119 10296 5117 Punkte/2 S+ ./Prüfung

Beim Betrachten der STAT Feld sehen Sie, dass Ihr Prozess ausgeführt wird, aber auf ein außerplanmäßiges Ereignis wartet, das dazu führt, dass er im Vordergrund ausgeführt wird.

Sie können sehen, dass der übergeordnete Prozess Ihrer Anwendung wie erwartet die Shell ist.

ps-jp 5119 
# Ausgabe 
PID PGID SID TTY ZEIT CMD
5119 5119 5117 Punkte/2 00:00:02 zsh

Kehren Sie nun zu dem Terminal zurück, auf dem Sie Ihre Anwendung ausführen, und drücken Sie Eingeben um die anzurufen _dämon Funktion. Sehen Sie sich dann die Prozessinformationen auf dem anderen Terminal erneut an.

ps-C Prüfung -o "pid ppid pgid sid tty StatBefehl"
# Ausgabe
PID PPID PGID SID TT STAT BEFEHL
22504 1 22481 5117 Pkt./2 S ./Prüfung

Zunächst einmal können Sie sagen, dass der neue Unterprozess im Hintergrund läuft, da Sie den nicht sehen + Charakter im STAT Feld. Untersuchen Sie nun mit dem folgenden Befehl, wer der übergeordnete Prozess des Prozesses ist:

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

Sie können jetzt sehen, dass der übergeordnete Prozess Ihres Prozesses der ist systemd Prozess. Es wurde oben erwähnt, dass für den nächsten Schritt eine neue Sitzung geöffnet und der Prozess vom Steuerterminal getrennt werden sollte. Dazu verwenden Sie die setsid-Funktion. Fügen Sie diesen Anruf zu Ihrem hinzu _dämon Funktion.

Der hinzuzufügende Codeabschnitt lautet wie folgt:

if (setsid() == -1) 
Rückkehr-1;

Nun, da Sie den Zustand zuvor inspiziert haben _dämon aufgerufen, können Sie nun die erste entfernen getchar Funktion in der test.c Code.

//test.c
#enthalten <stdio.h>
int_dämon(int, int);
inthauptsächlich()
{
	_daemon (0, 0);
	getchar();
Rückkehr0;
}

Nachdem Sie die Anwendung kompiliert und erneut ausgeführt haben, gehen Sie zu dem Terminal, in dem Sie Ihre Überprüfungen vorgenommen haben. Der neue Status Ihres Prozesses sieht wie folgt aus:

ps-C Prüfung -o "pid ppid pgid sid tty StatBefehl"
​​​​​​​# Ausgabe
PID PPID PGID SID TT STAT BEFEHL
25494 1 25494 25494? Ss ./Prüfung

Das ? melde dich an TT zeigt an, dass Ihr Prozess nicht mehr mit einem Terminal verbunden ist. Beachten Sie, dass die PID, PGID, und SID Werte Ihres Prozesses sind gleich. Ihr Prozess ist jetzt ein Sitzungsleiter.

Ändern Sie im nächsten Schritt das Arbeitsverzeichnis entsprechend dem Wert des übergebenen Arguments in das Stammverzeichnis. Sie können das folgende Snippet hinzufügen _dämon Funktion dazu:

if (!nochdir) {
 if (chdir("/") == -1)
Rückkehr-1;
}

Nun können gemäß dem übergebenen Argument alle Dateideskriptoren geschlossen werden. Fügen Sie den folgenden Code hinzu _dämon Funktion:

#define NR_OPEN 1024
if (!noclose) {
 für (i = 0; ich < NR_ÖFFNEN; i++)
 schließen (i);
 offen("/dev/Null", O_RDWR);
 doppelt (0);
 doppelt (0);
}

Nachdem alle Dateideskriptoren geschlossen wurden, werden neue vom Daemon geöffnete Dateien mit den Deskriptoren 0, 1 bzw. 2 angezeigt. In diesem Fall zum Beispiel die Druckf Befehle im Code werden an die zweite geöffnete Datei geleitet. Um dies zu vermeiden, zeigen die ersten drei Bezeichner auf die /dev/null Gerät.

In diesem Fall ist der Endzustand der _dämon Funktion wird wie folgt sein:

#enthalten <sys/types.h>
#enthalten <sys/stat.h>
#enthalten <stdio.h>
#enthalten <stdlib.h>
#enthalten <fcntl.h>
#enthalten <Fehlernr.h>
#enthalten <unistd.h>
#enthalten <syslog.h>
#enthalten <string.h>
int_dämon(Leere){
// PID: Prozess-ID
// SID: Sitzungs-ID
 pid_t pid, sid;
 pid = Gabel (); // Verzweige den übergeordneten Prozess
 wenn (pid < 0) {
Ausfahrt(EXIT_FAILURE);
 }
 wenn (pid > 0) {
Ausfahrt(EXIT_SUCCESS);
 }
 // Erstellen a SIDzumKind
 sid = setsid();
 wenn (sid < 0) {
// SCHEITERN
Ausfahrt(EXIT_FAILURE);
 }
 if ((chdir("/")) < 0) {
// SCHEITERN
Ausfahrt(EXIT_FAILURE);
 }
 schließen (STDIN_FILENO);
 schließen (STDOUT_FILENO);
 schließen (STDERR_FILENO);
während (1) {
// Einige Aufgaben
 schlafen (30);
 }
Ausfahrt(EXIT_SUCCESS);
}

Hier ist ein Beispiel für ein Code-Snippet, das die ausführt sshd Bewerbung als Dämon:

...
if (!(debug_flag || inetd_flag || no_daemon_flag)) {
int fd;
 if (Daemon (0, 0) < 0)
 tödlich("daemon() fehlgeschlagen: %.200s", Strerror (Errno));
/* Verbindung zum steuernden tty trennen. */
 fd = öffnen (_PATH_TTY, O_RDWR | O_NOCTTY);
 wenn (fd >= 0) {
 (Leere) ioctl (fd, TIOCNOTTY, NULL);
 schließen (fd);
 }
}
...

Daemons sind wichtig für die Linux-Systemprogrammierung

Daemons sind Programme, die als Reaktion auf bestimmte Ereignisse verschiedene Aktionen in einer vordefinierten Weise ausführen. Sie laufen unbemerkt auf Ihrem Linux-Rechner. Sie stehen nicht unter der direkten Kontrolle des Benutzers und jeder im Hintergrund laufende Dienst hat seinen Daemon.

Es ist wichtig, Daemons zu beherrschen, um die Kernelstruktur des Linux-Betriebssystems zu lernen und die Funktionsweise verschiedener Systemarchitekturen zu verstehen.

Was ist ein Dämon?

Lesen Sie weiter

Über den Autor