Hvordan lage en Daemon på Linux

Demoner er prosesser som ikke kjører direkte under kontroll av brukeren, men fungerer i bakgrunnen. Vanligvis starter de ved systemoppstart og kjører kontinuerlig til systemet slår seg av. Den eneste forskjellen mellom disse og vanlige prosesser er at de ikke sender meldinger til konsollen eller skjermen på noen måte.

Her er hvordan du kan lage en demon på en Linux-maskin.

En kort introduksjon til hvordan demoner skapes

Mange demoner kjører på systemet, og noen kjente daemon-eksempler er som følger:

• krone: Får kommandoer til å kjøre på det angitte tidspunktet
• sshd: Tillater pålogging til systemet fra eksterne maskiner
• httpd: Serverer nettsider
• nfsd: Tillater fildeling over nettverket

Også demonprosesser er vanligvis navngitt til å slutte med bokstaven d, selv om det ikke er obligatorisk.

For at en prosess skal kjøre som en demon, følges følgende bane:

• Innledende operasjoner, som å lese konfigurasjonsfiler eller skaffe nødvendige systemressurser, må utføres før prosessen blir en demon. På denne måten kan systemet rapportere de mottatte feilene til brukeren og prosessen vil bli avsluttet med en passende feilkode.
  instagram viewer
• En løpende bakgrunnsprosess opprettes med init som overordnet prosess. For dette formålet blir en delprosess forked fra init-prosessen først, og deretter avsluttes den øvre prosessen med exit.
• En ny økt skal åpnes ved å kalle setsid-funksjonen, og prosessen skal kobles fra terminalen.
• Alle åpne filbeskrivelser som er arvet fra den overordnede prosessen, er lukket.
• Standard inngang, utgang, og feilmeldinger blir omdirigert til /dev/null.
• Arbeidskatalogen til prosessen må endres.

Hva er Daemon-økter?

Etter å ha logget på systemet via en terminal, kan brukere kjøre mange applikasjoner gjennom shell-programmet. Disse prosessene skal lukkes når brukeren går ut av systemet. Operativsystemet grupperer disse prosessene i økt- og prosessgrupper.

Hver økt består av prosessgrupper. Du kan beskrive denne situasjonen som følger:

Terminalen der prosessene mottar sine innganger og sender sine utganger kalles den kontrollerende terminalen. En kontrollerende terminal er knyttet til kun én økt om gangen.

En sesjon og prosessgruppene i den har identifikasjonsnummer (ID); disse identifikasjonsnumrene er prosessidentifikasjonsnumrene (PID) til sesjons- og prosessgruppeledere. En underordnet prosess deler den samme gruppen som sin overordnede prosess. Når flere prosesser er kommuniserer med rørmekanismen, den første prosessen blir prosessgruppeleder.

Opprette en Daemon-prosess på Linux

Her vil du se hvordan du kan lage en daemon-funksjon. For dette formålet vil du opprette en funksjon som heter _daemon. Du kan starte med å navngi applikasjonskoden som skal kjøres som en demon som test.c, og koden du vil lage daemon-funksjonen som daemon.c.

//test.c
#inkludere <stdio.h>
int_daemon(int, int);
inthoved-()
{
	getchar();
	_daemon (0, 0);
	getchar();
komme tilbake0;
}

//daemon.c
#inkludere <sys/types.h>
#inkludere <sys/stat.h>
#inkludere <stdlib.h>
#inkludere <stdio.h>
#inkludere <fcntl.h>
#inkludere <unistd.h>
#inkludere <linux/fs.h>
#inkludere <linux/limits.h>
int_daemon(int nochdir, int noclose){
 pid_t pid;
 pid = gaffel(); // Forkast den overordnede prosessen
 hvis (pid < 0) {
exit(EXIT_FAILURE);
 }
 hvis (pid > 0) {
exit(EXIT_SUCCESS);
 }
komme tilbake0;
}

For å lage en demon trenger du en bakgrunnsprosess hvis overordnede prosess er igangsatt. I koden ovenfor, _daemon oppretter en barneprosess og dreper deretter foreldreprosessen. I dette tilfellet vil den nye prosessen din være en underprosess av init og vil fortsette å kjøre i bakgrunnen.

Kompiler nå applikasjonen med følgende kommando og undersøk statusen til prosessen før og etter _deamon er kalt:

gcc-otesttest.cdemon.c

Kjør programmet og bytt til en annen terminal uten å trykke på noen andre taster:

./test

Du kan se at verdiene knyttet til prosessen din er som følger. Her må du bruke ps-kommandoen for å få prosessrelatert informasjon. I dette tilfellet _daemon funksjonen er ikke kalt ennå.

ps -C test -o "pid ppid pgid sid tty statkommando"
# Utgang
PID PPID PGID SID TT STAT KOMMANDO
10296 5119 10296 5117 poeng/2 S+ ./test

Når du ser på STAT feltet, ser du at prosessen kjører, men venter på at en hendelse utenfor planen skal oppstå som vil føre til at den kjører i forgrunnen.

Du kan se at overordnet prosessen for søknaden din er skallet som forventet.

ps -jp 5119 
# Utgang 
PID PGID SID TTY TID CMD
5119 5119 5117 poeng/2 00:00:02 zsh

