Hur man skapar en Daemon på Linux

Demoner är processer som inte körs direkt under användarens kontroll utan fungerar i bakgrunden. Vanligtvis startar de vid systemstart och körs kontinuerligt tills systemet stängs av. Den enda skillnaden mellan dessa och normala processer är att de inte skickar meddelanden till konsolen eller skärmen på något sätt.

Så här kan du skapa en demon på en Linux-maskin.

En kort introduktion till hur demoner skapas

Många demoner körs på systemet och några välbekanta demonexempel är följande:

• crond: Gör att kommandon körs vid den angivna tiden
• sshd: Tillåter inloggning till systemet från fjärrdatorer
• httpd: Serverar webbsidor
• nfsd: Tillåter fildelning över nätverket

Demonprocesser brukar också kallas för att sluta med bokstaven d, även om det inte är obligatoriskt.

För att en process ska köras som en demon, följs följande sökväg:

• Inledande operationer, som att läsa konfigurationsfiler eller skaffa nödvändiga systemresurser, måste utföras innan processen blir en demon. På så sätt kan systemet rapportera de mottagna felen till användaren och processen kommer att avslutas med en lämplig felkod.
instagram viewer
• En bakgrundsprocess skapas med init som sin överordnade process. För detta ändamål delas en delprocess från init-processen först, och sedan avslutas den övre processen med exit.
• En ny session bör öppnas genom att anropa setsid-funktionen, och processen bör kopplas bort från terminalen.
• Alla öppna filbeskrivningar som ärvts från den överordnade processen stängs.
• Standard ingång, utgång, och felmeddelanden omdirigeras till /dev/null.
• Arbetskatalogen för processen måste ändras.

Vad är Daemon-sessioner?

Efter att ha loggat in i systemet via en terminal kan användare köra många applikationer genom skalprogrammet. Dessa processer bör stängas när användaren lämnar systemet. Operativsystemet grupperar dessa processer i sessions- och processgrupper.

Varje session består av processgrupper. Du kan beskriva den här situationen så här:

Terminalen där processerna tar emot sina ingångar och skickar sina utgångar kallas den styrande terminalen. En kontrollerande terminal är associerad med endast en session åt gången.

En session och processgrupperna i den har identifieringsnummer (ID); dessa identifikationsnummer är processidentifieringsnumren (PID) för sessions- och processgruppsledarna. En underordnad process delar samma grupp som sin överordnade process. När flera processer är kommunicerar med rörmekanismen, den första processen blir processgruppsledare.

Skapa en Daemon-process på Linux

Här kommer du att se hur du kan skapa en demonfunktion. För detta ändamål kommer du att skapa en funktion som heter _demon. Du kan börja med att namnge applikationskoden som kommer att köras som en demon som test.c, och koden som du kommer att skapa demonfunktionen som daemon.c.

//test.c
#omfatta <stdio.h>
int_demon(int, int);
inthuvud()
{
	getchar();
	_daemon (0, 0);
	getchar();
lämna tillbaka0;
}

//daemon.c
#omfatta <sys/types.h>
#omfatta <sys/stat.h>
#omfatta <stdlib.h>
#omfatta <stdio.h>
#omfatta <fcntl.h>
#omfatta <unistd.h>
#omfatta <linux/fs.h>
#omfatta <linux/limits.h>
int_demon(int nochdir, int noclose){
 pid_t pid;
 pid = gaffel(); // Ta bort föräldraprocessen
 om (pid < 0) {
utgång(EXIT_FAILURE);
 }
 om (pid > 0) {
utgång(EXIT_SUCCESS);
 }
lämna tillbaka0;
}

För att skapa en demon behöver du en bakgrundsprocess vars överordnade process är påbörjad. I koden ovan, _demon skapar en underordnad process och dödar sedan föräldraprocessen. I det här fallet kommer din nya process att vara en underprocess av init och kommer att fortsätta att köras i bakgrunden.

Kompilera nu applikationen med följande kommando och undersök statusen för processen före och efter _deamon kallas:

gcc-otestatesta.cdemon.c

Kör applikationen och byt till en annan terminal utan att trycka på några andra tangenter:

./testa

Du kan se att värdena relaterade till din process är följande. Här måste du använda kommandot ps för att få processrelaterad information. I det här fallet _demon Funktionen har inte anropats ännu.

ps -C testa -o "pid ppid pgid sid tty statistikkommando"
# Utgång
PID PPID PGID SID TT STATKOMMANDAND
10296 5119 10296 5117 pts/2 S+ ./testa

När du tittar på STATISTIK fältet ser du att din process körs men väntar på att en händelse utanför schemat ska inträffa som gör att den körs i förgrunden.

Du kan se att den överordnade processen för din ansökan är skalet som förväntat.

ps -jp 5119 
# Utgång 
PID PGID SID TTY TID CMD
5119 5119 5117 pts/2 00:00:02 zsh

Gå nu tillbaka till terminalen där du kör din applikation och tryck Stiga på att åberopa _demon fungera. Titta sedan på processinformationen på den andra terminalen igen.

