《APUE》：单实例守护进程的实现


《Unix环境高级编程》这本书附带了许多短小精美的小程序，我在阅读此书的时候，将书上的代码按照自己的理解重写了一遍（大部分是抄书上的），加深一下自己的理解（纯看书太困了，呵呵）。此例子在Ubuntu 10.04上测试通过。

相关链接

  • 《UNIX环境高级编程》（第二版）apue.h的错误
  • Unix环境高级编程 源代码地址

程序简介：这个DEMO是按照UNIX守护进程的编程规则实现的一个单实例的守护程序。

  1. //《APUE》程序13－1：初始化一个守护进程   
  2. //《APUE》程序13－2：保证只运行某个守护进程的一个副本   
  3. //《APUE》程序14－5：在文件整体加锁   
  4.   
  5. #include <stdio.h>   
  6. #include <stdlib.h>   
  7. #include <string.h>   
  8. #include <unistd.h>   
  9. #include <fcntl.h>   
  10. #include <time.h>   
  11. #include <signal.h>   
  12. #include <errno.h>   
  13. #include <sys/resource.h>   
  14. #include <sys/syslog.h>   
  15. #include <sys/file.h>   
  16. #include <sys/stat.h>   
  17.   
  18. //创建锁文件的路径   
  19. #define LOCKFILE "/var/run/daemon.pid"   
  20. //锁文件的打开模式   
  21. #define LOCKMODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)   
  22.   
  23. //输出错误信息并退出     
  24. void error_quit(const char *str)    
  25. {    
  26.     fprintf(stderr, "%s\n", str);    
  27.     exit(1);    
  28. }   
  29.   
  30. //对文件fd加上记录锁   
  31. int lockfile(int fd)  
  32. {  
  33.     struct flock fl;  
  34.     fl.l_type = F_WRLCK;  
  35.     fl.l_start = 0;  
  36.     fl.l_whence = SEEK_SET;  
  37.     fl.l_len = 0;  
  38.     return fcntl(fd, F_SETLK, &fl);  
  39. }  
  40.   
  41. //若程序已经运行，则返回1，否则返回0   
  42. int already_running(void)  
  43. {  
  44.     int fd;  
  45.     char buf[16];  
  46.   
  47.     //打开放置记录锁的文件   
  48.     fd = open(LOCKFILE, O_RDWR|O_CREAT, LOCKMODE);  
  49.     if( fd < 0 )  
  50.     {  
  51.         syslog(LOG_ERR, "can't open %s: %s", LOCKFILE, strerror(errno));  
  52.         exit(1);  
  53.     }  
  54.     //试图对文件fd加锁，   
  55.     //如果加锁失败的话   
  56.     if( lockfile(fd) < 0 )  
  57.     {  
  58.         //如果是因为权限不够或资源暂时不可用，则返回1   
  59.         if( EACCES == errno ||  
  60.             EAGAIN == errno )  
  61.         {  
  62.             close(fd);  
  63.             return 1;  
  64.         }  
  65.         //否则，程序出错，写入一条错误记录后直接退出   
  66.         syslog(LOG_ERR, "can't lock %s: %s", LOCKFILE, strerror(errno));  
  67.         exit(1);  
  68.     }  
  69.   
  70.     //先将文件fd清空，然后再向其中写入当前的进程号   
  71.     ftruncate(fd, 0);  
  72.     sprintf(buf, "%ld", (long)getpid());  
  73.     write(fd, buf, strlen(buf)+1);  
  74.     return 0;  
  75. }  
  76.   
  77. //将一个进程变为守护进程   
  78. void daemonize(void)  
  79. {  
  80.     int i, fd0, fd1, fd2;  
  81.     pid_t pid;  
  82.     struct rlimit rl;  
  83.     struct sigaction sa;  
  84.   
  85.     //见注解1   
  86.     umask(0);  
  87.   
  88.     //获取最大的文件描述号   
  89.     int temp;  
  90.     temp = getrlimit(RLIMIT_NOFILE, &rl);  
  91.     if( temp < 0 )  
  92.         error_quit("can't get file limit");  
  93.   
  94.     //见注解2，   
  95.     pid = fork();  
  96.     if( pid < 0 )  
  97.         error_quit("can't fork");  
  98.     else if(pid != 0)  
  99.         exit(0);  
  100.   
  101.     //见注解3   
  102.     setsid();  
  103.     sa.sa_handler = SIG_IGN;  
  104.     sigemptyset(&sa.sa_mask);  
  105.     sa.sa_flags = 0;  
  106.     temp = sigaction(SIGHUP, &sa, NULL);  
  107.     if( temp < 0 )  
  108.         error_quit("can't ignore SIGHUP");  
  109.   
  110.     ////确保子进程不会有机会分配到一个控制终端   
  111.     pid = fork();  
  112.     if( pid < 0 )  
  113.         error_quit("can't fork");  
  114.     else if(pid != 0)  
  115.         exit(0);  
  116.   
  117.     //见注解4   
  118.     temp = chdir("/");  
  119.     if( temp < 0 )  
  120.         error_quit("can't change directoy to /");  
  121.   
  122.     //见注解5   
  123.     if( rl.rlim_max == RLIM_INFINITY )  
  124.         rl.rlim_max = 1024;  
  125.     for(i=0; i<rl.rlim_max; i++)  
  126.         close(i);  
  127.   
  128.     //见注解6   
  129.     fd0 = open("/dev/null", O_RDWR);  
  130.     fd1 = dup(0);  
  131.     fd2 = dup(0);  
  132.   
  133.     if( fd0 != 0 ||  
  134.         fd1 != 1 ||  
  135.         fd2 != 2 )  
  136.     {  
  137.         syslog(LOG_ERR, "unexpected file descriptors %d %d %d",  
  138.             fd0, fd1, fd2);  
  139.         exit(1);  
  140.     }  
  141. }  
  142.   
  143. //该主函数是我原创的，呵呵   
  144. int main(void)  
  145. {  
  146.     //打开系统的日志文件   
  147.     openlog("my test log: ", LOG_CONS, LOG_DAEMON);  
  148.     daemonize();  
  149.   
  150.     //如果程序已经运行，则向记录文件中写入一句话，然后退出   
  151.     if( already_running() )  
  152.     {  
  153.         syslog(LOG_ERR, "daemon alread running");  
  154.         closelog();  
  155.         return 1;  
  156.     }  
  157.   
  158.     //向日志文件写入程序的开始（当前）时间，   
  159.     //过100秒后，再向记录文件写入结束时间，然后结束程序   
  160.     time_t tt = time(0);  
  161.     syslog(LOG_INFO, "the log program start at: %s",   
  162.         asctime(localtime(&tt)) );  
  163.     sleep(100);  
  164.     //pause()   
  165.     tt = time(0);  
  166.     syslog(LOG_INFO, "the log program end at: %s",   
  167.         asctime(localtime(&tt)) );  
  168.   
  169.     //关闭日志文件   
  170.     //虽然不关也没事，但为了和openlog配对，还是将它写上去吧   
  171.     closelog();  
  172.     return 0;  
  173. }  

