linux_api专题：poll

在用户空间应用程序向驱动程序请求数据时，有以下几种方式：

    1、不断查询，条件不满足的情况下就是死循环，非常耗cpu

    2、休眠唤醒的方式，如果条件不满足，应用程序则一直睡眠下去

    3、poll机制，如果条件不满足，休眠指定的时间，休眠时间内条件满足唤醒，条件一直不满足时间到达自动唤醒

    4、异步通知，应用程序注册信号处理函数，驱动程序发信号。类似于QT的信号与槽机制。

应用程序： poll 支持同时查询多个打开的文件

1. int main(int argc, char **argv)
2. {
3. int fd;
4. unsigned char key_val = 0;
6. int ret;
8. struct pollfd fds[1];
9. fd = open( "/dev/button", O_RDWR);
11. if (fd < 0)
12. {
13. printf( "can't open!\n");
14. }
16. fds[ 0].fd = fd;
17. fds[ 0].events = POLLIN;
19. while ( 1)
20. {
21. ret = poll(fds, 1, 5000);
22. if (ret == 0)
23. {
24. printf( "time out\n");
25. }
26. else
27. {
28. read(fd, &key_val, 1);
29. printf( "key_val = 0x%x\n", key_val);
30. }
31. }
33. return 0;
34. }

内核空间：sys_poll

1. asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
2. long timeout_msecs)
3. {
4. s64 timeout_jiffies;
6. if (timeout_msecs > 0) {
7. #if HZ > 1000
8. /* We can only overflow if HZ > 1000 */
9. if (timeout_msecs / 1000 > (s64) 0x7fffffffffffffffULL / (s64)HZ)
10. timeout_jiffies = -1;
11. else
12. #endif
13. timeout_jiffies = msecs_to_jiffies(timeout_msecs);
14. } else {
15. /* Infinite (< 0) or no (0) timeout */
16. timeout_jiffies = timeout_msecs;
17. }
18. // 转换等待时间,do_sts_poll 是重点
19. return do_sys_poll(ufds, nfds, &timeout_jiffies);
20. }

1. int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64 *timeout)
2. {
3. struct poll_wqueues table;
4. ...
5. long stack_pps[POLL_STACK_ALLOC/ sizeof( long)];
6. struct poll_list *stack_pp = NULL;
8. //table->pt->qproc = __pollwait
9. poll_initwait(&table);
10. /*
11. void poll_initwait(struct poll_wqueues *pwq)
12. {
13. init_poll_funcptr(&pwq->pt, __pollwait); // pt->qproc = qproc;
14. pwq->error = 0;
15. pwq->table = NULL;
16. pwq->inline_index = 0;
17. }
18. */
20. fdcount = do_poll(nfds, head, &table, timeout);
21. ...
22. poll_freewait(&table);
23. return err;
24. }

1. typedef struct poll_table_struct {
2. poll_queue_proc qproc;
3. } poll_table;
5. typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);

  do_sys_poll 干了一件重要的事：table->pt->qproc =  __pollwait ,驱动程序中会调用这个函数

