字符驱动学习二（阻塞I/O）

     上次调试好了一个基本的字符驱动，支持并发控制。在实际的使用中，read 和 write 系统调用要支持阻塞访问的。这次使用等待队列实现阻塞。在实现阻塞的代码中涉及进程调度的内容。下面是read和write 函数：

2. static ssize_t cfifo_read(struct file *filp, char __user *buf, size_t count, loff_t *fpos)
   
3.     62    {
   
4.     63        int ret = 0;
   
5.     64        struct cfifo_t *dev = filp->private_data;
   
6.     65        DECLARE_WAITQUEUE(wait, current);
   
7.     66    
   
8.     67        down(&dev->sem);
   
9.     68        add_wait_queue(&dev->r_wait, &wait);
   
10.     69    
    
11.     70        while(dev->current_len == 0){
    
12.     71            if(filp->f_flags & O_NONBLOCK){
    
13.     72                ret = -EAGAIN;
    
14.     73                goto out;
    
15.     74            }
    
16.     75    
    
17.     76            __set_current_state(TASK_INTERRUPTIBLE);
    
18.     77            up(&dev->sem);
    
19.     78    
    
20.     79            schedule(); /*调度其他进程运行*/
    
21.     80            if(signal_pending(current)){
    
22.     81                ret = -ERESTARTSYS;
    
23.     82                goto out2;
    
24.     83            }
    
25.     84    
    
26.     85            down(&dev->sem);
    
27.     86        }
    
28.     87    
    
29.     88        if(count > dev->current_len)
    
30.     89            count = dev->current_len;
    
31.     90    
    
32.     91        if(copy_to_user(buf, (void*)(dev->mem), count)){
    
33.     92            ret = -EFAULT;
    
34.     93            goto out;
    
35.     94        } else{
    
36.     95            memcpy(dev->mem, dev->mem + count, dev->current_len - count);
    
37.     96            dev->current_len -= count;
    
38.     97            *fpos =dev->current_len;
    
39.     98    
    
40.     99            wake_up_interruptible(&dev->w_wait);
    
41.    100            ret =count;
    
42.    101    
    
43.    102            printk(KERN_INFO "read %s %d bites \n", buf, count);
    
44.    103        }
    
45.    104    
    
46.    105    out:
    
47.    106        up(&dev->sem);
    
48.    107    out2:
    
49.    108        remove_wait_queue(&dev->r_wait, &wait);
    
50.    109        set_current_state(TASK_RUNNING);
    
51.    110    
    
52.    111        return ret;
    
53.    112    }
    
54.    113

2. static ssize_t cfifo_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
   
3.    115    {
   
4.    116        int ret = 0;
   
5.    117        struct cfifo_t *dev = filp->private_data;
   
6.    118        DECLARE_WAITQUEUE(wait, current);
   
7.    119    
   
8.    120        down(&dev->sem);
   
9.    121        add_wait_queue(&dev->w_wait, &wait);
   
10.    122    
    
11.    123        while(dev->current_len >= GLOBALMEM_SIZE){
    
12.    124            if(filp->f_flags & O_NONBLOCK){             
13.    125                ret = -EAGAIN;
    
14.    126                goto out;
    
15.    127            }
    
16.    128    
    
17.    129            __set_current_state(TASK_INTERRUPTIBLE);    /* 进程状态，定义在 linux/sched.h */
    
18.    130            up(&dev->sem);                              /* 释放信号量，避免死锁 */
    
19.    131    
    
20.    132            schedule();                                 /* 调度其他进程运行*/
    
21.    133            if(signal_pending(current)){                
    
22.    134                ret = -ERESTARTSYS;
    
23.    135                goto out2;
    
24.    136            }
    
25.    137    
    
26.    138            down(&dev->sem);
    
27.    139        }
    
28.    140    
    
29.    141        if(count > GLOBALMEM_SIZE - dev->current_len)
    
30.    142            count = GLOBALMEM_SIZE - dev->current_len;
    
31.    143    
    
32.    144    
    
33.    145        if(copy_from_user(dev->mem+dev->current_len, buf, count)){
    
34.    146            ret = - EFAULT;
    
35.    147            goto out;
    
36.    148        }
    
37.    149        else{
    
38.    150            dev->current_len += count;
    
39.    151            *fpos = dev->current_len;
    
40.    152            ret = count;
    
41.    153    
    
42.    154            wake_up_interruptible(&dev->r_wait);
    
43.    155            printk(KERN_INFO "write %s %d bites \n", buf, count);
    
44.    156        }
    
45.    157    
    
46.    158    out:
    
47.    159        up(&dev->sem);
    
48.    160    out2:
    
49.    161        remove_wait_queue(&dev->w_wait, &wait);
    
50.    162        set_current_state(TASK_RUNNING);
    
51.    163    
    
52.    164        return ret;
    
53.    165    }

  开始读，这时设备中没有内容，read函数会阻塞在79行。然后向设备中写入内容，write函数运行到154行时，会唤醒写的进程，和65行代码有关

