Daemon dalam Linux: Cara menulis dan menggunakan daemon mudah

Daemon ialah proses khas dalam sistem Linux Ia berjalan di latar belakang tanpa terminal kawalan dan tidak tertakluk kepada gangguan pengguna. Ia bertanggungjawab untuk melaksanakan beberapa tugas dan fungsi yang berkaitan dengan sistem. Peranan daemon adalah untuk meningkatkan kestabilan dan kecekapan sistem untuk menangani beberapa kemalangan atau keabnormalan yang tidak dijangka. Dalam peranti Linux terbenam, proses daemon boleh digunakan untuk melindungi proses utama dalam sistem dan menghalangnya daripada berakhir secara tidak normal, menyebabkan sistem ranap sepenuhnya dan memusnahkan pengalaman pengguna. Tetapi, adakah anda benar-benar memahami proses daemon di bawah Linux? Adakah anda tahu cara menulis dan menggunakan daemon mudah di bawah Linux? Artikel ini akan memperkenalkan anda kepada pengetahuan berkaitan proses daemon di bawah Linux secara terperinci, membolehkan anda menggunakan dan memahami dengan lebih baik jenis proses yang berkuasa ini di bawah Linux.

Buat proses daemon dalam peranti Linux untuk melindungi proses utama dalam sistem dan mengelakkan beberapa kemalangan yang tidak dijangka daripada menyebabkan proses utama berakhir secara tidak normal, menyebabkan sistem ditutup sepenuhnya tanpa sebarang tindak balas, memusnahkan pengalaman pengguna. Walau bagaimanapun, selepas menyemak banyak maklumat, saya mendapati kebanyakan orang hanya bercakap tentang cara mencipta dan melaksanakan proses daemon pada platform x86, dan tiada siapa yang memperkenalkan cara mencipta dan melaksanakan proses daemon pada platform terbenam. Oleh itu, selepas beberapa penerokaan dan pemahaman umum tentang segala-galanya daripada prinsip kepada kod, saya menghasilkan beberapa idea sendiri. Di bawah adalah ringkasan ringkas dan organisasi.

1. Prinsip teknikal

Berikut ialah petikan dari Internet tentang pengenalan dan penerangan proses daemon dalam sistem Linux x86.

Daemon ialah proses khas yang berjalan di latar belakang Ia bebas daripada terminal kawalan dan secara berkala melaksanakan tugas tertentu atau menunggu untuk memproses acara tertentu.

Proses daemon adalah proses anak yatim istimewa Proses seperti ini meninggalkan terminal. Sebab mengapa ia dipisahkan daripada terminal adalah untuk mengelakkan proses daripada terganggu oleh maklumat yang dijana oleh mana-mana terminal, dan maklumatnya semasa pelaksanaan tidak akan dipaparkan pada mana-mana terminal. Memandangkan dalam Linux, antara muka yang melaluinya setiap sistem berkomunikasi dengan pengguna dipanggil terminal, setiap proses yang mula berjalan dari terminal ini akan dilampirkan pada terminal ini Terminal ini dipanggil terminal kawalan proses ini , Proses yang sepadan akan ditutup secara automatik. Walau bagaimanapun, proses daemon boleh menembusi had ini Ia dipisahkan daripada terminal dan berjalan di latar belakang Tujuan dipisahkan daripada terminal adalah untuk menghalang maklumat semasa proses berjalan daripada dipaparkan dalam mana-mana terminal dan proses itu akan. tidak boleh diakses oleh mana-mana terminal Terganggu oleh mesej terminal yang dihasilkan. Ia mula berjalan apabila ia dilaksanakan dan tidak keluar sehingga keseluruhan sistem ditutup (sudah tentu ia boleh dianggap sebagai membunuh proses daemon yang sepadan). Jika anda mahu proses tidak terjejas oleh pengguna atau gangguan atau perubahan lain, maka anda mesti menukar proses ini menjadi proses daemon.

2. Langkah reka bentuk

Untuk sistem Linux pada platform x86, secara teorinya, untuk mencapai kesan di atas, proses daemon mempunyai set langkah pelaksanaan yang ketat. Dalam erti kata lain, proses daemon mesti mengalih keluar beberapa sekatan berkaitan sistem pada permulaan permulaan, supaya ia boleh berjalan dengan stabil di latar belakang tanpa diganggu dan terjejas oleh tugas lain.

Berikut ialah proses asas menulis daemon pada platform x86:

1. Sekat beberapa isyarat yang mengawal operasi terminal. Ini adalah untuk mengelakkan terminal kawalan daripada terganggu dan keluar atau tergantung sebelum daemon berjalan. Untuk penggunaan isyarat yang lebih terperinci, sila lihat "Pengendalian Sampukan Isyarat".
2. Berjalan di latar belakang. Ini adalah untuk meletakkan proses daemon ke latar belakang untuk mengelakkan terminal kawalan terputus. Kaedahnya adalah untuk memanggil fork() dalam proses untuk menamatkan proses induk dan membiarkan daemon melaksanakan di latar belakang dalam proses anak.
3. Tanggalkan kawalan terminal, sesi log masuk dan kumpulan proses. Pertama sekali, adalah perlu untuk memperkenalkan hubungan antara proses dan terminal kawalan, sesi log masuk dan kumpulan proses dalam Linux: proses tergolong dalam kumpulan proses, dan nombor kumpulan proses (GID) ialah nombor proses (PID) ketua kumpulan proses. . Sesi log masuk boleh mengandungi berbilang kumpulan proses. Kumpulan proses ini berkongsi terminal kawalan. Terminal kawalan ini biasanya terminal log masuk shell dari mana proses itu dibuat. Terminal mengawal, sesi log masuk dan kumpulan proses biasanya diwarisi daripada proses induk. Matlamat kami adalah untuk menyingkirkan mereka dan tidak terjejas oleh mereka. Oleh itu, setsid() perlu dipanggil untuk menjadikan anak memproses ketua sesi baharu. Selepas panggilan setsid() berjaya, proses menjadi ketua kumpulan sesi baharu dan ketua kumpulan proses baharu, dan dipisahkan daripada sesi log masuk dan kumpulan proses asal. Disebabkan oleh eksklusiviti proses sesi ke terminal kawalan, proses itu dipisahkan daripada terminal kawalan pada masa yang sama.
4. Menghalang proses daripada membuka semula terminal kawalan. Kini, proses itu telah menjadi peneraju sesi tanpa terminal, tetapi ia boleh memohon semula untuk membuka terminal kawalan. Anda boleh menghalang proses daripada membuka semula terminal kawalan dengan menjadikannya bukan lagi ketua sesi, dengan mencipta proses anak sekali lagi.
5. Tutup deskriptor fail yang terbuka. Proses mewarisi deskriptor fail terbuka daripada proses induk yang menciptanya. Jika ia tidak ditutup, sumber sistem akan menjadi sia-sia, sistem fail di mana proses itu terletak tidak akan dapat dinyahlekapkan, dan ralat yang tidak dapat diramalkan akan berlaku.
6. Tukar direktori kerja semasa. Semasa proses aktif, sistem fail yang mengandungi direktori kerjanya tidak boleh diputuskan. Secara amnya, anda perlu menukar direktori kerja kepada direktori akar. Untuk pembuangan teras yang perlu dilakukan, proses menulis log larian menukar direktori kerja kepada direktori tertentu seperti /tmp.
7. Tetapkan semula topeng penciptaan fail. Satu proses mewarisi topeng penciptaan fail daripada proses induk yang menciptanya. Ia boleh mengubah suai kebenaran akses fail yang dibuat oleh daemon. Untuk mengelakkan ini, topeng penciptaan fail mesti dikosongkan.
8. Kendalikan isyarat SIGCHLD. Untuk sesetengah proses, terutamanya proses pelayan, proses anak sering dihasilkan untuk mengendalikan permintaan apabila permintaan tiba. Jika proses induk tidak menunggu proses anak tamat, proses anak akan menjadi proses zombi (zombie) dan menduduki sumber sistem (untuk butiran lanjut tentang proses zombi, sila lihat "Proses Zombie"). Jika proses induk menunggu proses anak tamat, ia akan meningkatkan beban pada proses induk dan menjejaskan prestasi serentak proses pelayan. Di bawah Linux anda hanya boleh menetapkan operasi isyarat SIGCHLD kepada SIG_IGN. Dengan cara ini, kernel tidak akan mencipta proses zombi sehingga proses anak tamat.

–
Berikut ialah kod sumber lengkap yang diambil dari blog seorang senior:

#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. Keadaan sebenar

Seperti yang dapat dilihat daripada logik proses dan kod sebenar di atas, proses daemon platform x86 sebenarnya agak rumit dan memerlukan sekumpulan proses permulaan yang membosankan. Walau bagaimanapun, untuk platform terbenam, proses itu nampaknya lebih mudah, tanpa pemprosesan yang rumit. Kerana, proses daemon didayakan dalam sistem terbenam ini. Tujuannya adalah semata-mata untuk menggunakan proses daemon ini untuk memulakan proses daemon yang lain, dan kemudian memantau dengan kerap sama ada proses itu masih berjalan seperti biasa Setelah didapati ia berjalan secara tidak normal, mulakan semula proses dengan segera.

Jadi, saya mudahkan proses di atas dan mendapat proses berikut:

1. Mulakan proses yang perlu dipantau dalam proses daemon.
2. Buat benang dalam proses daemon untuk sentiasa memantau status berjalan proses daemon
3. Proses daemon menentukan sama ada proses daemon masih berjalan seperti biasa Sebaik sahaja ia mendapati ia berjalan secara tidak normal, ia segera memulakan semula proses.

– 4. Kod sumber sebenar

Berikut ialah kod lengkap modul proses daemon yang direka dalam projek sistem terbenam ini.

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

******** ** 函数名称: 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 下掌握守护进程的编写和使用。

Atas ialah kandungan terperinci Daemon dalam Linux: Cara menulis dan menggunakan daemon mudah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!