1. static int do_poll(unsigned int nfds, struct poll_list *list,
2. struct poll_wqueues *wait, s64 *timeout)
3. {
4. int count = 0;
5. poll_table* pt = &wait->pt;
7. for (;;) {
8. struct poll_list *walk;
9. long __timeout;
10. // 设置当前进程为可中断的
11. set_current_state(TASK_INTERRUPTIBLE);
12. for (walk = list; walk != NULL; walk = walk->next) {
13. struct pollfd * pfd, * pfd_end;
15. pfd = walk->entries;
16. pfd_end = pfd + walk->len;
17. for (; pfd != pfd_end; pfd++) {
18. // 调用驱动程序中的 poll，返回值>0 count++ ,直接返回,如果是0,休眠
19. // mask = file->f_op->poll(file, pwait);
20. // mask &= pollfd->events | POLLERR | POLLHUP;
21. // pollfd->revents = mask;
22. if (do_pollfd(pfd, pt)) {
23. count++;
24. pt = NULL;
25. }
26. }
27. }
28. // count非0表示 do_pollfd 至少有一个成功
29. // 跳出条件：有成功的，时间到，有信号需要处理
30. if (count || !*timeout || signal_pending(current))
31. break;
32. count = wait->error;
33. if (count)
34. break;
36. ...
37. // 进程的调度，休眠，要么时间到达，再去查询一次看是否满足，要么驱动程序中条件满足，驱动唤醒。
38. __timeout = schedule_timeout(__timeout);
39. if (*timeout >= 0)
40. *timeout += __timeout;
41. }
42. // 这里设置进程状态是因为，如果第一次查询就成功了，前面讲进程状态改变了 需要更正回运行状态。
43. __set_current_state(TASK_RUNNING);
44. return count;
45. }

  do_poll 函数中会调用驱动程序中的 poll 函数

驱动程序：

1. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
2. static unsigned poll_drv_poll(struct file *file, poll_table *wait)
3. {
4. unsigned int mask = 0;
5. poll_wait(file, &button_waitq, wait); // 将当前进程挂载到休眠队列，但是不会立即休眠
7. if (ev_press)
8. mask |= POLLIN | POLLRDNORM; //返回给sys_poll 判断条件是否满足 跳出 or 休眠
10. return mask;
11. }

1. 返回值，合法的事件如下：
2. POLLIN
3. 有数据可读。
4. POLLRDNORM
5. 有普通数据可读。
6. POLLRDBAND
7. 有优先数据可读。
8. POLLPRI
9. 有紧迫数据可读。
10. POLLOUT
11. 写数据不会导致阻塞。
12. POLLWRNORM
13. 写普通数据不会导致阻塞。
14. POLLWRBAND
15. 写优先数据不会导致阻塞。
16. POLLMSG
17. SIGPOLL 消息可用。

1. static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
2. {
3. if (p && wait_address)
4. p->qproc(filp, wait_address, p); // __pollwait(filp, wait_address, p)
5. }
6. static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
7. poll_table *p)
8. {
9. struct poll_table_entry *entry = poll_get_entry(p);
10. if (!entry)
11. return;
12. get_file(filp);
13. entry->filp = filp;
14. entry->wait_address = wait_address;
15. init_waitqueue_entry(&entry->wait, current);
16. add_wait_queue(wait_address, &entry->wait);
17. }

 驱动程序中一开始定义了一个等待队列头，在__pollwait中初始化了等待队列头，并将其加入等待队列。接着就会有下面几种情况：

  1、do_poll 函数第一次查询就OK，直接跳出 for 循环，将进程状态改回running状态，继续执行

  2、do_poll 函数查询失败，进程调度，当前进程进入休眠状态，这个状态下又会产生以下几种情况

    1、在休眠过程中驱动程序条件得到满足，驱动程序唤醒休眠进程，万事大吉

    2、在休眠时间过程中一直不满足，休眠给定时间到达，自动唤醒，再次查询，查询ok 唤醒，查询失败继续休眠给定时间，一直循环下去。

在驱动程序中条件满足，唤醒进程

1. static irqreturn_t buttons_irq(int irq, void *dev_id)
2. {
3. struct keys_desc * keys_desc = (struct keys_desc *)dev_id;
4. unsigned int keyval;
6. keyval = s3c2410_gpio_getpin(keys_desc->key_addr);
8. if (keyval)
9. {
10. /* 松开 */
11. key_val = keys_desc->key_value_up;
12. }
13. else
14. {
15. /* 按下 */
16. key_val = keys_desc->key_value_down;
17. }
19. ev_press = 1; /* 表示中断发生了 */
20. wake_up_interruptible(&button_waitq); /* 唤醒休眠的进程 */
23. return IRQ_RETVAL(IRQ_HANDLED);
24. }