【Linux驱动】轮询操作select()和poll()

使用非阻塞I/O的应用程序通常会使用select()和poll()系统调用查询可对设备进行无阻塞的访问。select()和poll()系统调用最终会引发设备驱动中的poll()函数被执行。
select()和poll()系统调用的本质是一样的。本系列只关注设备驱动中的函数层，对于应用层具体请参考《APUE》或《TLPI》(linux/unix系统编程手册)，楼主手上就有这两本书，在编写应用态测试程序时，拿这两本书当参考手册。
还算和前面一样，本系列也不负责具体驱动层函数原型的解释，请参考《LDD》，先看代码：

关键词：poll_wait()

#include <linux/module.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <asm/uaccess.h>
#include <linux/poll.h>
#include <linux/semaphore.h>

MODULE_LICENSE("Dual BSD/GPL");

#define DEBUG_SWITCH 1
#if DEBUG_SWITCH
    #define P_DEBUG(fmt, args...)  printk("<1>" "<kernel>[%s]"fmt,__FUNCTION__, ##args)
#else
    #define P_DEBUG(fmt, args...)  printk("<7>" "<kernel>[%s]"fmt,__FUNCTION__, ##args)
#endif

#define DEV_SIZE 20//方便测试写进程阻塞
#define WQ_MAJOR 230

struct wq_dev{
    char kbuf[DEV_SIZE];//缓冲区
    dev_t devno;//设备号
    unsigned int major;
    struct cdev wq_cdev;
    unsigned int cur_size;//可读可写的数据量
    struct semaphore sem;//信号量
    wait_queue_head_t r_wait;//读等待队列
    wait_queue_head_t w_wait;//写等待队列
};

//struct wq_dev *wq_devp;

int wq_open(struct inode *inodep, struct file *filp)
{
    struct wq_dev *dev;
    dev = container_of(inodep->i_cdev, struct wq_dev, wq_cdev);
    filp->private_data = dev;
    printk(KERN_ALERT "open is ok!\n");
    return 0;
}

int wq_release(struct inode *inodep, struct file *filp)
{
    printk(KERN_ALERT "release is ok!\n");
    return 0;
}

static ssize_t wq_read(struct file *filp, char __user *buf, size_t count, loff_t *offset)
{
    struct wq_dev *dev = filp->private_data;

    P_DEBUG("read data...\n");

    if(down_interruptible(&dev->sem))//获取信号量
    {
        P_DEBUG("enter read down_interruptible\n");
        return -ERESTARTSYS;
    }
    P_DEBUG("read first down\n");
    while(dev->cur_size == 0){//无数据可读，进入休眠lon
        up(&dev->sem);//释放信号量,不然写进程没有机会来唤醒(没有获得锁)
        if(filp->f_flags & O_NONBLOCK)//检查是否是阻塞型I/O
            return -EAGAIN;
        P_DEBUG("%s reading:going to sleep\n", current->comm);
        if(wait_event_interruptible(dev->r_wait, dev->cur_size != 0))//休眠等待被唤醒
        {
            P_DEBUG("read wait interruptible\n");
            return -ERESTARTSYS;
        }
        P_DEBUG("wake up r_wait\n");
        if(down_interruptible(&dev->sem))//获取信号量
            return -ERESTARTSYS;
    }

    //数据已就绪
    P_DEBUG("[2]dev->cur_size is %d\n", dev->cur_size);
    if(dev->cur_size > 0)
        count = min(count, dev->cur_size);

    //从内核缓冲区赋值数据到用户空间，复制成功返回0
    if(copy_to_user(buf, dev->kbuf, count))
    {
        up(&dev->sem);
        return -EFAULT;
    }   
    dev->cur_size -= count;//可读数据量更新
    up(&dev->sem);
    wake_up_interruptible(&dev->w_wait);//唤醒写进程
    P_DEBUG("%s did read %d bytes\n", current->comm, (unsigned int)count);
    return count;
}

static ssize_t wq_write(struct file *filp, char __user *buf, size_t count, loff_t *offset)
{
    struct wq_dev *dev = filp->private_data;
    //wait_queue_t my_wait;
    P_DEBUG("write is doing\n");    
    if(down_interruptible(&dev->sem))//获取信号量
    {
        P_DEBUG("enter write down_interruptible\n");
        return -ERESTARTSYS;
    }
//  init_wait(&my_wait);
//  add_wait_queue(&dev->w_wait, &my_wait);
    P_DEBUG("write first down\n");
    while(dev->cur_size == DEV_SIZE){//判断空间是否已满

        up(&dev->sem);//释放信号量
        if(filp->f_flags & O_NONBLOCK)
            return -EAGAIN;
        P_DEBUG("writing going to sleep\n");
        if(wait_event_interruptible(dev->w_wait, dev->cur_size < DEV_SIZE))
            return -ERESTARTSYS;
    //  __set_current_state(TASK_INTERRUPTIBLE);//设置当前进程状态
    //  up(&dev->sem);//释放信号量
    //  P_DEBUG("befor schedule\n");
    //  schedule();//进程调度，当前进程进入休眠
    //  if(signal_pending(current))//检查当前进程是否有信号处理，返回不为0表示有信号处理
    //      return -EAGAIN;
    //  P_DEBUG("after schedule\n");
        if(down_interruptible(&dev->sem))//获取信号量
            return -ERESTARTSYS;
    }
    if(count > DEV_SIZE - dev->cur_size)
        count = DEV_SIZE - dev->cur_size;

    if(copy_from_user(dev->kbuf, buf, count))//数据复制
        return -EFAULT;
    dev->cur_size += count;//更新数据量
    P_DEBUG("write %d bytes , cur_size:[%d]\n", count, dev->cur_size);
    P_DEBUG("kbuf is [%s]\n", dev->kbuf);
    up(&dev->sem);
    wake_up_interruptible(&dev->r_wait);//唤醒读进程队列
    return count;
}

static unsigned int wq_poll(struct file *filp, poll_table *wait)
{
    struct wq_dev *dev = filp->private_data;
    unsigned int mask = 0;

    if(down_interruptible(&dev->sem))//获取信号量
        return -ERESTARTSYS;
    poll_wait(filp, &dev->w_wait, wait);//添加写等待队列
    poll_wait(filp, &dev->r_wait, wait);//添加读等待队列

    if(dev->cur_size != 0)//判断是否可读取
        mask |= POLLIN | POLLRDNORM;
    if(dev->cur_size != DEV_SIZE)//判断是否可写入
        mask |= POLLOUT | POLLWRNORM;

    up(&dev->sem);//释放信号量
    return mask;
}
struct file_operations wq_fops = {
    .open = wq_open,
    .release = wq_release,
    .write = wq_write,
    .read = wq_read,
    .poll = wq_poll,
};

struct wq_dev my_dev;

static int __init wq_init(void)
{
    int result = 0;
    my_dev.cur_size = 0;
    my_dev.devno = MKDEV(WQ_MAJOR, 0);
    //设备号分配
    if(WQ_MAJOR)
        result = register_chrdev_region(my_dev.devno, 1, "wqlkp");
    else
    {
        result = alloc_chrdev_region(&my_dev.devno, 0, 1, "wqlkp");
        my_dev.major = MAJOR(my_dev.devno);
    }
    if(result < 0)
        return result;

    cdev_init(&my_dev.wq_cdev, &wq_fops);//设备初始化
    my_dev.wq_cdev.owner = THIS_MODULE;
    sema_init(&my_dev.sem, 1);//信号量初始化
    init_waitqueue_head(&my_dev.r_wait);//等待队列初始化
    init_waitqueue_head(&my_dev.w_wait);

    result = cdev_add(&my_dev.wq_cdev, my_dev.devno, 1);//设备注册
    if(result < 0)
    {
        P_DEBUG("cdev_add error!\n");
        goto err;
    }
    printk(KERN_ALERT "hello kernel\n");
    return 0;

err:
    unregister_chrdev_region(my_dev.devno,1);
}

static void __exit wq_exit(void)
{
    cdev_del(&my_dev.wq_cdev);
    unregister_chrdev_region(my_dev.devno, 1);
}

module_init(wq_init);
module_exit(wq_exit);

我们分析下wq_poll函数：你会发现其中的两个参数与用户层调用的select/poll函数的参数不一致，实际上这两参数都不是用户传给他的，全部是由内核传的。

重点是poll_wait(struct file , wait_queue_head_t , poll_table *);看源码

