Daemons unter Linux: So schreiben und verwenden Sie einfache Daemons

Der Daemon ist ein spezieller Prozess im Linux-System. Er läuft im Hintergrund ohne Steuerterminal und unterliegt keinen Benutzereingriffen. Er ist für die Ausführung einiger system- oder anwendungsbezogener Aufgaben und Funktionen verantwortlich. Die Rolle des Dämons besteht darin, die Stabilität und Effizienz des Systems zu verbessern, um mit unerwarteten Unfällen oder Anomalien umzugehen. In eingebetteten Linux-Geräten kann der Daemon-Prozess verwendet werden, um den Hauptprozess im System zu schützen und zu verhindern, dass er abnormal beendet wird, was zu einem vollständigen Systemabsturz und einer Zerstörung des Benutzererlebnisses führt. Aber verstehen Sie den Daemon-Prozess unter Linux wirklich? Wissen Sie, wie man einen einfachen Daemon unter Linux schreibt und verwendet? In diesem Artikel werden Ihnen die relevanten Kenntnisse über Daemon-Prozesse unter Linux im Detail vorgestellt, damit Sie diesen leistungsstarken Prozesstyp unter Linux besser nutzen und verstehen können.

Erstellen Sie einen Daemon-Prozess auf einem Linux-Gerät, um den Hauptprozess im System zu schützen und zu verhindern, dass unerwartete Vorfälle dazu führen, dass der Hauptprozess abnormal beendet wird, wodurch das System ohne Reaktion vollständig heruntergefahren wird und das Benutzererlebnis beeinträchtigt wird. Nachdem ich jedoch viele Informationen überprüft hatte, stellte ich fest, dass die meisten Leute nur darüber sprachen, wie man Daemon-Prozesse auf der x86-Plattform erstellt und implementiert, und niemand vorstellte, wie man Daemon-Prozesse auf eingebetteten Plattformen erstellt und implementiert. Nach einiger Erkundung und einem allgemeinen Verständnis von allem, von den Prinzipien bis zum Code, kam ich selbst auf einige Ideen. Nachfolgend finden Sie eine kurze Zusammenfassung und Organisation.

1. Technische Grundsätze

Das Folgende ist ein Auszug aus dem Internet zur Einführung und Beschreibung des Daemon-Prozesses im x86-Linux-System.

Daemon ist ein spezieller Prozess, der im Hintergrund läuft. Er ist unabhängig vom Steuerterminal und führt regelmäßig bestimmte Aufgaben aus oder wartet auf die Verarbeitung bestimmter Ereignisse.

Der Daemon-Prozess ist ein spezieller verwaister Prozess. Warum muss er das Terminal verlassen? Der Grund für die Trennung vom Terminal besteht darin, zu verhindern, dass der Prozess durch von einem Terminal generierte Informationen unterbrochen wird und seine Informationen während der Ausführung auf keinem Terminal angezeigt werden. Da in Linux die Schnittstelle, über die jedes System mit Benutzern kommuniziert, als Terminal bezeichnet wird, wird jeder Prozess, der von diesem Terminal aus ausgeführt wird, an dieses Terminal angeschlossen. Dieses Terminal wird als Steuerterminal dieser Prozesse bezeichnet , Die entsprechenden Prozesse werden automatisch geschlossen. Der Daemon-Prozess kann diese Einschränkung jedoch durchbrechen. Er ist vom Terminal getrennt und läuft im Hintergrund. Der Zweck der Trennung vom Terminal besteht darin, zu verhindern, dass die Informationen während des laufenden Prozesses in irgendeinem Terminal angezeigt werden kann von keinem Terminal abgerufen werden. Wird durch die generierte Terminalnachricht unterbrochen. Es beginnt mit der Ausführung, wenn es ausgeführt wird, und wird erst beendet, wenn das gesamte System heruntergefahren wird (natürlich kann es als Abbruch des entsprechenden Daemon-Prozesses angesehen werden). Wenn Sie möchten, dass ein Prozess nicht durch Benutzer, Unterbrechungen oder andere Änderungen beeinträchtigt wird, müssen Sie diesen Prozess in einen Daemon-Prozess umwandeln.

2. Designschritte