运行示例（红色字体的为输入）：

www.bkjia.com @ubuntu:~/code$ gcc temp.c -o temp
www.bkjia.com @ubuntu:~/code$ sudo ./temp
www.bkjia.com @ubuntu:~/code$ sudo ./temp
www.bkjia.com @ubuntu:~/code$ ps axj | grep temp
    1  2648  2647  2647 ?           -1 S        0   0:00 ./temp
 2127  2673  2672  2127 pts/0     2672 S+    1000   0:00 grep --color=auto temp

#两分钟后，再打开日志文件，查看一下程序的日志
www.bkjia.com @ubuntu:~/code$ tail -f /var/log/syslog
Sep 24 07:53:58 ubuntu my test log: : the log program start at: Mon Sep 24 07:53:58 2012
Sep 24 07:54:07 ubuntu my test log: : daemon alread running
Sep 24 07:55:38 ubuntu my test log: : the log program end at: Mon Sep 24 07:55:38 2012

注解：守护进程的编程规则
1：首先要调用umask将文件模式创建屏蔽字设置为0.由继承得来的文件模式创建屏蔽字可能会拒绝设置某些权限。
2：调用fork，然后使父进程退出（exit）。这样做实现了两点：第一，如果该守护进程是作为一条简单shell命令启动的，那么父进程终止使得shell认为这条命令已经执行完毕；第二，子进程继承了���进程的进程组ID，但具有一个新的进程ID，这就保证了子进程不是一个进程组的组长进程。这是setsid调用必要前提条件。
3：调用setsid以创建一个新会话。执行三个操作，（a）成为新会话的首进程，（b）成为一个新进程的组长进程，（c）没有控制终端。
4：将当前工作目录更改为根目录。进程活动时，其工作目录所在的文件系统不能卸下。一般需要将工作目录改变到根目录。对于需要转储核心，写运行日志的进程将工作目录改变到特定目录
5：关闭不再需要的文件描述符。进程从创建它的父进程那里继承了打开的文件描述符。如不关闭，将会浪费系统资源，造成进程所在的文件系统无法卸下以及引起无法预料的错误。
6：重定向0,1,2到/dev/null，使任何一个试图读标准输入，写标准输出和标准出错的程序库都不会产生任何效果。

相关内容