Cum se creează un daemon pe Linux

Demonii sunt procese care nu rulează direct sub controlul utilizatorului, ci servesc în fundal. De obicei, pornesc la pornirea sistemului și rulează continuu până când sistemul se oprește. Singura diferență dintre acestea și procesele normale este că nu trimit mesaje către consolă sau ecran în niciun fel.

Iată cum puteți crea un daemon pe o mașină Linux.

O scurtă introducere în modul în care sunt creați demonii

O mulțime de demoni rulează pe sistem și câteva exemple de demoni familiare sunt după cum urmează:

• crond: Face ca comenzile să ruleze la ora specificată
• sshd: Permite autentificarea la sistem de la mașini la distanță
• httpd: Servește pagini web
• nfsd: Permite partajarea fișierelor în rețea

De asemenea, procesele demon sunt de obicei numite pentru a se termina cu litera d, deși nu este obligatoriu.

Pentru ca un proces să ruleze ca demon, este urmată următoarea cale:

• Operațiunile inițiale, cum ar fi citirea fișierelor de configurare sau obținerea resurselor de sistem necesare, trebuie efectuate înainte ca procesul să devină un demon. În acest fel, sistemul poate raporta utilizatorului erorile primite și procesul va fi încheiat cu un cod de eroare corespunzător.
  instagram viewer
• Un proces de rulare în fundal este creat cu init ca proces părinte. În acest scop, un sub-proces este mai întâi bifurcat de la procesul de init, iar apoi procesul superior este terminat cu ieșire.
• O nouă sesiune ar trebui să se deschidă prin apelarea funcției setsid, iar procesul ar trebui să fie deconectat de la terminal.
• Toți descriptorii de fișier deschis moșteniți de la procesul părinte sunt închise.
• Intrare, ieșire standard, iar mesajele de eroare sunt redirecționate către /dev/null.
• Directorul de lucru al procesului trebuie să se schimbe.

Ce sunt sesiunile Daemon?

După conectarea la sistem printr-un terminal, utilizatorii pot rula multe aplicații prin programul shell. Aceste procese ar trebui să se închidă când utilizatorul iese din sistem. Sistemul de operare grupează aceste procese în sesiune și grupuri de procese.

Fiecare sesiune este formată din grupuri de procese. Puteți descrie această situație după cum urmează:

Terminalul la care procesele își primesc intrările și își trimit ieșirile se numește terminal de control. Un terminal de control este asociat cu o singură sesiune la un moment dat.

O sesiune și grupurile de procese din ea au numere de identificare (ID); aceste numere de identificare sunt numerele de identificare a procesului (PID) ale liderilor de sesiune și de grup de proces. Un proces copil împarte același grup ca și procesul părinte. Când mai multe procese sunt comunicând cu mecanismul conductei, primul proces devine liderul grupului de procese.

Crearea unui proces Daemon pe Linux

Aici veți vedea cum puteți crea o funcție demon. În acest scop, veți crea o funcție numită _daemon. Puteți începe prin a numi codul aplicației care va rula ca demon ca test.c, și codul cu care veți crea funcția demon ca daemon.c.

//test.c
#include <stdio.h>
int_daemon(int, int);
intprincipal()
{
	getchar();
	_daemon (0, 0);
	getchar();
întoarcere0;
}

//daemon.c
#include <sys/tipuri.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/fs.h>
#include <linux/limits.h>
int_daemon(int nochdir, int noclose){
 pid_t pid;
 pid = furca(); // Dezactivați procesul părinte
 dacă (pid < 0) {
Ieșire(EXIT_FAILURE);
 }
 dacă (pid > 0) {
Ieșire(EXIT_SUCCESS);
 }
întoarcere0;
}

Pentru a crea un demon, aveți nevoie de un proces de fundal al cărui proces părinte este init. În codul de mai sus, _daemon creează un proces copil și apoi oprește procesul părinte. În acest caz, noul dumneavoastră proces va fi un subproces al init și va continua să ruleze în fundal.

Acum compilați aplicația cu următoarea comandă și examinați starea procesului înainte și după _diamon se numește:

gcc-oTestTest.cdemonul.c

Rulați aplicația și comutați la un alt terminal fără a apăsa alte taste:

./Test

Puteți vedea că valorile legate de procesul dumneavoastră sunt următoarele. Aici, va trebui să folosești comanda ps pentru a obține informații legate de proces. În acest caz, _daemon funcția nu a fost apelată încă.

ps -C Test -o "pid ppid pgid sid tty statcomanda"
# Ieșire
PID PPID PGID SID TT COMANDĂ STAT
10296 5119 10296 5117 puncte/2 S+ ./Test

Când te uiți la STAT câmp, vedeți că procesul dumneavoastră rulează, dar așteaptă să apară un eveniment în afara programului, care îl va determina să ruleze în prim-plan.

Puteți vedea că procesul părinte al aplicației dvs. este shell-ul așa cum era de așteptat.

ps -jp 5119 
# Ieșire 
PID PGID SID TTY TIME CMD
5119 5119 5117 puncte/2 00:00:02 zsh

