Linux监控重要进程的实现方法

本文转自：https://blog.csdn.net/lcy4599/article/details/52267517

不管后台服务程序写的多么健壮，还是可能会出现core dump等程序异常退出的情况，但是一般情况下需要在无人为干预情况下，能够自动重新启动，保证服务进程能够服务用户。这时就需要一个监控程序来实现能够让服务进程自动重新启动。查阅相关资料及尝试一些方法之后，总结linux系统监控重要进程的实现方法：脚本检测和子进程替换。

1、脚本检测

(1) 基本思路: 通过shell命令(ps -e | grep "$1" | grep -v "grep" | wc -l) 获取 $1 ($1 代表进程的名字)的进程数，脚本根据进程数来决定下一步的操作。通过一个死循环，每隔几秒检查一次系统中的指定程序的进程数，这里也可使用crontab来实现。

(2) 具体实现过程的代码如下: [ supervisor.sh ]

[plain]  view plain  copy

1. #! /bin/sh  
2. # supervisor process   
3.   
4. LOG_FILE=/var/log/supervisor_sh.log  
5.   
6. # log function   
7. function log() {  
8.     local t=$(date +"%F %X")  
9.     echo "[ $t ] $0 : $1 " >> ${LOG_FILE}  
10. }  
11.   
12. # check process number   
13. # $1 : process name   
14. function check_process() {  
15.     if [ -z $1 ]; then  
16.         log "Input parameter is empty."  
17.         return 0       
18.     fi  
19.       
20.     p_num=$(ps -e | grep "$1" | grep -v "grep" | wc -l)  
21.     log "p_num = $p_num"   
22.     echo $p_num  
23. }  
24.   
25. # supervisor process   
26. while [ 1 ]  
27. do   
28.     declare -i ch_num  
29.     p_name="apache2"  
30.     ch_num=$(check_process $p_name)  
31.     if [ $ch_num -eq 0 ]; then  
32.         killall $p_name  
33.         service $p_name start    
34.     fi  
35.     sleep 3   
36. done  

2、子进程替换
(1) 基本思路: 
a. 使用fork函数创建一个新的进程，在进程表中创建一个新的表项，而创建者(即父进程)按原来的流程继续执行，子进程执行自己的控制流程
b. 运用execv函数把当前进程替换为一个新的进程，新进程由path或file参数指定，可以使用execv函数将程序的执行从一个程序切换到另一个程序

c. 当fork启动一个子进程时，子进程就有了它自己的生命周期并将独立运行，此时可以在父进程中调用wait函数让父进程等待子进程的结束

(2) 基本的实现步骤: 
a. 首先使用fork系统调用，创建子进程
b. 在子进程中使用execv函数，执行需要自动重启的程序

c. 在父进程中执行wait函数等待子进程的结束，然后重新创建一个新的子进程

(3) 具体实现的代码如下: supervisor.c

[cpp]  view plain  copy

