深入理解Linux内核之进程唤醒

Posted 2021-09-09 宋宝华

1.开场白

环境：

• 处理器架构：arm64

• 内核源码：linux-5.10.50

• ubuntu版本：20.04.1

• 代码阅读工具：vim+ctags+cscope

前面文章，我们介绍了进程是如何睡眠，本文来揭开进程唤醒的神秘面纱。

进程睡眠主要内容如下：

 2.应用场景

 3.选择cpu

 4.加入运行队列

 5.唤醒抢占

      5.1 抢占条件

      5.2 本地cpu

      5.3 远程cpu

6.总结

2.应用场景

进程唤醒主要应用场景如下：

• fork的时候唤醒子进程 

• exec的时候唤醒进程 

• 睡眠超时唤醒 

• 睡眠锁释放唤醒 

• IO读写完成唤醒 

• 其他正常的唤醒路径

注：应用场景在此不再分析，感兴趣的小伙伴可以自行查阅内核源代码！

主要的调用链：

//kernel/sched/core.c


wake_up_process
->try_to_wake_up(p, TASK_NORMAL, 0)
    ->if (!(p->state & state))  //判断是否为特定状态的进程 
        goto unlock;
       ...
    cpu = select_task_rq(p, p->wake_cpu, SD_BALANCE_WAKE, wake_flags); //选择合适的cpu
    ...
     ttwu_queue(p, cpu, wake_flags)
     ->ttwu_do_activate
        ->int en_flags = ENQUEUE_WAKEUP | ENQUEUE_NOCLOCK;
        if (wake_flags & WF_MIGRATED)
              en_flags |= ENQUEUE_MIGRATED;

         activate_task(rq, p, en_flags);
         ->enqueue_task(rq, p, flags)  //加入运行队列
            ->p->sched_class->enqueue_task(rq, p, flags)
           -> p->on_rq = TASK_ON_RQ_QUEUED
         ttwu_do_wakeup(rq, p, wake_flags, rf)
        ->check_preempt_curr(rq, p, wake_flags); //唤醒抢占
        -> p->state = TASK_RUNNING; //设置运行状态

进程唤醒的主要调用链如上：会唤醒特定状态的进程（wake_up_process唤醒三种睡眠状态的进程，睡眠文章已经讲到），然后选择一个合适的cpu，接着会加入到cpu的运行队列以及进行唤醒抢占操作（这里还会有很多防止并发访问的自旋锁、关抢占、内存屏障等操作，大家自行研究）。

3.选择cpu

选择cpu实际上是为唤醒的进程选择运行队列，根据不同的应用场景会有不同的选择算法：如EAS调度器选择最节能的cpu、wake_addine特性尽可能运行在唤醒cpu、选择最空闲的cpu等。

对于cfs调度类, 选择最空闲的cpu如下：

try_to_wake_up
->select_task_rq
    ->cpu = p->sched_class->select_task_rq
        ->select_task_rq_fair  //kernel/sched/fair.c
            ->find_idlest_cpu
                ->group = find_idlest_group(sd, p, cpu)  //调度域中选择 最空闲的调度组
                 ->new_cpu = find_idlest_group_cpu(group, p, cpu) //调度组中选择最空闲的cpu

4.加入运行队列

上面已经选择了一个合适的cpu，现在就需要将唤醒的进程加入到cpu的运行队列。

调用链如下：

try_to_wake_up
->ttwu_queue
    ->ttwu_do_activate
        ->int en_flags = ENQUEUE_WAKEUP | ENQUEUE_NOCLOCK;  
       -> if (wake_flags & WF_MIGRATED)
              en_flags |= ENQUEUE_MIGRATED;
      ->activate_task(rq, p, en_flags)
                ->enqueue_task(rq, p, flags);
                    -> p->sched_class->enqueue_task(rq, p, flags);  //调用调度类的入队回调函数
                        ->enqueue_task_fair  //cfs类的入队回调
                p->on_rq = TASK_ON_RQ_QUEUED;  //设置进程描述符的on_rq 为入队标志 标识进程加入到了运行队列

