诡异的守护进程中的文件描述符，标题要长长长长长。。

ChiyuT

今天被这个诡异的问题弄得茶不思来饭不想， 哪位达人能够拯救我！！

问题如下：

主程序是一段很简单的代码，我放到最前边。里边的 daemon_init 和各种打印函数都是直接照抄的《UNIX网络编程》第一卷中的附录D，我放到后边，大家有兴趣的可以自己研究。

1. #include <stdio.h>
   
2. #include <syslog.h>
   
3. #include <unistd.h>
   
4. #include <signal.h>
   
5. #include <string.h>
   
6. #include <fcntl.h>
   
7. #include <stdarg.h>
   
8. #include <syslog.h>
   
9. #include <stdlib.h>
   
10. #include <errno.h>
    
11. 
    
12. int main(int argc, char * argv[])
    
13. {
    
14. 
    
15.         daemon_init(argv[0], 0);
    
16.        
    
17.         int fd = open("tmp1", O_RDWR | O_CREAT | O_TRUNC, 0666);
    
18.         err_ret("fd = %d\n", fd);
    
19. 
    
20.         write(fd, "hello world!", strlen("hello world!"));
    
21. 
    
22.         fd = open("tmp2", O_RDWR | O_CREAT | O_TRUNC, 0666);
    
23.         err_ret("fd = %d\n", fd);
    
24. 
    
25.         return 0;
    
26. }

复制代码

然后我检查log，记录如下：

1. 7444 Aug 31 20:23:44 localhost ./daemon[5901]: fd = 3: Bad file descriptor
   
2. 7445 Aug 31 20:23:44 localhost ./daemon[5901]: fd = 5: Bad file descriptor

复制代码

问题一：   

为什么文件描述符不是连续的？ 4 跑到哪儿去了？？？？Bad file descriptor该怎么理解？ 我确实在tmp1里边看到了我写入的内容。

继续，如果我将 daemon_init 中下边代码注释掉，即不关闭所继承的文件描述符。

1.         /*        Close off file descriptors        */
   
2.         for (i = 0; i < MAXFD; i++) {
   
3.                 close(i);
   
4.         }

复制代码

运行，再次检查log，记录如下：

1. 7448 Aug 31 20:29:27 localhost ./daemon[6100]: fd = 6: Success
   
2. 7449 Aug 31 20:29:27 localhost ./daemon[6100]: fd = 8: Success

复制代码

问题二：

为什么文件描述符不是连续的？为什么是从6开始？3、4、5都跑哪儿去了？ 7 又跑到哪儿去了？？？？ 这次为什么是Success ？？


相关代码：

1. #define MAXFD 64
   
2. #define MAXLINE 4096
   
3. 
   
4. int daemon_proc;
   
5. 
   
6. static void err_doit(int, int, const char *, va_list);
   
7. 
   
8. /*
   
9. *        Nonfatal error related to a system call,
   
10. *        print a message and return.
    
11. */
    
12. void err_ret(const char * fmt, ...)
    
13. {
    
14.         va_list ap;
    
15.        
    
16.         va_start(ap, fmt);
    
17.         err_doit(1, LOG_INFO, fmt, ap);
    
18.         va_end(ap);
    
19. 
    
20.         return;
    
21. }
    
22. 
    
23. /*
    
24. *        Fatal error related to a system call,
    
25. *        print a message and terminate.
    
26. */
    
27. void err_sys(const char * fmt, ...)
    
28. {
    
29.         va_list ap;
    
30.        
    
31.         va_start(ap, fmt);
    
32.         err_doit(1, LOG_ERR, fmt, ap);
    
33.         va_end(ap);
    
34. 
    
35.         exit(1);
    
36. }
    
37. 
    
38. /*
    
39. *        Fatal error related to a system call,
    
40. *        print a message, dump core, and terminate.
    
41. */
    
42. void err_dump(const char * fmt, ...)
    
43. {
    
44.         va_list ap;
    
45.        
    
46.         va_start(ap, fmt);
    
47.         err_doit(1, LOG_ERR, fmt, ap);
    
48.         va_end(ap);
    
49.         abort();
    
50.         exit(1);
    
51. }
    
52. 
    
