深入浅出Linux设备驱动之阻塞与非阻塞

阻塞操作是指，在执行设备操作时，若不能获得资源，则进程挂起直到满足可操作的条件再进行操作。非阻塞操作的进程在不能进行设备操作时，并不挂起。被挂起的进程进入sleep状态，被从调度器的运行队列移走，直到等待的条件被满足。

在Linux驱动程序中，我们可以使用等待队列（wait queue）来实现阻塞操作。wait queue很早就作为一个基本的功能单位出现在Linux内核里了，它以队列为基础数据结构，与进程调度机制紧密结合，能够用于实现核心的异步事件通知机制。等待队列可以用来同步对系统资源的访问，上节中所讲述Linux信号量在内核中也是由等待队列来实现的。

wait的API：

1. wait_event(queue, condition)
   
2. 
   
3. wait_event_interruptible(queue, condition)
   
4. 
   
5. wait_event_timeout(queue, condition, timeout)
   
6. 
   
7. wait_event_interruptible_timeout(queue, condition, timeout)

复制代码

等待condition变为true，否则一直睡眠

condition可以在任何地方被改变，但改变时须wake_up 等待队列wq里面的process。

唤醒函数：

void wake_up(wait_queue_head_t *queue); //唤醒所有

void wake_up_interruptible(wait_queue_head_t *queue); //唤醒interruptible 

下面我们重新定义设备"globalvar"，它可以被多个进程打开，但是每次只有当一个进程写入了一个数据之后本进程或其它进程才可以读取该数据，否则一直阻塞。

1. #include <linux/module.h>
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. 
   
8. 
   
9. MODULE_LICENSE("GPL");
   
10. #define MAJOR_NUM 254
    
11. 
    
12. 
    
13. static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);
    
14. 
    
15. 
    
16. static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);
    
17. 
    
18. struct file_operations globalvar_fops =
    
19. {
    
20. read: globalvar_read,
    
21. write: globalvar_write,
    
22. };
    
23. 
    
24. 
    
25. static int global_var = 0;
    
26. static struct semaphore sem;
    
27. static wait_queue_head_t outq;
    
28. static int flag = 0;
    
29. 
    
30. 
    
31. static int __init globalvar_init(void)
    
32. {
    
33. int ret;
    
34. ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);
    
35. if (ret)
    
36. {
    
37. printk("globalvar register failure");
    
38. }
    
39. else
    
40. {
    
41. printk("globalvar register success");
    
42. init_MUTEX(&sem);
    
43. init_waitqueue_head(&outq);
    
44. }
    
45. return ret;
    
46. }
    
47. 
    
48. static void __exit globalvar_exit(void)
    
49. {
    
50. int ret;
    
51. ret = unregister_chrdev(MAJOR_NUM, "globalvar");
    
52. if (ret)
    
53. {
    
54. printk("globalvar unregister failure");
    
55. }
    
56. else
    
57. {
    
58. printk("globalvar unregister success");
    
59. }
    
60. }
    
61. 
    
62. static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)
    
63. {
    
64. 
    
65. if (wait_event_interruptible(outq, flag != 0))
    
66. {
    
67. return - ERESTARTSYS;
    
68. }
    
69. 
    
70. if (down_interruptible(&sem))
    
71. {
    
72. return - ERESTARTSYS;
    
73. }
    
74. 
    
75. flag = 0;
    
76. if (copy_to_user(buf, &global_var, sizeof(int)))
    
77. {
    
78. up(&sem);
    
79. return - EFAULT;
    
80. }
    
81. up(&sem);
    
82. return sizeof(int);
    
83. }
    
84. 
    
85. static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len,loff_t *off)
    
86. {
    
87. if (down_interruptible(&sem))
    
88. {
    
89. return - ERESTARTSYS;
    
90. }
    
91. if (copy_from_user(&global_var, buf, sizeof(int)))
    
92. {
    
93. up(&sem);
    
94. return - EFAULT;
    
95. }
    
96. up(&sem);
    
97. flag = 1;
    
98. 
    
99. wake_up_interruptible(&outq);
    
100. return sizeof(int);
     
101. }
     
