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

---

搜索关注【嵌入式小生】wx公众号获取更多精彩内容>>>>