1. DECLARE_WAITQUEUE(wait, current)

下面是验证：

1. root@wang:/work/wanghuan/drives# ls
   
2. cdev.c cfifo.c cfifo.ko Makefile modules.order
   
3. root@wang:/work/wanghuan/drives# insmod cfifo.ko
   
4. root@wang:/work/wanghuan/drives# ls /dev/cfifo*
   
5. /dev/cfifo0 /dev/cfifo1
   
6. root@wang:/work/wanghuan/drives# cat /dev/cfifo0 &
   
7. [1] 2889
   
8. root@wang:/work/wanghuan/drives# ps
   
9.   PID TTY TIME CMD
   
10.  2046 pts/0 00:00:00 bash
    
11.  2889 pts/0 00:00:00 cat
    
12.  2890 pts/0 00:00:00 ps
    
13. root@wang:/work/wanghuan/drives# ls > /dev/cfifo0
    
14. cdev.c
    
15. cfifo.c
    
16. cfifo.ko
    
17. Makefile
    
18. modules.order
    
19. root@wang:/work/wanghuan/drives# ls > /dev/cfifo1
    
20. cdev.c
    
21. cfifo.c
    
22. cfifo.ko
    
23. Makefile
    
24. modules.order
    
25. root@wang:/work/wanghuan/drives

下面是完整的源码：

1. /**
   
2.  * =====================================================================================
   
3.  * Filename: cfifo.c
   
4.  * Description: 字符设备驱动模型 阻塞I/O
   
5.  * Version: 1.0
   
6.  * Created: 2011年06月12日 17时19分50秒
   
7.  * Revision: none
   
8.  * Compiler: gcc
   
9.  *
   
10.  * Author: wanghuan,
    
11.  * Company:
    
12.  * =====================================================================================
    
13.  */
    
14. 
    
15. #include <linux/module.h>
    
16. #include <linux/types.h>
    
17. #include <linux/fs.h>         /* file_operation */
    
18. #include <linux/errno.h>     /* Error number */
    
19. #include <linux/mm.h>    
    
20. #include <linux/sched.h>    
    
21. #include <linux/slab.h>    
    
22. #include <linux/init.h>     /* __init __exit */
    
23. #include <linux/device.h>
    
24. #include <linux/cdev.h>    
    
25. #include <asm/io.h>    
    
26. #include <asm/system.h>    
    
27. #include <asm/uaccess.h>     /* copy_to_user, copy_from_user */
    
28. #include <linux/kernel.h>     /* printk() */
    
29. 
    
30. #define GLOBALMEM_SIZE 0x1000
    
31. #define MEM_CLEAN 0x1
    
32. #define DEV_NAME "cfifo"
    
33. #define MEM_CLEAR _IO(GLOBALMEM_SIZE, 0)
    
