@上一篇介绍了linux阻塞与非阻塞的基本概念，以及应用程序的小demo和kernel层对应的api函数。那接下来就以实例来分析，如何在linux驱动层添加等待队列和轮询的方法，以及区别。
**
一：简介
**
在linux驱动中，存在很常见的两种设备访问模式，所以在编写驱动的时候，一定要考虑到阻塞和非阻塞。这样做有以下好处
1. linux驱动标准的的写法，让你写的驱动正式，拿的出手，也能锻炼个人的规划能力、编程能力、思维能力；
2. 提高个人的审美能力，当你去看一个驱动，里面的各种框架，组件的交叉的逻辑之美，你会不禁赞叹，linux内核原来是这样，会有一种恍然大悟的感觉；
3.以上两点均是个人见解，阻塞和非阻塞有它存在的意义：针对不同的驱动设备，应运而生，提高驱动对设备资源访问的及时性，有效性，提高cpu的使用效率；
4.在应用程序对具体设备进行编程时，加阻塞和非阻塞对cpu的使用率，占有率是有巨大的影响。
举个例子：我们编写一个应用程序，读写按键的状态。在应用程序中，在while中轮询访问设备节点。如果应用中不加入阻塞方式，驱动中不加载阻塞方式，你应用程序在执行时，可以top看一下，执行文件在系统中占用cpu的使用率，接近100%，这样极大影响系统的整体性能，也非常不合理。加入阻塞方式，使用率会几乎为0%，这样才是我们寻求的正确方式。
**
二：等待队列
**
1. 实例分析：
以usb/class/usblp.c 为例,在probe中init rwait wwrite 等待队列头，注册设备类—>设备类里加入设备文件操作接口—>在接口里添加文件poll属性—>编写对应的poll函数，当应用程序读访问时，宏定义一个read等待队列，如果没有数据可读，切换状态进入休眠状态，等待唤醒；如果可读，设置状态为runing，删除read等待队列。写同样，如下：
#include <linux/poll.h>
struct usblp {
......
wait_queue_head_t rwait, wwait;
......
};
static void usblp_bulk_read(struct urb *urb)
{
......
//如果有数据可读，就唤醒read队列
wake_up(&usblp->rwait);
......
}
static void usblp_bulk_write(struct urb *urb)
{
......
//如果有数据可写，就唤醒write队列
wake_up(&usblp->wwait);
......
}
/* No kernel lock - fine */
static __poll_t usblp_poll(struct file *file, struct poll_table_struct *wait)
{
__poll_t ret;
unsigned long flags;
struct usblp *usblp = file->private_data;
/* Should we check file->f_mode & FMODE_WRITE before poll_wait()? */
poll_wait(file, &usblp->rwait, wait);
poll_wait(file, &usblp->wwait, wait);
spin_lock_irqsave(&usblp->lock, flags);
ret = ((usblp->bidir && usblp->rcomplete) ? EPOLLIN | EPOLLRDNORM : 0) |
((usblp->no_paper || usblp->wcomplete) ? EPOLLOUT | EPOLLWRNORM : 0);
spin_unlock_irqrestore(&usblp->lock, flags);
return ret;
}
static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
{
......
if ((rv = usblp_wwait(usblp, !!(file->f_flags & O_NONBLOCK))) < 0)
goto raise_wait;
......
wake_up(&usblp->wwait);
/*
* Step 2: Wait for transfer to end, collect results.
*/
rv = usblp_wwait(usblp, !!(file->f_flags&O_NONBLOCK));
......
}
static int usblp_wwait(struct usblp *usblp, int nonblock)
{
DECLARE_WAITQUEUE(waita, current);//创建一个等待队列
int rc;
int err = 0;
//如果不可write，就将当前任务添加到wwait中宝股份，
add_wait_queue(&usblp->wwait, &waita);
for (;;) {
if (mutex_lock_interruptible(&usblp->mut)) {
rc = -EINTR;
break;
}
//设置可以被TASK_INTERRUPTIBLE 信号打断。
set_current_state(TASK_INTERRUPTIBLE);
rc = usblp_wtest(usblp, nonblock);
mutex_unlock(&usblp->mut);
if (rc <= 0)
break;
//进行任务切换，当前进程进入睡眠状态
if (schedule_timeout(msecs_to_jiffies(1500)) == 0) {
if (usblp->flags & LP_ABORT) {
err = usblp_check_status(usblp, err);
if (err == 1) { /* Paper out */
rc = -ENOSPC;
break;
}
} else {
/* Prod the printer, Gentoo#251237. */
mutex_lock(&usblp->mut);
usblp_read_status(usblp, usblp->statusbuf);
mutex_unlock(&usblp->mut);
}
}
}
//如果可write，将当前任务状态设置为running，调用remove_wait_queue将进程从等待队列中删除
set_current_state(TASK_RUNNING);
remove_wait_queue(&usblp->wwait, &waita);
return rc;
}
static int usblp_rwait_and_lock(struct usblp *usblp, int nonblock)
{
DECLARE_WAITQUEUE(waita, current);
int rc;
add_wait_queue(&usblp->rwait, &waita);
for (;;) {
if (mutex_lock_interruptible(&usblp->mut)) {
rc = -EINTR;
break;
}
set_current_state(TASK_INTERRUPTIBLE);
if ((rc = usblp_rtest(usblp, nonblock)) < 0) {
mutex_unlock(&usblp->mut);
break;
}
if (rc == 0) /* Keep it locked */
break;
mutex_unlock(&usblp->mut);
schedule();
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&usblp->rwait, &waita);
return rc;
}
static const struct file_operations usblp_fops = {
.owner = THIS_MODULE,
.read = usblp_read,
.write = usblp_write,
.poll = usblp_poll,
.unlocked_ioctl = usblp_ioctl,
.compat_ioctl = usblp_ioctl,
.open = usblp_open,
.release = usblp_release,
.llseek = noop_llseek,
};
static struct usb_class_driver usblp_class = {
.name = "lp%d",
.devnode = usblp_devnode,
.fops = &usblp_fops,
.minor_base = USBLP_MINOR_BASE,
};
static int usblp_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
......
init_waitqueue_head(&usblp->rwait);
init_waitqueue_head(&usblp->wwait);
......
retval = usb_register_dev(intf, &usblp_class);
......
return 0;
}
static void usblp_disconnect(struct usb_interface *intf)
{
......
wake_up(&usblp->wwait);
wake_up(&usblp->rwait);
......
}
static struct usb_driver usblp_driver = {
.name = "usblp",
.probe = usblp_probe,
.disconnect = usblp_disconnect,
.suspend = usblp_suspend,
.resume = usblp_resume,
.id_table = usblp_ids,
.supports_autosuspend = 1,
};
......
2.注意事项
a.将任务或者进程加入到等待队列头；
b.在合适的点唤醒等待队列，一般在中断中。
三：轮询
**
实例分析：
以kernel/usb/misc/ldusb.c 为例,在probe中init read write 等带队列，注册设备类—>设备类里加入设备文件操作接口—>在接口里添加文件poll属性—>编写对应的poll函数，当应用程序读写访问时，判断是否为非阻塞访问，根据poll函数pollin状态，就会调用相关的wake up函数，实现数据访问，实现非阻塞式方式。
#include <linux/poll.h>//kernel轮询头文件
/* Structure to hold all of our device specific stuff */
struct ld_usb {
......
wait_queue_head_t read_wait; //读队列头
wait_queue_head_t write_wait; //写队列头
......
};
/**
* ld_usb_write
*/
static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
size_t count, loff_t *ppos)
{
......
/* wait until previous transfer is finished */
//判断是否为非阻塞式访问，如果是write有效，没有返回-EAGAIN。
if (dev->interrupt_out_busy) {
if (file->f_flags & O_NONBLOCK) {
retval = -EAGAIN;
goto unlock_exit;
}
//同read
retval = wait_event_interruptible(dev->write_wait, !dev->interrupt_out_busy);
if (retval < 0) {
goto unlock_exit;
}
}
......
}
/**
* ld_usb_read
*/
static ssize_t ld_usb_read(struct file *file, char __user *buffer, size_t count,
loff_t *ppos)
{
......
//判断是否为非阻塞式访问，如果是read有效，没有返回-EAGAIN。
if (file->f_flags & O_NONBLOCK) {
retval = -EAGAIN;
goto unlock_exit;
}
//加入等待队列，等待唤醒，也就是有数据读，实现非阻塞read
retval = wait_event_interruptible(dev->read_wait, dev->interrupt_in_done);
......
};
/**
* ld_usb_poll
* 用于处理非阻塞访问函数
* 参数file：要打开的设备文件
* 参数wait：等待列表(poll_table)
*/
static __poll_t ld_usb_poll(struct file *file, poll_table *wait)
{
struct ld_usb *dev;
__poll_t mask = 0;
dev = file->private_data;
if (!dev->intf)
return EPOLLERR | EPOLLHUP;
//将等待队列头加到poll_table中
poll_wait(file, &dev->read_wait, wait);
poll_wait(file, &dev->write_wait, wait);
if (dev->ring_head != dev->ring_tail) //如果有数据，就返回EPOLLIN，表示有数据
mask |= EPOLLIN | EPOLLRDNORM;
if (!dev->interrupt_out_busy)
mask |= EPOLLOUT | EPOLLWRNORM;
}
/* file operations needed when we register this driver */
static const struct file_operations ld_usb_fops = {
.owner = THIS_MODULE,
.read = ld_usb_read,
.write = ld_usb_write,
.open = ld_usb_open,
.release = ld_usb_release,
.poll = ld_usb_poll,
.llseek = no_llseek,
};
/*
* usb class driver info in order to get a minor number from the usb core,
* and to have the device registered with the driver core
*/
static struct usb_class_driver ld_usb_class = {
......
.fops = &ld_usb_fops,
......
};
static int ld_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
......
//初始化read，write等待队列头
init_waitqueue_head(&dev->read_wait);
init_waitqueue_head(&dev->write_wait);
//注册类，实现poll，供应用程序访问
......
retval = usb_register_dev(intf, &ld_usb_class);
......
}
/**
* ld_usb_disconnect
*
* Called by the usb core when the device is removed from the system.
*/
static void ld_usb_disconnect(struct usb_interface *intf)
{
......
usb_deregister_dev(intf, &ld_usb_class);
......
//唤醒poller
wake_up_interruptible_all(&dev->read_wait);
wake_up_interruptible_all(&dev->write_wait);
......
};
/* usb specific object needed to register this driver with the usb subsystem */
static struct usb_driver ld_usb_driver = {
.name = "ldusb",
.probe = ld_usb_probe,
.disconnect = ld_usb_disconnect,
.id_table = ld_usb_table,
};
module_usb_driver(ld_usb_driver);
四：区别
a.等待队列：在read、write函数中，初始化化一个等待队列，并且实现状态切换，进入睡眠状态。
b.轮询：在read、write中判断函数是否为非阻塞式访问，在poll函数根据pollin状态唤醒等待队列，读写数据。