【linux kernel】linux内核如何唤醒线程

//本文代码片段出自linux内核版本：4.1.15

linux内核唤醒线程主要使用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;

	
	smp_mb__before_spinlock();
	raw_spin_lock_irqsave(&p->pi_lock, flags);
	if (!(p->state & state))
		goto out;

	success = 1; 
	cpu = task_cpu(p);

    
	if (p->on_rq && ttwu_remote(p, wake_flags))
		goto stat;

#ifdef CONFIG_SMP
    
	while (p->on_cpu)
		cpu_relax();
	
	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);
	
	cpu = select_task_rq(p, p->wake_cpu, SD_BALANCE_WAKE, wake_flags);
    
	if (task_cpu(p) != cpu) {
		wake_flags |= WF_MIGRATED;
		set_task_cpu(p, cpu);
	}
#endif 
	
	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()函数定义如下：

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); 
		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 (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算法、内存屏障机制的实现机制和思路。

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

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

站在巨人的肩膀上

【1】https://www.freesion.com/article/623242533/