Für Linux-Systeme auf der x86-Plattform verfügt der Daemon-Prozess theoretisch über eine Reihe strenger Implementierungsschritte, um die oben genannten Effekte zu erzielen. Mit anderen Worten: Der Daemon-Prozess muss zu Beginn des Startvorgangs einige systembedingte Einschränkungen beseitigen, damit er stabil im Hintergrund laufen kann, ohne von anderen Aufgaben beeinträchtigt und beeinträchtigt zu werden.

Das Folgende ist der grundlegende Prozess zum Schreiben eines Daemons auf der x86-Plattform:

1. Blockieren Sie einige Signale, die den Terminalbetrieb steuern. Dadurch soll verhindert werden, dass das Steuerterminal gestört wird und beendet wird oder hängen bleibt, bevor der Daemon ausgeführt wird. Weitere Informationen zur Verwendung von Signalen finden Sie unter „Verarbeitung von Signalunterbrechungen“.
2. Läuft im Hintergrund. Dadurch wird der Daemon-Prozess in den Hintergrund gestellt, um ein Hängenbleiben des Steuerterminals zu vermeiden. Die Methode besteht darin, fork() im Prozess aufzurufen, um den übergeordneten Prozess zu beenden und den Daemon im Hintergrund im untergeordneten Prozess ausführen zu lassen.
3. Trennen Sie die Kontrolle über Terminals, Anmeldesitzungen und Prozessgruppen. Zunächst muss die Beziehung zwischen Prozessen und Steuerterminals, Anmeldesitzungen und Prozessgruppen in Linux eingeführt werden: Ein Prozess gehört zu einer Prozessgruppe, und die Prozessgruppennummer (GID) ist die Prozessnummer (PID) des Prozessgruppenleiters . Eine Anmeldesitzung kann mehrere Prozessgruppen enthalten. Diese Prozessgruppen teilen sich ein Steuerterminal. Dieses steuernde Terminal ist normalerweise das Shell-Anmeldeterminal, von dem aus der Prozess erstellt wurde. Steuernde Terminals, Anmeldesitzungen und Prozessgruppen werden normalerweise vom übergeordneten Prozess geerbt. Unser Ziel ist es, sie loszuwerden und nicht von ihnen betroffen zu sein. Daher muss setsid() aufgerufen werden, um den untergeordneten Prozess zum neuen Sitzungsleiter zu machen. Nachdem der Aufruf von setsid () erfolgreich war, wird der Prozess zum neuen Sitzungsgruppenleiter und neuen Prozessgruppenleiter und wird von der ursprünglichen Anmeldesitzung und Prozessgruppe getrennt. Durch die Exklusivität des Sitzungsprozesses gegenüber dem Kontrollterminal wird gleichzeitig der Prozess vom Kontrollterminal entkoppelt.
4. Verhindert, dass der Prozess das steuernde Terminal erneut öffnet. Jetzt ist der Prozess zum terminallosen Sitzungsleiter geworden, kann aber erneut angewendet werden, um ein steuerndes Terminal zu öffnen. Sie können verhindern, dass ein Prozess das steuernde Terminal erneut öffnet, indem Sie ihn nicht mehr zum Sitzungsleiter machen, indem Sie erneut einen untergeordneten Prozess erstellen.
5. Schließen Sie einen geöffneten Dateideskriptor. Ein Prozess erbt offene Dateideskriptoren vom übergeordneten Prozess, der ihn erstellt hat. Wenn es nicht geschlossen wird, werden Systemressourcen verschwendet, das Dateisystem, in dem sich der Prozess befindet, kann nicht ausgehängt werden und es treten unvorhersehbare Fehler auf.
6. Ändern Sie das aktuelle Arbeitsverzeichnis. Während ein Prozess aktiv ist, kann die Bereitstellung des Dateisystems, das sein Arbeitsverzeichnis enthält, nicht aufgehoben werden. Im Allgemeinen müssen Sie das Arbeitsverzeichnis in das Stammverzeichnis ändern. Für Core-Dumps, die durchgeführt werden müssen, ändert der Prozess, der das Ausführungsprotokoll schreibt, das Arbeitsverzeichnis in ein bestimmtes Verzeichnis, z. B. /tmp.
7. Dateierstellungsmaske zurücksetzen. Ein Prozess erbt die Dateierstellungsmaske vom übergeordneten Prozess, der ihn erstellt hat. Es kann die Zugriffsberechtigungen der vom Daemon erstellten Dateien ändern. Um dies zu verhindern, muss die Dateierstellungsmaske gelöscht werden.
8. Behandeln Sie das SIGCHLD-Signal. Für einige Prozesse, insbesondere Serverprozesse, werden häufig untergeordnete Prozesse generiert, um Anfragen zu verarbeiten, wenn Anfragen eingehen. Wenn der übergeordnete Prozess nicht auf das Ende des untergeordneten Prozesses wartet, wird der untergeordnete Prozess zu einem Zombie-Prozess (Zombie) und belegt Systemressourcen (weitere Informationen zu Zombie-Prozessen finden Sie unter „Zombie-Prozesse“). Wenn der übergeordnete Prozess auf das Ende des untergeordneten Prozesses wartet, erhöht dies die Belastung des übergeordneten Prozesses und beeinträchtigt die Parallelitätsleistung des Serverprozesses. Unter Linux können Sie die Funktion des SIGCHLD-Signals einfach auf SIG_IGN setzen. Auf diese Weise generiert der Kernel keine Zombie-Prozesse, bis der untergeordnete Prozess endet.