34. 
    
35. static int MAJOR_NR = 255;        /* Driver Major Number */
    
36. //static int MINOR_NR = 0;        /* Driver Major Number */
    
37. 
    
38. struct cfifo_t{
    
39.     struct cdev cdev;
    
40.     unsigned char mem[GLOBALMEM_SIZE];
    
41.     struct semaphore sem;
    
42. 
    
43.     unsigned int current_len;
    
44.     wait_queue_head_t r_wait;
    
45.     wait_queue_head_t w_wait;
    
46. };
    
47. static struct cfifo_t *cfifo_p;
    
48. 
    
49. static int cfifo_open(struct inode *inode, struct file *filp)
    
50. {
    
51.     struct cfifo_t *dev;
    
52.     dev = container_of(inode->i_cdev, struct cfifo_t, cdev);
    
53.     filp->private_data = dev;
    
54.     return 0;
    
55. }
    
56. static int cfifo_release(struct inode *inode, struct file *filp)
    
57. {
    
58.     filp->private_data = NULL;
    
59.     return 0;
    
60. }
    
61. static ssize_t cfifo_read(struct file *filp, char __user *buf, size_t count, loff_t *fpos)
    
62. {
    
63.     int ret = 0;
    
64.     struct cfifo_t *dev = filp->private_data;
    
65.     DECLARE_WAITQUEUE(wait, current);
    
66.     
    
67.     down(&dev->sem);
    
68.     add_wait_queue(&dev->r_wait, &wait);
    
69. 
    
70.     while(dev->current_len == 0){
    
71.         if(filp->f_flags & O_NONBLOCK){
    
72.             ret = -EAGAIN;
    
73.             goto out;
    
74.         }
    
75. 
    
76.         __set_current_state(TASK_INTERRUPTIBLE);
    
77.         up(&dev->sem);
    
78. 
    
79.         schedule(); /*调度其他进程运行*/
    
80.         if(signal_pending(current)){
    
81.             ret = -ERESTARTSYS;
    
82.             goto out2;
    
83.         }
    
84. 
    
85.         down(&dev->sem);
    
86.     }
    
87. 
    
88.     if(count > dev->current_len)
    
89.         count = dev->current_len;
    
90. 
    
91.     if(copy_to_user(buf, (void*)(dev->mem), count)){
    
92.         ret = -EFAULT;
    
93.         goto out;
    
94.     } else{
    
95.         memcpy(dev->mem, dev->mem + count, dev->current_len - count);
    
96.         dev->current_len -= count;
    
97.         *fpos =dev->current_len;
    
98. 
    
99.         wake_up_interruptible(&dev->w_wait);
    
100.         ret =count;
     
101. 
     
102.         printk(KERN_INFO "read %s %d bites \n", buf, count);
     
103.     }
     
104. 
     
105. out:
     
106.     up(&dev->sem);
     
107. out2:
     
108.     remove_wait_queue(&dev->r_wait, &wait);
     
109.     set_current_state(TASK_RUNNING);
     
110. 
     
111.     return ret;
     
112. }
     
113. 
     
114. static ssize_t cfifo_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
     
