Linux驱动之poll机制的理解与简单使用

之前在Linux驱动之按键驱动编写（中断方式）中编写的驱动程序，如果没有按键按下。read函数是永远没有返回值的，现在想要做到即使没有按键按下，在一定时间之后也会有返回值。要做到这种功能，可以使用poll机制。分以下几部来介绍poll机制

1、poll机制的使用，编写测试程序

2、poll机制的调用过程分析

3、poll机制的驱动编写

1、poll机制的使用，编写测试程序。

直接看到测试程序的代码。

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

/*
  *usage ./buttonstest
  */
int main(int argc, char **argv)
{
    int fd;
    char* filename="dev/buttons";
   unsigned char key_val;
   unsigned long cnt=;
   int ret;
   struct pollfd *key_fds;//定义一个pollfd结构体key_fds

    fd = open(filename, O_RDWR);//打开dev/firstdrv设备文件
    if (fd < )//小于0说明没有成功
    {
        printf("error, can't open %s\n", filename);
        return ;
    }

    if(argc !=)
    {
        printf("Usage : %s ",argv[]);
     return ;
    }
    key_fds ->fd = fd;//文件
    key_fds->events = POLLIN;//poll直接返回需要的条件
  while()
  {
     ret =  poll(key_fds, , );//调用sys_poll系统调用，如果5S内没有产生POLLIN事件，那么返回，如果有POLLIN事件，直接返回
    if(!ret)
    {
    printf("time out\n");
     }
    else
    {
        if(key_fds->revents==POLLIN)//如果返回的值是POLLIN，说明有数据POLL才返回的
            {
        read(fd, &key_val, );           //读取按键值
             printf("key_val: %x\n",key_val);//打印
            }
    }

  }

   return ;
}

从代码可以看出，相比较第三个测试程序third_test。程序源码见Linux驱动之按键驱动编写（中断方式），多定义了一个pollfd 结构体，它的结构如下：

struct pollfd {
    int fd;          //打开的文件节点
    short events;    //poll直接返回，需要产生的事件
    short revents;   //poll函数返回的事件
};

测试程序调用C库函数的poll函数时会用到这个结构体poll(key_fds, 1, 5000);其中第一个参数就是这个结构体的指针，对于多个目标文件来说是首地址，第二个参数为poll等待的文件个数，第三个参数为超时时间。那么poll是怎么实现的呢？

2、poll机制的调用过程分析

应用层利用C库函数调用poll函数的时候，会通过swi软件中断进入到内核层，然后调用sys_poll系统调用。它位于fs\Select.c中。

asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
            long timeout_msecs)
{
    s64 timeout_jiffies;

    if (timeout_msecs > ) {//超时参数验证以及处理
#if HZ > 1000
        /* We can only overflow if HZ > 1000 */
        if (timeout_msecs /  > (s64)0x7fffffffffffffffULL / (s64)HZ)
            timeout_jiffies = -;
        else
#endif
            timeout_jiffies = msecs_to_jiffies(timeout_msecs);
    } else {
        /* Infinite (< 0) or no (0) timeout */
        timeout_jiffies = timeout_msecs;
    }

    return do_sys_poll(ufds, nfds, &timeout_jiffies);//调用do_sys_poll

 }

可以看到sys_poll系统调用经过一些参数的验证之后直接调用了do_sys_poll，对于do_sys_poll做一个简单的介绍，它也位于fs\Select.c，它主要调用poll_initwait、do_poll函数

    int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64 *timeout)
    {
    ...
    ...
        poll_initwait(&table);//最终table->pt->qproc = __pollwait
    ...
    ...
        fdcount = do_poll(nfds, head, &table, timeout);
    ...
    ...
    }

先看到poll_initwait函数，它的主要功能是将table->pt->qproc = __pollwait，后面会用到

void poll_initwait(struct poll_wqueues *pwq)
{
    init_poll_funcptr(&pwq->pt, __pollwait);//pt->qproc = qproc;即table->pt->qproc = __pollwait
    pwq->error = ;
    pwq->table = NULL;
    pwq->inline_index = ;
}

接着看到do_poll(nfds, head, &table, timeout)，这里面的主要函数是do_pollfd(pfd, pt)与schedule_timeout(__timeout);下面分别介绍

static int do_poll(unsigned int nfds,  struct poll_list *list,
           struct poll_wqueues *wait, s64 *timeout)
{
    int count = ;
    poll_table* pt = &wait->pt;

    /* Optimise the no-wait case */
    if (!(*timeout))//处理没有超时的情况
        pt = NULL;

    for (;;) {//大循环，一直等待超时时间到或者有相应的事件触发唤醒进程
        struct poll_list *walk;
        long __timeout;

        set_current_state(TASK_INTERRUPTIBLE);//设置当前进程为可中断状态
        for (walk = list; walk != NULL; walk = walk->next) {//循环查找poll_fd列表
            struct pollfd * pfd, * pfd_end;

            pfd = walk->entries;
            pfd_end = pfd + walk->len;
            for (; pfd != pfd_end; pfd++) {
                /*
                 * Fish for events. If we found one, record it
                 * and kill the poll_table, so we don't
                 * needlessly register any other waiters after
                 * this. They'll get immediately deregistered
                 * when we break out and return.
                 */
                if (do_pollfd(pfd, pt)) {//pwait = table->pt。调用驱动的poll函数获取mask值，另外将进程放入等待队列
                    count++;
                    pt = NULL;
                }
            }
        }
        /*
         * All waiters have already been registered, so don't provide
         * a poll_table to them on the next loop iteration.
         */
        pt = NULL;
        if (count || !*timeout || signal_pending(current))//如果超时时间到了或者没有poll_fd或者事件发生了，直接退出
            break;
        count = wait->error;
        if (count)
            break;

        if (*timeout < ) {
            /* Wait indefinitely */
            __timeout = MAX_SCHEDULE_TIMEOUT;
        } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT-)) {
            /*
             * Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in
             * a loop
             */
            __timeout = MAX_SCHEDULE_TIMEOUT - ;
            *timeout -= __timeout;
        } else {
            __timeout = *timeout;
            *timeout = ;
        }

        __timeout = schedule_timeout(__timeout);//设置超时时间，进程休眠
        if (*timeout >= )
            *timeout += __timeout;
    }
    __set_current_state(TASK_RUNNING);//重新运行调用sys_poll的进程
    return count;
}

现在看到do_pollfd(pfd, pt)函数,它最终会调用驱动层的poll函数file->f_op->poll(file, pwait)，这就跟驱动扯上关系了， __pollwait在这里就被用到了，它将当前进程放入驱动层的等待列表，但是这时候当前进程还未休眠。

static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
{
    unsigned int mask;
    int fd;

    mask = ;
    fd = pollfd->fd;//根据pollfd找到文件节点
    if (fd >= ) {
        int fput_needed;
        struct file * file;

        file = fget_light(fd, &fput_needed);//根据文件节点fd找到文件的file结构
        mask = POLLNVAL;
        if (file != NULL) {
            mask = DEFAULT_POLLMASK;
            if (file->f_op && file->f_op->poll)
                mask = file->f_op->poll(file, pwait);//根据file结构找到驱动的f_op结构，然后调用它的poll函数，并且返回mask
                                                     //这个函数就跟驱动相关了，猜测调用poll_wati将当前进程放到驱动的等待列表。如果有数据的话，那么设置mask = POLLIN
            /* Mask out unneeded events. */
            mask &= pollfd->events | POLLERR | POLLHUP;
            fput_light(file, fput_needed);
        }
    }
    pollfd->revents = mask;

    return mask;
}

继续看到schedule_timeout(__timeout)函数，它位于kernel\Timer.c，它的主要作用就是设置一个定时器，当超时时间到的时候利用定时器的函数将进程唤醒。最后它还调用schedule()，进行进程的切换，因为在do_poll中已经被设置为TASK_INTERRUPTIBLE状态了。

fastcall signed long __sched schedule_timeout(signed long timeout)
{
    struct timer_list timer;
    unsigned long expire;

    switch (timeout)
    {
    case MAX_SCHEDULE_TIMEOUT:
        /*
         * These two special cases are useful to be comfortable
         * in the caller. Nothing more. We could take
         * MAX_SCHEDULE_TIMEOUT from one of the negative value
         * but I' d like to return a valid offset (>=0) to allow
         * the caller to do everything it want with the retval.
         */
        schedule();
        goto out;
    default:
        /*
         * Another bit of PARANOID. Note that the retval will be
         * 0 since no piece of kernel is supposed to do a check
         * for a negative retval of schedule_timeout() (since it
         * should never happens anyway). You just have the printk()
         * that will tell you if something is gone wrong and where.
         */
        if (timeout < ) {
            printk(KERN_ERR "schedule_timeout: wrong timeout "
                "value %lx\n", timeout);
            dump_stack();
            current->state = TASK_RUNNING;
            goto out;
        }
    }

    expire = timeout + jiffies;

    setup_timer(&timer, process_timeout, (unsigned long)current);//设置一个定时器，处理函数为process_timeout，传入的参数为当前进程，作用是时间到唤醒当前进程
    __mod_timer(&timer, expire);//修改定时器的定时时间
    schedule();//调度其它进程运行
    del_singleshot_timer_sync(&timer);//删除定时器

    timeout = expire - jiffies;

 out:
    return timeout <  ?  : timeout;
}

这就是整个poll机制的过程，接下来需要编写驱动程序file_operations 的poll函数

3、poll机制的驱动编写

直接看到源代码，从源码可以看到相比较third_drv.c驱动，这个在forth_drv_ops结构体中增加了一个forth_drv_poll函数，它的作用就是将调用sys_poll系统调用的的进程放入button_waitq等待队列。如果有按键值改变，那么将返回值设为POLLIN。这个函数在do_pollfd被调用。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <asm/io.h>        //含有iomap函数iounmap函数
#include <asm/uaccess.h>//含有copy_from_user函数
#include <linux/device.h>//含有类相关的处理函数
#include <asm/arch/regs-gpio.h>//含有S3C2410_GPF0等相关的
#include <linux/irq.h>    //含有IRQ_HANDLED\IRQ_TYPE_EDGE_RISING
#include <asm-arm/irq.h>   //含有IRQT_BOTHEDGE触发类型
#include <linux/interrupt.h> //含有request_irq、free_irq函数
#include <linux/poll.h>
//#include <asm-arm\arch-s3c2410\irqs.h>

static struct class *forth_drv_class;//类
static struct class_device *forth_drv_class_dev;//类下面的设备
static int forthmajor;

static unsigned long *gpfcon = NULL;
static unsigned long *gpfdat = NULL;
static unsigned long *gpgcon = NULL;
static unsigned long *gpgdat = NULL;

static unsigned int key_val;

struct pin_desc
{
    unsigned int pin;
    unsigned int key_val;
};

static struct pin_desc  pins_desc[] =
{
    {S3C2410_GPF0,0x01},
    {S3C2410_GPF2,0x02},
    {S3C2410_GPG3,0x03},
    {S3C2410_GPG11,0x04}
};

unsigned int ev_press;
DECLARE_WAIT_QUEUE_HEAD(button_waitq);//注册一个等待队列button_waitq

/*
  *0x01、0x02、0x03、0x04表示按键被按下
  */

/*
  *0x81、0x82、0x83、0x84表示按键被松开
  */

/*
  *利用dev_id的值为pins_desc来判断是哪一个按键被按下或松开
  */
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
    unsigned int pin_val;
    struct pin_desc * pin_desc = (struct pin_desc *)dev_id;//取得哪个按键被按下的状态

    pin_val = s3c2410_gpio_getpin(pin_desc->pin);

    if(pin_val) //按键松开
        key_val = 0x80 | pin_desc->key_val;
    else
        key_val = pin_desc->key_val;

    wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
    ev_press = ;    

    return IRQ_HANDLED;
}

