x4412&ibox项目实战38－使用等待队列实现阻塞进程的唤醒

armeasy

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

等待队列具有以下操作方式。

一：定义等待队列头

1. wait_queue_head_t my_queue;

复制代码

二：初始化等待队列头

1. init_waitqueue_head(&my_queue);

复制代码

三：定义等待队列

1. DECLARE_WAITQUEUE(name, tsk)

复制代码

该宏用于定义并初始化一个名为name的等待队列，它等效于前面两步的操作。

四：添加/移除等待队列

1. void fastcall add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
   
2. void fastcall remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);

复制代码

add_wait_queue()用于将等待队列wait添加到等待队列头q指向的等待队列链表中，而 remove_wait_queue()用于将等待队列wait从附属的等待队列头q指向的等待队列链表中移除。

五：等待事件

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

复制代码

等待第一个参数queue作为等待队列头的等待队列被唤醒，而且第二个参数condition必须满足，否则阻塞。wait_event()和 wait_event_interruptible()的区别在于后者可以被信号打断，而前者不能。加上_timeout 后的宏意味着阻塞等待的超时时间，以jiffy为单位，在第三个参数的timeout到达时，不论condition是否满足，均返回。当condition满足时，以上四个函数均会立即返回，否则，阻塞等待 condition 满足。

六：唤醒队列

1. void wake_up(wait_queue_head_t *queue);
   
2. void wake_up_interruptible(wait_queue_head_t *queue);

复制代码

上述操作会唤醒以queue作为等待队列头的所有等待队列中所有属于该等待队列头的等待队列对应的进程。

wake_up() 应与wait_event()或wait_event_timeout()成对使用，而wake_up_interruptible() 则应与wait_event_interruptible()或wait_event_interruptible_timeout()成对使用。wake_up()可 唤醒处于TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE的进程，而wake_up_interruptible()只能唤醒处于TASK_INTERRUPTIBLE的进程。

七：在等待队列上睡眠

1. sleep_on(wait_queue_head_t *q );
   
2. interruptible_sleep_on(wait_queue_head_t *q );

复制代码

sleep_on()函数的作用就是将目前进程的状态置成TASK_UNINTERRUPTIBLE，并定义一个等待队列，之后把它附属到等待队列头q，直到资源可获得，q引导的等待队列被唤醒。

interruptible_sleep_on()与 sleep_on()函数类似，其作用是将目前进程的状态置成TASK_INTERRUPTIBLE，并定义一个等待队列，之后把它附属到等待队列头q，直到资源可获得，q引导的等待队列被唤醒或者进程收到信号。

sleep_on()函数应该与wake_up()成对使用，interruptible_sleep_on()应该与wake_up_interruptible()成对使用。

不论是sleep_on()还是interruptible_sleep_on()，其流程都如下所示。

（1）定义并初始化一个等待队列，将进程状态改变为TASK_UNINTERRUPTIBLE（不能被信号打断）或TASK_INTERRUPTIBLE（可以被信号打断），并将等待队列添加到等待队列头。

（2）通过 schedule()放弃 CPU，调度其他进程执行。

（3）进程被其他地方唤醒，将等待队列移出等待队列头。

在内核中使用set_current_state()函数或__add_wait_queue()函数来实现目前进程状态的改变，直接采用current->state = TASK_UNINTERRUPTIBLE类似的赋值语句也是可行的。通常而言，set_current_state()函数在任何环境下都可以使用，不会存在并发问题，但是效率要低于__add_ wait_queue()。因此，在许多设备驱动中，并不调用sleep_on()或 interruptible_sleep_on()，而是亲自进行进程的状态改变和切换。

编写驱动，实现以下几个功能：

一：在驱动中定义一个4KB的全局内存，用于和进程间交互数据；

二：该全局内存类似于一个先进先出的仓库，即FIFO；

三：当有进程给FIFO写数据时，读进程将会从FIFO中读出数据，并实时清空FIFO；

四：只有当FIFO没有填满时，才允许给FIFO填写数据。

在kernel/drivers/char/x4412目录下新建x4412-globalfifo.c文件，编辑内容如下：

