在Linux内核中等待队列有很多用途,可用于中断处理、进程同步及定时。我们在这里只说,进程经常必须等待某些事件的发生。等待队列实现了在事件上的条件等待: 希望等待特定事件的进程把自己放进合适的等待队列,并放弃控制全。因此,等待队列表示一组睡眠的进程,当某一条件为真时,由内核唤醒它们。
等待队列由循环链表实现,其元素包括指向进程描述符的指针。每个等待队列都有一个等待队列头(wait queue head),等待队列头是一个类型为wait_queue_head_t的数据结构
(1)定义等待队列头(相关内容可以在linux/include/wait.h中找到)
等待队列头结构体的定义:
struct __wait_queue_head {
spinlock_t lock; //自旋锁变量,用于在对等待队列头
struct list_head task_list; // 指向等待队列的list_head
};
typedef struct __wait_queue_head wait_queue_head_t;
使用等待队列时首先需要定义一个wait_queue_head,这可以通过DECLARE_WAIT_QUEUE_HEAD宏来完成,这是静态定义的方法。该宏会定义一个wait_queue_head,并且初始化结构中的锁以及等待队列。当然,动态初始化的方法也很简单,初始化一下锁及队列就可以了。
#define DECLARE_WAIT_QUEUE_HEAD(name) \
wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
#define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \
.lock = __SPIN_LOCK_UNLOCKED(name.lock), \
.task_list = { &(name).task_list, &(name).task_list } }
将lock赋为unlocked, 将等待队列头指向的等待队列链表指向name,从而将等待队列头和等待队列连起来;
一般在写程序的时候将DECLARE_WAIT_QUEUE_HEAD分成两步来完成:
声明:
wait_queue_head_t wait_que;
初始化:
init_waitqueue_head( &wait_que);
Linux中等待队列的实现思想如下图所示,当一个任务需要在某个wait_queue_head上睡眠时,将自己的进程控制块信息封装到wait_queue中,然后挂载到wait_queue的链表中,执行调度睡眠。当某些事件发生后,另一个任务(进程)会唤醒wait_queue_head上的某个或者所有任务,唤醒工作也就是将等待队列中的任务设置为可调度的状态,并且从队列中删除。
(2)等待队列中存放的是在执行设备操作时不能获得资源而挂起的进程
定义等待对列:
struct __wait_queue {
unsigned int flags; //prepare_to_wait()里有对flags的操作,查看以得出其含义
#define WQ_FLAG_EXCLUSIVE 0x01 //一个常数,在prepare_to_wait()用于修改flags的值
void * private //通常指向当前任务控制块
wait_queue_func_t func; //唤醒阻塞任务的函数 ,决定了唤醒的方式
struct list_head task_list; // 阻塞任务链表
};
typedef struct __wait_queue wait_queue_t;
//声明一个等待队列并初始化为name
#define DECLARE_WAITQUEUE(name, tsk) \
wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
#define __WAITQUEUE_INITIALIZER(name, tsk) { \
.private = tsk, \
.func = default_wake_function, \
.task_list = { NULL, NULL } }
//下列两个函数用于对特定的成员进行赋值(当传入不同类型的参数时);
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; // 自定义的唤醒函数
}
(3)对等待队列进行操作
static inline int waitqueue_active(wait_queue_head_t *q)
{
return !list_empty(&q->task_list);
}
判断等待对列头是否为空,当一个进程访问设备而得不到资源时就会被放入等待队列头指向的等待队列中。
static inline void __add_wait_queue(wait_queue_head_t *head,\ wait_queue_t *new) /
{
list_add(&new->task_list, &head->task_list);
}
//增加一个等待队列new到等待队列头head指向的等待队列链表中;
static inline void __add_wait_queue_tail(wait_queue_head_t *head, wait_queue_t *new)
{
list_add_tail(&new->task_list, &head->task_list);
}
增加一个等待队列到表尾
static inline void __remove_wait_queu (wait_queue_head_t *head, wait_queue_t *old)
{
list_del(&old->task_list);
}
//wq: 在等待事件的等待队列,condition: 等待的条件
#define __wait_event(wq, condition) \
do { \
DEFINE_WAIT(__wait); \ //定义并初始化一个wait_queue_t结构
for (;;) { \
prepare_to_wait(&wq, &__wait,TASK_UNINTERRUPTIBLE); \
if (condition) \ //看wait_queue:wq要等的condition是否满足
break; \
schedule(); \ //condition不成立,放弃cpu重新调度一个task
} \
finish_wait(&wq, &__wait); \
} while (0)
上面程序的执行过程:
1.用当前的进程描述块(PCB)初始化一个wait_queue描述的等待任务。
2.在等待队列锁资源的保护下,将等待任务加入等待队列。
3.判断等待条件是否满足,如果满足,那么将等待任务从队列中移出,退出函数。
4.如果条件不满足,那么任务调度,将CPU资源交与其它任务。
5.当睡眠任务被唤醒之后,需要重复(2)、(3)步骤,如果确认条件满足,退出等待事件函数。
我在一个程序中因为使用使用wait_event_interruptible()遇到了很大的麻烦,原因就是不知道condition在函数中具体起个什么作用,通过分析源码终于搞清楚。(后面会有专门的文章来介绍那个问题。)
等待队列编程接口:
wait_event(wq, condition)
这是一个宏,让当前任务处于等待事件状态。输入参数如下:
@wq:等待队列
@conditions:等待条件
wait_event_timeout(wq, condition, timeout)
功能与wait_event类似,多了一个超时机制。参数中多了一项超时时间。
wait_event_interruptible(wq, condition)
这是一个宏,与前两个宏相比,该宏定义的等待能够被消息唤醒。如果被消息唤醒,那么返回- ERESTARTSYS。输入参数如下:
@wq:等待队列
@condition:等待条件
@rt:返回值
wait_event_interruptible_timeout(wq, condition, timeout)
与上一个相比,多了超时机制
wake_up(x)
唤醒等待队列中的一个任务
wake_up_interruptible(x)
用于唤醒wake_event_interruptible()睡眠的进程
wake_up_all(x)
唤醒等待队列中的所有任务
Linux将进程状态描述为如下五种:
TASK_RUNNING:可运行状态。处于该状态的进程可以被调度执行而成为当前进程。
TASK_INTERRUPTIBLE:可中断的睡眠状态。处于该状态的进程在所需资源有效时被唤醒,也可以通过信号或定时中断唤醒(因为有signal_pending()函数)。
TASK_UNINTERRUPTIBLE:不可中断的睡眠状态。处于该状态的进程仅当所需资源有效时被唤醒。
TASK_ZOMBIE:僵尸状态。表示进程结束且已释放资源,但其task_struct仍未释放。
TASK_STOPPED:暂停状态。处于该状态的进程通过其他进程的信号才能被唤醒。
在Linux内核中等待队列有很多用途,可用于中断处理、进程同步及定时。我们在这里只说,进程经常必须等待某些事件的发生。等待队列实现了在事件上的条件等待: 希望等待特定事件的进程把自己放进合适的等待队列,并放弃控制全。因此,等待队列表示一组睡眠的进程,当某一条件为真时,由内核唤醒它们。
等待队列由循环链表实现,其元素包括指向进程描述符的指针。每个等待队列都有一个等待队列头(wait queue head),等待队列头是一个类型为wait_queue_head_t的数据结构
(1)定义等待队列头(相关内容可以在linux/include/wait.h中找到)
等待队列头结构体的定义:
struct __wait_queue_head {
spinlock_t lock; //自旋锁变量,用于在对等待队列头
struct list_head task_list; // 指向等待队列的list_head
};
typedef struct __wait_queue_head wait_queue_head_t;
使用等待队列时首先需要定义一个wait_queue_head,这可以通过DECLARE_WAIT_QUEUE_HEAD宏来完成,这是静态定义的方法。该宏会定义一个wait_queue_head,并且初始化结构中的锁以及等待队列。当然,动态初始化的方法也很简单,初始化一下锁及队列就可以了。
#define DECLARE_WAIT_QUEUE_HEAD(name) \
wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
#define __WAIT_QUEUE_HEAD_INITIALIZER(name) { \
.lock = __SPIN_LOCK_UNLOCKED(name.lock), \
.task_list = { &(name).task_list, &(name).task_list } }
将lock赋为unlocked, 将等待队列头指向的等待队列链表指向name,从而将等待队列头和等待队列连起来;
一般在写程序的时候将DECLARE_WAIT_QUEUE_HEAD分成两步来完成:
声明:
wait_queue_head_t wait_que;
初始化:
init_waitqueue_head( &wait_que);
Linux中等待队列的实现思想如下图所示,当一个任务需要在某个wait_queue_head上睡眠时,将自己的进程控制块信息封装到wait_queue中,然后挂载到wait_queue的链表中,执行调度睡眠。当某些事件发生后,另一个任务(进程)会唤醒wait_queue_head上的某个或者所有任务,唤醒工作也就是将等待队列中的任务设置为可调度的状态,并且从队列中删除。
(2)等待队列中存放的是在执行设备操作时不能获得资源而挂起的进程
定义等待对列:
struct __wait_queue {
unsigned int flags; //prepare_to_wait()里有对flags的操作,查看以得出其含义
#define WQ_FLAG_EXCLUSIVE 0x01 //一个常数,在prepare_to_wait()用于修改flags的值
void * private //通常指向当前任务控制块
wait_queue_func_t func; //唤醒阻塞任务的函数 ,决定了唤醒的方式
struct list_head task_list; // 阻塞任务链表
};
typedef struct __wait_queue wait_queue_t;
//声明一个等待队列并初始化为name
#define DECLARE_WAITQUEUE(name, tsk) \
wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
#define __WAITQUEUE_INITIALIZER(name, tsk) { \
.private = tsk, \
.func = default_wake_function, \
.task_list = { NULL, NULL } }
//下列两个函数用于对特定的成员进行赋值(当传入不同类型的参数时);
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; // 自定义的唤醒函数
}
(3)对等待队列进行操作
static inline int waitqueue_active(wait_queue_head_t *q)
{
return !list_empty(&q->task_list);
}
判断等待对列头是否为空,当一个进程访问设备而得不到资源时就会被放入等待队列头指向的等待队列中。
static inline void __add_wait_queue(wait_queue_head_t *head,\ wait_queue_t *new) /
{
list_add(&new->task_list, &head->task_list);
}
//增加一个等待队列new到等待队列头head指向的等待队列链表中;
static inline void __add_wait_queue_tail(wait_queue_head_t *head, wait_queue_t *new)
{
list_add_tail(&new->task_list, &head->task_list);
}
增加一个等待队列到表尾
static inline void __remove_wait_queu (wait_queue_head_t *head, wait_queue_t *old)
{
list_del(&old->task_list);
}
//wq: 在等待事件的等待队列,condition: 等待的条件
#define __wait_event(wq, condition) \
do { \
DEFINE_WAIT(__wait); \ //定义并初始化一个wait_queue_t结构
for (;;) { \
prepare_to_wait(&wq, &__wait,TASK_UNINTERRUPTIBLE); \
if (condition) \ //看wait_queue:wq要等的condition是否满足
break; \
schedule(); \ //condition不成立,放弃cpu重新调度一个task
} \
finish_wait(&wq, &__wait); \
} while (0)
上面程序的执行过程:
1.用当前的进程描述块(PCB)初始化一个wait_queue描述的等待任务。
2.在等待队列锁资源的保护下,将等待任务加入等待队列。
3.判断等待条件是否满足,如果满足,那么将等待任务从队列中移出,退出函数。
4.如果条件不满足,那么任务调度,将CPU资源交与其它任务。
5.当睡眠任务被唤醒之后,需要重复(2)、(3)步骤,如果确认条件满足,退出等待事件函数。
我在一个程序中因为使用使用wait_event_interruptible()遇到了很大的麻烦,原因就是不知道condition在函数中具体起个什么作用,通过分析源码终于搞清楚。(后面会有专门的文章来介绍那个问题。)
等待队列编程接口:
wait_event(wq, condition)
这是一个宏,让当前任务处于等待事件状态。输入参数如下:
@wq:等待队列
@conditions:等待条件
wait_event_timeout(wq, condition, timeout)
功能与wait_event类似,多了一个超时机制。参数中多了一项超时时间。
wait_event_interruptible(wq, condition)
这是一个宏,与前两个宏相比,该宏定义的等待能够被消息唤醒。如果被消息唤醒,那么返回- ERESTARTSYS。输入参数如下:
@wq:等待队列
@condition:等待条件
@rt:返回值
wait_event_interruptible_timeout(wq, condition, timeout)
与上一个相比,多了超时机制
wake_up(x)
唤醒等待队列中的一个任务
wake_up_interruptible(x)
用于唤醒wake_event_interruptible()睡眠的进程
wake_up_all(x)
唤醒等待队列中的所有任务
Linux将进程状态描述为如下五种:
TASK_RUNNING:可运行状态。处于该状态的进程可以被调度执行而成为当前进程。
TASK_INTERRUPTIBLE:可中断的睡眠状态。处于该状态的进程在所需资源有效时被唤醒,也可以通过信号或定时中断唤醒(因为有signal_pending()函数)。
TASK_UNINTERRUPTIBLE:不可中断的睡眠状态。处于该状态的进程仅当所需资源有效时被唤醒。
TASK_ZOMBIE:僵尸状态。表示进程结束且已释放资源,但其task_struct仍未释放。
TASK_STOPPED:暂停状态。处于该状态的进程通过其他进程的信号才能被唤醒。
通过 前一篇文章 的介绍我们队等待队列有了一个比较具体的认识,本文将来分析一下等待队列是如何睡眠一个进程和如何唤醒一个进程的。
使用等待队列前通常先定义一个等待队列头:static wait_queue_head_t wq ,然后调用wait_event_*函数将等待某条件condition的当前进程插入到等待队列wq中并睡眠,一直等到condition条件满足后,内核再将睡眠在等待队列wq上的某一进程或所有进程唤醒。
这里我们来分析一下唤醒的过程,举比较常用的wait_event_interruptible来分析:
/** * wait_event_interruptible - sleep until a condition gets true * @wq: the waitqueue to wait on * @condition: a C expression for the event to wait for * * The process is put to sleep (TASK_INTERRUPTIBLE) until the * @condition evaluates to true or a signal is received. * The @condition is checked each time the waitqueue @wq is woken up. * * wake_up() has to be called after changing any variable that could * change the result of the wait condition. * * The function will return -ERESTARTSYS if it was interrupted by a * signal and 0 if @condition evaluated to true. */ #define wait_event_interruptible(wq, condition) \ ({ \ int __ret = 0; \ if (!(condition)) \ __wait_event_interruptible(wq, condition, __ret); \ __ret; \ })
这里很简单,判断一下condition条件是否满足,如果不满足则调用__wait_event_interruptible函数。
#define __wait_event_interruptible_timeout(wq, condition, ret) \ do { \ DEFINE_WAIT(__wait); \ \ for (;;) { \ prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE); \ if (condition) \ break; \ if (!signal_pending(current)) { \ ret = schedule_timeout(ret); \ if (!ret) \ break; \ continue; \ } \ ret = -ERESTARTSYS; \ break; \ } \ finish_wait(&wq, &__wait); \ } while (0)
__wait_event_interruptible首先定义了一个wait_queue_t类型的等待队列项__wait:
#define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function) #define DEFINE_WAIT_FUNC(name, function) \ wait_queue_t name = { \ .private = current, \ .func = function, \ .task_list = LIST_HEAD_INIT((name).task_list), \ }
可以发现,这里__wait的private成员(通常用来存放进程的描述符)已经被初始化为current, 表示该等待队列项对应为当前进程。func成员为该等待队列项对应的唤醒函数,该进程被唤醒后会执行它,已经被初始化为默认的autoremove_wake_function函数。
然后在一个for (;;) 循环内调用prepare_to_wait函数:
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); }
prepare_to_wait做如下两件事,将先前定义的等待队列项__wait插入到等待队列头wq,然后将当前进程设为TASK_INTERRUPTIBLE状态。prepare_to_wait执行完后立马再检查一下condition有没有满足,如果此时碰巧满足了则不必要在睡眠了。如果还没有满足,则准备睡眠。
睡眠是通过调用schedule()函数实现的,由于之前已经将当前进程设置为TASK_INTERRUPTIBLE状态,因而这里再执行schedule()进行进程切换的话,之后就永远不会再调度到该进程运行的,直到该进程被唤醒(即更改为TASK_RUNNING状态)。
这里在执行schedule()切换进程前会先判断一下有没signal过来,如果有则立即返回ERESTARTSYS。没有的话则执行schedule()睡眠去了。
for (;;) 循环的作用是让进程被唤醒后再一次去检查一下condition是否满足。主要是为了防止等待队列上的多个进程被同时唤醒后有可能其他进程已经抢先把资源占有过去造成资源又变为不可用,因此最好再判断一下。(当然,内核也提供了仅唤醒一个或多个进程(独占等待进程)的方式,有兴趣的可以参考相关资料)
进程被唤醒后最后一步是调用finish_wait(&wq, &__wait)函数进行清理工作。finish_wait将进程的状态再次设为TASK_RUNNING并从等待队列中删除该进程。
void finish_wait(wait_queue_head_t *q, wait_queue_t *wait) { unsigned long flags; __set_current_state(TASK_RUNNING); if (!list_empty_careful(&wait->task_list)) { spin_lock_irqsave(&q->lock, flags); list_del_init(&wait->task_list); spin_unlock_irqrestore(&q->lock, flags); } }
再往后就是返回你先前调用wait_event_interruptible(wq, condition)被阻塞的地方继续往下执行。
3. 等待队列的唤醒过程
直到这里我们明白等待队列是如何睡眠的,下面我们分析等待队列的唤醒过程。
使用等待队列有个前提,必须得有人唤醒它,如果没人唤醒它,那么同眠在该等待队列上的所有进程岂不是变成“僵尸进程”了。
对于设备驱动来讲,通常是在中断处理函数内唤醒该设备的等待队列。驱动程序通常会提供一组自己的读写等待队列以实现上层(user level)所需的BLOCK和O_NONBLOCK操作。当设备资源可用时,如果驱动发现有进程睡眠在自己的读写等待队列上便会唤醒该等待队列。
唤醒一个等待队列是通过wake_up_*函数实现的。这里我们举对应的wake_up_interruptible作为例子分析。定义如下:
#define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
这里的参数x即要唤醒的等待队列对应的等待队列头。唤醒TASK_INTERRUPTIBLE类型的进程并且默认唤醒该队列上所有非独占等待进程和一个独占等待进程。
__wake_up定义如下:
/** * __wake_up - wake up threads blocked on a waitqueue. * @q: the waitqueue * @mode: which threads * @nr_exclusive: how many wake-one or wake-many threads to wake up * @key: is directly passed to the wakeup function */ void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, void *key) { unsigned long flags; spin_lock_irqsave(&q->lock, flags); __wake_up_common(q, mode, nr_exclusive, 0, key); spin_unlock_irqrestore(&q->lock, flags); } __wake_up 简单的调用__wake_up_common进行实际唤醒工作。 __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 wake_flags, void *key) { wait_queue_t *curr, *next; list_for_each_entry_safe(curr, next, &q->task_list, task_list) { unsigned flags = curr->flags; if (curr->func(curr, mode, wake_flags, key) && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive) break; } }
__wake_up_common循环遍历等待队列内的所有元素,分别执行其对应的唤醒函数。这里的唤醒函数即先前定义等待队列项DEFINE_WAIT(__wait)时默认初始化的autoremove_wake_function函数。autoremove_wake_function最终会调用try_to_wake_up函数将进程置为TASK_RUNNING状态。这样后面的进程调度便会调度到该进程,从而唤醒该进程继续执行。
根据内核3.1.6版本源码、书籍和网上资料,对几个函数进行分析
介绍这几个函数,不得不先介绍等待队列wait_queue_head_t与完成量completion。
等待队列用于使得进程等待某一特定事件的发生,无需频繁的轮询,进程在等待周期中睡眠,当时间发生后由内核自动唤醒。
完成量机制是基于等待队列的,内核利用该机制等待某一操作的结束。这两种经常被使用。
一、等待队列
(一)数据结构
等待队列结构如下,因为每个等待队列都可以再中断时被修改,因此,在操作等待队列之前必须获得一个自旋锁。
- struct __wait_queue_head {
- spinlock_t lock;
- struct list_head task_list;
- };
- typedef struct__wait_queue_head wait_queue_head_t;
- typedef struct__wait_queue wait_queue_t;
- struct __wait_queue {
- unsigned int flags;
- #defineWQ_FLAG_EXCLUSIVE 0x01 /* 表示等待进程想要被独占地唤醒 */
- void *private; /* 指向等待进程的task_struct实例 */
- wait_queue_func_t func; /* 用于唤醒等待进程 */
- struct list_head task_list; /* 用于链表元素,将wait_queue_t链接到wait_queue_head_t */
- };
等待队列如何使用哪?分两步
1. 为了使得等待进程在一个等待队列中睡眠,需要调用函数wait_event()函数。进程进入睡眠,将控制权释放给调度器。
2. 在内核中另一处,调用wake_up()函数唤醒等待队列中的睡眠进程。
注:使用wait_event()函数使得进程睡眠;而在内核另一处有一个对应的wake_up()函数被调用。
(二)初始化等待队列元素
有两种方法初始化队列:
1. 动态初始化init_waitqueue_entry()
- 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;
- }
2. 静态初始化DEFINE_WAIT()
- #define DEFINE_WAIT_FUNC(name, function) \
- wait_queue_t name = { \
- .private = current, \
- .func = function, \
- .task_list = LIST_HEAD_INIT((name).task_list), \
- }
- #define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)
其中函数autoremove_wake_function()是用来唤醒进程的,该函数不经调用default_wake_function(),还将所属等待队列成员从等待队列删除。
(三)进程睡眠
1. 通过add_wait_queue()函数将一个进程添加到等待队列,首先获得自旋锁,然后调用__add_wait_queue()实现将新的等待进程添加等待队列(添加到等待队列的头部),然后解锁;代码如下:
- static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
- {
- list_add(&new->task_list, &head->task_list);
- }
另一个函数add_wait_queue_exclusive()的含义与add_wait_queue()函数类似,但是将等待进程添加到等待队列的尾部,并设置WQ_EXCLUSIXE标志。
使得进程在等待队列上睡眠的另一种方法是:prepare_to_wait(),除了有add_wait_queue()函数的参数外,还要设置进程的状态。
另一个函数prepare_to_wait_exclusive()语义类似。
通常情况下,add_wait_queue()函数不会直接使用,而是调用wait_evnet()函数
- /**
- * wait_event - sleep until a condition gets true
- * @wq: the waitqueue to wait on
- * @condition: a C expression for the event to wait for
- *
- * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
- * @condition evaluates to true. The @condition is checked each time
- * the waitqueue @wq is woken up.
- *
- * wake_up() has to be called after changing any variable that could
- * change the result of the wait condition.
- */
- #define wait_event(wq, condition) \
- do { \
- if (condition) \
- break; \
- __wait_event(wq, condition); \
- } while (0)
- #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 (0)
其中wq是等待进程需要加入的等待队列,而condition是通过与所等待时间有关的一个C表达式形式给出。表示,条件满足时,可以立即停止处理。主要工作由__wait_event()来完成。
分析__wait_event()函数,
(1) 调用DEFINE_WAIT宏建立等待队列成员;
(2) 使用一个无线循环,在循环体内,
(a) 调用prepare_to_wait()使得进程在等待队列上等待;
(b) 当进程被唤醒时,检查指定的条件condition是否满足,如果满足则跳出循环,否则将控制权交给调度器,然后进程继续睡眠。
(3) 调用函数finish_wait()将进程状态设置为TASK_RUNNING,并从等待队列的链表中移除对应的成员。
其他与wait_event类似的函数:
1. wait_event_timeout()函数 ,使得进程处于TASK_INTERRUPTIBLE状态,从而睡眠进程可以通过接收信号被唤醒;
2. wait_event_timeout()函数,等待满足指定的条件,但是如果等待时间超过指定的超时限制则停止睡眠,可以防止进程永远睡眠;
3. wait_event_interruptible_timeout() 使得进程睡眠,但是可以通过接收信号被唤醒,也具有超时限制。
(四)进程睡眠
内核中虽然定义了很多唤醒等待队列中进程的函数,但是最终调用的都是__wake_up()
- #define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
- #define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
- #define wake_up_all(x) __wake_up(x, TASK_NORMAL, 0, NULL)
- #define wake_up_locked(x) __wake_up_locked((x), TASK_NORMAL)
- #define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
- #define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
- #define wake_up_interruptible_all(x) __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
- #define wake_up_interruptible_sync(x) __wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
而__wake_up()函数在加锁之后调用的是__wake_up_common()
- static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
- int nr_exclusive, int wake_flags, void *key)
- {
- wait_queue_t *curr, *next;
- list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
- unsigned flags = curr->flags;
- if (curr->func(curr, mode, wake_flags, key) &&
- (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
- break;
- }
- }
其中:q是等待队列,mode指定进程的状态,用于控制唤醒进程的条件,nr_exclusive表示将要唤醒的设置了WQ_FLAG_EXCLUSIVE标志的进程的数目。
然后扫描链表,调用func,直至没有更多的进程被唤醒,或者被唤醒的的独占进程数目已经达到规定数目。
完成量,下一次在学习。
参考资料:
(1) http://blog.chinaunix.net/space.php?uid=20565550&do=blog&id=303575
(2) 《深入linuc内核架构》
完成量机制是基于等待队列的,内核使用该机制等待某一操作的完成。其有两个参与者:一是等待某操作完成;另一是在操作完成时发出声明。当然可以有“任意数目”个进程等待操作完成。
完成量的数据描述如下:
- struct completion {
- unsigned int done; /* 用于处理“在进程开始等待之前,事件或操作已经完成” */
- wait_queue_head_t wait; /* 地等待队列 */
- };
初始化一个动态分配的completion完成量结构体,
- static inline void init_completion(struct completion *x)
- {
- x->done = 0;
- init_waitqueue_head(&x->wait);
- }
- #define DECLARE_COMPLETION(work) \
- struct completion work = COMPLETION_INITIALIZER(work)
进程可以通用一下函数添加到等待队列
- void __sched wait_for_completion(struct completion *x)
- unsigned long __sched wait_for_completion_timeout(struct completion *x, unsigned long timeout)
- int __sched wait_for_completion_interruptible(struct completion *x)
- long __sched wait_for_completion_interruptible_timeout(struct completion *x, unsigned long timeout)
- int __sched wait_for_completion_killable(struct completion *x)
- long __sched wait_for_completion_killable_timeout(struct completion *x, unsigned long timeout)
(2) wait_for_completion_timeout表示等待事件的发生,并且提供超时设置,如果超过了这一设置,则取消等待,可防止无限等待;如果在超时之前完成则返回剩余时间,否则返回0。
(3) wait_for_completion_killable表示可以由kill信号中断。
其他函数均是这三者的变种。
三、唤醒进程
进程唤醒,可以通过以下函数实现:
- extern void complete(struct completion *);
- extern void complete_all(struct completion *);
(2) complete_all唤醒所有的等待线程。
done的解释:
每次调用complete,done计数器都会+1,仅当done=0时,wait_for系列函数才会使得调用进程睡眠。
后续会进行complete编程练习......