Hoe maak je een Daemon op Linux

Daemons zijn processen die niet direct onder controle van de gebruiker worden uitgevoerd, maar op de achtergrond worden uitgevoerd. Gewoonlijk beginnen ze bij het opstarten van het systeem en lopen ze continu door totdat het systeem wordt uitgeschakeld. Het enige verschil tussen deze en normale processen is dat ze op geen enkele manier berichten naar de console of het scherm sturen.

Hier leest u hoe u een daemon kunt maken op een Linux-machine.

Een korte introductie over hoe Daemons worden gemaakt

Veel daemons draaien op het systeem en enkele bekende daemon-voorbeelden zijn als volgt:

• crond: Laat opdrachten uitvoeren op het opgegeven tijdstip
• sshd: Staat inloggen op het systeem toe vanaf externe machines
• httpd: Biedt webpagina's aan
• nfsd: Staat het delen van bestanden via het netwerk toe

Ook worden daemon-processen meestal genoemd om te eindigen met de letter d, hoewel het niet verplicht is.

Om een ​​proces als een daemon te laten draaien, wordt het volgende pad gevolgd:

• De eerste bewerkingen, zoals het lezen van configuratiebestanden of het verkrijgen van de benodigde systeembronnen, moeten worden uitgevoerd voordat het proces een daemon wordt. Op deze manier kan het systeem de ontvangen fouten melden aan de gebruiker en wordt het proces beëindigd met een passende foutcode.
  instagram viewer
• Er wordt een lopend proces op de achtergrond gemaakt met init als bovenliggend proces. Hiertoe wordt eerst een subproces uit het init-proces gevorkt en vervolgens wordt het bovenste proces met exit beëindigd.
• Een nieuwe sessie moet worden geopend door de setsid-functie aan te roepen en het proces moet worden losgekoppeld van de terminal.
• Alle open bestandsdescriptors die zijn overgenomen van het bovenliggende proces, zijn gesloten.
• Standaard invoer, uitvoer, en foutmeldingen worden omgeleid naar /dev/null.
• De werkdirectory van het proces moet veranderen.

Wat zijn Daemon-sessies?

Nadat ze via een terminal op het systeem zijn ingelogd, kunnen gebruikers veel applicaties uitvoeren via het shell-programma. Deze processen zouden moeten sluiten wanneer de gebruiker het systeem verlaat. Het besturingssysteem groepeert deze processen in sessie- en procesgroepen.

Elke sessie bestaat uit procesgroepen. U kunt deze situatie als volgt omschrijven:

De terminal waar de processen hun invoer ontvangen en hun uitvoer verzenden, wordt de controlerende terminal genoemd. Een besturingsterminal is slechts aan één sessie tegelijk gekoppeld.

Een sessie en de procesgroepen daarin hebben identificatie (ID) nummers; deze identificatienummers zijn de procesidentificatienummers (PID) van de sessie- en procesgroepleiders. Een onderliggend proces deelt dezelfde groep als het bovenliggende proces. Wanneer meerdere processen zijn communiceren met het pijpmechanisme, wordt het eerste proces de procesgroepleider.

Een Daemon-proces maken op Linux

Hier ziet u hoe u een daemon-functie kunt maken. Voor dit doel maakt u een functie met de naam _demon. U kunt beginnen door de applicatiecode die als een daemon wordt uitgevoerd een naam te geven als test.c, en de code waarmee u de daemon-functie gaat maken als daemon.c.

//test.c
#erbij betrekken <stdio.h>
int_demon(int, int);
inthoofd()
{
	getchar();
	_daemon (0, 0);
	getchar();
opbrengst0;
}

//daemon.c
#erbij betrekken <sys/types.h>
#erbij betrekken <sys/stat.h>
#erbij betrekken <stdlib.h>
#erbij betrekken <stdio.h>
#erbij betrekken <fcntl.h>
#erbij betrekken <unistd.h>
#erbij betrekken <linux/fs.h>
#erbij betrekken <linux/limits.h>
int_demon(int nochdir, int niet sluiten){
 pid_t pid;
 pid = vork(); // Fork uit het bovenliggende proces
 als (pid < 0) {
Uitgang(EXIT_FAILURE);
 }
 als (pid > 0) {
Uitgang(EXIT_SUCCESS);
 }
opbrengst0;
}

Om een ​​daemon te maken, hebt u een achtergrondproces nodig waarvan het bovenliggende proces init is. In de bovenstaande code, _demon maakt een onderliggend proces aan en doodt vervolgens het bovenliggende proces. In dit geval is uw nieuwe proces een subproces van init en blijft het op de achtergrond draaien.

Compileer nu de applicatie met de volgende opdracht en onderzoek de status van het proces voor en na: _deamon wordt genoemd:

gcc-Otesttest.cdemon.c

Start de applicatie en schakel over naar een andere terminal zonder op andere toetsen te drukken:

./test

U kunt zien dat de waarden met betrekking tot uw proces als volgt zijn. Hier, je zult moeten gebruiken het ps-commando om procesgerelateerde informatie te krijgen. In dit geval is de _demon functie is nog niet aangeroepen.

ps -C test -o "pid ppid pgid sid tty statopdracht"
# Uitgang
PID PPID PGID SID TT STAT COMMANDO
10296 5119 10296 5117 punten/2 S+ ./test

Als je kijkt naar de STAT veld ziet, ziet u dat uw proces wordt uitgevoerd, maar wacht op een gebeurtenis die buiten de planning plaatsvindt, waardoor het op de voorgrond wordt uitgevoerd.

U kunt zien dat het bovenliggende proces van uw toepassing de shell is zoals verwacht.

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