1. #include <linux/module.h>
   
2. #include <linux/types.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/errno.h>
   
5. #include <linux/sched.h>
   
6. #include <linux/init.h>
   
7. #include <linux/cdev.h>
   
8. #include <asm/uaccess.h>
   
9. #include <linux/kernel.h>
   
10. #include <linux/workqueue.h>
    
11. #include <linux/slab.h>
    
12. #include <linux/device.h>
    
13. #define GLOBALFIFO_SIZE 0x1000
    
14. #define FIFO_CLEAR 0x1
    
15. static int globalfifo_major;
    
16. static struct class *cdev_class;
    
17. DEFINE_SEMAPHORE(sem);
    
18. DECLARE_WAIT_QUEUE_HEAD(r_wait);
    
19. DECLARE_WAIT_QUEUE_HEAD(w_wait);
    
20. struct globalfifo_dev                                    
    
21. {
    
22.          struct cdev cdev;
    
23.          unsigned int current_len;
    
24.          unsigned char mem[GLOBALFIFO_SIZE];               
    
25. };
    
26. struct globalfifo_dev *globalfifo_devp;
    
27. int globalfifo_open(struct inode *inode, struct file *filp)
    
28. {
    
29.          filp->private_data = globalfifo_devp;
    
30.          return 0;
    
31. }
    
32. int globalfifo_release(struct inode *inode, struct file *filp)
    
33. {
    
34.          return 0;
    
35. }
    
36. static long globalfifo_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
    
37. {
    
38.          struct globalfifo_dev *dev = filp->private_data;
    
39.          switch (cmd)
    
40.          {
    
41.                    case FIFO_CLEAR:
    
42.                             down(&sem);  
    
43.                             dev->current_len = 0;
    
44.                             memset(dev->mem,0,GLOBALFIFO_SIZE);
    
45.                             up(&sem);
    
46.                             printk(KERN_INFO "globalfifo is set to zero\n");     
    
47.                    break;
    
48.                    default:
    
49.                             return  - EINVAL;
    
50.          }
    
51.          return 0;
    
52. }
    
53. static ssize_t globalfifo_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
    
54. {
    
55.          int ret;
    
56.          struct globalfifo_dev *dev = filp->private_data;
    
57.          DECLARE_WAITQUEUE(wait, current);
    
58.          down(&sem);
    
59.          add_wait_queue(&r_wait, &wait);
    
60.          if (dev->current_len == 0)
    
61.          {
    
62.                    if (filp->f_flags &O_NONBLOCK)
    
63.                    {
    
64.                             ret =  - EAGAIN;
    
65.                             goto out;
    
66.                    }
    
67.                    __set_current_state(TASK_INTERRUPTIBLE);
    
68.                    up(&sem);
    
69.                    schedule();
    
70.                    if (signal_pending(current))
    
71.                    {
    
72.                             ret =  - ERESTARTSYS;
    
73.                             goto out2;
    
74.                    }
    
75.                    down(&sem);
    
76.          }
    
77.          if (count > dev->current_len)
    
78.                    count = dev->current_len;
    
79.          if (copy_to_user(buf, dev->mem, count))
    
80.          {
    
81.                    ret =  - EFAULT;
    
82.                    goto out;
    
83.          }
    
84.          else
    
85.          {
    
86.                    memcpy(dev->mem, dev->mem + count, dev->current_len - count);
    
87.                    dev->current_len -= count;
    
88.                    printk(KERN_INFO "read %d bytes(s),current_len:%d\n", count, dev->current_len);
    
89.                    wake_up_interruptible(&w_wait);
    
90.                    ret = count;
    
91.          }
    
92. out:
    
93.          up(&sem);
    
94. out2:
    
95.          remove_wait_queue(&w_wait, &wait);
    
96.          set_current_state(TASK_RUNNING);
    
97.          return ret;
    
98. }
    
99. static ssize_t globalfifo_write(struct file *filp, const char __user *buf,size_t count, loff_t *ppos)
    
