linux进程的管理与调度 --- wake_up_process

如下为唤醒进程的API，执行内容如下：

• 给待唤醒进程选择一个合适的CPU
• 将待唤醒进程放入选定CPU的运行队列，每个CPU都有一个运行队列
• 判断当前进程是否应该被待唤醒进程抢占，如果应该，置位当前进程的 TIF_NEED_RESCHED 标志

int wake_up_process(struct task_struct *p) // 入参为待唤醒的进程
{
    return try_to_wake_up(p, TASK_NORMAL, 0);
}

#define TASK_NORMAL         (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)

 

struct task_struct 的成员变量 on_rq 一共有三个取值，0（进程不再允许）、TASK_ON_RQ_QUEUED（进程已经在某个CPU的运行队列）、TASK_ON_RQ_MIGRATING（为了CPU之间的负载均衡，进程正在从一个CPU的运行队列迁移到另个CPU的运行队列）

struct thread_info 的成员变量 cpu 指示进程是在哪个CPU上运行

static int
try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
{
    unsigned long flags;
    int cpu, success = 0;

    preempt_disable();
    if (p == current) { // 待唤醒的进程为当前进程

        if (!ttwu_state_match(p, state, &success))
            goto out; // 待唤醒的进程为非阻塞态（比如运行态）

        trace_sched_waking(p);
        WRITE_ONCE(p->__state, TASK_RUNNING); // 待唤醒的进程为阻塞态，改为运行态
        trace_sched_wakeup(p);
        goto out;
    }

    raw_spin_lock_irqsave(&p->pi_lock, flags);
    smp_mb__after_spinlock();
    if (!ttwu_state_match(p, state, &success))
        goto unlock; // 待唤醒的进程为非阻塞态（比如运行态）

    trace_sched_waking(p);

    smp_rmb();
    if (READ_ONCE(p->on_rq) && ttwu_runnable(p, wake_flags))
        goto unlock; // 待唤醒的进程在某一个CPU的运行队列

#ifdef CONFIG_SMP

    smp_acquire__after_ctrl_dep();

    WRITE_ONCE(p->__state, TASK_WAKING);

    if (smp_load_acquire(&p->on_cpu) &&
        ttwu_queue_wakelist(p, task_cpu(p), wake_flags | WF_ON_CPU))
        goto unlock;

    smp_cond_load_acquire(&p->on_cpu, !VAL);

    // 给唤醒的进程选择一个合适的处理器
    cpu = select_task_rq(p, p->wake_cpu, wake_flags | WF_TTWU);
    if (task_cpu(p) != cpu) {
        if (p->in_iowait) {
            delayacct_blkio_end(p);
            atomic_dec(&task_rq(p)->nr_iowait);
        }

        wake_flags |= WF_MIGRATED;
        psi_ttwu_dequeue(p);
        set_task_cpu(p, cpu);
    }
#else
    cpu = task_cpu(p);
#endif /* CONFIG_SMP */

    ttwu_queue(p, cpu, wake_flags); // 将待唤醒的进程加入到CFS就绪队列中
unlock:
    raw_spin_unlock_irqrestore(&p->pi_lock, flags);
out:
    if (success)
        ttwu_stat(p, task_cpu(p), wake_flags);
    preempt_enable();

    return success;
}

static void ttwu_queue(struct task_struct *p, int cpu, int wake_flags)
{
    struct rq *rq = cpu_rq(cpu);
    struct rq_flags rf;

    if (ttwu_queue_wakelist(p, cpu, wake_flags))
        return;

    rq_lock(rq, &rf);
    update_rq_clock(rq);
    ttwu_do_activate(rq, p, wake_flags, &rf);
    rq_unlock(rq, &rf);
}

static void
ttwu_do_activate(struct rq *rq, struct task_struct *p, int wake_flags,
         struct rq_flags *rf)
{
    int en_flags = ENQUEUE_WAKEUP | ENQUEUE_NOCLOCK;

    lockdep_assert_rq_held(rq);

    if (p->sched_contributes_to_load)
        rq->nr_uninterruptible--;

#ifdef CONFIG_SMP
    if (wake_flags & WF_MIGRATED)
        en_flags |= ENQUEUE_MIGRATED;
    else
#endif
    if (p->in_iowait) {
        delayacct_blkio_end(p);
        atomic_dec(&task_rq(p)->nr_iowait);
    }

    activate_task(rq, p, en_flags); // 将待唤醒的进程加入CFS就绪队列中，也就是将进程调度实体加入红黑树中
    ttwu_do_wakeup(rq, p, wake_flags, rf); // 检查待唤醒的进程是否应该发生抢占
}

void activate_task(struct rq *rq, struct task_struct *p, int flags)
{
    enqueue_task(rq, p, flags);

    p->on_rq = TASK_ON_RQ_QUEUED;
}

static inline void enqueue_task(struct rq *rq, struct task_struct *p, int flags)
{
    if (!(flags & ENQUEUE_NOCLOCK))
        update_rq_clock(rq);

    if (!(flags & ENQUEUE_RESTORE)) {
        sched_info_enqueue(rq, p);
        psi_enqueue(p, flags & ENQUEUE_WAKEUP);
    }

    uclamp_rq_inc(rq, p);
    p->sched_class->enqueue_task(rq, p, flags);

    if (sched_core_enabled(rq))
        sched_core_enqueue(rq, p);
}

 

DEFINE_SCHED_CLASS(fair) = {

    .enqueue_task        = enqueue_task_fair,
    .dequeue_task        = dequeue_task_fair,
    .yield_task        = yield_task_fair,

 

static void ttwu_do_wakeup(struct rq *rq, struct task_struct *p, int wake_flags,
               struct rq_flags *rf)
{
    check_preempt_curr(rq, p, wake_flags);
    WRITE_ONCE(p->__state, TASK_RUNNING);
    trace_sched_wakeup(p);
}

 

void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags)
{
    if (p->sched_class == rq->curr->sched_class)
        rq->curr->sched_class->check_preempt_curr(rq, p, flags);
    else if (p->sched_class > rq->curr->sched_class)
        resched_curr(rq);

    /*
     * A queue event has occurred, and we're going to schedule.  In
     * this case, we can save a useless back to back clock update.
     */
    if (task_on_rq_queued(rq->curr) && test_tsk_need_resched(rq->curr))
        rq_clock_skip_update(rq);
}

 

DEFINE_SCHED_CLASS(fair) = {
    .check_preempt_curr    = check_preempt_wakeup,

 

/*
 * Preempt the current task with a newly woken task if needed:
 */
static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
{
    (1)
    //获取当前处理器运行队列正在运行的进程：rq->curr 
    struct task_struct *curr = rq->curr;
    (2)
    //获取当前处理器运行队列正在运行的进程调度实体：&curr->se
    //获取唤醒进程的调度实体&p->se
    struct sched_entity *se = &curr->se, *pse = &p->se;
    struct cfs_rq *cfs_rq = task_cfs_rq(curr);
    int scale = cfs_rq->nr_running >= sched_nr_latency;

    if (test_tsk_need_resched(curr))
        return;

    (3)
    //如果当前任务是空闲进程，那么唤醒的进程就应该发起抢占，因为空闲进程的优先级最低
    /* Idle tasks are by definition preempted by non-idle tasks. */
    if (unlikely(curr->policy == SCHED_IDLE) &&
        likely(p->policy != SCHED_IDLE))
        goto preempt;

    /*
     * Batch and idle tasks do not preempt non-idle tasks (their preemption
     * is driven by the tick):
     */
    if (unlikely(p->policy != SCHED_NORMAL) || !sched_feat(WAKEUP_PREEMPTION))
        return;

    //与任务调度组有关：CONFIG_FAIR_GROUP_SCHED
    find_matching_se(&se, &pse);
    (4)
    //更行当前处理器正在运行进程的 vruntime
    update_curr(cfs_rq_of(se));
    BUG_ON(!pse);
    (5)
    // 调用wakeup_preempt_entity判断唤醒的进程是否发生抢占
　　 // 这里调用wakeup_preempt_entity函数计算是否将当前正在运行的进程标记为应该被抢占时，如果当前处理器正在运行的进程的 vruntime 大于唤醒进程的 vruntime，不
　　 // 是直接就确定将当前正在运行的进程标记为应该被抢占，而是增加了一个时间缓冲，如果唤醒的进程 vruntime 加上进程最小运行时间（sysctl_sched_wakeup_granularity = 1ms转化为虚拟时间）
　　 // 仍然小于当前处理器正在运行的进程的 vruntime，那么就确定当前处理器正在运行的进程应该被抢占，增加一个时间缓冲避免进程切换过于频繁，花费过多的时间在上下文切换中。

    if (wakeup_preempt_entity(se, pse) == 1) {
        /*
         * Bias pick_next to pick the sched entity that is
         * triggering this preemption.
         */
        if (!next_buddy_marked)
            set_next_buddy(pse);
        //唤醒的进程应该发起抢占
        goto preempt;
    }

    return;

    (6)
    //将当前进程标记为应该被抢占
　　 // 注意这里只是当前进程标记为应该被抢占，请求重新调度，但是真正的抢占动作并没有发生。
　　 // resched_task将进程的struct thread_info的flags成员设置为：TIF_NEED_RESCHED
preempt:
    resched_task(curr);
    /*
     * Only set the backward buddy when the current task is still
     * on the rq. This can happen when a wakeup gets interleaved
     * with schedule on the ->pre_schedule() or idle_balance()
     * point, either of which can * drop the rq lock.
     *
     * Also, during early boot the idle thread is in the fair class,
     * for obvious reasons its a bad idea to schedule back to it.
     */
    if (unlikely(!se->on_rq || curr == rq->idle))
        return;

    if (sched_feat(LAST_BUDDY) && scale && entity_is_task(se))
        set_last_buddy(se);
}