对于cfs调度类的进程会最终通过enqueue_task_fair加入到cpu的cfs运行队列。

enqueue_entity
->if (!curr)
        __enqueue_entity(cfs_rq, se) //加入cfs红黑树
->se->on_rq = 1;  //设置调度实体的on_rq为1

5.唤醒抢占

唤醒的进程可能优先级比较高，在唤醒的时候就需要检查是否可以抢占当前进程（如实时进程抢占当前普通cfs进程、优先级高的普通cfs进程抢占优先级低的普通cfs进程、普通cfs进程抢占idle进程等）。

调用链如下：

try_to_wake_up
->ttwu_queue
    ->ttwu_do_activate
        ->check_preempt_curr(rq, p, wake_flags)
            ->if (p->sched_class == rq->curr->sched_class)  //如果进程的调度类等于运行队列当前进程的调度类
                    rq->curr->sched_class->check_preempt_curr(rq, p, flags);  //调用curr进程调度类的check_preempt_curr方法进行唤醒抢占处理
                    ->check_preempt_wakeup,  //对于cfs调度类的进程调用check_preempt_wakeup
            else if (p->sched_class > rq->curr->sched_class)  //如果进程的调度类大于运行队列当前进程的调度类
                    resched_curr(rq); //抢占当前进程

唤醒抢占处理会分为两种情况：

• 如果进程的调度类等于运行队列当前进程的调度类，则调用curr进程调度类的check_preempt_curr方法进行唤醒抢占处理，对于cfs调度类的进程调用check_preempt_wakeup 。

• 如果进程的调度类大于运行队列当前进程的调度类，抢占当前进程。

5.1 抢占条件

对于cfs调度类的进程：

抢占处理调用链如下：

check_preempt_wakeup  //kernel/sched/fair.c
-> 
    struct task_struct *curr = rq->curr;
    struct sched_entity *se = &curr->se, *pse = &p->se;
    struct cfs_rq *cfs_rq = task_cfs_rq(curr);

    if (unlikely(se == pse))  //如果是运行队列的当前调度实体和当前进程的调度实体相同，直接返回不进行抢占处理
                return;
        if (test_tsk_need_resched(curr))  //已经设置了重新调度标志直接返回不进行抢占处理
                return;
        if (unlikely(task_has_idle_policy(curr)) &&   //运行队列的当前进程是idle，唤醒的进程不是idle进程，进行抢占处理
        ¦   likely(!task_has_idle_policy(p)))
                goto preempt;
         if (unlikely(p->policy != SCHED_NORMAL) || !sched_feat(WAKEUP_PREEMPTION))  //对于批处理进程和没有打开唤醒抢占特性的情况直接返回不进行抢占处理
                 return;

         find_matching_se(&se, &pse);  //寻找匹配的调度实体（如果se和pse不是同一个层级任务组， 让se和pse处于同一调度组，一般都属于根任务组）
         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;

         preempt:
                 resched_curr(rq); //抢占处理

唤醒抢占中，会做一些基本的判断，如唤醒进程是否是运行队列当前进程、是否已经设置了重新调度标志、抢占idle进程处理等，然后调整唤醒进程的调度实体和运行队列当前进程调度实体在同一层次任务组中，最后进行关键的唤醒抢占条件判断，满足条件则进行唤醒抢占处理。

下面看下比较关键的抢占条件判断：

    static int
wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
{
        s64 gran, vdiff = curr->vruntime - se->vruntime; //计算当前进程虚拟运行时间和唤醒进程虚拟运行时间的差值

        if (vdiff <= 0) //唤醒进程的虚拟运行时间较大  返回-1表示不可抢占
                return -1;

        gran = wakeup_gran(se);  //计算抢占粒度转换的虚拟运行时间
        if (vdiff > gran)  //唤醒进程的虚拟运行时间要小 且差值比抢占粒度转换的虚拟运行时间还大  返回1表示可以抢占
                return 1;

        return 0;  //vdiff <= gran  的情况，返回0
}

这里会有三种情况：

• 唤醒进程的虚拟运行时间较大  返回-1表示不可抢占。

• 唤醒进程的虚拟运行时间较小，且差值大于抢占粒度转换的虚拟运行时间， 返回1表示可以抢占。

• 唤醒进程的虚拟运行时间较小，但是差值小于等于抢占粒度转换的虚拟运行时间，返回0。

下面来看下抢占粒度的计算：

unsigned int sysctl_sched_wakeup_granularity                    = 1000000UL;

wakeup_gran
->unsigned long gran = sysctl_sched_wakeup_granularity;
   return calc_delta_fair(gran, se);

可以看到可调参数sysctl_sched_wakeup_granularity默认值为1ms（可以通过/proc/sys/kernel/sched_wakeup_granularity_ns调节），然后转换为虚拟运行时间。

接下来看下抢占操作：resched_curr。

5.2 抢占本地cpu

kernel/sched/core.c

resched_curr
-> struct task_struct *curr = rq->curr;  //获得运行队列当前进程
    if (test_tsk_need_resched(curr)) //判断是否已经设置重新调度标志
            return;

    cpu = cpu_of(rq); //获得运行队列的cpu

    if (cpu == smp_processor_id()) { //是当前cpu
            set_tsk_need_resched(curr); //设置重新调度标志
            set_preempt_need_resched(); //设置抢占重新调度标志
            return;
    }

如果唤醒进程的cpu是本地cpu,则直接设置重新调度标志和抢占重新调度标志即可，具体设置如下：

set_tsk_need_resched
->set_tsk_thread_flag(tsk,TIF_NEED_RESCHED)
    ->set_ti_thread_flag(task_thread_info(tsk), flag)
        ->set_bit(flag, (unsigned long *)&ti->flags)   //即是设置task->thread_info->flags = TIF_NEED_RESCHED
        
 set_preempt_need_resched
 ->current_thread_info()->preempt.need_resched = 0;  //arch/arm64/include/asm/preempt.h  //设置task->thread_info->preempt.need_resched = 0

5.3 抢占远程cpu

唤醒的进程可能运行在远程的cpu上，这个时候我们需要发送IPI中断，让远程cpu重新调度。

调用链如下：

resched_curr
-> if (set_nr_and_not_polling(curr))  //设置task->thread_info->flags = TIF_NEED_RESCHED
    smp_send_reschedule
    -> smp_cross_call(cpumask_of(cpu), IPI_RESCHEDULE);    arch/arm64/kernel/smp.c
    
    
//ipi处理  arch/arm64/kernel/smp.c
 do_handle_IPI
 -> case IPI_RESCHEDULE:
         scheduler_ipi();
    ->preempt_fold_need_resched();
          ->do { \\
                if (tif_need_resched()) \\
                        set_preempt_need_resched(); \\   //设置task->thread_info->preempt.need_resched = 0
        } while (0)

可以看到，对于远程的cpu的重新调度和本地cpu就不一样，本地cpu直接设置了两个标志即可，而远程需要发生ipi触发处理器间中断将TIF_NEED_RESCHED标志折叠到preempt_count中（即设置task->thread_info->preempt.need_resched = 0），这是因为本地cpu一定不是idle状态（因为本地cpu正在做唤醒操作），而远程cpu可能处于idle状态，需要发生ipi来唤醒远程cpu处理重新调度（在中断处理返回内核态前夕就可以发生调度了）。

resched_curr主要用于设置重新调度标志和抢占重新调度标志，会考虑是本地cpu还是远程cpu的情况，并不是发生调度，需要等到最近的调度点到来时发生调度（可能是重新开启抢占的时候，也可能是中断返回前夕，见之前讲解到的内核抢占相关文章）。

6.总结

进程唤醒主要步骤如下：

• 根据不同的应用场景选择合适的目标cpu，这里会调用select_task_rq回调，如选择最空闲的cpu。 

• 将唤醒进程加入到目标cpu的运行队列，这里会调用到调度enqueue_task回调,如加入cfs的红黑树。 

• 唤醒抢占处理，被唤醒的高优先级进程可以抢占当前进程。最后，需要注意的是，唤醒的进程并不会马上获得cpu, 需要等到最近的调度点到来时发生调度。