100. {
     
101.          int ret;
     
102.          struct globalfifo_dev *dev = filp->private_data;
     
103.          DECLARE_WAITQUEUE(wait, current);
     
104.          down(&sem);
     
105.          add_wait_queue(&w_wait, &wait);
     
106.          if (dev->current_len == GLOBALFIFO_SIZE)
     
107.          {
     
108.                   if (filp->f_flags &O_NONBLOCK)
     
109.                    {
     
110.                             ret =  - EAGAIN;
     
111.                             goto out;
     
112.                    }
     
113.                    __set_current_state(TASK_INTERRUPTIBLE);
     
114.                    up(&sem);
     
115.                    schedule();
     
116.                    if (signal_pending(current))
     
117.                    {
     
118.                             ret =  - ERESTARTSYS;
     
119.                             goto out2;
     
120.                    }
     
121.                    down(&sem);
     
122.          }
     
123.          if (count > GLOBALFIFO_SIZE - dev->current_len)
     
124.                    count = GLOBALFIFO_SIZE - dev->current_len;
     
125.          if (copy_from_user(dev->mem + dev->current_len, buf, count))
     
126.          {
     
127.                    ret =  - EFAULT;
     
128.                    goto out;
     
129.          }
     
130.          else
     
131.          {
     
132.                    dev->current_len += count;
     
133.                    printk(KERN_INFO "written %d bytes(s),current_len:%d\n", count, dev->current_len);
     
134.                    wake_up_interruptible(&r_wait);
     
135.                    ret = count;
     
136.          }
     
137. out:
     
138.          up(&sem);
     
139. out2:
     
140.          remove_wait_queue(&w_wait, &wait);
     
141.          set_current_state(TASK_RUNNING);
     
142.          return ret;
     
143. }
     
144. static const struct file_operations globalfifo_fops =
     
145. {
     
146.          .owner = THIS_MODULE,
     
147.          .read = globalfifo_read,
     
148.          .write = globalfifo_write,
     
149.          .unlocked_ioctl = globalfifo_ioctl,
     
150.          .open = globalfifo_open,
     
151.          .release = globalfifo_release,
     
152. };
     
153. static void globalfifo_setup_cdev(struct globalfifo_dev *dev, int index)
     
154. {
     
155.          int err, devno = MKDEV(globalfifo_major, index);
     
156.          cdev_init(&dev->cdev, &globalfifo_fops);
     
157.          dev->cdev.owner = THIS_MODULE;
     
158.          dev->cdev.ops = &globalfifo_fops;
     
159.          err = cdev_add(&dev->cdev, devno, 1);
     
160.          if (err)
     
161.                    printk(KERN_NOTICE "Error %d adding LED%d", err, index);
     
162. }
     
163. int globalfifo_init(void)
     
164. {
     
165.          int ret;
     
166.          dev_t devno;
     
167.          ret = alloc_chrdev_region(&devno, 0, 1, "x4412-globalfifo");
     
168.          globalfifo_major = MAJOR(devno);
     
169.          if (ret < 0)
     
170.                    return ret;
     
171.          globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);
     
172.          if (!globalfifo_devp)
     
173.          {
     
174.                    ret =  - ENOMEM;
     
175.                    goto fail_malloc;
     
176.          }
     
177.          memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev));
     
178.          globalfifo_setup_cdev(globalfifo_devp, 0);
     
179.          cdev_class = class_create(THIS_MODULE,"x4412-globalfifo");
     
180.          if(IS_ERR(cdev_class))
     
181.                    goto fail_class;
     
182.          device_create(cdev_class,NULL,devno,NULL,"x4412-globalfifo");
     
183.          return 0;
     
184. fail_class:
     
185.          class_destroy(cdev_class);
     
186. fail_malloc:
     
187.          unregister_chrdev_region(devno, 1);
     
188.          return ret;
     
189. }
     
190. void globalfifo_exit(void)
     
191. {
     
192.          device_destroy(cdev_class,MKDEV(globalfifo_major,0));
     
193.          class_destroy(cdev_class);
     
194.          cdev_del(&globalfifo_devp->cdev);
     
195.          kfree(globalfifo_devp);
     
196.          unregister_chrdev_region(MKDEV(globalfifo_major, 0), 1);
     
197. }
     