102. 
     
103. module_init(globalvar_init);
     
104. module_exit(globalvar_exit);

复制代码

　　编写两个用户态的程序来测试，第一个用于阻塞地读/dev/globalvar，另一个用于写/dev/globalvar。只有当后一个对/dev/globalvar进行了输入之后，前者的read才能返回。


读的程序为：

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. 
   
6. 
   
7. 
   
8. main()
   
9. {
   
10. 　int fd, num;
    
11. 
    
12. 　fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);
    
13. 　if (fd != - 1)
    
14. 　{
    
15. 　　while (1)
    
16. 　　{
    
17. read(fd, &num, sizeof(int));//程序将阻塞在此语句，除非有针对globalvar的输入
    
18. 　　　printf("The globalvar is %d\n", num);
    
19. 
    
20. 　　　//如果输入是0，则退出
    
21. 　　　if (num == 0)
    
22. 　　　{
    
23. 　　　　close(fd);
    
24. 　　　　break;
    
25. 　　　}
    
26. 　　}
    
27. 　}
    
28. 　else
    
29. 　{
    
30. 　　printf("device open failure\n");
    
31. 　}
    
32. }

复制代码

　
写的程序为：

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. main()
   
6. {
   
7. 　int fd, num;
   
8. 
   
9. 　fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);
   
10. 　if (fd != - 1)
    
11. 　{
    
12. 　　while (1)
    
13. 　　{
    
14. 　　　printf("Please input the globalvar:\n");
    
15. 　　　scanf("%d", &num);
    
16. 　　　write(fd, &num, sizeof(int));
    
17. 
    
18. 　　　//如果输入0，退出
    
19. 　　　if (num == 0)
    
20. 　　　{
    
21. 　　　　close(fd);
    
22. 　　　　break;
    
23. 　　　}
    
24. 　　}
    
25. 　}
    
26. 　else
    
27. 　{
    
28. 　　printf("device open failure\n");
    
29. 　}
    
30. }

复制代码

　　

打开两个终端，分别运行上述两个应用程序，发现当在第二个终端中没有输入数据时，第一个终端没有输出（阻塞），每当我们在第二个终端中给globalvar输入一个值，第一个终端就会输出这个值。

没有办法，我们还是要借助fork函数，完成验证，呵呵，fork大练兵了。
程序如下：

1. #include
   
2. 
   
3. #include
   
4. 
   
5. #include
   
6. 
   
7. #include
   
8. 
   
9. #include
   
10. 
    
11. int main(void)
    
12. {
    
13. 
    
14. pid_t pid;
    
15. 
    
16. pid=fork();
    
17. 
    
18. if(pid < 0)printf("error in fork!");
    
19. else if (pid == 0)
    
20. { int fd, num;
    
21. printf("I am parent\n");
    
22. 
    
23. fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);
    
24. if (fd != - 1)
    
25. {
    
26. while (1)
    
27. {
    
28. read(fd, &num, sizeof(int));
    
29. printf("The globalvar is %d\n", num);
    
30. 
    
31. 
    
32. if (num == 0)
    
33. {
    
34. close(fd);
    
35. break;
    
36. }
    
37. }
    
38. }
    
39. else
    
40. {
    
41. printf("device open failure\n");
    
42. }
    
43. } 
    
44. 
    
45. else
    
46. {int fd, num;
    
47. printf( "I am child\n");
    
48. 
    
49. fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);
    
50. if (fd != - 1)
    
51. {
    
52. while (1)
    
53. {
    
54. printf("Please input the globalvar:\n");
    
55. scanf("%d", &num);
    
56. write(fd, &num, sizeof(int));
    
57. 
    
58. if (num == 0)
    
59. {
    
60. close(fd);
    
61. break;
    
62. }
    
63. 
    
64. }
    
65. } 
    
66. else
    
67. {
    
68. printf("device open failure\n");
    
69. }
    
70. 
    
71. 
    
72. 
    
73. 
    
