linux 进程调度3

asmlinkage __visible void __sched schedule(void)
{
  struct task_struct *tsk = current;


  sched_submit_work(tsk);
  do {
    preempt_disable();
    __schedule(false);
    sched_preempt_enable_no_resched();
  } while (need_resched());
}

static void __sched notrace __schedule(bool preempt)
{
  struct task_struct *prev, *next;
  unsigned long *switch_count;
  struct rq_flags rf;
  struct rq *rq;
  int cpu;


  cpu = smp_processor_id();
  rq = cpu_rq(cpu);
  prev = rq->curr;
......
}

next = pick_next_task(rq, prev, &rf);
clear_tsk_need_resched(prev);
clear_preempt_need_resched();

static inline struct task_struct *
pick_next_task(struct rq *rq, struct task_struct *prev, struct rq_flags *rf)
{
  const struct sched_class *class;
  struct task_struct *p;
  /*
   * Optimization: we know that if all tasks are in the fair class we can call that function directly, but only if the @prev task wasn‘t of a higher scheduling class, because otherwise those loose the opportunity to pull in more work from other CPUs.
   */
  if (likely((prev->sched_class == &idle_sched_class ||
        prev->sched_class == &fair_sched_class) &&
       rq->nr_running == rq->cfs.h_nr_running)) {
    p = fair_sched_class.pick_next_task(rq, prev, rf);
    if (unlikely(p == RETRY_TASK))
      goto again;
    /* Assumes fair_sched_class->next == idle_sched_class */
    if (unlikely(!p))
      p = idle_sched_class.pick_next_task(rq, prev, rf);
    return p;
  }
again:
  for_each_class(class) {
    p = class->pick_next_task(rq, prev, rf);
    if (p) {
      if (unlikely(p == RETRY_TASK))
        goto again;
      return p;
    }
  }
}