198. module_init(globalfifo_init);
     
199. module_exit(globalfifo_exit);
     
200. MODULE_AUTHOR("www.9tripod.com");
     
201. MODULE_LICENSE("Dual BSD/GPL");

复制代码

       在读写函数以及IOCTL中使用了信号量，在最前面通过DEFINE_SEMAPHORE(sem)声明信号量后，再将指定的临界区添加down(&sem)和up(&sem)函数即可。

       在程序开始定义并初始化了r_wait和w_wait两个等待队列头，分别用于阻塞读和阻塞写。在读函数globalfifo_read中，DECLARE_WAITQUEUE宏初始化一个名为wait的等待队列，然后再通过add_wait_queue函数将等待队列wait添加到等待队列头r_wait指向的等待队列列表中。

       在程序中有一个关键的变量dev->current_len，它在globalfifo_init函数中已经通过memset函数初始化为0，它时刻记录着当前指向的内存偏移位置。每读count个值，它将会向左偏移count位，每写count个值，它将向右偏移count位。当dev->current_len为0时，表示内存已经清空，当dev->current_len等于GLOBALFIFO_SIZE时，表示内存已经写满。

       再回到读函数，if条件语句判断dev->current_len是否为0，如果为0，表示FIFO内容为空，这时通过__set_current_state函数设置工作队列的状态为睡眠，然后通过schedule函数调度其他进程运行。一旦等待队列检测到被唤醒，表明FIFO已经有写的动作，将通过copy_to_user函数将写入的数据上报给应用。然后通过memcpy函数将FIFO数据前移，dev->current_len也随之向左移动相应位，读完之后再唤醒写等待队列，移除当前队列，并将进程设置为TASK_RUNNING。随后，程序交将给写等待队列。

       在写等待队列中，if语句判断dev->current_len是否等于GLOBALFIFO_SIZE。如果相等，则表明FIFO已满，__set_current_state函数将写等待队列设置为睡眠，再通过schedule函数调度其他进程运行。一旦写等待队列被唤醒，将通过copy_from_user函数将数据写入FIFO，同时dev->current_len右移，写完之后再唤醒读等待队列，程序再交给读等待队列，如此反复循环。

       编辑kernel/drivers/char/x4412/Kconfig文件，添加如下语句：

1. config X4412_GLOBALFIFO_DRIVER
   
2.          tristate "x4412 globalfifo driver"
   
3.          default m
   
4.          help
   
5.          compile for x4412 globalfifo driver,y for kernel,m for module.

复制代码

       编辑kernel/drivers/char/x4412/Makefile文件，添加如下语句：

1. obj-$(CONFIG_X4412_GLOBALFIFO_DRIVER) += x4412-globalfifo.o

复制代码

       编译内核，在kernel/drivers/char/x4412目录下将会生成目标文件x4412-globalfifo.ko。加载该驱动模块，使用命令行测试，效果如下：

1. [root@x4412 mnt]# insmod x4412-globalfifo.ko
   
2. [root@x4412 mnt]# mdev -s  
   
3. [root@x4412 mnt]# cat /dev/x4412-globalfifo &
   
4. [1] 1205
   
5. [root@x4412 mnt]# echo 'www.9tripod.com' > /dev/x4412-globalfifo
   
6. [  113.292857] written 16 bytes(s),current_len:16
   
7. [  113.296925] read 16 bytes(s),current_len:0
   
8. www.9tripod.com
   
9. [root@x4412 mnt]# echo 'www.bbs.9tripod.com' > /dev/x4412-globalfifo
   
10. [  145.165674] written 14 bytes(s),current_len:14
    
11. [  145.168950] read 14 bytes(s),current_len:0
    
12. www.bbs.9tripod.com
    
13. [root@x4412 mnt]#

复制代码

       可见，每当echo进程向/dev/x4412-globalfifo写入一串数据，cat进程就立即将这串数据显示出来。

可直接在x4412开发板＆ibox卡片电脑上运行的驱动模块：
x4412-globalfifo.ko (5.56 KB, 下载次数: 4)

2014-10-10 09:40 上传

点击文件名下载附件