74. }
    
75. return 0;
    
76. }
    
77. 运行结果如下：
    
78. [root@(none) study]$./gtest1 
    
79. I am child 
    
80. Please input the globalvar: 
    
81. I am parent 
    
82. 1 
    
83. Please input the globalvar: 
    
84. The globalvar is 1 
    
85. 2 
    
86. Please input the globalvar: 
    
87. The globalvar is 2 
    
88. 0 
    
89. The globalvar is 0 
    
90. 
    
91. [root@(none) study]$./gtest1 
    
92. I am child 
    
93. Please input the globalvar: 
    
94. I am parent 
    
95. 0 
    
96. The globalvar is 0 
    
97. 
    
98. [root@(none) study]$./gtest1 
    
99. I am child 
    
100. Please input the globalvar: 
     
101. I am parent 
     
102. 0 
     
103. The globalvar is 0 
     
104. [root@(none) study]$./gtest1 
     
105. I am parent 
     
106. I am child 
     
107. Please input the globalvar: 
     
108. 0 
     
109. The globalvar is 0 
     
110. [root@(none) study]$./gtest1 
     
111. I am child 
     
112. Please input the globalvar: 
     
113. I am parent 
     
114. 1 
     
115. Please input the globalvar: 
     
116. The globalvar is 1 
     
117. 2 
     
118. Please input the globalvar: 
     
119. The globalvar is 2 
     
120. 3 
     
121. Please input the globalvar: 
     
122. The globalvar is 3 
     
123. 0 
     
124. The globalvar is 0 
     
125. [root@(none) study]$./gtest1 
     
126. I am child 
     
127. I am parent 
     
128. Please input the globalvar: 
     
129. 1 
     
130. Please input the globalvar: 
     
131. The globalvar is 1 
     
132. 2 
     
133. Please input the globalvar: 
     
134. The globalvar is 2 
     
135. 0 
     
136. The globalvar is 0

复制代码

分析一下不难得出结论，我们的阻塞得到了验证。



关于上述例程，我们补充说一点，如果将驱动程序中的read函数改为：

1. static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)
   
2. {
   
3. 　//获取信号量：可能阻塞
   
4. 　if (down_interruptible(&sem))
   
5. 　{
   
6. 　　return - ERESTARTSYS;
   
7. 　}
   
8. 
   
9. 　//等待数据可获得：可能阻塞
   
10. 　if (wait_event_interruptible(outq, flag != 0))
    
11. 　{
    
12. 　　return - ERESTARTSYS;
    
13. 　}
    
14. 　flag = 0;
    
15. 
    
16. 　//临界资源访问
    
17. 　if (copy_to_user(buf, &global_var, sizeof(int)))
    
18. 　{
    
19. 　　up(&sem);
    
20. 　　return - EFAULT;
    
21. 　}
    
22. 
    
23. 　//释放信号量
    
24. 　up(&sem);
    
25. 
    
26. 　return sizeof(int);
    
27. }

复制代码

　　即交换wait_event_interruptible(outq, flag != 0)和down_interruptible(&sem)的顺序，这个驱动程序将变得不可运行。实际上，当两个可能要阻塞的事件同时出现时，即两个wait_event或down摆在一起的时候，将变得非常危险，死锁的可能性很大，这个时候我们要特别留意它们的出现顺序。当然，我们应该尽可能地避免这种情况的发生！

还有一个与设备阻塞与非阻塞访问息息相关的论题，即select和poll，select和 poll的本质一样，前者在BSD Unix中引入，后者在System V中引入。poll和select用于查询设备的状态，以便用户程序获知是否能对设备进行非阻塞的访问，它们都需要设备驱动程序中的poll函数支持。

　驱动程序中poll函数中最主要用到的一个API是poll_wait，其原型如下：

void poll_wait(struct file *filp, wait_queue_heat_t *queue, poll_table * wait); 

poll_wait函数所做的工作是把当前进程添加到wait参数指定的等待列表（poll_table）中。下面我们给globalvar的驱动添加一个poll函数：