115. {
     
116.     int ret = 0;
     
117.     struct cfifo_t *dev = filp->private_data;
     
118.     DECLARE_WAITQUEUE(wait, current);
     
119. 
     
120.     down(&dev->sem);
     
121.     add_wait_queue(&dev->w_wait, &wait);
     
122. 
     
123.     while(dev->current_len >= GLOBALMEM_SIZE){
     
124.         if(filp->f_flags & O_NONBLOCK){
     
125.             ret = -EAGAIN;
     
126.             goto out;
     
127.         }
     
128. 
     
129.         __set_current_state(TASK_INTERRUPTIBLE); /* 进程状态，定义在 linux/sched.h */
     
130.         up(&dev->sem); /* 释放信号量，避免死锁 */
     
131. 
     
132.         schedule(); /* 调度其他进程运行*/
     
133.         if(signal_pending(current)){
     
134.             ret = -ERESTARTSYS;
     
135.             goto out2;
     
136.         }
     
137. 
     
138.         down(&dev->sem);
     
139.     }
     
140. 
     
141.     if(count > GLOBALMEM_SIZE - dev->current_len)
     
142.         count = GLOBALMEM_SIZE - dev->current_len;
     
143. 
     
144. 
     
145.     if(copy_from_user(dev->mem+dev->current_len, buf, count)){
     
146.         ret = - EFAULT;
     
147.         goto out;
     
148.     }
     
149.     else{
     
150.         dev->current_len += count;
     
151.         *fpos = dev->current_len;
     
152.         ret = count;
     
153. 
     
154.         wake_up_interruptible(&dev->r_wait);
     
155.         printk(KERN_INFO "write %s %d bites \n", buf, count);
     
156.     }
     
157. 
     
158. out:
     
159.     up(&dev->sem);
     
160. out2:
     
161.     remove_wait_queue(&dev->w_wait, &wait);
     
162.     set_current_state(TASK_RUNNING);
     
163. 
     
164.     return ret;
     
165. }
     
166. 
     
167. static loff_t cfifo_llseek(struct file *filp, loff_t offset, int orig)
     
168. {
     
169.     loff_t ret;
     
170.     switch(orig){
     
171.         case 0:
     
172.             if(offset < 0){
     
173.                 ret = -EFAULT;
     
174.                 break;
     
175.             }
     
176.             if((unsigned int)offset > GLOBALMEM_SIZE){
     
177.                 ret = -EFAULT;
     
178.                 break;
     
179.             }
     
180. 
     
181.             filp->f_pos = (unsigned int)offset;
     
182.             ret = filp->f_pos;
     
183.             break;
     
184.         case 1:
     
185.             if(filp->f_pos + offset > GLOBALMEM_SIZE){
     
186.                 ret = -EFAULT;
     
187.                 break;
     
188.             }
     
189. 
     
190.             if(filp->f_pos + offset < 0){
     
191.                 ret = -EFAULT;
     
192.                 break;
     
193.             }
     
194. 
     
195.             filp->f_pos += offset;
     
196.             ret = filp->f_pos;
     
197.             break;
     
198.         default:
     
199.             ret = -EFAULT;
     
200.     }
     
201.     return ret;
     
202. }
     
203. 
     
204. static int cfifo_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
     
205. {
     
206.     struct cfifo_t *dev = filp->private_data;
     
207.     switch(cmd){
     
208.         case MEM_CLEAR:
     
209.             if(down_interruptible(&dev->sem))
     
210.                 return -ERESTARTSYS;
     
211. 
     
212.             memset(dev->mem, 0, GLOBALMEM_SIZE);
     
213. 
     
214.             up(&dev->sem);
     
215.             printk(KERN_INFO "globalmem is set to zero \n");
     
216.             break;
     
217.         default:
     
218.             return -EINVAL;
     
219.     }
     
220. 
     
221.     return 0;
     
222. }
     
223. 
     
224. static const struct file_operations cfifo_fops = {
     
225.     .owner = THIS_MODULE,
     
226.     .open = cfifo_open,
     
227.     .release = cfifo_release,
     
228.     .read = cfifo_read,
     
229.     .write = cfifo_write,
     
230.     .ioctl = cfifo_ioctl,
     
231.     .llseek = cfifo_llseek,
     
232. };
     
233. 
     
234. static void cfifo_setup_cdev(struct cfifo_t *cfifo_cdev, int minor)
     