//poll.h(source insight 3.5)
/* 
 * structures and helpers for f_op->poll implementations
 */
typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);

typedef struct poll_table_struct {
    poll_queue_proc qproc;
} poll_table;

static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
    if (p && wait_address)
        p->qproc(filp, wait_address, p);
}
static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
{
    pt->qproc = qproc;
}
//poll_wait()的参数就是传到poll_table_entry结构体中
struct poll_table_entry {
    struct file * filp;
    wait_queue_t wait;
    wait_queue_head_t * wait_address;
};

//select.h
/* Add a new entry */
static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
                poll_table *p)
{
    struct poll_table_entry *entry = poll_get_entry(p);//得到实体结构
    if (!entry)
        return;
    get_file(filp);
    entry->filp = filp;
    entry->wait_address = wait_address;
    init_waitqueue_entry(&entry->wait, current);//初始化
    add_wait_queue(wait_address,&entry->wait);//添加到等待队列中
}

综上，poll的内部实现主要是调用poll_wait()实现的，poll_wait()实际上是调用__pollwait()，该函数先通过参数poll_table型参数p获得一个poll_table_entry结构，然后初始化该结构，然后添加到等待队列中。
简而言之就是，把当前进程（通过成员找到整个结构体，container_of）添加到wait参数指定的等待队列(poll_table)中。

需要注意的是，从poll_wait的源码可以看出，该函数并不会引起阻塞。
阻塞发生在select/poll系统调用。等到有数据时被唤醒（可写或者可读），在有数据时，需要唤醒等待队列头，此时设备可工作（读或写）了，就会再次调用wq_poll()，返回相应掩码调用成功。

从do_select()中，我们可以看到wq_poll()会被调用多次（f_op->poll），其在循环中不断轮询，所以可以看出poll只是做了一个判断工作，真正的阻塞发生在select中。

那么select又是怎么操作的呢？继续挖掘：
这是Linux内核中select的调用。select() -> sys_select() -> core_sys_select() -> do_select() -> poll_initwait() -> init_poll_funcptr()

PS：小技巧，你要查看应用层的API的内核实现源码的话，一般进入系统调用是sys_API函数名，然后里会调用do_API函数名之类的

（点到即止，不然进死胡同了…参数省略了，读者可逐步跟踪，通过阅读上面函数的实现，可以看出阻塞是发生在select的系统调用中，我们的wq_poll内部不阻塞）其中，init_poll_funcptr(&pwq->pt, __pollwait);
从这里就可以看出poll_wait，最终调用的就是__pollwait函数
用户态程序：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <unistd.h>

int main(void)
{
    int fd;
    fd_set r_fset, w_fset;

    fd = open("/dev/wqlkp", O_RDWR);
    if(fd < 0)
    {
        perror("open");
        return -1;
    }

    FD_ZERO(&r_fset);
    FD_ZERO(&w_fset);

    while(1)
    {
        FD_SET(fd, &r_fset);
        FD_SET(fd, &w_fset);

        select(fd+1, &r_fset, &w_fset, NULL, NULL);

        if(FD_ISSET(fd, &r_fset))
            printf("device readable\n");
        if(FD_ISSET(fd, &w_fset))
            printf("device writeable\n");

    }

    return 0;
}

测试需要结合前面的./app_write和./app_read。
运行./app_poll （gcc -o app_poll app_poll.c），终端不断打印可写入通知，然后运行./app_write之后，终端就会打印可写入和可读出通知，当连续运行几次./app_write，内核缓冲区满了之后，就只会连续打印可读出通知。

可以看出，linux内核设备驱动就是根据VFS提供的函数接口，来针对性的实现你的底层操作，file_operations结构体的赋值实际上可以看做是这些底层操作函数的注册。

这样保证了应用层依旧用统一的函数接口来编写应用程序，不用管底层驱动是怎么实现的，这对于应用程序员来说就是一个黑盒子，类似于我们的linux应用程序开发，只需要如何操作API就行，具体这些API内部是怎么实现的就是linux驱动开发人员负责的事情了，驱动开发人员要尽量保证自己实现的语义是和标准语义是一致的。
所以，对于linux内核驱动开发而言，除了熟悉linux 内核之外，也是需要了解应用层API的，算起来高端一丢丢