linux等待队列

一.头文件

#include <linux/wait.h>

二.结构体

1.等待队列头

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

2.等待队列

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;

三.初始化

1.等待队列头

定义声明等待队列头

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

2.等待队列

定义声明等待队列

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

四.添加与移除等待队列

1.添加等待队列

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);
}

__add_wait_queue本质上就是添加等待队列的task_list进等待队列头的task_list为首项的list链表

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);
}

2.移除等待队列

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

	spin_lock_irqsave(&q->lock, flags);
	__remove_wait_queue(q, wait);
	spin_unlock_irqrestore(&q->lock, flags);
}

__remove_wait_queue本质上就是从等待队列头的task_list为首项的list链表中移除等待队列的task_list

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

五.等待,唤醒,睡眠
1.等待

1.1 wait_event 等待事件发生,不可中断

#define wait_event(wq, condition) 					\
do {								\
	if (condition)	 					\	//唤醒的条件为真,则退出
		break;						\
	__wait_event(wq, condition);				\
} while (0)

__wait_event

#define __wait_event(wq, condition) 					\
do {								\
	DEFINE_WAIT(__wait);					\
								\
	for (;;) {						\
		prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);	\	//TASK_UNINTERRUPTIBLE标明不可中断
		if (condition)					\	//唤醒的条件为真,则退出for循环
			break;					\
		schedule();					\	//进入调度
	}							\
	finish_wait(&wq, &__wait);					\	//设置进程为TASK_RUNNING,并移除等待队列中的队列项
} while (0)

1.2 wait_event_interruptible 等待事件发生,可中断

#define wait_event_interruptible(wq, condition)			\
({								\
	int __ret = 0;						\
	if (!(condition))						\	//条件为真则退出
		__wait_event_interruptible(wq, condition, __ret);	\	
	__ret;							\
})

__wait_event_interruptible

#define __wait_event_interruptible(wq, condition, ret)			\
do {								\
	DEFINE_WAIT(__wait);					\
								\
	for (;;) {						\
		prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);	\	//TASK_INTERRUPTIBLE标明可中断
		if (condition)					\	//唤醒的条件为真,则退出for循环
			break;					\
		if (!signal_pending(current)) {			\	//检测当前进程是否有信号要处理
			schedule();				\	//进入调度
			continue;					\
		}						\
		ret = -ERESTARTSYS;				\
		break;						\
	}							\
	finish_wait(&wq, &__wait);					\	//设置进程为TASK_RUNNING,并移除等待队列中的队列项
} while (0)

1.3 wait_event_timeout 超时等待事件，不可中断

#define wait_event_timeout(wq, condition, timeout)			\
({								\
	long __ret = timeout;					\
	if (!(condition)) 						\	//等待条件为真则退出
		__wait_event_timeout(wq, condition, __ret);		\	
	__ret;							\
})

__wait_event_timeout

#define __wait_event_timeout(wq, condition, ret)			\
do {								\
	DEFINE_WAIT(__wait);					\
								\
	for (;;) {						\
		prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);	\	//TASK_UNINTERRUPTIBLE标明不可中断
		if (condition)					\	//唤醒的条件为真,则退出for循环
			break;					\
		ret = schedule_timeout(ret);			\	//调度,并设置超时值
		if (!ret)						\	//超时则退出
			break;					\
	}							\
	finish_wait(&wq, &__wait);					\	//设置进程为TASK_RUNNING,并移除等待队列中的队列项	
} while (0)

1.4 wait_event_interruptible_timeout 超时等待事件,可中断

#define wait_event_interruptible_timeout(wq, condition, timeout)	\
({								\
	long __ret = timeout;					\
	if (!(condition))						\	//等待条件为真则退出
		__wait_event_interruptible_timeout(wq, condition, __ret); \	
	__ret;							\
})

__wait_event_interruptible_timeout

#define __wait_event_interruptible_timeout(wq, condition, ret)		\
do {								\
	DEFINE_WAIT(__wait);					\
								\
	for (;;) {						\
		prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);	\	//TASK_INTERRUPTIBLE标明可中断
		if (condition)					\	//唤醒的条件为真,则退出for循环
			break;					\
		if (!signal_pending(current)) {			\	//检测当前进程是否有信号要处理
			ret = schedule_timeout(ret);		\	//调度,并设置超时值
			if (!ret)					\	//超时则退出
				break;				\
			continue;					\	
		}						\
		ret = -ERESTARTSYS;				\
		break;						\
	}							\
	finish_wait(&wq, &__wait);					\	//设置进程为TASK_RUNNING,并移除等待队列中的队列项
} while (0)

2.唤醒
2.1 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)

2.2 wake_up_interruptible唤醒可中断的等待队列

#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

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);	//-->__wake_up_common
	spin_unlock_irqrestore(&q->lock, flags);
}

__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;	
		//调用其等待队列项的func方法,-->default_wake_function
		if (curr->func(curr, mode, wake_flags, key) &&(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
			break;
	}
}