1. /** 
2.  * 
3.  * supervisor  
4.  * 
5.  * date: 2016-08-10  
6.  *  
7.  */  
8.   
9. #include <stdio.h>  
10. #include <unistd.h>  
11. #include <errno.h>  
12. #include <string.h>  
13. #include <sys/types.h>  
14. #include <sys/wait.h>  
15. #include <stdlib.h>  
16. #include <time.h>  
17.   
18. #define LOG_FILE "/var/log/supervisor.log"  
19.   
20. void s_log(char *text) {  
21.     time_t      t;  
22.     struct tm  *tm;  
23.     char *log_file;  
24.     FILE *fp_log;  
25.     char date[128];  
26.       
27.     log_file = LOG_FILE;  
28.     fp_log = fopen(log_file, "a+");  
29.     if (NULL == fp_log) {  
30.         fprintf(stderr, "Could not open logfile '%s' for writing\n", log_file);  
31.     }  
32.       
33.     time(&t);  
34.     tm = localtime(&t);  
35.     strftime(date, 127, "%Y-%m-%d %H:%M:%S", tm);  
36.       
37.     /* write the message to stdout and/or logfile */      
38.     fprintf(fp_log, "[%s] %s\n", date, text);  
39.     fflush(fp_log);  
40.     fclose(fp_log);  
41. }   
42.   
43. int main(int argc, char **argv) {  
44.     int ret, i, status;  
45.     char *child_argv[100] = {0};  
46.     pid_t pid;  
47.     if (argc < 2) {  
48.         fprintf(stderr, "Usage:%s <exe_path> <args...>", argv[0]);  
49.         return -1;  
50.     }  
51.       
52.     for (i = 1; i < argc; ++i) {  
53.         child_argv[i-1] = (char *)malloc(strlen(argv[i])+1);  
54.         strncpy(child_argv[i-1], argv[i], strlen(argv[i]));  
55.         //child_argv[i-1][strlen(argv[i])] = '0';  
56.     }  
57.       
58.     while(1) {  
59.         pid = fork();   
60.         if (pid == -1) {  
61.             fprintf(stderr, "fork() error.errno:%d error:%s", errno, strerror(errno));  
62.             break;  
63.         }  
64.         if (pid == 0) {  
65.             s_log(child_argv[0]);  
66.             ret = execv(child_argv[0], (char **)child_argv);  
67.             s_log("execv return");  
68.             if (ret < 0) {  
69.                 fprintf(stderr, "execv ret:%d errno:%d error:%s", ret, errno, strerror(errno));  
70.                 continue;  
71.             }  
72.             s_log("exit child process");  
73.             exit(0);  
74.         }  
75.         if (pid > 0) {  
76.             pid = wait(&status);  
77.             fprintf(stdout, "Child process id: %d\n", pid);  
78.             //fprintf(stdout, "wait return");  
79.             s_log("Wait child process return");  
80.         }  
81.     }  
82.       
83.     return 0;  
84. }  

(4) 测试验证
a. 假设需要自动重启的程序为demo.c，其代码实现如下所示：

[cpp]  view plain  copy

1. /* 
2. * 
3. * demo   
4. * 
5. */  
6.   
7. #include <stdio.h>  
8. #include <unistd.h>  
9. #include <errno.h>  
10. #include <string.h>  
11. #include <sys/types.h>  
12. #include <sys/wait.h>  
13. #include <stdlib.h>  
14. #include <time.h>  
15.   
16. #define LOG_FILE "/var/log/demo.log"  
17.   
18. void demo_log(int num) {  
19.     time_t      t;  
20.     struct tm  *tm;  
21.     char *log_file;  
22.     FILE *fp_log;  
23.     char date[128];  
24.       
25.     log_file = LOG_FILE;  
26.     fp_log = fopen(log_file, "a+");  
27.     if (NULL == fp_log) {  
28.         fprintf(stderr, "Could not open logfile '%s' for writing\n", log_file);  
29.     }  
30.       
31.     time(&t);  
32.     tm = localtime(&t);  
33.     strftime(date,127,"%Y-%m-%d %H:%M:%S",tm);  
34.       
35.     /* write the message to stdout and/or logfile */      
36.     fprintf(fp_log, "[%s] num = %d\n", date, num);  
37.     fflush(fp_log);  
38.     fclose(fp_log);  
39. }   
40.   
41. int main(int argc, char **argv[]) {  
42.     int num = 0;  
43.       
44.     while(1) {  
45.         sleep(10);  
46.         num++;  
47.         demo_log(num);  
48.     }  
49. }  

b. 测试准备和说明:

b1. 以上相关服务程序编译后的二进制文件为: supervisor 和 demo 

b2. 执行如下测试命令 ./supervisor ./demo  

c. 测试的结果:

c1. execv(progname, arg) 执行成功后，其后的代码不会执行；只有当执行错误时，才会返回 -1。原来调用execv进程的代码段会被progname应用程序的代码段替换。

c2. 当kill掉子进程时，父进程wait函数会接收到子进程退出的信号，进而循环再启动子进程，此过程实时性非常高。

c3. 当kill掉父进程时，子进程会被init进程接管，如果此时再kill掉子进程，则子进程会退出。

c4. 当同时kill掉父子进程，则父子进程都会退出。