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

 

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

刺猬@http://blog.csdn.net/littlehedgehog

注: 该系列文章转载自arm+linux chinaunix博客圈圈主之博客——http://blog.chinaunix.net/u/22630 /article_54997.html   为了适合我的编译环境，源代码有改动，但是相信我更改后的代码更加适合现在大多数读者的pc环境。


阻塞操作是指，在执行设备操作时，若不能获得资源，则进程挂起直到满足可操作的条件再进行操作。被挂起的进程进入sleep状态，被从调度器的运行队列移走，直到等待的条件被满足。非阻塞操作的进程在不能进行设备操作时，并不挂起。比如socket里面的read，如果客户端不发送数据，那么服务端就要一直等下去。

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

wait的API：

wait_event(queue, condition)

wait_event_interruptible(queue, condition)

wait_event_timeout(queue, condition, timeout)

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. #ifndef __KERNEL__
2. #define __KERNEL__
4. #endif
5. #ifndef MODULE
6. #define MODULE
7. #endif
9. #include <linux/module.h>
11. #include <linux/init.h>
13. #include <linux/fs.h>
15. #include <linux/wait.h>
17. #include <linux/sched.h>
19. #include <asm/uaccess.h>
21. #include <asm/semaphore.h>
23. MODULE_LICENSE("GPL");
25. #define MAJOR_NUM 250 //主设备号
27. static ssize_t globalvar_read(struct file *, char *, size_t, loff_t*);
29. static ssize_t globalvar_write(struct file *, const char *, size_t, loff_t*);
31. static int globalvar_open(struct inode *,struct file *);
33. static int globalvar_release(struct inode *,struct file *);
36. //初始化字符设备驱动的file_operations结构体
38. struct file_operations globalvar_fops =
39. {
40.     read:globalvar_read,
41.     write:globalvar_write,
42.     open:globalvar_open,
43.     release:globalvar_release,
44. };
46. static int global_var = 0; //"globalvar"设备的全局变量
47. static int global_count=0;
48. static wait_queue_head_t wait_q;    //定义等待队列头部
49. static int flag=0;      //这个是读写标志
50. static struct semaphore sem;
51. static spinlock_t spin=SPIN_LOCK_UNLOCKED;
53. static int __init globalvar_init(void)
54. {
56.     int ret;
57.     //注册设备驱动
58.     ret = register_chrdev(MAJOR_NUM, "globalvar", &globalvar_fops);
59.     if (ret)
60.         printk("globalvar register failure!/n");
61.     else
62.     {
63.         printk("globalvar register success!/n");
64.         init_MUTEX(&sem);
65.         init_waitqueue_head(&wait_q);
66.     }
67.     return ret;
68. }
70. static void __exit globalvar_exit(void)
71. {
72.     printk("globalvar unregister!/n");
73.     unregister_chrdev(MAJOR_NUM, "globalvar");
74. }
76. static int globalvar_open(struct inode *inode,struct file *filep)
77. {
78.     spin_lock(&spin);   //这里就限制了只能一个进程
79.     if(global_count)
80.     {
81.         spin_unlock(&spin);
82.         return -EBUSY;
83.     }
84.     global_count++;
85.     spin_unlock(&spin);
86.     return 0;
87. }
89. static int globalvar_release(struct inode *inode,struct file *filep)
90. {
91.     global_count--;
92.     return 0;
93. }
95. static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)
96. {
97.     printk("0/n");   //这是我作调试用的 
98.     if(wait_event_interruptible(wait_q,flag!=0))//注意 这里等待的条件flag==0 只要flag!=0 执行write进程会马上唤醒这个进程
99.     {
100.         return -ERESTARTSYS;
101.     }
102.     
103.     if(down_interruptible(&sem))
104.         return -ERESTARTSYS;
105.     printk("1/n");
106.     if (copy_to_user(buf, &global_var, sizeof(int)))
107.     {
108.         up(&sem);
109.         return -EFAULT;
110.     }
111.     printk("2/n");
112.     flag=0;
113.     up(&sem);
114.     printk("3/n");
115.     return sizeof(int);
116. }
118. static ssize_t globalvar_write(struct file *filp,const char *buf,size_t len,loff_t *off)
119. {
120.     if(down_interruptible(&sem))
121.         return -ERESTARTSYS;
122. //将用户空间的数据复制到内核空间的global_var
123.     if (copy_from_user(&global_var, buf, sizeof(int)))
124.     {
125.         up(&sem);
126.         return -EFAULT;
127.     }
128.     up(&sem);
129.     flag=1;
130.     wake_up_interruptible(&wait_q);
131.     return sizeof(int);
132. }
135. module_init(globalvar_init);
136. module_exit(globalvar_exit);
138. MODULE_LICENSE("GPL");
139. MODULE_AUTHOR("neo");

下面是测试程序，同样，我自己改了下。最好自己写，这样加深了解   [刺猬]

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <stdio.h>
4. #include <fcntl.h>
5. #include <unistd.h>
7. //#define DEBUG 
9. int main()
10. {
11.     int fd,readnum=13,writenum=22;
12.     int pid=1;
14.     if((fd=open("/dev/test",O_RDWR, S_IRUSR | S_IWUSR))==-1)
15.     {
16.         perror("damn! failed");
17.         return -1;
18.     }
20. #ifndef DEBUG
21.     if((pid=fork())==-1)
22.         return -1;
23. #endif
24.     sleep(3);
25.     if(pid)
26.     {
27.         printf("I am a parent! /nMy work is to read the globalvar device/n");
28.         sleep(3);
29.         printf("now read ... until one of my children write into it/n");
30.         read(fd,&readnum,sizeof(int));
31.         printf("at last ! someone's written %d my job's done/n",readnum);
32.     }
33.     else
34.     {
35.         printf("I am a child/nMy work is to write/n");
36.         sleep(2);
37.         printf("now write!/n");
38.         write(fd,&writenum,sizeof(int));
39.         printf("done! I write %d",writenum);
40.         sleep(8);
41.     }
42.     return 0;
43. }