default_wake_function

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

try_to_wake_up

static int try_to_wake_up(struct task_struct *p, unsigned int state,int wake_flags)
{
	int cpu, orig_cpu, this_cpu, success = 0;
	unsigned long flags;
	unsigned long en_flags = ENQUEUE_WAKEUP;
	struct rq *rq;
	this_cpu = get_cpu();

	smp_wmb();
	rq = task_rq_lock(p, &flags);
	if (!(p->state & state))
		goto out;

	if (p->se.on_rq)
		goto out_running;

	cpu = task_cpu(p);
	orig_cpu = cpu;

#ifdef CONFIG_SMP
	if (unlikely(task_running(rq, p)))
		goto out_activate;

	if (task_contributes_to_load(p)) {
		if (likely(cpu_online(orig_cpu)))
			rq->nr_uninterruptible--;
		else
			this_rq()->nr_uninterruptible--;
	}
	p->state = TASK_WAKING;

	if (p->sched_class->task_waking) {
		p->sched_class->task_waking(rq, p);
		en_flags |= ENQUEUE_WAKING;
	}

	cpu = select_task_rq(rq, p, SD_BALANCE_WAKE, wake_flags);
	if (cpu != orig_cpu)
		set_task_cpu(p, cpu);
	__task_rq_unlock(rq);

	rq = cpu_rq(cpu);
	raw_spin_lock(&rq->lock);

	WARN_ON(task_cpu(p) != cpu);
	WARN_ON(p->state != TASK_WAKING);

#ifdef CONFIG_SCHEDSTATS
	schedstat_inc(rq, ttwu_count);
	if (cpu == this_cpu)
		schedstat_inc(rq, ttwu_local);
	else {
		struct sched_domain *sd;
		for_each_domain(this_cpu, sd) {
			if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
				schedstat_inc(sd, ttwu_wake_remote);
				break;
			}
		}
	}
#endif /* CONFIG_SCHEDSTATS */

out_activate:
#endif /* CONFIG_SMP */
	ttwu_activate(p, rq, wake_flags & WF_SYNC, orig_cpu != cpu, cpu == this_cpu, en_flags);	//最终调用activate_task激活等待进程
	success = 1;
out_running:
	ttwu_post_activation(p, rq, wake_flags, success);
out:
	task_rq_unlock(rq, &flags);
	put_cpu();

	return success;
}

3.睡眠

3.1 sleep_on 睡眠,不可中断

void __sched sleep_on(wait_queue_head_t *q)
{
	sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
}

3.2 interruptible_sleep_on 睡眠,可中断

void __sched interruptible_sleep_on(wait_queue_head_t *q)
{
	sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
}

3.3 sleep_on_timeout 超时睡眠,不可中断

long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
{
	return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);
}

3.4 interruptible_sleep_on_timeout 超时睡眠,可中断

long __sched interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
{
	return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);
}

睡眠api最终都会调用sleep_on_common

static long __sched
sleep_on_common(wait_queue_head_t *q, int state, long timeout)
{
	unsigned long flags;
	wait_queue_t wait;

	init_waitqueue_entry(&wait, current);	//初始化等待队列项

	__set_current_state(state);		//设置当前进程的状态TASK_UNINTERRUPTIBLE、TASK_INTERRUPTIBLE

	spin_lock_irqsave(&q->lock, flags);
	__add_wait_queue(q, &wait);	//添加等待队列项
	spin_unlock(&q->lock);
	timeout = schedule_timeout(timeout);	//调度,设置超时值
	spin_lock_irq(&q->lock);
	__remove_wait_queue(q, &wait);	//移除等待队列项
	spin_unlock_irqrestore(&q->lock, flags);

	return timeout;
}

六.整理

//等待队列头
wait_queue_head_t	
//初始化等待队列头
DECLARE_WAIT_QUEUE_HEAD(name)

//等待队列项
wait_queue_t	
//初始化等待队列项
DECLARE_WAITQUEUE(name, tsk)	
//添加移除等待队列项
void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)		//添加等待队列项
void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)	//移除等待队列项
//等待事件
wait_event(wq, condition) 						//等待事件,不可中断	
wait_event_interruptible(wq, condition)				//等待事件,可中断		 
wait_event_timeout(wq, condition, timeout)				//超时等待,不可中断
wait_event_interruptible_timeout(wq, condition, timeout)		//超时等待,可中断	
//唤醒事件
wake_up(x)							//唤醒事件,不可中断
wake_up_interruptible(x)						//唤醒事件,可中断
//等待队列上睡眠
void __sched sleep_on(wait_queue_head_t *q)				//睡眠,不可中断
void __sched interruptible_sleep_on(wait_queue_head_t *q)		//睡眠,可中断
long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout) 	//超时睡眠,不可中断
long __sched interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout) //超时睡眠,可中断

等待和睡眠本质上在于有无条件,睡眠属于旧版本内核的东西,很少使用到