Linux 内核等待队列

Linux内核中的等待队列是一种延时机制，其用于当前进程需要等待某些资源而进入一种sleep状态，当等待条件为真时， 进程被唤醒，继续执行。显然，这里涉及三个方面，即，一是等待时当前进程处理， 二是进程等待时所关注的资源处理，三时进程何时被唤醒继续执行。 所以，我们这里需要几个数据结构，主要描述如下： typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);   struct __wait_queue {  unsigned int  flags;  void   *private;  wait_queue_func_t func;  struct list_head task_list; }; typedef struct __wait_queue wait_queue_t; 此结构用于把当前进程进入睡眠时保持状态信息，   struct __wait_queue_head {  spinlock_t  lock;  struct list_head task_list; }; typedef struct __wait_queue_head wait_queue_head_t; 此结构用于定义一个等待队列，task_list是在等待队列上的任务，即等待任务的状态信息，即链表上是 struct __wait_queue 对象。   对于等待队列中的数据结构，有时也可以使用下面这个：

struct wait_bit_key {  void   *flags;  int   bit_nr; #define WAIT_ATOMIC_T_BIT_NR -1  unsigned long  timeout; };

struct wait_bit_queue {  struct wait_bit_key key;  wait_queue_t  wait; };

 

对于等待队列头来说，可以通过下面方式初始化：

#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)

 

而对于等待队列中的成员来说，其因为使用了struct __wait_queue结构，所以，

一般对等待队列中成员定义如下：

#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)

或者其他一些形式定义，如下：

#define __WAIT_BIT_KEY_INITIALIZER(word, bit)    \  { .flags = word, .bit_nr = bit, }

#define __WAIT_ATOMIC_T_KEY_INITIALIZER(p)    \  { .flags = p, .bit_nr = WAIT_ATOMIC_T_BIT_NR, }

 

#define init_waitqueue_head(q)    \  do {      \   static struct lock_class_key __key; \        \   __init_waitqueue_head((q), #q, &__key); \  } while (0)

简单函数形式如下：

static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p) {  q->flags = 0;  q->private = p;  q->func  = default_wake_function;带唤醒函数 }

static inline void init_waitqueue_func_entry(wait_queue_t *q, wait_queue_func_t func) {  q->flags = 0;  q->private = NULL;  q->func  = func;设置唤醒函数，但任务未设置 }

简单的加入队列过程：

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

 

对外简单封装函数有：

一.

void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait) {  unsigned long flags;

 wait->flags &= ~WQ_FLAG_EXCLUSIVE;  spin_lock_irqsave(&q->lock, flags);  __add_wait_queue(q, wait);  spin_unlock_irqrestore(&q->lock, flags); } EXPORT_SYMBOL(add_wait_queue);

二.

void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state) {  unsigned long flags;

 wait->flags &= ~WQ_FLAG_EXCLUSIVE;  spin_lock_irqsave(&q->lock, flags);  if (list_empty(&wait->task_list))   __add_wait_queue(q, wait);  set_current_state(state);  spin_unlock_irqrestore(&q->lock, flags); } EXPORT_SYMBOL(prepare_to_wait);

 

三. long prepare_to_wait_event(wait_queue_head_t *q, wait_queue_t *wait, int state) {  unsigned long flags;  long ret = 0;

 spin_lock_irqsave(&q->lock, flags);  if (unlikely(signal_pending_state(state, current))) {   /*    * Exclusive waiter must not fail if it was selected by wakeup,    * it should "consume" the condition we were waiting for.    *    * The caller will recheck the condition and return success if    * we were already woken up, we can not miss the event because    * wakeup locks/unlocks the same q->lock.    *    * But we need to ensure that set-condition + wakeup after that    * can't see us, it should wake up another exclusive waiter if    * we fail.    */   list_del_init(&wait->task_list);   ret = -ERESTARTSYS;  } else {   if (list_empty(&wait->task_list)) {    if (wait->flags & WQ_FLAG_EXCLUSIVE)     __add_wait_queue_tail(q, wait);    else     __add_wait_queue(q, wait);   }   set_current_state(state);  }  spin_unlock_irqrestore(&q->lock, flags);

 return ret; } 四.

static inline void __add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait) {  wait->flags |= WQ_FLAG_EXCLUSIVE;  __add_wait_queue(q, wait); }

 

等待队列的简单使用：

一， 定义等待队列头对象

如static DECLARE_WAIT_QUEUE_HEAD(nl_table_wait);

二. 等待资源时，把当前进程加入等待队列，队列成员

void netlink_table_grab(void) __acquires(nl_table_lock) {  might_sleep();

 write_lock_irq(&nl_table_lock);

 if (atomic_read(&nl_table_users)) {   DECLARE_WAITQUEUE(wait, current);自定义队列成员，并简单初始化

  add_wait_queue_exclusive(&nl_table_wait, &wait);只是进入队列，但进程还可以运行   for (;;) {    set_current_state(TASK_UNINTERRUPTIBLE);//改变进程状态    if (atomic_read(&nl_table_users) == 0)必须满足这个条件，否则不会被唤醒     break;//唤醒后，跳出    write_unlock_irq(&nl_table_lock);    schedule();这一步放弃CPU，真正调度出去，回来也是从这里开始    write_lock_irq(&nl_table_lock);//再次回来时，获取锁   }

  __set_current_state(TASK_RUNNING);//设置可运行   remove_wait_queue(&nl_table_wait, &wait);//把之前设置释放。  } }

三. 唤醒路径

void netlink_table_ungrab(void) __releases(nl_table_lock) {  write_unlock_irq(&nl_table_lock);  wake_up(&nl_table_wait); }