等待队列，poll

水深无声 2024-04-20 08:17 8阅读 0赞

原文网址：[等待队列，poll\_IT利刃出鞘的博客-CSDN博客][poll_IT_-CSDN]

# 等待队列 #

见《Linux设备驱动开发详解》=> 8.1.1 等待队列

# poll\_wait #

**poll\_wait()退出循环的条件**  
(1)count非0，超时、有信号等待处理  
(2)发生错误  
(3)我们的驱动程序里注册的poll函数返回值非0

应用程序执行poll调用后，如果(1)(2)(3)的条件不满足，进程就会进入休眠。那么，谁唤醒呢？除了休眠到指定时间被系统唤醒外，还可以被驱动程序唤醒，这就是驱动的poll里要调用poll\_wait的原因，后面分析。  
poll\_wait()作用  
把当前进程（app）挂入我们驱动程序里定义的一个队列里（为了让驱动程序能找到要唤醒的进程）。  
一般poll\_wait()函数在驱动的.poll中调用。如果应用程序没用到poll，可以不调用poll\_wait。例：驱动的.read函数里调用wait\_event\_interruptible，中断里wake\_up。  
  
poll （app调用） => sys\_poll => do\_sys\_poll => poll\_initwait(&table) => do\_poll  
=> do\_pollfd => .poll //驱动中自己写的poll函数； schedule\_timeout //进入休眠。  
如果我们的驱动程序发现情况就绪，可以把这个队列上挂着的进程唤醒。

**wait\_event\_interruptible()**  
成功地唤醒一个被wait\_event\_interruptible()的进程，需要满足：  
(1)condition为真的前提下 (2) 调用wake\_up()。  
condition一般声明为static volatile int类型

**wait\_event\_interruptible的返回值**   
根据 wait\_event\_interruptible 的宏定义知：  
1) 条件condition为真时调用这个函数将直接返回0，而当前进程不会  
被 wait\_event\_interruptible和从runqueue队列中删除。  
2) 如果要被wait\_event\_interruptible的当前进程有nonblocked pending  
signals, 那么会直接返回-ERESTARTSYS(i.e. -512)，当前进程不会  
被wait\_event\_interruptible 和从runqueue队列中删除。  
3) 其他情况下，当前进程会被正常的wait\_event\_interruptible，并从  
runqueue队列中删除，进入TASK\_INTERRUPTIBLE状态退出运行调度，  
直到再次被唤醒加入runqueue队列中后而参与调度，将正常返回0。

**wait\_event\_interruptible**

\#define wait\_event\_interruptible(wq, condition) \\  
(\{ \\  
int \_\_ret = 0; \\  
if (!(condition)) \\  
\_\_wait\_event\_interruptible(wq, condition, \_\_ret); \\  
\_\_ret; \\  
\})

注: C语言中\{a,b, ..., x\}的的值等于最后一项，即x，因此上述  
宏的值是 \_\_ret。  
\#define \_\_wait\_event\_interruptible(wq, condition, ret) \\  
do \{ \\  
DEFINE\_WAIT(\_\_wait); \\  
for (;;) \{ \\  
prepare\_to\_wait(&wq, &\_\_wait, TASK\_INTERRUPTIBLE); \\  
if (condition) \\  
break; \\  
if (!signal\_pending(current)) \{ \\  
schedule(); \\  
continue; \\  
\} \\  
ret = -ERESTARTSYS; \\  
break; \\  
\} \\  
finish\_wait(&wq, &\_\_wait); \\  
\} while (0)

**总结一下poll机制**  
1. poll（应用程序） > sys\_poll > do\_sys\_poll > poll\_initwait，poll\_initwait函数注册一下回调函数  
\_\_pollwait，它就是我们的驱动程序执行poll\_wait时，真正被调用的函数。  
2. 接下来执行file->f\_op->poll，即我们驱动程序里自己实现的poll函数  
它会调用poll\_wait把当前进程（app）挂入我们的驱动自己定义的队列；  
它还判断一下设备是否就绪。（即驱动的poll的返回值是不是0，若 不是0，则设备就绪）  
3. 如果设备未就绪，do\_sys\_poll里会让进程休眠应用中指定的时间  
4. 进程被唤醒的条件有2：一是上面说的“一定时间”到了，二是被驱动程序唤醒。驱动程序发现条件就绪时，  
就把“某个队列”上挂着的进程唤醒，这个队列，就是前面通过poll\_wait把本进程挂过去的队列。  
5. 如果驱动程序没有去唤醒进程，那么chedule\_timeout(\_\_timeou)超时后，会重复2、3动作，  
直到应用程序的 poll调用传入的时间到达。

# 代码分析 #

## poll系统调用 ##

//驱动中定义  
static DECLARE\_WAIT\_QUEUE\_HEAD(read\_wq);  
  
