浅谈等待队列的内部实现（二）

浅谈等待队列的内部实现（一）

http://blog.csdn.net/yyttiao/article/details/7875871

上面讲到添加和等待。这次主要讲如何唤醒

#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_interruptible 这个函数，因为上一章节中对应。
这一章主要看流程及代码注释。讲解会比较少

#define wake_up_interruptible(x)	__wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
/**
 * __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
 *
 * It may be assumed that this function implies a write memory barrier before
 * changing the task state if and only if any tasks are woken up.
 */
void __wake_up(wait_queue_head_t *q, unsigned int mode,
			int nr_exclusive, void *key)
{
	unsigned long flags;
	/* 锁定wait_queue_head_t 的操作，并关闭中断，保存中断状态 */
	spin_lock_irqsave(&q->lock, flags);
	__wake_up_common(q, mode, nr_exclusive, 0, key);
	spin_unlock_irqrestore(&q->lock, flags);
}
/*
 * 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;
		/* 调用默认的default_wake_function函数接口，在初始化的时候指定 */
		if (curr->func(curr, mode, wake_flags, key) &&
				(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
			break;
	}
}
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 - wake up a thread
 * @p: the thread to be awakened
 * @state: the mask of task states that can be woken
 * @wake_flags: wake modifier flags (WF_*)
 *
 * Put it on the run-queue if it's not already there. The "current"
 * thread is always on the run-queue (except when the actual
 * re-schedule is in progress), and as such you're allowed to do
 * the simpler "current->state = TASK_RUNNING" to mark yourself
 * runnable without the overhead of this.
 *
 * Returns %true if @p was woken up, %false if it was already running
 * or @state didn't match @p's state.
 */
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;
	/* 关闭内核抢占,获得本地cpu编号 */
	this_cpu = get_cpu();
	/* 设置内存写屏障 */
	smp_wmb();
	/* 获取最后执行该进程的run_queue and lock it */
	rq = task_rq_lock(p, &flags);
	/* 状态不一致，则直接退出 */
	if (!(p->state & state))
		goto out;


	if (p->se.on_rq)
		goto out_running;
	/* 获取最后执行该任务的CPU */
	cpu = task_cpu(p);
	/* save origin cpu */
	orig_cpu = cpu;


	/* support smp 在很多架构上还不支持smp可以忽略此处
	 * 判断是否要将任务转移到另外一个CPU的执行队列上，消耗平衡
	 * 此处大部分代码等以后深入详解的时候探讨。此次主要为浅谈
	 */
#ifdef CONFIG_SMP
	if (unlikely(task_running(rq, p)))
		goto out_activate;

	/*
	 * In order to handle concurrent wakeups and release the rq->lock
	 * we put the task in TASK_WAKING state.
	 *
	 * First fix up the nr_uninterruptible count:
	 */
	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);

	/*
	 * We migrated the task without holding either rq->lock, however
	 * since the task is not on the task list itself, nobody else
	 * will try and migrate the task, hence the rq should match the
	 * cpu we just moved it to.
	 */
	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 */
	/* 将进程P送入目标运行队列rq
	 * 内部调用activate_task 将任务q加入到rq里
     */
	ttwu_activate(p, rq, wake_flags & WF_SYNC, orig_cpu != cpu,
		      cpu == this_cpu, en_flags);
	success = 1;
out_running:
	/* 将任务状态重新设置回TASK_RUNING，以便cpu可以重新调度该任务 
	   下面的函数中有这么一句话 p->state = TASK_RUNNING;
	   最终任务的状态又回来了，这便唤醒了该任务
	*/
	ttwu_post_activation(p, rq, wake_flags, success);
out:
	task_rq_unlock(rq, &flags);
	put_cpu();

	return success;
}

总结：对于等待队列，其实最主要的就是对任务状态的切换，使其是否能被schedule拉取被执行。如何通过设置让它满足这些条件，就是等待队列机制的原理。

在wait_event中将任务设置为非TASK_RUNING而在wake_up中将任务设置回TASK_RUNING

其实很多时候wait_event并不会直接去调用，而是会像我在第一篇文章中第一段代码那样去判断条件，因为有时候要考虑是否阻塞，在非阻塞方式下，就不需要

wait_event了。当然也有别的方法来完成，因人而异。。

等以后讲解玩schedule之后，再详细分析smp的情况是如何执行的，以及对消耗平衡的处理方式等

谢谢

浅谈等待队列的内部实现（一）

http://blog.csdn.net/yyttiao/article/details/7875871