–
Das Folgende ist ein vollständiger Satz Quellcode aus dem Blog eines Seniors:

#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
int init_daemon(void) { 
    int pid; int i; // 1）屏蔽一些控制终端操作的信

号  signal(SIGTTOU,SIG_IGN); signal(SIGTTIN,SIG_IGN); signal(SIGTSTP,SIG_IGN); signal(SIGHU

P ,SIG_IGN); // 2）在后台运行  if( pid=fork() ){// 父进程  exit(0);//结束父进程，子进程继

续  }else if(pid 的宏定义  // NOFILE 为文件描述符最大个数，不同系统有不同限

制  for(i=0; i

3. Tatsächliche Situation

Aus der obigen Prozesslogik und dem tatsächlichen Code geht hervor, dass der Daemon-Prozess der x86-Plattform tatsächlich recht komplex ist und eine Reihe langwieriger Initialisierungsprozesse erfordert. Bei eingebetteten Plattformen scheint der Prozess jedoch einfacher zu sein, da die Verarbeitung nicht so kompliziert ist. Denn der Daemon-Prozess ist in diesem eingebetteten System aktiviert. Der Zweck besteht einfach darin, mit diesem Daemon-Prozess einen anderen Daemon-Prozess zu starten und dann regelmäßig zu überwachen, ob der Prozess noch normal läuft. Sobald festgestellt wird, dass er abnormal läuft, starten Sie den Prozess einfach sofort neu.

Also habe ich den obigen Prozess vereinfacht und den folgenden Prozess erhalten:

1. Starten Sie den Prozess, der im Daemon-Prozess überwacht werden muss.
2. Erstellen Sie einen Thread im Daemon-Prozess, um regelmäßig den Ausführungsstatus des Daemon-Prozesses zu überwachen
3. Der Daemon-Prozess stellt fest, ob der dämonisierte Prozess noch normal läuft. Sobald er feststellt, dass er abnormal läuft, startet er den Prozess sofort neu.

– 4. Tatsächlicher Quellcode

Das Folgende ist der vollständige Code des Daemon-Prozessmoduls, das in diesem eingebetteten Systemprojekt entwickelt wurde.

/******************************************************************************************

******** ** 函数名称: lockfile ** 功能描述: 对文件加锁/解锁 ** 输入参数: lock: 1表示进行加锁处理，

0表示进行解锁处理 ** 输出参数: 无 ** 返回参

数: 无 *************************************************************************************

*************/ int tryto_lockfile(int fd, int lock) { struct flock fl; fl.l_type = (lock =

= 1) ? F_WRLCK : F_UNLCK; fl.l_start = 0; fl.l_whence = SEEK_SET; fl.l_len = 0; return (f

cntl(fd, F_SETLK, &fl)); } /***************************************************************

*********************************** ** 函数名称: get_proc_running_state ** 功能描述: 获取进程

运行状态 ** 输入参数: 无 ** 输出参数: 无 ** 返回参数: 返回-1表示路径错误 ** 返回参数: 返回0表示进程

从未运行过，返回1表示进程曾经运行过但是现在停止运行了，返回2表示进程正在运行

中 ****************************************************************************************

**********/ static int get_proc_running_state(const char* filename) { int fd; if (filename

 == NULL) { /* 文件名为

空 */ return -1; } fd = open(filename, O_RDWR, (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)); i

f (fd 0) { /* 文件不存在，表示进程从未运行

过 */ return 0; } if (tryto_lockfile(fd, 1) == -1) { /* 文件加锁失败，表示进程在运行

中 */ close(fd); return 2; } else { /* 文件加锁成功，表示进程已经消

失 */ tryto_lockfile(fd, 0); /* 此处要注意记得解锁和关闭文

件 */ close(fd); return 1; } } /***********************************************************

*************************************** ** 函数名称: proc_watch ** 功能描述: 检测进程是否有在运

行，没有运行则重新启动之 ** 输入参数: procname: 进程名 ** 输出参数: 无 ** 返回参数: 返回-1表示进程从

未运行过；返回0表示进程当前运行正常； ** 返回参数: 返回其他非零值表示进程不存在且已被重新启动，返回的值

是新的pid值 ***************************************************************************

***********************/ int proc_watch(const char *procname) { int result, state; char fi

lename[100]; result = 0; sprintf(filename, "/var/run/%s.pid", procname); state = get_proc_

running_state(filename); switch (state) { case 0: result = -1; break; case 1: result = sta

rt_proc_by_name(procname); break; case 2: result = 0; break; default: break; } return resu

lt; } /************************************************************************************

************** ** 函数名称: start_proc ** 功能描述: 启动进程开始运行 ** 输入参数: 无 ** 输出参

数: 无 ** 返回参数: 进程的ID号，若启动失败则返回

0 *****************************************************************************************

*********/ int start_proc_by_name(const char* procname) { pid_t pid, child_pid; char filen

ame[100]; sprintf(filename, "%s%s", PROC_FILE_PATH, procname); child_pid = 0; if (access(f

ilename, X_OK | F_OK) != 0) { /* 如果文件存在，并且可执行 */ return 0; } pid = fork(); /* 首

先要fork一个进程出来 */ if (pid 0) { /* 创建进程失

败 */ return 0; } else if (pid == 0) { /* 创建进程成功，此处是子进程的代

码 */ if (execl(filename, procname, (char *)NULL) != -1) { return 1; } else { return 0; } 

} else { /* 创建进程成功，此处是父进程代


******************************************************************* ** 函数名

称: thread_client_hdl ** 功能描述: client进程监视线程 ** 输入参数: 无 ** 输出参数: 无 ** 返回参

数: 无 *************************************************************************************

*************/ static void *thread_client_hdl(void *pdata) { int result; pdata = pdata; sl

eep(10); /* 第一次要进行延

时 */ for (;;) { printf("time to check thread_client...\n"); result = proc_watch(PROC_NAME



_CLIENT); if (result == -1) { printf("thread_client never exist...\n"); } else if (result 

== 0) { printf("thread_client running ok...\n"); } else { printf("thread_client has gone! 

but restarted...\n"); } sleep(10); } return NULL; } /*************************************

************************************************************* ** 函数名称: main ** 功能描

述: 入口主函数 ** 输入参数: 无 ** 输出参数: 无 ** 返回参

数: 无 *************************************************************************************

*************/ int main(int argc, char *argv[]) { int client_para; char *p, *process_name;

 pthread_t thread_client; process_name = argv[0]; /* 获取进程名

称 */ p = process_name + strlen(process_name); while (*p != '/' && p != process_name) { p-

-; } if (*p == '/') { process_name = p + 1; } printf("\"%s\" starting...\n", process_name)

; client_para = 0x01; if (pthread_create(&thread_client, NULL, thread_client_hdl, &client_

para) != 0) { printf("create thread_client failed!\n"); return 1; } if (start_proc_by_name

(PROC_NAME_CLIENT) == 0) { printf("start thread_client failed!\n"); return 1; } for (;;) {

 sleep(60); printf("i am still alive...\n"); } return 0; }

通过本文，你应该对 Linux 下的守护进程有了一个基本的了解，知道了它的定义、特点和用途。你也应该明白了如何在 Linux 下编写和使用简单的守护进程，以及使用守护进程时需要注意的一些问题和技巧。我们建议你在使用 Linux 系统时，使用守护进程来提高系统的稳定性和效率。同时，我们也提醒你在使用守护进程时要注意一些潜在的问题和挑战，如信号处理、日志记录、资源管理等。希望本文能够帮助你更好地使用 Linux 系统，让你在 Linux 下掌握守护进程的编写和使用。

Das obige ist der detaillierte Inhalt vonDaemons unter Linux: So schreiben und verwenden Sie einfache Daemons. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!