53. /*
    
54. *        Nonfatal error unrelated to a system call,
    
55. *        print a message and return
    
56. */
    
57. void err_msg(const char * fmt, ...)
    
58. {
    
59.         va_list ap;
    
60.        
    
61.         va_start(ap, fmt);
    
62.         err_doit(0, LOG_INFO, fmt, ap);
    
63.         va_end(ap);
    
64. 
    
65.         return;
    
66. }
    
67. 
    
68. /*
    
69. *        Fatal error unrelated to a system call,
    
70. *        print a message and terminate.
    
71. */
    
72. void err_quit(const char * fmt, ...)
    
73. {
    
74.         va_list ap;
    
75.        
    
76.         va_start(ap, fmt);
    
77.         err_doit(0, LOG_ERR, fmt, ap);
    
78.         va_end(ap);
    
79. 
    
80.         exit(1);
    
81. }
    
82. 
    
83. /*
    
84. *        Print a message and return to caller,
    
85. *        caller specifies "errnoflag" and "level".
    
86. */
    
87. static void err_doit(int errnoflag, int level, const char * fmt, va_list ap)
    
88. {
    
89.         int errno_save, n;
    
90.         char buf[MAXLINE + 1];
    
91. 
    
92.         errno_save = errno;                                        /*        Value caller might want printed.        */
    
93. #ifdef HAVE_VSNPRINTF
    
94.         vsnprintf(buf, MAXLINE, fmt, ap);
    
95. #else
    
96.         vsprintf(buf, fmt, ap);                                /*        This is not safe        */
    
97. #endif
    
98.         n = strlen(buf);
    
99.         if (errnoflag) {
    
100.                 snprintf(buf + n, MAXLINE - n, ": %s", strerror(errno_save));
     
101.         }
     
102.         strcat(buf, "\n");
     
103. 
     
104.         if (daemon_proc) {
     
105.                 syslog(level, buf);
     
106.         } else {
     
107.                 fflush(stdout);                                        /*        In case stdout and stderr are the same        */
     
108.                 fputs(buf, stderr);
     
109.                 fflush(stderr);
     
110.         }
     
111. 
     
112.         return;
     
113. }
     
114. 
     
115. int daemon_init(const char * name, int facility)
     
116. {
     
117.         int                i;
     
118.         pid_t        pid;
     
119.         struct sigaction sa_dae;
     
120. 
     
121.         if ((pid = fork()) < 0) {
     
122.                 return -1;
     
123.         } else if (pid) {
     
124.                 _exit(0);                                                        /*        Parent terminates        */
     
125.         }
     
126. 
     
127.         /*        Child 1 continue...        */
     
128.         if (setsid() < 0) {                                                /*        Become session leader        */
     
129.                 return -1;
     
130.         }
     
131.        
     
132.         sa_dae.sa_handler = SIG_IGN;
     
133.         if ((sigaction(SIGHUP, &sa_dae, NULL)) < 0) {
     
134.                 perror("sigaction");
     
135.                 return -1;
     
136.         }
     
137. 
     
138.         if ((pid = fork()) < 0) {
     
139.                 return -1;
     
140.         } else if (pid) {
     
141.                 _exit(0);                                                        /*        Child 1 terminates        */
     
142.         }
     
143. 
     
144.         /*        Child 2 continues...        */
     
145.         daemon_proc = 1;
     
146. 
     
147. //        chdir("/");                                                                /*        Change working directory        */
     
148. 
     
149.         /*        Close off file descriptors        */
     
150.         for (i = 0; i < MAXFD; i++) {
     
151.                 close(i);
     
152.         }
     
153. 
     
154.         /*        Redirect stdin, stdout, and stderr to /dev/null        */
     
155.         open("/dev/null", O_RDONLY);
     
156.         open("/dev/null", O_RDWR);
     
157.         open("/dev/null", O_RDWR);
     
158. 
     
159.         openlog(name, LOG_PID, facility);
     
160. 
     
161.         return 0;                                                                /*        Success        */
     
162. }
     
163.                

复制代码

雨过白鹭洲

一个一个问题来哈


问题一：   