Gå nå tilbake til terminalen der du kjører applikasjonen og trykk Tast inn å påberope seg _daemon funksjon. Se så på prosessinformasjonen på den andre terminalen igjen.

ps -C test -o "pid ppid pgid sid tty statkommando"
# Utgang
PID PPID PGID SID TT STAT KOMMANDO
22504 1 22481 5117 poeng/2 S ./test

Først av alt kan du si at den nye underprosessen kjører i bakgrunnen siden du ikke ser + karakter i STAT felt. Undersøk nå hvem som er den overordnede prosessen til prosessen ved å bruke følgende kommando:

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

Du kan nå se at den overordnede prosessen til prosessen din er systemd prosess. Det er nevnt ovenfor at for neste trinn skal en ny økt åpnes og prosessen kobles fra kontrollterminalen. Til dette bruker du setsid-funksjonen. Legg denne samtalen til din _daemon funksjon.

Kodebiten som skal legges til er som følger:

if (setsid() == -1) 
komme tilbake-1;

Nå som du har inspisert staten før _daemon kalt, kan du nå fjerne den første getchar funksjon i test.c kode.

//test.c
#inkludere <stdio.h>
int_daemon(int, int);
inthoved-()
{
	_daemon (0, 0);
	getchar();
komme tilbake0;
}

Etter å ha kompilert og kjørt applikasjonen på nytt, gå til terminalen der du la anmeldelsene dine. Den nye statusen for prosessen din er som følger:

ps -C test -o "pid ppid pgid sid tty statkommando"
​​​​​​​# Utgang
PID PPID PGID SID TT STAT KOMMANDO
25494 1 25494 25494? Ss ./test

De ? logg inn på TT feltet indikerer at prosessen din ikke lenger er koblet til en terminal. Legg merke til at PID, PGID, og SID verdiene i prosessen din er de samme. Din prosess er nå en sesjonsleder.

I neste trinn endrer du arbeidskatalogen til rotkatalogen i henhold til verdien av argumentet du sendte. Du kan legge til følgende utdrag til _daemon funksjon for dette:

if (!nochdir) {
 if (chdir("/") == -1)
komme tilbake-1;
}

Nå, i henhold til argumentet som ble bestått, kan alle filbeskrivelser lukkes. Legg til følgende kode til _daemon funksjon:

#define NR_OPEN 1024
if (!noclose) {
 for (i = 0; Jeg < NR_OPEN; i++)
 lukke (i);
 åpen("/dev/null", O_RDWR);
 dup (0);
 dup (0);
}

Etter at alle filbeskrivelser er lukket, vil nye filer åpnet av daemon vises med beskrivelsene 0, 1 og 2 henholdsvis. I dette tilfellet, for eksempel printf kommandoer i koden vil bli dirigert til den andre åpnede filen. For å unngå dette peker de tre første identifikatorene til /dev/null enhet.

I dette tilfellet er den endelige tilstanden til _daemon funksjonen vil være som følger:

#inkludere <sys/types.h>
#inkludere <sys/stat.h>
#inkludere <stdio.h>
#inkludere <stdlib.h>
#inkludere <fcntl.h>
#inkludere <errno.h>
#inkludere <unistd.h>
#inkludere <syslog.h>
#inkludere <streng.h>
int_daemon(tomrom){
// PID: Prosess-ID
// SID: Sesjons-ID
 pid_t pid, sid;
 pid = gaffel(); // Forkast den overordnede prosessen
 hvis (pid < 0) {
exit(EXIT_FAILURE);
 }
 hvis (pid > 0) {
exit(EXIT_SUCCESS);
 }
 // Skape en SIDtilbarn
 sid = setsid();
 hvis (sid < 0) {
// FAIL
exit(EXIT_FAILURE);
 }
 hvis ((chdir("/")) < 0) {
// FAIL
exit(EXIT_FAILURE);
 }
 lukk (STDIN_FILENO);
 lukk (STDOUT_FILENO);
 lukk (STDERR_FILENO);
samtidig som (1) {
// Noen oppgaver
 søvn (30);
 }
exit(EXIT_SUCCESS);
}

Her er et eksempel på en kodebit som kjører sshd søknad som en demon:

...
if (!(debug_flag || inetd_flag || no_daemon_flag)) {
int fd;
 if (demon (0, 0) < 0)
 fatal("daemon() mislyktes: %.200s", strerror (feilno));
/* Koble fra den kontrollerende tty. */
 fd = åpen (_PATH_TTY, O_RDWR | O_NOCTTY);
 hvis (fd >= 0) {
 (tomrom) ioctl (fd, TIOCNOTTY, NULL);
 lukke (fd);
 }
}
...

Demoner er viktige for Linux-systemprogrammering

Demoner er programmer som utfører ulike handlinger på en forhåndsdefinert måte satt som svar på visse hendelser. De kjører stille på Linux-maskinen din. De er ikke under direkte kontroll av brukeren, og hver tjeneste som kjører i bakgrunnen har sin demon.

Det er viktig å mestre demoner for å lære kjernestrukturen til Linux-operativsystemet og for å forstå hvordan ulike systemarkitekturer fungerer.

Hva er en demon?

Les Neste

Om forfatteren