浅谈等待队列的内部实现（二）
上面讲到添加和等待。这次主要讲如何唤醒

#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_SMPif (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--;elsethis_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_SCHEDSTATSschedstat_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的情况是如何执行的，以及对消耗平衡的处理方式等
谢谢