ps -C testa -o "pid ppid pgid sid tty statistikkommando"
# Utgång
PID PPID PGID SID TT STATKOMMANDAND
22504 1 22481 5117 poäng/2 S ./testa

Först och främst kan du säga att den nya delprocessen körs i bakgrunden eftersom du inte ser + karaktär i STATISTIK fält. Undersök nu vem som är förälderprocessen för processen med följande kommando:

ps -jp 1 
​​​​​​​# Utgång 
PID PGID SID TTY TID CMD
1 1 1? 00:00:01systemd

Du kan nu se att föräldraprocessen för din process är systemd bearbeta. Det nämns ovan att för nästa steg bör en ny session öppnas och processen bör kopplas bort från kontrollterminalen. För detta använder du setsid-funktionen. Lägg till detta samtal till din _demon fungera.

Kodbiten som ska läggas till är följande:

if (setsid() == -1) 
lämna tillbaka-1;

Nu när du har inspekterat staten tidigare _demon ringde kan du nu ta bort den första getchar funktion i test.c koda.

//test.c
#omfatta <stdio.h>
int_demon(int, int);
inthuvud()
{
	_daemon (0, 0);
	getchar();
lämna tillbaka0;
}

Efter att ha sammanställt och kört programmet igen, gå till terminalen där du gjorde dina recensioner. Den nya statusen för din process är som följer:

ps -C testa -o "pid ppid pgid sid tty statistikkommando"
​​​​​​​# Utgång
PID PPID PGID SID TT STATKOMMANDAND
25494 1 25494 25494? Ss ./testa

De ? logga in TT fältet indikerar att din process inte längre är ansluten till en terminal. Lägg märke till att PID, PGID, och SID värderingarna i din process är desamma. Din process är nu en sessionsledare.

I nästa steg ändrar du arbetskatalogen till rotkatalogen enligt värdet på argumentet du skickade. Du kan lägga till följande utdrag till _demon funktion för detta:

if (!nochdir) {
 if (chdir("/") == -1)
lämna tillbaka-1;
}

Nu, enligt argumentet som passerats, kan alla fildeskriptorer stängas. Lägg till följande kod till _demon fungera:

#define NR_OPEN 1024
if (!noclose) {
 för (i = 0; i < NR_OPEN; i++)
 nära (i);
 öppen("/dev/null", O_RDWR);
 dup (0);
 dup (0);
}

Efter att alla filbeskrivningar har stängts kommer nya filer som öppnas av daemon att visas med deskriptorerna 0, 1 respektive 2. I det här fallet, till exempel printf kommandon i koden kommer att dirigeras till den andra öppnade filen. För att undvika detta pekar de tre första identifierarna på /dev/null enhet.

I det här fallet är det slutliga tillståndet för _demon funktionen blir som följer:

#omfatta <sys/types.h>
#omfatta <sys/stat.h>
#omfatta <stdio.h>
#omfatta <stdlib.h>
#omfatta <fcntl.h>
#omfatta <errno.h>
#omfatta <unistd.h>
#omfatta <syslog.h>
#omfatta <sträng.h>
int_demon(tomhet){
// PID: Process ID
// SID: Sessions-ID
 pid_t pid, sid;
 pid = gaffel(); // Ta bort föräldraprocessen
 om (pid < 0) {
utgång(EXIT_FAILURE);
 }
 om (pid > 0) {
utgång(EXIT_SUCCESS);
 }
 // Skapa a SIDförbarn
 sid = setsid();
 om (sid < 0) {
// FAIL
utgång(EXIT_FAILURE);
 }
 om ((chdir("/")) < 0) {
// FAIL
utgång(EXIT_FAILURE);
 }
 stäng (STDIN_FILENO);
 stäng (STDOUT_FILENO);
 stäng (STDERR_FILENO);
medan (1) {
// Vissa uppgifter
 sömn (30);
 }
utgång(EXIT_SUCCESS);
}

Här är ett exempel på ett kodavsnitt som kör sshd ansökan som en demon:

...
if (!(debug_flag || inetd_flag || no_daemon_flag)) {
int fd;
 if (demon (0, 0) < 0)
 dödlig("daemon() misslyckades: %.200s", strerror (errno));
/* Koppla bort från den kontrollerande tty. */
 fd = öppen (_PATH_TTY, O_RDWR | O_NOCTTY);
 om (fd >= 0) {
 (tomhet) ioctl (fd, TIOCNOTTY, NULL);
 nära (fd);
 }
}
...

Demoner är viktiga för Linux-systemprogrammering

Demoner är program som utför olika åtgärder på ett fördefinierat sätt som svar på vissa händelser. De körs tyst på din Linux-maskin. De är inte under direkt kontroll av användaren och varje tjänst som körs i bakgrunden har sin demon.

Det är viktigt att bemästra demoner för att lära sig kärnstrukturen i Linux-operativsystemet och för att förstå hur olika systemarkitekturer fungerar.

Vad är en Daemon?

Läs Nästa

Om författaren