static struct task_struct *
pick_next_task_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf)
{
  struct cfs_rq *cfs_rq = &rq->cfs;
  struct sched_entity *se;
  struct task_struct *p;
  int new_tasks;

    struct sched_entity *curr = cfs_rq->curr;
    if (curr) {
      if (curr->on_rq)
        update_curr(cfs_rq);
      else
        curr = NULL;
......
    }
    se = pick_next_entity(cfs_rq, curr);

  p = task_of(se);


  if (prev != p) {
    struct sched_entity *pse = &prev->se;
......
    put_prev_entity(cfs_rq, pse);
    set_next_entity(cfs_rq, se);
  }


  return p

if (likely(prev != next)) {
    rq->nr_switches++;
    rq->curr = next;
    ++*switch_count;
......
    rq = context_switch(rq, prev, next, &rf);

    注意

    进程调度与抢占的区别

    进程调度不一定发生抢占, 但是抢占时却一定发生了调度

    在进程发生调度时, 只有当前内核发生当前进程因为主动或者被动需要放弃CPU时, 内核才会选择一个与当前活动进程不同的进程来抢占CPU

/*
 * context_switch - switch to the new MM and the new thread‘s register state.
 */
static __always_inline struct rq *
context_switch(struct rq *rq, struct task_struct *prev,
           struct task_struct *next)
{
    struct mm_struct *mm, *oldmm;

    /*  完成进程切换的准备工作  */
    prepare_task_switch(rq, prev, next);

    mm = next->mm;
    oldmm = prev->active_mm;
    /*
     * For paravirt, this is coupled with an exit in switch_to to
     * combine the page table reload and the switch backend into
     * one hypercall.
     */
    arch_start_context_switch(prev);

    /*  如果next是内核线程，则线程使用prev所使用的地址空间
     *  schedule( )函数把该线程设置为懒惰TLB模式
     *  内核线程并不拥有自己的页表集(task_struct->mm = NULL)
     *  它使用一个普通进程的页表集
     *  不过，没有必要使一个用户态线性地址对应的TLB表项无效
     *  因为内核线程不访问用户态地址空间。
    */
    if (!mm)        /*  内核线程无虚拟地址空间, mm = NULL*/
    {
        /*  内核线程的active_mm为上一个进程的mm
         *  注意此时如果prev也是内核线程,
         *  则oldmm为NULL, 即next->active_mm也为NULL  */
        next->active_mm = oldmm;
        /*  增加mm的引用计数  */
        atomic_inc(&oldmm->mm_count);
        /*  通知底层体系结构不需要切换虚拟地址空间的用户部分
         *  这种加速上下文切换的技术称为惰性TBL  */
        enter_lazy_tlb(oldmm, next);
    }
    else            /*  不是内核线程, 则需要切切换虚拟地址空间  */
        switch_mm(oldmm, mm, next);

    /*  如果prev是内核线程或正在退出的进程
     *  就重新设置prev->active_mm
     *  然后把指向prev内存描述符的指针保存到运行队列的prev_mm字段中
     */
    if (!prev->mm)
    {
        /*  将prev的active_mm赋值和为空  */
        prev->active_mm = NULL;
        /*  更新运行队列的prev_mm成员  */
        rq->prev_mm = oldmm;
    }
    /*
     * Since the runqueue lock will be released by the next
     * task (which is an invalid locking op but in the case
     * of the scheduler it‘s an obvious special-case), so we
     * do an early lockdep release here:
     */
    lockdep_unpin_lock(&rq->lock);
    spin_release(&rq->lock.dep_map, 1, _THIS_IP_);

    /* Here we just switch the register state and the stack. 
     * 切换进程的执行环境, 包括堆栈和寄存器
     * 同时返回上一个执行的程序
     * 相当于prev = witch_to(prev, next)  */
    switch_to(prev, next, prev);

    /*  switch_to之后的代码只有在
     *  当前进程再次被选择运行(恢复执行)时才会运行
     *  而此时当前进程恢复执行时的上一个进程可能跟参数传入时的prev不同
     *  甚至可能是系统中任意一个随机的进程
     *  因此switch_to通过第三个参数将此进程返回
     */


    /*  路障同步, 一般用编译器指令实现
     *  确保了switch_to和finish_task_switch的执行顺序
     *  不会因为任何可能的优化而改变  */
    barrier();  

    /*  进程切换之后的处理工作  */
    return finish_task_switch(prev);
}

struct mm_struct *mm, *oldmm;

prepare_task_switch(rq, prev, next);    /*  完成进程切换的准备工作  */

/**
 * prepare_task_switch - prepare to switch tasks
 * @rq: the runqueue preparing to switch
 * @prev: the current task that is being switched out
 * @next: the task we are going to switch to.
 *
 * This is called with the rq lock held and interrupts off. It must
 * be paired with a subsequent finish_task_switch after the context
 * switch.
 *
 * prepare_task_switch sets up locking and calls architecture specific
 * hooks.
 */
static inline void
prepare_task_switch(struct rq *rq, struct task_struct *prev,
            struct task_struct *next)
{
    sched_info_switch(rq, prev, next);
    perf_event_task_sched_out(prev, next);
    fire_sched_out_preempt_notifiers(prev, next);
    prepare_lock_switch(rq, next);
    prepare_arch_switch(next);
}

/*  如果next是内核线程，则线程使用prev所使用的地址空间
 *  schedule( )函数把该线程设置为懒惰TLB模式
 *  内核线程并不拥有自己的页表集(task_struct->mm = NULL)
 *  它使用一个普通进程的页表集
 *  不过，没有必要使一个用户态线性地址对应的TLB表项无效
 *  因为内核线程不访问用户态地址空间。
*/
if (!mm)        /*  内核线程无虚拟地址空间, mm = NULL*/
{
    /*  内核线程的active_mm为上一个进程的mm
     *  注意此时如果prev也是内核线程,
     *  则oldmm为NULL, 即next->active_mm也为NULL  */
    next->active_mm = oldmm;
    /*  增加mm的引用计数  */
    atomic_inc(&oldmm->mm_count);
    /*  通知底层体系结构不需要切换虚拟地址空间的用户部分
     *  这种加速上下文切换的技术称为惰性TBL  */
    enter_lazy_tlb(oldmm, next);
}
else            /*  不是内核线程, 则需要切切换虚拟地址空间  */
    switch_mm(oldmm, mm, next);

/*
 * Saving eflags is important. It switches not only IOPL between tasks,
 * it also protects other tasks from NT leaking through sysenter etc.
*/
#define switch_to(prev, next, last)

 switch_to(prev, next, last);
 即
 prev = last = switch_to(prev, next);

/*
 * Saving eflags is important. It switches not only IOPL between tasks,
 * it also protects other tasks from NT leaking through sysenter etc.
 */
#define switch_to(prev, next, last)                                     do {                                                                            /*                                                                       * Context-switching clobbers all registers, so we clobber               * them explicitly, via unused output variables.                         * (EAX and EBP is not listed because EBP is saved/restored              * explicitly for wchan access and EAX is the return value of            * __switch_to())                                                        */                                                                     unsigned long ebx, ecx, edx, esi, edi;                                                                                                          asm volatile("pushfl\n\t" /* save flags 保存就的ebp、和flags寄存器到旧进程的内核栈中*/                        "pushl %%ebp\n\t"          /* save    EBP   */                          "movl %%esp,%[prev_sp]\n\t"        /* save ESP  将旧进程esp保存到thread_info结构中 */                      "movl %[next_sp],%%esp\n\t"        /* restore ESP 用新进程esp填写esp寄存器，此时内核栈已切换  */                      "movl $1f,%[prev_ip]\n\t"  /* save EIP 将该进程恢复执行时的下条地址保存到旧进程的thread中*/                          "pushl %[next_ip]\n\t"     /* restore EIP 将新进程的ip值压入到新进程的内核栈中 */                          __switch_canary                                                         "jmp __switch_to\n"        /* regparm call  */                          "1:\t"                                                                  "popl %%ebp\n\t"           /* restore EBP 该进程执行，恢复ebp寄存器*/                          "popfl\n"                  /* restore flags  恢复flags寄存器*/                                                                                                  /* output parameters */                                                 : [prev_sp] "=m" (prev->thread.sp),                                       [prev_ip] "=m" (prev->thread.ip),                                       "=a" (last),                                                                                                                                    /* clobbered output registers: */                                       "=b" (ebx), "=c" (ecx), "=d" (edx),                                     "=S" (esi), "=D" (edi)                                                                                                                          __switch_canary_oparam                                                                                                                          /* input parameters: */                                               : [next_sp]  "m" (next->thread.sp),                                       [next_ip]  "m" (next->thread.ip),                                                                                                               /* regparm parameters for __switch_to(): */                             [prev]     "a" (prev),                                                  [next]     "d" (next)                                                                                                                           __switch_canary_iparam                                                                                                                        : /* reloaded segment registers */                                         "memory");                                      } while (0)

/*  switch_to之后的代码只有在
 *  当前进程再次被选择运行(恢复执行)时才会运行
 *  而此时当前进程恢复执行时的上一个进程可能跟参数传入时的prev不同
 *  甚至可能是系统中任意一个随机的进程
 *  因此switch_to通过第三个参数将此进程返回
*/


/*  路障同步, 一般用编译器指令实现
 *  确保了switch_to和finish_task_switch的执行顺序
 *  不会因为任何可能的优化而改变  */
barrier();

/*  进程切换之后的处理工作  */
return finish_task_switch(prev);

// http://lxr.free-electrons.com/source/include/linux/compiler-gcc.h?v=4.6#L15
/* Copied from linux/compiler-gcc.h since we can‘t include it directly 
 * 采用内敛汇编实现
 *  __asm__用于指示编译器在此插入汇编语句
 *  __volatile__用于告诉编译器，严禁将此处的汇编语句与其它的语句重组合优化。
 *  即：原原本本按原来的样子处理这这里的汇编。
 *  memory强制gcc编译器假设RAM所有内存单元均被汇编指令修改，这样cpu中的registers和cache中已缓存的内存单元中的数据将作废。cpu将不得不在需要的时候重新读取内存中的数据。这就阻止了cpu又将registers，cache中的数据用于去优化指令，而避免去访问内存。
 *  "":::表示这是个空指令。barrier()不用在此插入一条串行化汇编指令。在后文将讨论什么叫串行化指令。
*/
#define barrier() __asm__ __volatile__("": : :"memory")

 1 /**
 2  * finish_task_switch - clean up after a task-switch
 3  * @prev: the thread we just switched away from.
 4  *
 5  * finish_task_switch must be called after the context switch, paired
 6  * with a prepare_task_switch call before the context switch.
 7  * finish_task_switch will reconcile locking set up by prepare_task_switch,
 8  * and do any other architecture-specific cleanup actions.
 9  *
10  * Note that we may have delayed dropping an mm in context_switch(). If
11  * so, we finish that here outside of the runqueue lock. (Doing it
12  * with the lock held can cause deadlocks; see schedule() for
13  * details.)
14  *
15  * The context switch have flipped the stack from under us and restored the
16  * local variables which were saved when this task called schedule() in the
17  * past. prev == current is still correct but we need to recalculate this_rq
18  * because prev may have moved to another CPU.
19  */
20 static struct rq *finish_task_switch(struct task_struct *prev)
21         __releases(rq->lock)
22 {
23         struct rq *rq = this_rq();
24         struct mm_struct *mm = rq->prev_mm;
25         long prev_state;
26 
27         /*
28          * The previous task will have left us with a preempt_count of 2
29          * because it left us after:
30          *
31          *      schedule()
32          *        preempt_disable();                    // 1
33          *        __schedule()
34          *          raw_spin_lock_irq(&rq->lock)        // 2
35          *
36          * Also, see FORK_PREEMPT_COUNT.
37          */
38         if (WARN_ONCE(preempt_count() != 2*PREEMPT_DISABLE_OFFSET,
39                       "corrupted preempt_count: %s/%d/0x%x\n",
40                       current->comm, current->pid, preempt_count()))
41                 preempt_count_set(FORK_PREEMPT_COUNT);
42 
43         rq->prev_mm = NULL;
44 
45         /*
46          * A task struct has one reference for the use as "current".
47          * If a task dies, then it sets TASK_DEAD in tsk->state and calls
48          * schedule one last time. The schedule call will never return, and
49          * the scheduled task must drop that reference.
50          *
51          * We must observe prev->state before clearing prev->on_cpu (in
52          * finish_lock_switch), otherwise a concurrent wakeup can get prev
53          * running on another CPU and we could rave with its RUNNING -> DEAD
54          * transition, resulting in a double drop.
55          */
56         prev_state = prev->state;
57         vtime_task_switch(prev);
58         perf_event_task_sched_in(prev, current);
59         finish_lock_switch(rq, prev);
60         finish_arch_post_lock_switch();
61 
62         fire_sched_in_preempt_notifiers(current);
63         if (mm)
64                 mmdrop(mm);
65         if (unlikely(prev_state == TASK_DEAD))  /*  如果上一个进程已经终止，释放其task_struct 结构  */
66         {
67                 if (prev->sched_class->task_dead)
68                         prev->sched_class->task_dead(prev);
69 
70                 /*
71                  * Remove function-return probe instances associated with this
72                  * task and put them back on the free list.
73                  */
74                 kprobe_flush_task(prev);
75                 put_task_struct(prev);
76         }
77 
78         tick_nohz_task_switch();
79         return rq;
80 }