Keer nu terug naar de terminal waar u uw toepassing uitvoert en druk op Binnenkomen aanroepen van de _demon functie. Kijk dan nog eens naar de procesinformatie op de andere terminal.

ps -C test -o "pid ppid pgid sid tty statopdracht"
# Uitgang
PID PPID PGID SID TT STAT COMMANDO
22504 1 22481 5117 punten/2 S ./test

Allereerst kun je zeggen dat het nieuwe subproces op de achtergrond draait, omdat je de. niet ziet + karakter in de STAT veld. Onderzoek nu wie het bovenliggende proces van het proces is met behulp van de volgende opdracht:

ps -jp 1 
​​​​​​​# Uitgang 
PID PGID SID TTY TIME CMD
1 1 1? 00:00:01systeemd

U kunt nu zien dat het bovenliggende proces van uw proces de systeemd Verwerken. Hierboven is vermeld dat voor de volgende stap een nieuwe sessie moet worden geopend en dat het proces moet worden losgekoppeld van de bedieningsterminal. Hiervoor gebruik je de setsid functie. Voeg deze oproep toe aan je _demon functie.

Het stukje code dat moet worden toegevoegd is als volgt:

als (setsid() == -1) 
opbrengst-1;

Nu je de staat eerder hebt geïnspecteerd _demon gebeld, u kunt nu de eerste verwijderen getchar functie in de test.c code.

//test.c
#erbij betrekken <stdio.h>
int_demon(int, int);
inthoofd()
{
	_daemon (0, 0);
	getchar();
opbrengst0;
}

Nadat u de applicatie opnieuw hebt gecompileerd en uitgevoerd, gaat u naar de terminal waar u uw beoordelingen hebt gemaakt. De nieuwe status van uw proces is als volgt:

ps -C test -o "pid ppid pgid sid tty statopdracht"
​​​​​​​# Uitgang
PID PPID PGID SID TT STAT COMMANDO
25494 1 25494 25494? ss./test

De ? meld je aan TT veld geeft aan dat uw proces niet langer is verbonden met een terminal. Merk op dat de PID, PGID, en SID waarden van uw proces zijn hetzelfde. Uw proces is nu een sessieleider.

Wijzig in de volgende stap de werkdirectory in de hoofddirectory volgens de waarde van het argument dat u hebt doorgegeven. U kunt het volgende fragment toevoegen aan de _demon functie hiervoor:

als (!nochdir) {
 als (chdir("/") == -1)
opbrengst-1;
}

Nu, volgens het doorgegeven argument, kunnen alle bestandsdescriptors worden gesloten. Voeg de volgende code toe aan de _demon functie:

#define NR_OPEN 1024
if (!noclose) {
 voor (i = 0; i < NR_OPEN; ik++)
 sluiten (ik);
 open("/dev/nul", O_RDWR);
 dup (0);
 dup (0);
}

Nadat alle bestandsdescriptors zijn gesloten, worden nieuwe bestanden geopend door daemon weergegeven met respectievelijk de descriptors 0, 1 en 2. In dit geval is bijvoorbeeld de printf commando's in de code worden doorgestuurd naar het tweede geopende bestand. Om dit te voorkomen, wijzen de eerste drie identifiers naar de /dev/null apparaat.

In dit geval is de eindtoestand van de _demon functie zal als volgt zijn:

#erbij betrekken <sys/types.h>
#erbij betrekken <sys/stat.h>
#erbij betrekken <stdio.h>
#erbij betrekken <stdlib.h>
#erbij betrekken <fcntl.h>
#erbij betrekken <errno.h>
#erbij betrekken <unistd.h>
#erbij betrekken <syslog.h>
#erbij betrekken <string.h>
int_demon(leegte){
// PID: proces-ID
// SID: Sessie-ID
 pid_t pid, sid;
 pid = vork(); // Fork uit het bovenliggende proces
 als (pid < 0) {
Uitgang(EXIT_FAILURE);
 }
 als (pid > 0) {
Uitgang(EXIT_SUCCESS);
 }
 // Creëren a SIDvoorkind
 sid = setsid();
 als (sid < 0) {
// MISLUKKING
Uitgang(EXIT_FAILURE);
 }
 als ((chdir("/")) < 0) {
// MISLUKKING
Uitgang(EXIT_FAILURE);
 }
 sluiten (STDIN_FILENO);
 sluiten (STDOUT_FILENO);
 sluiten (STDERR_FILENO);
terwijl (1) {
// Sommige taken
 slapen (30);
 }
Uitgang(EXIT_SUCCESS);
}

Hier is een voorbeeld van een codefragment dat de. uitvoert sshd toepassing als een demon:

...
if (!(debug_flag || inetd_flag || no_daemon_flag)) {
int fd;
 als (daemon (0, 0) < 0)
 dodelijk ("daemon() mislukt: %.200s", strerror (errno));
/* Verbreek de verbinding met de controlerende tty. */
 fd = open (_PATH_TTY, O_RDWR | O_NOCTTY);
 als (fd >= 0) {
 (leegte) ioctl (fd, TIOCNOTTY, NULL);
 sluiten (fd);
 }
}
...

Daemons zijn belangrijk voor Linux-systeemprogrammering

Daemons zijn programma's die verschillende acties uitvoeren op een vooraf gedefinieerde manier die is ingesteld als reactie op bepaalde gebeurtenissen. Ze draaien geruisloos op je Linux-machine. Ze staan ​​niet onder de directe controle van de gebruiker en elke service die op de achtergrond draait, heeft zijn daemon.

Het is belangrijk om daemons onder de knie te krijgen om de kernelstructuur van het Linux-besturingssysteem te leren kennen en om de werking van verschillende systeemarchitecturen te begrijpen.

Wat is een daemon?

Lees volgende

Over de auteur