linux内核如何唤醒线程
//本文代码片段出自linux内核版本：4.1.15
linux内核唤醒线程主要使用wake_up_process()。
一、wake_up_process()分析
在linux内核中，唤醒线程由wake_up_process()函数实现。其定义在（/kernel/sched/core.c）：
int wake_up_process(struct task_struct *p)
{
WARN_ON(task_is_stopped_or_traced(p));
return try_to_wake_up(p, TASK_NORMAL, 0);
}
在wake_up_process()将调用try_to_wake_up()函数：
static int try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
{
unsigned long flags;
int cpu, success = 0;
/*
* If we are going to wake up a thread waiting for CONDITION we
* need to ensure that CONDITION=1 done by the caller can not be
* reordered with p->state check below. This pairs with mb() in
* set_current_state() the waiting thread does.
*/
smp_mb__before_spinlock();
raw_spin_lock_irqsave(&p->pi_lock, flags);
if (!(p->state & state))
goto out;
success = 1; /* we're going to change ->state */
cpu = task_cpu(p);
/* 使用内存屏障保证p->on_rq的数值是最新的。如果线程已经在运行队列rq里面了，即进程已经处于
runnable/running状态。ttwu_remote目的是由于线程 p已经在运行队列rq里面了，并且没有完全
取消调度，再次唤醒的话，需要将线程的状态翻转：将状态设置为TASK_RUNNING，这样
线程就一直在运行队列里面了。这种情况则直接退出后续流程，并对调度状态/数据进行统计 */
if (p->on_rq && ttwu_remote(p, wake_flags))
goto stat;
#ifdef CONFIG_SMP
/* 等待在其他cpu上的线程调度完成 */
while (p->on_cpu)
cpu_relax();
/*
* Pairs with the smp_wmb() in finish_lock_switch().
*/
smp_rmb();
p->sched_contributes_to_load = !!task_contributes_to_load(p);
p->state = TASK_WAKING;
/* 根据进程的所属的调度类调用相应的回调函数 */
if (p->sched_class->task_waking)
p->sched_class->task_waking(p);
/* 根据线程p相关参数和系统状态，为线程p选择合适的cpu */
cpu = select_task_rq(p, p->wake_cpu, SD_BALANCE_WAKE, wake_flags);
/* 如果选择的cpu与线程p当前所在的cpu不相同，则将线程的wake_flags设置为需要迁移，然后将线程p迁移到cpu上 */
if (task_cpu(p) != cpu) {
wake_flags |= WF_MIGRATED;
set_task_cpu(p, cpu);
}
#endif /* CONFIG_SMP */
/* 线程p入队操作并标记线程p为runnable状态，同时唤醒抢占 */
ttwu_queue(p, cpu);
stat:
/* 与调度相关的统计 */
ttwu_stat(p, cpu, wake_flags);
out:
raw_spin_unlock_irqrestore(&p->pi_lock, flags);
return success;
}
第14~15行代码，如果进程状态不是：TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE，则就不是normal task，这时候直接退出wakeup流程。所以在内核里面只要使用wake_up_process()，函数都会将进程设置为TASK_INTERRUPTIBLE or TASK_UNINTERRUPTIBLE这两种状态之一。
第23~46行代码是SMP环境下的相关处理机制：（详见代码上的注释）
在try_to_wake_up()函数的最后将调用ttwu_queue()，下文将分析这个函数。
二、ttwu_queue()函数分析
ttwu_queue()函数定义如下：
static void ttwu_queue(struct task_struct *p, int cpu)
{
struct rq *rq = cpu_rq(cpu);
#if defined(CONFIG_SMP)
if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) {
sched_clock_cpu(cpu); /* sync clocks x-cpu */
ttwu_queue_remote(p, cpu);
return;
}
#endif
raw_spin_lock(&rq->lock);
ttwu_do_activate(rq, p, 0);
raw_spin_unlock(&rq->lock);
}
static void ttwu_do_activate(struct rq *rq, struct task_struct *p, int wake_flags)
{
#ifdef CONFIG_SMP
if (p->sched_contributes_to_load)
rq->nr_uninterruptible--;
#endif
//将线程p加入运行队列rq中
ttwu_activate(rq, p, ENQUEUE_WAKEUP | ENQUEUE_WAKING);
//将任务标记为可运行的，并执行唤醒抢占。
ttwu_do_wakeup(rq, p, wake_flags);
}
static void ttwu_activate(struct rq *rq, struct task_struct *p, int en_flags)
{
activate_task(rq, p, en_flags);
p->on_rq = TASK_ON_RQ_QUEUED;
/* if a worker is waking up, notify workqueue */
if (p->flags & PF_WQ_WORKER)
wq_worker_waking_up(p, cpu_of(rq));
}
static void enqueue_task(struct rq *rq, struct task_struct *p, int flags)
{
update_rq_clock(rq);
sched_info_queued(rq, p);
p->sched_class->enqueue_task(rq, p, flags);
}
void activate_task(struct rq *rq, struct task_struct *p, int flags)
{
if (task_contributes_to_load(p))
rq->nr_uninterruptible--;
enqueue_task(rq, p, flags);
}
//将任务标记为可运行的，并执行唤醒抢占操作
static void ttwu_do_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
{
check_preempt_curr(rq, p, wake_flags);
trace_sched_wakeup(p, true);
//将线程p的状态设置为TASK_RUNNING
p->state = TASK_RUNNING;
#ifdef CONFIG_SMP
if (p->sched_class->task_woken)
p->sched_class->task_woken(rq, p);
if (rq->idle_stamp) {
u64 delta = rq_clock(rq) - rq->idle_stamp;
u64 max = 2*rq->max_idle_balance_cost;
update_avg(&rq->avg_idle, delta);
if (rq->avg_idle > max)
rq->avg_idle = max;
rq->idle_stamp = 0;
}
#endif
}
（注：以上代码为了便于阅读而放置）
从以上代码片段可知，ttwu_queue()函数的功能是：
（1）将线程p入队操作并标记线程p为runnable状态。（ttwu_activate()部分），本质是调用与线程相关联的调度类的enqueue_task回调函数（以CFS调度策略为例，参见附录的enqueue_task_fair()函数），实现将线程p加入到rq运行队列中。
p->sched_class->enqueue_task(rq, p, flags);
（2）将当前线程标记为TASK_RUNNING，并执行唤醒抢占操作。 （ttwu_do_wakeup()部分）
三、后续与附录
1、在wake_up_process（）中常常使用linux内核的内存屏障机制。
2、通过WALT算法：计算出运行队列当前线程和新唤醒的线程p相关的task load和运行队列相关的runnable_load的数值。
后续将学习、了解一下WALT算法、内存屏障机制的实现机制和思路。
/*在增加nr_running之前调用enqueue_task（）函数。在这里，将更新公平调度统计数据，然后将线程
p放入rbtree红黑树中。*/
static void enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags)
{
struct cfs_rq *cfs_rq;
struct sched_entity *se = &p->se;
for_each_sched_entity(se) {
if (se->on_rq)
break;
cfs_rq = cfs_rq_of(se);
enqueue_entity(cfs_rq, se, flags);
/*
* end evaluation on encountering a throttled cfs_rq
*
* note: in the case of encountering a throttled cfs_rq we will
* post the final h_nr_running increment below.
*/
if (cfs_rq_throttled(cfs_rq))
break;
cfs_rq->h_nr_running++;
flags = ENQUEUE_WAKEUP;
}
for_each_sched_entity(se) {
cfs_rq = cfs_rq_of(se);
cfs_rq->h_nr_running++;
if (cfs_rq_throttled(cfs_rq))
break;
update_cfs_shares(cfs_rq);
update_entity_load_avg(se, 1);
}
if (!se) {
update_rq_runnable_avg(rq, rq->nr_running);
add_nr_running(rq, 1);
}
hrtick_update(rq);
}