wait queue机制

3950阅读　0评论2014-06-05　wangbaolin719
分类：LINUX


  1. //Based on linux v3.14 source code
  2. 一、概述
  3. 等待队列在内核中有很多用途，尤其在中断处理、进程同步及定时。等待队列实现事件上的条件等待；希望等待特定事件的进程把自己放在合适的等待队列，并放弃控制权。

  5. 二、相关结构体
  6. 1. 等待队列由双向链表实现，其元素包括指向进程描述符的指针。每个等待队列都有一个等待队列头，即wait_queue_head_t结构。
  7. struct __wait_queue_head {
  8.     spinlock_t lock;
  9.     struct list_head task_list; //等待进程链表
  10. };
  11. typedef struct __wait_queue_head wait_queue_head_t;

  13. 2. 等待队列链表中的元素，即wait_queue_t结构
  14. 等待队列链表中的每个元素代表一个睡眠进程，进程描述符地址存入private字段中。
  15. typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);

  17. struct __wait_queue {
  18.     unsigned int flags;    //标志
  19. #define WQ_FLAG_EXCLUSIVE 0x01
  20.     void *private;    //进程描述符
  21.     wait_queue_func_t func;    //唤醒函数，缺省为default_wake_function
  22.     struct list_head task_list;    //链接到等待队列链表中
  23. };
  24. typedef struct __wait_queue wait_queue_t;

  26. 三、等待队列操作
  27. 1. 定义等待队列头
  28. (1)静态定义
  29. #define DECLARE_WAIT_QUEUE_HEAD(name) wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)

  31. #define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \
  32.     .lock = __SPIN_LOCK_UNLOCKED(name.lock), \
  33.     .task_list = { &(name).task_list, &(name).task_list } }
  34.  
  35. (2)动态初始化
  36. #define init_waitqueue_head(q) \
  37.     do { \
  38.         static struct lock_class_key __key; \
  39.      \
  40.         __init_waitqueue_head((q), #q, &__key); \
  41.     } while (0)

  43. void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *key)
  44. {
  45.     spin_lock_init(&q->lock);
  46.     lockdep_set_class_and_name(&q->lock, key, name);
  47.     INIT_LIST_HEAD(&q->task_list);
  48. }

  50. 2. 定义等待队列元素wait_queue_t
  51. (1)静态定义，定义一个名为name的等待队列项，并将当前进程的进程描述符赋值给private，并设置缺省的唤醒函数default_wake_function。
  52. #define DECLARE_WAITQUEUE(name, tsk) \
  53.             wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)

  55. #define __WAITQUEUE_INITIALIZER(name, tsk) { \
  56.     .private = tsk, \
  57.     .func = default_wake_function, \
  58.     .task_list = { NULL, NULL } }
  59.  
  60. 3. 将元素插入等待队列
  61. void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
  62. {
  63.     unsigned long flags;
  64.     
  65.     wait->flags &= ~WQ_FLAG_EXCLUSIVE;
  66.     //上锁，关中断
  67.     spin_lock_irqsave(&q->lock, flags);
  68.     //将等待队列项wait挂入等待队列
  69.     __add_wait_queue(q, wait);
  70.     spin_unlock_irqrestore(&q->lock, flags);
  71. }

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

  78. add_wait_queue()是把一个非互斥进程插入等待队列的第一个位置。
  79. add_wait_queue_exclusive()是把一个互斥进程插入等待队列的最后一个位置。

  81. 4. 将元素从等待队列中删除
  82. void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
  83. {
  84.     unsigned long flags;
  85.          
  86.     spin_lock_irqsave(&q->lock, flags);
  87.     __remove_wait_queue(q, wait);
  88.     spin_unlock_irqrestore(&q->lock, flags);
  89. }

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

  96. 5. 实例 sleep_on_common()函数
  97. static long __sched sleep_on_common(wait_queue_head_t *q, int state, long timeout)
  98. {
  99.     unsigned long flags;
  100.     wait_queue_t wait;

  102.     //初始化进程所在的等待队列项wait
  103.     init_waitqueue_entry(&wait, current);

  105.     //设置进程状态
  106.     __set_current_state(state);

  108.     spin_lock_irqsave(&q->lock, flags);
  109.     //将当前进程所在的等待队列项wait挂入等待队列中
  110.     __add_wait_queue(q, &wait);
  111.     spin_unlock(&q->lock);
  112.     //进行进程调度
  113.     timeout = schedule_timeout(timeout);
  114.     
  115.     //进程被唤醒
  116.     spin_lock_irq(&q->lock);
  117.     //将该进程进程所在的等待队列项从等待队列中删除
  118.     __remove_wait_queue(q, &wait);
  119.     spin_unlock_irqrestore(&q->lock, flags);

  121.     return timeout;
  122. }

  124. 6. 根据等待队列的实现，linux提供了多种休眠、唤醒方式。
  125. (1) 基于sleep_on_common的休眠。当要必须测试条件，当条件不满足时接着睡眠，就不能使用sleep_on类的睡眠。应当使用手工睡眠，或者wait_event类的函数
  126. //sleep_on将进程设置为TASK_UNINTERRUPTIBLE状态，然后插入等待队列
  127. void __sched sleep_on(wait_queue_head_t *q)
  128. {
  129.     sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
  130. }

  132. //interruptible_sleep_on将进程设置为TASK_INTERRUPTIBLE状态，然后插入等待队列.因此接受一个信号就能唤醒队列
  133. void __sched interruptible_sleep_on(wait_queue_head_t *q)
  134. {
  135.     sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
  136. }

  138. //sleep_on_timeout与sleep_on类似，但是设置了时间间隔，过了间隔会唤醒进程。时间未到会返回剩余时间
  139. long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
  140. {
  141.     return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);
  142. }

  144. //interruptible_sleep_on_timeout与interruptible_sleep_on类似，只是设置了时间间隔
  145. long __sched interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
  146. {
  147.     return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);
  148. }

  150. (2)手工休眠
  151. 1)建立并初始化一个等待队列项
  152. DEFINE_WAIT(my_wait) <==> wait_queue_t my_wait; init_wait(&my_wait);
  153. 2)将等待队列项添加到等待队列头中，并设置进程的状态
  154. void prepare_to_wait(wait_queue_head_t *queue, wait_queue_t *wait, int state)
  155. void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state)
  156. 3)调用schedule()，告诉内核调度别的进程运行
  157. 4)schedule返回，完成后续清理工作finish_wait()

  159. void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
  160. {
  161.     unsigned long flags;
  162.     
  163.     wait->flags &= ~WQ_FLAG_EXCLUSIVE;
  164.     spin_lock_irqsave(&q->lock, flags);
  165.     if (list_empty(&wait->task_list))
  166.         __add_wait_queue(q, wait);
  167.     set_current_state(state);
  168.     spin_unlock_irqrestore(&q->lock, flags);
  169. }

  171. void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
  172. {
  173.     unsigned long flags;
  174.         
  175.     __set_current_state(TASK_RUNNING);

  177.     if (!list_empty_careful(&wait->task_list)) {
  178.         spin_lock_irqsave(&q->lock, flags);
  179.         list_del_init(&wait->task_list);
  180.         spin_unlock_irqrestore(&q->lock, flags);
  181.     }
  182. }

  184. (3) wait_event类睡眠，有条件的睡眠，condition是任意一个布尔表达式，在休眠前后多次对condition求值，为真则唤醒
  185. //进程将被置于非中断休眠，只有condition为真进程才退出睡眠
  186. wait_event(queue, condition)
  187. //进程可被信号中断休眠,或者condition为真进程退出睡眠
  188. wait_event_interruptible(queue, condition)
  189. //等待限定时间timeout，或者condition为真退出睡眠
  190. wait_event_timeout(queue, condition, timeout)
  191. //进程可被信号中断休眠,或者等待限定时间timeout，或者condition为真进程退出睡眠
  192. wait_event_interruptible_timeout(queue, condition, timeout)

  194. (4)唤醒进程的基本函数是wake_up
  195. #define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
  196. #define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
  197. #define wake_up_all(x) __wake_up(x, TASK_NORMAL, 0, NULL)
  198. #define wake_up_locked(x) __wake_up_locked((x), TASK_NORMAL, 1)
  199. #define wake_up_all_locked(x) __wake_up_locked((x), TASK_NORMAL, 0)

  201. #define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
  202. #define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
  203. #define wake_up_interruptible_all(x) __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
  204. #define wake_up_interruptible_sync(x) __wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
  205. 注意：
  206. <1>所有宏都考虑到处于TASK_INTERRUPTIBLE状态的睡眠进程，如果宏中带有interruptible的，则会也唤醒处于TASK_UNINTERRUPTIBLE状态的睡眠进程.
  207. <2>所有宏都唤醒具有请求状态的非互斥进程。
  208. <3>宏中含有nr的宏，唤醒给定数目的具有请求状态的互斥进程(非互斥进程都被唤醒)。
  209. <4>宏中含有all的宏，唤醒所有具有请求状态的互斥进程(非互斥进程都被唤醒)。
  210. <5>宏中含有sync的宏，检查被唤醒的进程优先级是否高于系统中正在运行进程的优先级，并在必要时调用schedule().
  211. void __wake_up(wait_queue_head_t *q, unsigned int mode,int nr_exclusive, void *key)
  212. {
  213.     unsigned long flags;
  214.     
  215.     spin_lock_irqsave(&q->lock, flags);
  216.     __wake_up_common(q, mode, nr_exclusive, 0, key);
  217.     spin_unlock_irqrestore(&q->lock, flags);
  218. }

  220. static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,int nr_exclusive, int wake_flags, void *key)
  221. {
  222.     wait_queue_t *curr, *next;
  223.          
  224.     list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
  225.         unsigned flags = curr->flags;
  226.         //调用唤醒函数，缺省为default_wake_function，调用try_to_wake_up将进程更改为可运行状态并置待调度标志
  227.         if (curr->func(curr, mode, wake_flags, key) && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
  228.             break;
  229.     }
  230. }

  232. try_to_wake_up涉及到进程调度，不在这里深究。


上一篇：wake lock机制
下一篇：Linux双核SMP系统启动流程（Zynq-ARM-CortexA9）