Linux等待队列与唤醒

1.数据结构

1.1等待队列头

 struct __wait_queue_head {
     spinlock_t lock;
     struct list_head task_list;
 };
 typedef struct __wait_queue_head wait_queue_head_t;

初始化等待队列头

 #define __WAIT_QUEUE_HEAD_INITIALIZER(name) {                \
     .lock        = __SPIN_LOCK_UNLOCKED(name.lock),        \
     .task_list    = { &(name).task_list, &(name).task_list } }

 #define DECLARE_WAIT_QUEUE_HEAD(name) \
     wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)

1.2等待队列

 typedef struct __wait_queue wait_queue_t;
 typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int sync, void *key);
 int default_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);

 struct __wait_queue {
     unsigned int flags;
 #define WQ_FLAG_EXCLUSIVE    0x01
     void *private;
     wait_queue_func_t func;
     struct list_head task_list;
 };

初始化等待队列

 #define __WAITQUEUE_INITIALIZER(name, tsk) {                \
     .private    = tsk,                        \
     .func        = default_wake_function,            \
     .task_list    = { NULL, NULL } }

 #define DECLARE_WAITQUEUE(name, tsk)                    \
     wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)

等待队列的task_list加入等待队列头的task_list链表。一般将wait_queue_func_t赋值为下面的默认处理函数：

 int default_wake_function(wait_queue_t *curr, unsigned mode, int sync,
               void *key)
 {
     return try_to_wake_up(curr->private, mode, sync);
 }

1.3添加/删除等待队列

 static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
 {
     list_add(&new->task_list, &head->task_list);
 }

 static inline void __remove_wait_queue(wait_queue_head_t *head,
                             wait_queue_t *old)
 {
     list_del(&old->task_list);
 }

2等待事件

调用以下四个宏等待事件，等待以第一个参数作为等待队列头的等待队列被唤醒，第二个参数condition必须被满足，否则继续阻塞。

wait_event()和wait_event_interruptible()的区别是后者可以被信号打断，而前者不能。

加上timeout后的宏意味着阻塞等待的超时时间，以jiffy为单位，在timeout到达时，不论condition是否满足，均返回。

 #define wait_event(wq, condition)
 #define wait_event_timeout(wq, condition, timeout)
 #define wait_event_interruptible(wq, condition)
 #define wait_event_interruptible_timeout(wq, condition, timeout)

下面以wait_event()为例分析执行过程

 #define wait_event(wq, condition)                     \
 do {                                    \
     if (condition)                             \
         break;                            \
     __wait_event(wq, condition);                    \
 } while ()
 #define __wait_event(wq, condition)                     \
 do {                                    \
     DEFINE_WAIT(__wait);                        \
                                     \
     for (;;) {                            \
         prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \
         if (condition)                        \
             break;                        \
         schedule();                        \
     }                                \
     finish_wait(&wq, &__wait);                    \
 } while ()

wait_event(wq, condition)

 wait_event(wq, condition)
     -->__wait_event(wq, condition);
         -->DEFINE_WAIT(__wait);
         -->prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);
             -->__add_wait_queue(q, wait);//将等待队列添加到等待队列头
             -->set_current_state(state);
         -->schedule();    //切换到其它进程
         -->被唤醒切换回来
         -->finish_wait(&wq, &__wait);
             -->__set_current_state(TASK_RUNNING);
             -->list_del_init(&wait->task_list);//将唤醒的等待队列删除

注意上面的DEFINE_WAIT(__wait)宏展开如下

 #define DEFINE_WAIT(name)                        \
     wait_queue_t name = {                        \
         .private    = current,                \
         .func        = autoremove_wake_function,        \
         .task_list    = LIST_HEAD_INIT((name).task_list),    \
     }

 int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
 {
     int ret = default_wake_function(wait, mode, sync, key);

     if (ret)
         list_del_init(&wait->task_list);
     return ret;
 }

autoremove_wake_function

3.唤醒队列

wake_up()可唤醒处于TASK_UNINTERRUPTIBLE 和 TASK_INTERRUPTIBLE的进程，而wake_up_interruptible只能唤醒处于TASK_INTERRUPTIBLE的进程。

#define wake_up(x)            __wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1, NULL)
#define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)

下面以wake_up()为例分析，

 wake_up(x)
     -->__wake_up(x, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, , NULL)
         -->__wake_up_common(q, mode, nr_exclusive, , key);//唤醒等待队列头链表中的所有等待队列

关键在于__wake_up_common()函数

 /*
  * The core wakeup function.  Non-exclusive wakeups (nr_exclusive == 0) just
  * wake everything up.  If it's an exclusive wakeup (nr_exclusive == small +ve
  * number) then we wake all the non-exclusive tasks and one exclusive task.
  *
  * There are circumstances in which we can try to wake a task which has already
  * started to run but is not in state TASK_RUNNING.  try_to_wake_up() returns
  * zero in this (rare) case, and we handle it by continuing to scan the queue.
  */
 static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
                  int nr_exclusive, int sync, void *key)
 {
     struct list_head *tmp, *next;

     list_for_each_safe(tmp, next, &q->task_list) {
         wait_queue_t *curr = list_entry(tmp, wait_queue_t, task_list);
         unsigned flags = curr->flags;

         if (curr->func(curr, mode, sync, key) &&
                 (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
             break;
     }
 }

其中的curr->func即指向autoremove_wake_function()函数。

唤醒进程是在try_to_wake_up(curr->private, mode, sync)函数中具体执行的，唤醒较复杂，后面有时间在分析。

可以简单理解为执行完该函数，2中wait_event()挂起的等待队列就被唤醒回来继续执行了。