(fs/select.c)  
SYSCALL\_DEFINE3(poll, struct pollfd \_\_user \*, ufds, unsigned int, nfds, int, timeout\_msecs)  
//设置超时时间  
poll\_select\_set\_timeout  
do\_sys\_poll(ufds, nfds, to);  
struct poll\_wqueues table;  
poll\_initwait(&table);  
init\_poll\_funcptr(&pwq->pt, \_\_pollwait);  
//此函数会在驱动中调用poll\_wait时调用  
pwq->p->\_qproc = \_\_pollwait;  
do\_poll(nfds, head, &table, end\_time);  
for(;;)\{  
//系统调用poll时，会调用一次驱动中定义的poll函数，若返回值不是0，则count++，会退出循环  
if (do\_pollfd(pfd, table->pt)) \{ table->pt的类型是poll\_table  
\{fd = pollfd->fd;  
//调用驱动中的poll函数  
mask = file->f\_op->poll(file, table->pt);  
//将do\_sys\_poll中定义的table插入到驱动定义的队列中  
poll\_wait(file, &read\_wq, wait)  
\_\_pollwait(file, &read\_wq, wait)  
return mask;\}  
count++;  
pt->\_qproc = NULL;  
\}  
if (count || timed\_out)  
break;  
if (!poll\_schedule\_timeout(wait, TASK\_INTERRUPTIBLE, to, slack))  
\{set\_current\_state(TASK\_INTERRUPTIBLE)  
if (!pwq->triggered)  
rc = schedule\_hrtimeout\_range(expires, slack, HRTIMER\_MODE\_ABS);  
//sleep until timeout  
schedule\_hrtimeout\_range\_clock(expires, delta, mode,  
CLOCK\_MONOTONIC);  
\_\_set\_current\_state(TASK\_RUNNING);\}  
timed\_out = 1;  
\}

## wait\_event\_interruptible(wq, condition) ##

wait\_event\_interruptible(read\_queue\_head, ev\_write); //include/linux/wait.h  
int \_\_ret = 0;  
if (!(ev\_write))  
\_\_wait\_event\_interruptible(wq, condition, \_\_ret); //include/linux/wait.h  
DEFINE\_WAIT(\_\_wait); //include/linux/wait.h  
DEFINE\_WAIT\_FUNC(\_\_wait, autoremove\_wake\_function)  
//autoremove\_wake\_function:唤醒等待队列wait中的thread，成功唤醒则清空等待队列wait  
wait\_queue\_t \_\_wait = \{  
.private = current,  
.func = function,  
\}  
for (;;) \{  
//把wait.h中定义的\_\_wait插入到驱动定义的等待队列read\_wq中  
prepare\_to\_wait(&wq, &\_\_wait, TASK\_INTERRUPTIBLE);  
if (list\_empty(&\_\_wait->task\_list))  
\_\_add\_wait\_queue(&wq, \_\_wait);  
//如果事件发生了，则跳出循环  
if (condition)  
break;  
//如果不是信号唤醒的，则进入  
if (!signal\_pending(current)) \{  
ret = schedule\_timeout(ret);  
expire = timeout + jiffies;  
\_\_mod\_timer(&timer, expire, false, TIMER\_NOT\_PINNED);  
schedule();  
timeout = expire - jiffies;  
if (!ret)  
break;  
continue;  
\}  
ret = -ERESTARTSYS;  
break;  
\}  
finish\_wait(&wq, &\_\_wait);

源码分析：  
wait\_event\_interruptible()分析：  
读一下wait\_event\_interruptible()的源码，不难发现这个函数先将 当前进程的状态设置成TASK\_INTERRUPTIBLE，如果condition为假，调用schedule()， 而schedule()会将位于TASK\_INTERRUPTIBLE状态的当前进程从runqueue 队列中删除。从runqueue队列中删除的结果是，当前这个进程将不再参 与调度，除非通过其他函数将这个进程重新放入这个runqueue队列中， 这就是wake\_up()的作用了。  
由于这一段代码位于一个由condition控制的for(;;)循环中，所以当由 shedule()返回时(当然是被wake\_up之后，通过其他进程的schedule()而再次调度本进程)，如果条件condition不满足，本进程将自动再次被设 置为TASK\_INTERRUPTIBLE状态，接下来执行schedule()的结果是再次被 从runqueue队列中删除。这时候就需要再次通过wake\_up重新添加到 runqueue队列中。  
如此反复，直到condition为真的时候被wake\_up.

## wake\_up\_interruptible(&read\_wq); ##

include/linux/wait.h

wake\_up\_interruptible(&read\_queue\_head); //include/linux/wait.h  
\_\_wake\_up(&read\_queue\_head, TASK\_INTERRUPTIBLE, 1, NULL) //sched/wait.c  
//kernel/sched/core.c  
\_\_wake\_up\_common(&read\_queue\_head, TASK\_INTERRUPTIBLE, nr\_exclusive, 0, NULL); //sched/wait.c  
list\_for\_each\_entry\_safe(curr, next, &read\_queue\_head->task\_list, task\_list) \{  
if (curr->func(curr, TASK\_INTERRUPTIBLE, wake\_flags, key) &&  
(flags & WQ\_FLAG\_EXCLUSIVE) && !--nr\_exclusive)  
//此函数在wait\_event\_interruptible中指定的  
  
//kernel/wait.c中实现  
autoremove\_wake\_function(curr, TASK\_INTERRUPTIBLE, wake\_flags, NULL)  
//kernel/wait.c  
ret = default\_wake\_function(wait, TASK\_INTERRUPTIBLE, sync, NULL)  
//kernel/sched/core.c  
try\_to\_wake\_up(curr->private, TASK\_INTERRUPTIBLE, wake\_flags);  
//curr->private = current  
//wait\_event\_interruptible中指定的  
//对于单cpu来说，此处返回0  
cpu = task\_cpu(curr->private);  
ttwu\_queue(curr->private, cpu);  
struct rq \*rq = cpu\_rq(cpu);  
ttwu\_do\_activate(rq, curr->private, 0);  
if (ret)  
list\_del\_init(&wait->task\_list);  
break;  
\}

[poll_IT_-CSDN]: https://knife.blog.csdn.net/article/details/101054835