Acum reveniți la terminalul în care rulați aplicația și apăsați introduce a invoca pe _daemon funcţie. Apoi priviți din nou informațiile despre proces de pe celălalt terminal.

ps -C Test -o "pid ppid pgid sid tty statcomanda"
# Ieșire
PID PPID PGID SID TT COMANDĂ STAT
22504 1 22481 5117 puncte/2 S ./Test

În primul rând, puteți spune că noul subproces rulează în fundal, deoarece nu vedeți + caracter în STAT camp. Acum examinați cine este procesul părinte al procesului folosind următoarea comandă:

ps -jp 1 
​​​​​​​# Ieșire 
PID PGID SID TTY TIME CMD
1 1 1? 00:00:01systemd

Acum puteți vedea că procesul părinte al procesului dvs. este systemd proces. Se menționează mai sus că pentru următorul pas ar trebui să se deschidă o nouă sesiune și procesul să fie deconectat de la terminalul de control. Pentru aceasta, utilizați funcția setsid. Adăugați acest apel la dvs _daemon funcţie.

Codul de adăugat este următorul:

dacă (setsid() == -1) 
întoarcere-1;

Acum că ai inspectat statul înainte _daemon apelat, acum îl puteți elimina pe primul getchar funcţia în test.c cod.

//test.c
#include <stdio.h>
int_daemon(int, int);
intprincipal()
{
	_daemon (0, 0);
	getchar();
întoarcere0;
}

După ce ai compilat și rulat din nou aplicația, mergi la terminalul unde ți-ai făcut recenziile. Noul statut al procesului dvs. este următorul:

ps -C Test -o "pid ppid pgid sid tty statcomanda"
​​​​​​​# Ieșire
PID PPID PGID SID TT COMANDĂ STAT
25494 1 25494 25494? Ss./Test

The ? semnează în TT câmpul indică faptul că procesul dumneavoastră nu mai este conectat la un terminal. Observați că PID, PGID, și SID valorile procesului dumneavoastră sunt aceleași. Procesul dvs. este acum un lider de sesiune.

În pasul următor, schimbați directorul de lucru în directorul rădăcină în funcție de valoarea argumentului pe care l-ați transmis. Puteți adăuga următorul fragment la _daemon functie pentru asta:

dacă (!nochdir) {
 dacă (chdir("/") == -1)
întoarcere-1;
}

Acum, conform argumentului transmis, toți descriptorii de fișiere pot fi închiși. Adăugați următorul cod la _daemon funcţie:

#define NR_OPEN 1024
dacă (!noclose) {
 pentru (i = 0; i < NR_DESCHIS; i++)
 închide (i);
 deschis("/dev/nul", O_RDWR);
 dup (0);
 dup (0);
}

După ce toți descriptorii de fișiere sunt închiși, fișierele noi deschise de demon vor fi afișate cu descriptorii 0, 1 și, respectiv, 2. În acest caz, de exemplu, printf comenzile din cod vor fi direcționate către al doilea fișier deschis. Pentru a evita acest lucru, primii trei identificatori indică /dev/null dispozitiv.

În acest caz, starea finală a _daemon funcția va fi după cum urmează:

#include <sys/tipuri.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <syslog.h>
#include <sfoară.h>
int_daemon(vid){
// PID: ID proces
// SID: ID sesiune
 pid_t pid, sid;
 pid = furca(); // Dezactivați procesul părinte
 dacă (pid < 0) {
Ieșire(EXIT_FAILURE);
 }
 dacă (pid > 0) {
Ieșire(EXIT_SUCCESS);
 }
 // Crea A SIDpentrucopil
 sid = setsid();
 dacă (sid < 0) {
// ESCĂ
Ieșire(EXIT_FAILURE);
 }
 dacă ((chdir("/")) < 0) {
// ESCĂ
Ieșire(EXIT_FAILURE);
 }
 închidere (STDIN_FILENO);
 închidere (STDOUT_FILENO);
 închidere (STDERR_FILENO);
in timp ce (1) {
// Unele sarcini
 somn (30);
 }
Ieșire(EXIT_SUCCESS);
}

Iată un exemplu de fragment de cod care rulează sshd cerere ca a demonul:

...
dacă (!(debug_flag || inetd_flag || no_daemon_flag)) {
int fd;
 dacă (daemon (0, 0) < 0)
 fatal("daemon() a eșuat: %.200s", strerror (errno));
/* Deconectați-vă de la tty-ul de control. */
 fd = deschis (_PATH_TTY, O_RDWR | O_NOCTTY);
 dacă (fd >= 0) {
 (vid) ioctl (fd, TIOCNOTTY, NULL);
 închidere (fd);
 }
}
...

Demonii sunt importanți pentru programarea sistemului Linux

Demonii sunt programe care efectuează diverse acțiuni într-o manieră predefinită stabilită ca răspuns la anumite evenimente. Ele rulează în tăcere pe mașina dvs. Linux. Nu sunt sub controlul direct al utilizatorului și fiecare serviciu care rulează în fundal are demonul său.

Este important să stăpânești demonii pentru a învăța structura nucleului sistemului de operare Linux și pentru a înțelege funcționarea diferitelor arhitecturi de sistem.

Ce este un Daemon?

Citiți în continuare

Despre autor