static int forth_drv_open (struct inode * inode, struct file * file)
{
    int ret;
    ret = request_irq(IRQ_EINT0, buttons_irq, IRQT_BOTHEDGE, "s1", (void * )&pins_desc[]);
    if(ret)
    {
        printk("open failed 1\n");
        return -;
    }
    ret = request_irq(IRQ_EINT2, buttons_irq, IRQT_BOTHEDGE, "s2", (void * )& pins_desc[]);
    if(ret)
    {
        printk("open failed 2\n");
        return -;
    }
    ret = request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "s3", (void * )&pins_desc[]);
    if(ret)
    {
        printk("open failed 3\n");
        return -;
    }
    ret = request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "s4", (void * )&pins_desc[]);
    if(ret)
    {
        printk("open failed 4\n");
        return -;
    }

    return ;
}

static int forth_drv_close(struct inode * inode, struct file * file)
{
    free_irq(IRQ_EINT0 ,(void * )&pins_desc[]);

     free_irq(IRQ_EINT2 ,(void * )& pins_desc[]);

    free_irq(IRQ_EINT11 ,(void * )&pins_desc[]);

    free_irq(IRQ_EINT19 ,(void * )&pins_desc[]);

    return ;
}

static ssize_t forth_drv_read(struct file * file, char __user * userbuf, size_t count, loff_t * off)
{
    int ret;

    if(count != )
    {
        printk("read error\n");
        return -;
    }

//    wait_event_interruptible(button_waitq, ev_press);//将当前进程放入等待队列button_waitq中

    ret = copy_to_user(userbuf, &key_val, );
    ev_press = ;//按键已经处理可以继续睡眠

    if(ret)
    {
        printk("copy error\n");
        return -;
    }

    return ;
}

static unsigned int forth_drv_poll(struct file *file, poll_table *wait)
{
    unsigned int ret = ;
    poll_wait(file, &button_waitq, wait);//将当前进程放到button_waitq列表

    if(ev_press)
        ret |=POLLIN;//说明有数据被取到了

    return ret;
}

static struct file_operations forth_drv_ops =
{
    .owner   = THIS_MODULE,
    .open    =  forth_drv_open,
    .read     = forth_drv_read,
    .release = forth_drv_close,
    .poll      =  forth_drv_poll,
};

static int forth_drv_init(void)
{
    forthmajor = register_chrdev(, "buttons", &forth_drv_ops);//注册驱动程序

    if(forthmajor < )
        printk("failes 1 buttons_drv register\n");

    forth_drv_class = class_create(THIS_MODULE, "buttons");//创建类
    if(forth_drv_class < )
        printk("failes 2 buttons_drv register\n");
    forth_drv_class_dev = class_device_create(forth_drv_class, NULL, MKDEV(forthmajor,), NULL,"buttons");//创建设备节点
    if(forth_drv_class_dev < )
        printk("failes 3 buttons_drv register\n");

    gpfcon = ioremap(0x56000050, );//重映射
    gpfdat = gpfcon + ;
    gpgcon = ioremap(0x56000060, );//重映射
    gpgdat = gpgcon + ;

    printk("register buttons_drv\n");
    return ;
}

static void forth_drv_exit(void)
{
    unregister_chrdev(forthmajor,"buttons");

    class_device_unregister(forth_drv_class_dev);
    class_destroy(forth_drv_class);

    iounmap(gpfcon);
    iounmap(gpgcon);

    printk("unregister buttons_drv\n");
}

module_init(forth_drv_init);
module_exit(forth_drv_exit);

MODULE_LICENSE("GPL");

再回到测试程序，可以看到如果在5s内按键没有按键则也会返回，而不会一直睡眠。

具体程序的编译参考Linux驱动之按键驱动编写（中断方式）。

以上就是poll机制的实现过程以及使用方法。