235. {
     
236.     int err;
     
237.     dev_t devno = MKDEV(MAJOR_NR, minor);
     
238.     
     
239.     cdev_init(&cfifo_cdev->cdev, &cfifo_fops);
     
240.     cfifo_p->cdev.owner = THIS_MODULE;
     
241.     err = cdev_add(&cfifo_cdev->cdev, devno, 1);
     
242.     if(err != 0)
     
243.         printk(KERN_NOTICE "Error %d adding gmen", err);
     
244. 
     
245.     cfifo_cdev->current_len = 0;
     
246.     init_MUTEX(&cfifo_cdev->sem);
     
247.     init_waitqueue_head(&cfifo_cdev->r_wait);
     
248.     init_waitqueue_head(&cfifo_cdev->w_wait);
     
249. }
     
250. 
     
251. static struct class *cdev_class;
     
252. static int __init cfifo_cdev_init(void)
     
253. {
     
254.     int result;
     
255.     dev_t devno = MKDEV(MAJOR_NR, 0);
     
256. 
     
257.     if(0 != MAJOR_NR){
     
258.         result = register_chrdev_region(devno, 1, DEV_NAME); //注册设备 支持两个设备，此设备号从0开始
     
259.     } else {
     
260.         result = alloc_chrdev_region(&devno, 0, 1, DEV_NAME);
     
261.         MAJOR_NR = MAJOR(devno);
     
262.     }
     
263. 
     
264.     printk(KERN_CRIT"hello cfifo\n");
     
265.     if(result < 0)
     
266.         return result;
     
267. 
     
268.     cfifo_p = kmalloc(2*sizeof(struct cfifo_t), GFP_KERNEL);
     
269.     if(NULL == cfifo_p){
     
270.         unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 1);
     
271.         result = -ENOMEM;
     
272.     }
     
273. 
     
274.     memset(cfifo_p, 0, 1*sizeof(struct cfifo_t));
     
275.     cfifo_setup_cdev(&cfifo_p[0], 0);
     
276.     cfifo_setup_cdev(&cfifo_p[0], 1);
     
277. 
     
278.     cdev_class = class_create(THIS_MODULE, DEV_NAME);
     
279.     if(IS_ERR(cdev_class))
     
280.         return PTR_ERR(cdev_class);
     
281. 
     
282.     device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 0),    NULL, DEV_NAME"%d", 0);
     
283.     device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 1),    NULL, DEV_NAME"%d", 1);
     
284.     return 0;
     
285. }
     
286. 
     
287. void cfifo_cdev_exit(void)
     
288. {
     
289.     cdev_del(&cfifo_p[0].cdev);
     
290.     cdev_del(&cfifo_p[0].cdev);
     
291. 
     
292.     device_destroy(cdev_class, MKDEV(MAJOR_NR, 0)); //delete device node under /dev
     
293.     device_destroy(cdev_class, MKDEV(MAJOR_NR, 1)); //delete device node under /dev
     
294.     class_destroy(cdev_class); //delete class created by us
     
295. 
     
296.     kfree(cfifo_p);
     
297.     unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 1); //由于注册了两个设备，最后一个参数为 2
     
298. }
     
299. 
     
300. module_init(cfifo_cdev_init);
     
301. module_exit(cfifo_cdev_exit);
     
302. MODULE_LICENSE("GPL");
     
303. MODULE_AUTHOR("wanghuan");

Makefile：

1. #===============================================================================
   
2. # Filename: Makefile
   
3. # Description:
   
4. #
   
5. # Author: wanghuan
   
6. # Company:
   
7. #
   
8. #==============================================================================
   
9. 
   
10. obj-m :=cfifo.o #目标文件
    
11. KDIR :=/lib/modules/2.6.35-22-generic/build #内核路径
    
12. PWD := $(shell pwd) #模块源文件路径
    
13. all:    
    
14.     $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
    
15.     @rm -rf *.mod.*
    
16.     @rm -rf .*.cmd
    
17.     @rm -rf *.o
    
18.     @rm -rf Module.*
    
19.     chmod a+x cfifo.ko
    
20. clean: