标准输入使用信号驱动I/O，无限捕捉SIGIO

McHeaven

代码如下，打算设置标准输入为信号驱动I/O，
当输入内容的时候能够触发signal handler进行处理

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <errno.h>
   
6. #include <fcntl.h>
   
7. #include <signal.h>
   
8. 
   
9. 
   
10. void sigio_handler(int sig)
    
11. {
    
12.     static int cnt = 0;
    
13. 
    
14.     printf("receive SIGIO signal %d\n", ++cnt);
    
15.     fflush(stdin);
    
16.     fflush(stdout);
    
17. }
    
18. 
    
19. int main(int argc, char **argv)
    
20. {
    
21.     struct sigaction sig_act;
    
22.     int fl = 0;
    
23. 
    
24.     //signal driven I/O setting
    
25.     fflush(stdin);
    
26.     fflush(stdout);
    
27.     fl = fcntl(STDIN_FILENO, F_GETFL, 0);
    
28.     fcntl(STDIN_FILENO, F_SETFL, fl | O_NONBLOCK | O_ASYNC );
    
29.     fcntl(STDIN_FILENO, F_SETOWN, getpid());
    
30.     sigemptyset(&sig_act.sa_mask);
    
31.     sig_act.sa_flags = 0;
    
32.     sig_act.sa_handler = sigio_handler;
    
33.     sigaction(SIGIO, &sig_act, NULL);
    
34. 
    
35.     printf("test start\n");
    
36.     fflush(stdin);
    
37.     fflush(stdout);
    
38. 
    
39.     while (1)
    
40.     {
    
41.         sleep(1);
    
42.     }
    
43. 
    
44.     return 0;
    
45. }
    

复制代码

运行的结果是signal handler被无限调用，也就是说SIGIO不断产生，结果如下：

1. 
   
2. test start
   
3. receive SIGIO signal 1
   
4. receive SIGIO signal 2
   
5. receive SIGIO signal 3
   
6. receive SIGIO signal 4
   
7. receive SIGIO signal 5
   
8. receive SIGIO signal 6
   
9. receive SIGIO signal 7
   
10. receive SIGIO signal 8
    
11. receive SIGIO signal 9
    
12. receive SIGIO signal 10
    
13. receive SIGIO signal 11
    
14. receive SIGIO signal 12
    
15. receive SIGIO signal 13
    
16. receive SIGIO signal 14
    
17. receive SIGIO signal 15
    
18. receive SIGIO signal 16
    
19. receive SIGIO signal 17
    
20. receive SIGIO signal 18
    
21. ...
    

复制代码

现在想知道标准输入/输出产生SIGIO的情况是什么
现在遇到的情况是不是因为标准输出也会产生SIGIO信号，不停触发signal handler
可是我绑定时候使用的是STDIN_FILENO，而且每次printf了之后也使用fflush对缓冲区进行了冲洗
请指教，谢谢

羽剑天涯

回复 1# McHeaven


    感觉\n和fflush(stdout)（在有输出缓冲时）都会在stdin中产生输入（回车输入？），你的中断函数中printf有\n(同时有fflush(stdout))，则此时又触发一次中断，如此进入了恶性循环，从而SIGIO无限触发。你把这两处去掉，计数放在程序退出前打印，就不会这样了，修改后的代码：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <errno.h>
   
5. #include <fcntl.h>
   
6. #include <signal.h>
   
7. #include <time.h>
   
8. 
   
9. static int cnt = 0;
   
10. void sigio_handler(int sig)
    
11. {
    
12. 
    
13.     printf("receive SIGIO signal %d", ++cnt);
    
14.     fflush(stdin);
    
15.     //fflush(stdout);
    
16. }
    
17. 
    
18. int main(int argc, char **argv)
    
19. {
    
20.     struct sigaction sig_act;
    
21.     int fl = 0;
    
22. 
    
23.     //signal driven I/O setting
    
24.     fflush(stdin);
    
25.     fflush(stdout);
    
26.     fl = fcntl(STDIN_FILENO, F_GETFL, 0);
    
27.     fcntl(STDIN_FILENO, F_SETFL, fl | O_NONBLOCK | O_ASYNC );
    
28.     fcntl(STDIN_FILENO, F_SETOWN, getpid());
    
29.     sigemptyset(&sig_act.sa_mask);
    
30.     sig_act.sa_flags = 0;
    
31.     sig_act.sa_handler = sigio_handler;
    
32.     sigaction(SIGIO, &sig_act, NULL);
    
33. 
    
34.     printf("test start\n");
    
35.     fflush(stdin);
    
36.     fflush(stdout);
    
37. 
    
38.         time_t st=time(NULL);
    
39.     while (time(NULL) < st+5)
    
40.     {
    
41.         sleep(1);
    
42.     }
    
43.     printf("\ncnt=%d\n",cnt);
    
44. 
    
45.     return 0;
    
46. }

复制代码

McHeaven

我自己也做了几个实验，得到这样的结论：

对于stdin绑定了信号驱动I/O的进程，在stdout上的输出能触发SIGIO信号需要满足：stdout缓冲区中有数据，stdout缓冲区必须被冲洗；而与缓冲区中数据大小无关。在Linux 2.6上，每键入一个字符就会触发一次SIGIO信号，包括回车键；而在Linux 3.13上，只有敲入了回车键之后才会触发一次SIGIO信号。

这是我写的总结，有兴趣可以帮我看看有什么疏漏的：
blog.csdn.net/mcheaven/article/details/44303753

羽剑天涯

回复 3# McHeaven


    我觉得应该是这样：标准输入和标准输出（包括错误输出）都是关联在同一个”设备“（如pts、tty等）上，则这个”设备“上有IO输入输出时都会产生SIGIO（在这个”设备“的fd(s)上有开启O_ASYNC的情况下）。
    你总结中做的那些实验，都是因为确实产生了输出（如果缓冲了，就没有产生输出），才会产生SIGIO，你可以尝试关闭输出的缓冲setbuf(stdout,NULL)，这样的话，只要有输出（不必一定有换号和刷新缓冲），就会立刻显示出来，同时就会产生SIGIO信号。
    另外，我认为，试验中的按键输入产生的中断，在2.6和3.13中不同，也是因为输入缓冲实现不同（2.6下没有这个缓冲？估计3.13也有什么设置可以关闭这个缓冲），如果进入缓冲（此时驱动认为不需要通知应用），则不会产生SIGIO，这样也可以解释，你输入4、回车、5，最后4和回车被程序捕获了，而5最后遗留在外边，测试如图：

    对应的代码：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <errno.h>
   
5. #include <fcntl.h>
   
6. #include <signal.h>
   
7. #include <time.h>
   
8. 
   
9. static int cnt = 0;
   
10. void sigio_handler(int sig)
    
11. {
    
12.     char buf[100];
    
13.     cnt++;
    
14.     read(STDIN_FILENO, buf, 100);
    
15. }
    
16. 
    
17. int main(int argc, char **argv)
    
18. {
    
19.     struct sigaction sig_act;
    
20.     int fl = 0;
    
21.     setbuf(stdin, NULL);
    
22.     setbuf(stdout,NULL);
    
23.     fl = fcntl(STDIN_FILENO, F_GETFL, 0);
    
24.     fcntl(STDIN_FILENO, F_SETFL, fl | O_NONBLOCK | O_ASYNC );
    
25.     fcntl(STDIN_FILENO, F_SETOWN, getpid());
    
26.     sigemptyset(&sig_act.sa_mask);
    
27.     sig_act.sa_flags = 0;
    
28.     sig_act.sa_handler = sigio_handler;
    
29.     sigaction(SIGIO, &sig_act, NULL);
    
30. 
    
31.     time_t st=time(NULL);
    
32.     while (time(NULL) < st+5)
    
33.     {
    
34.         sleep(1);
    
35.     }
    
36.     printf("\ncnt=%d\n", cnt);
    
37. 
    
38.     return 0;
    
39. }
    

复制代码

我认为，其实，SIGIO信号的产生完全由对应”设备“的驱动程序实现决定，它什么时候调用kill_fasync，应用就什么时候收到对应信号，如果驱动中认为不需要发送信号（如缓冲掉），则程序就不会收到对应的信号。

羽剑天涯

另外3.13中缓冲的事情也可以解决，你把输入输出的终端设置为非标准模式（non-canonical mode）,此时也可以按键就触发SIGIO，代码如下：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <errno.h>
   
5. #include <fcntl.h>
   
6. #include <signal.h>
   
7. #include <time.h>
   
8. #include <termios.h>
   
9. 
   
10. static int cnt = 0;
    
11. char buf[100];
    
12. int l=0;
    
13. void sigio_handler(int sig)
    
14. {
    
15.     cnt++;
    
16.     while (l<100 && read(STDIN_FILENO, buf+l, 1) == 1) {
    
17.                 l++;
    
18.     }
    
19. 
    
20. int main(int argc, char **argv)
    
21. {
    
22.     int fl = 0;
    
23.     struct termios o={0},n={0};
    
24. 
    
25.         setbuf(stdin, NULL);
    
26.         setbuf(stdout,NULL);
    
27. 
    
28.         cfmakeraw(&n);
    
29.         tcgetattr(STDIN_FILENO,&o);
    
30.         tcsetattr(STDIN_FILENO,TCSANOW,&n);
    
31.     fl = fcntl(STDIN_FILENO, F_GETFL, 0);
    
32.     fcntl(STDIN_FILENO, F_SETFL, fl | O_NONBLOCK | O_ASYNC );
    
33.     fcntl(STDIN_FILENO, F_SETOWN, getpid());
    
34.     fflush(stdin);
    
35.     fflush(stdout);
    
36.     signal(SIGIO, sigio_handler);
    
37. 
    
38.         time_t st=time(NULL);
    
39.     while (time(NULL) < st+5)
    
40.     {
    
41.         sleep(1);
    
42.     }
    
43.     signal(SIGIO, SIG_IGN);
    
44.     printf("\ncnt=%d,l=%d\n", cnt,l);
    
45.     int i=0;
    
46. 
    
47.     for (i=0; i<l; i++) {
    
48.                 printf("%d,",buf[i]);
    
49.     }
    
50.     printf("\n");
    
51.         tcsetattr(STDIN_FILENO, TCSANOW, &o);
    
52. 
    
53.     return 0;
    
54. }
    

复制代码

McHeaven

感谢回复，你的思考让我加深了理解
关于键入字符触发SIGIO，两个版本表现不同应该就是终端设置的原因

让我费解的是：
程序里面O_ASYNC标志绑定的是标准输入的描述符
为什么标准输出上的成功输出会产生SIGIO信号
两者描述符是不同的
难道是驱动程序认为只要指定了0/1/2中其中一个是O_ASYNC，其他的也都是？
或者两者共用了什么东西的缘故？

羽剑天涯

回复 6# McHeaven


    0-2其实用的是同一个设备（驱动理论上肯定是一个），如下图所示