为什么文件描述符不是连续的？ 4 跑到哪儿去了？？？？Bad file descriptor该怎么理解？ 我确实在tmp1里边看到了我写入的内容。

4跑哪里去了，我也不知道

Bad file descriptor不是因为你open出错了，而是前面daemon_init里面的代码出错设置了errno，而系统调用成功时是不会修改errno的，这样你看到的就是之前的errno错误码

1. /*        Close off file descriptors        */
   
2.         for (i = 0; i < MAXFD; i++) {
   
3.                 close(i);
   
4.         }
   
5. 
   
6.                 errno = 0;

复制代码

很明显是close(i)的时候关闭了并未打开的文件描述符，因此close设置了errno为Bad file descriptor

像上面这样重置一下errno，就不会再看到log中的Bad file descriptor啦

两个文件都是打开成功的，因此你向tmp1写入数据，就能看到里面的内容

雨过白鹭洲

问题二：

为什么文件描述符不是连续的？为什么是从6开始？3、4、5都跑哪儿去了？ 7 又跑到哪儿去了？？？？ 这次为什么是Success ？？

为什么不连续，我同样不知道

从6开始是因为系统默认为你打开了0，1，2三个文件描述符，你把daemon_init中关闭描述符的代码注释了，然后里面又打开了
        /*        Redirect stdin, stdout, and stderr to /dev/null        */
        open("/dev/null", O_RDONLY);
        open("/dev/null", O_RDWR);
        open("/dev/null", O_RDWR);

三个文件描述符，这就是3，4，5

因此你下次在main函数里open自然就是从6开始了。

7跑哪里了？god knows!

为什么是Success，参考问题一，你没有调用close关闭未打开的文件描述符，因此就没有出错并设置errno为bad file descriptor啦

ChiyuT

回复 3# 雨过白鹭洲

多谢多谢！恍然大悟。  

现在就剩下那个不连续的问题了。

ChiyuT

我在怀疑是不是syslog本身要占用一个文件描述符。{:3_194:} 因为两个打开文件的操作中间，都调用了一次syslog，估计得研究一下它的实现。

ChiyuT

回复 3# 雨过白鹭洲

果然如此，我改了一下代码：

1.         int fd1 = open("tmp1", O_RDWR | O_CREAT | O_TRUNC, 0666);
   
2.        
   
3. //        write(fd, "hello world!", strlen("hello world!"));
   
4. 
   
5.         int fd2 = open("tmp2", O_RDWR | O_CREAT | O_TRUNC, 0666);
   
6.         err_ret("fd1 = %d, fd2 = %d", fd1, fd2);

复制代码

这回就连续了，汗一个：

1. 8431 Aug 31 22:08:35 localhost ./daemon[3494]: fd1 = 3, fd2 = 4: Bad file descriptor
   

复制代码

雨过白鹭洲

补充一下为什么4或者7文件描述符不见了

原因是err_ret调用了syslog，而syslog打开并占用了一个文件描述符，标准里面有描述：

The openlog() and syslog() functions  may  allocate  a  file descriptor.   It is not necessary to call openlog() prior to calling syslog().

看下面代码

1. int fd = open("tmp1", O_RDWR | O_CREAT | O_TRUNC, 0666);
   
2. // err_ret("fd = %d\n", fd);
   
3. 
   
4. fd = open("tmp2", O_RDWR | O_CREAT | O_TRUNC, 0666);
   
5. // err_ret("fd = %d\n", fd);
   
6.         
   
7. fd = open("tmp3", O_RDWR | O_CREAT | O_TRUNC, 0666);
   
8. // err_ret("fd = %d\n", fd);

复制代码

开放第一个err_ret，文件描述符是0，1，2，3，5，6             err_ret使用了4
开放第二个err_ret，文件描述符是0，1，2，3，4，6             err_ret使用了5
开放第三个err_ret，文件描述符是0，1，2，3，4，5             err_ret使用了6


从上面的试验来看，是syslog()而不是openlog()打开了文件描述符，而且重复调用syslog()只会打开一个描述符

ChiyuT

回复 7# 雨过白鹭洲

多谢多谢！都如你如言。{:3_192:} 咱可以安心睡个好觉了。

shengery

楼主难道没有用过strace吗？