1. static unsigned int globalvar_poll(struct file *filp, poll_table *wait)
   
2. {
   
3. 　unsigned int mask = 0;
   
4. 
   
5. 　poll_wait(filp, &outq, wait);
   
6. 
   
7. 　//数据是否可获得？ 
   
8. 　if (flag != 0)
   
9. 　{
   
10. 　　mask |= POLLIN | POLLRDNORM; //标示数据可获得
    
11. 　}
    
12. 　return mask;
    
13. }

复制代码

需要说明的是，poll_wait函数并不阻塞，程序中poll_wait(filp, &outq, wait)这句话的意思并不是说一直等待outq信号量可获得，真正的阻塞动作是上层的select/poll函数中完成的。select/poll会在一个循环中对每个需要监听的设备调用它们自己的poll支持函数以使得当前进程被加入各个设备的等待列表。若当前没有任何被监听的设备就绪，则内核进行调度（调用schedule）让出cpu进入阻塞状态，schedule返回时将再次循环检测是否有操作可以进行，如此反复；否则，若有任意一个设备就绪， select/poll都立即返回。

我们编写一个用户态应用程序来测试改写后的驱动。程序中要用到BSD Unix中引入的select函数，其原型为：

int select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); 

其中readfds、writefds、exceptfds分别是被select()监视的读、写和异常处理的文件描述符集合，numfds的值是需要检查的号码最高的文件描述符加1。timeout参数是一个指向struct timeval类型的指针，它可以使select()在等待timeout时间后若没有文件描述符准备好则返回。struct timeval数据结构为： 

struct timeval 
{ 
　　int tv_sec; /* seconds */ 
　　int tv_usec; /* microseconds */ 
};


除此之外，我们还将使用下列API：
FD_ZERO(fd_set *set)――清除一个文件描述符集； 
FD_SET(int fd,fd_set *set)――将一个文件描述符加入文件描述符集中FD_CLR(int fd,fd_set *set)――将文件描述符从文件描述符集中清除； 
FD_ISSET(int fd,fd_set *set)――判断文件描述符是否被置位。

下面的用户态测试程序等待/dev/globalvar可读，但是设置了5秒的等待超时，若超过5秒仍然没有数据可读，则输出"No data within 5 seconds"：

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. #include
   
8. int main(void)
   
9. {
   
10. 　int fd, num;
    
11. 　fd_set rfds;
    
12. 　struct timeval tv;
    
13. 
    
14. 　fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);
    
15. 　if (fd != - 1)
    
16. 　{
    
17. 　　while (1)
    
18. 　　{
    
19. 　　　//查看globalvar是否有输入
    
20. 　　　FD_ZERO(&rfds);
    
21. 　　　FD_SET(fd, &rfds);
    
22. 　　　//设置超时时间为5s
    
23. 　　　tv.tv_sec = 5;
    
24. 　　　tv.tv_usec = 0;
    
25. 　　　select(fd + 1, &rfds, NULL, NULL, &tv);
    
26. 
    
27. 　　　//数据是否可获得？
    
28. 　　　if (FD_ISSET(fd, &rfds))
    
29. 　　　{
    
30. 　　　　read(fd, &num, sizeof(int));
    
31. 　　　　printf("The globalvar is %d\n", num);
    
32. 
    
33. 　　　　//输入为0，退出
    
34. 　　　　if (num == 0)
    
35. 　　　　{
    
36. 　　　　　close(fd);
    
37. 　　　　　break;
    
38. 　　　　}
    
39. 　　　}
    
40. 　　　else
    
41. 　　　　printf("No data within 5 seconds.\n");
    
42. 　　}
    
43. 　}
    
44. 　else
    
45. 　{
    
46. 　　printf("device open failure\n");
    
47. 　}
    
48. }

复制代码

　　开两个终端，分别运行程序：一个对globalvar进行写，一个用上述程序对 globalvar进行读。当我们在写终端给globalvar输入一个值后，读终端立即就能输出该值，当我们连续5秒没有输入时，"No data within 5 seconds"在读终端被输出。