1. asmlinkage void __sched schedule(void)
2. {
3. struct task_struct *prev, *next;
4. unsigned long *switch_count;
5. struct rq *rq;
6. int cpu;
7. need_resched:
8. preempt_disable();
9. cpu = smp_processor_id(); /* 获取当前cpu */
10. rq = cpu_rq(cpu);  /* 得到指定cpu的rq */
11. rcu_sched_qs(cpu);
12. prev = rq->curr;  /* 当前的运行进程 */
13. switch_count = &prev->nivcsw;  /* 进程切换计数 */
14. release_kernel_lock(prev);
15. need_resched_nonpreemptible:
16. schedule_debug(prev);
17. if (sched_feat(HRTICK))
18. hrtick_clear(rq);
19. spin_lock_irq(&rq->lock);
20. update_rq_clock(rq);  /* 更新rq的clock属性 */
21. clear_tsk_need_resched(prev);  /* 清楚prev进程的调度位 */
22. if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
23. if (unlikely(signal_pending_state(prev->state, prev)))
24. prev->state = TASK_RUNNING;
25. else  /* 从运行队列中删除prev进程,根据调度类的不同实现不同，
26. 对CFS，deactivate_task调用dequeue_task_fair完成进程删除 */
27. deactivate_task(rq, prev, 1);
28. switch_count = &prev->nvcsw;
29. }
30. pre_schedule(rq, prev);  /* 现只对实时进程有用 */
31. if (unlikely(!rq->nr_running))
32. idle_balance(cpu, rq);
33. put_prev_task(rq, prev); /* 将切换出去进程插到队尾 */
34. next = pick_next_task(rq); /* 选择下一个要运行的进程 */
35. if (likely(prev != next)) {
36. sched_info_switch(prev, next); /* 更新进程的相关调度信息 */
37. perf_event_task_sched_out(prev, next, cpu);
38. rq->nr_switches++; /* 切换次数记录 */
39. rq->curr = next;
40. ++*switch_count;
41. /* 进程上下文切换 */
42. context_switch(rq, prev, next); /* unlocks the rq */
43. /*
44. * the context switch might have flipped the stack from under
45. * us, hence refresh the local variables.
46. */
47. cpu = smp_processor_id();
48. rq = cpu_rq(cpu);
49. } else
50. spin_unlock_irq(&rq->lock);
51. post_schedule(rq); /* 对于实时进程有用到 */
52. if (unlikely(reacquire_kernel_lock(current) < 0))
53. goto need_resched_nonpreemptible;
54. preempt_enable_no_resched();
55. if (need_resched())
56. goto need_resched;
57. }
58. EXPORT_SYMBOL(schedule);

1. static void deactivate_task(struct rq *rq, struct task_struct *p, int sleep)
2. {
3. if (task_contributes_to_load(p))
4. rq->nr_uninterruptible++;
5. dequeue_task(rq, p, sleep); /* 具体操作 */
6. dec_nr_running(rq); /* rq中当前进程的运行数减一 */
7. }
8. static void dequeue_task(struct rq *rq, struct task_struct *p, int sleep)
9. {
10. if (sleep) { /* 如果sleep不为0，更新调度实体se中的相关变量 */
11. if (p->se.last_wakeup) {
12. update_avg(&p->se.avg_overlap,
13. p->se.sum_exec_runtime - p->se.last_wakeup);
14. p->se.last_wakeup = 0;
15. } else {
16. update_avg(&p->se.avg_wakeup,
17. sysctl_sched_wakeup_granularity);
18. }
19. }
20. /* 更新进程的sched_info数据结构中相关属性 */
21. sched_info_dequeued(p);
22. /* 调用具体调度类的函数从它的运行队列中删除 */
23. p->sched_class->dequeue_task(rq, p, sleep);
24. p->se.on_rq = 0;
25. }

1. static inline struct task_struct *
2. pick_next_task(struct rq *rq)
3. {
4. const struct sched_class *class;
5. struct task_struct *p;
6. /*
7. * Optimization: we know that if all tasks are in
8. * the fair class we can call that function directly:
9. */
10. if (likely(rq->nr_running == rq->cfs.nr_running)) {
11. p = fair_sched_class.pick_next_task(rq);
12. if (likely(p))
13. return p;
14. }
15. class = sched_class_highest;
16. for ( ; ; ) { /* 对每一个调度类 */
17. /* 调用该调度类中的函数，找出下一个task */
18. p = class->pick_next_task(rq);
19. if (p)
20. return p;
21. /*
22. * Will never be NULL as the idle class always
23. * returns a non-NULL p:
24. */
25. class = class->next; /* 访问下一个调度类 */
26. }
27. }

1. static inline void
2. __sched_info_switch(struct task_struct *prev, struct task_struct *next)
3. {
4. struct rq *rq = task_rq(prev);
5. /*
6. * prev now departs the cpu.  It's not interesting to record
7. * stats about how efficient we were at scheduling the idle
8. * process, however.
9. */
10. if (prev != rq->idle)  /* 如果被切换出去的进程不是idle进程 */
11. sched_info_depart(prev);  /* 更新prev进程和他对应rq的相关变量 */
12. if (next != rq->idle)  /* 如果切换进来的进程不是idle进程 */
13. sched_info_arrive(next);  /* 更新next进程和对应队列的相关变量 */
14. }
15. static inline void sched_info_depart(struct task_struct *t)
16. {
17. /* 计算进程在rq中运行的时间长度 */
18. unsigned long long delta = task_rq(t)->clock -
19. t->sched_info.last_arrival;
20. /* 更新RunQueue中的Task所得到CPU执行时间的累加值 */
21. rq_sched_info_depart(task_rq(t), delta);
22. /* 如果被切换出去进程的状态是运行状态
23. 那么将进程sched_info.last_queued设置为rq的clock
24. last_queued为最后一次排队等待运行的时间 */
25. if (t->state == TASK_RUNNING)
26. sched_info_queued(t);
27. }
28. static void sched_info_arrive(struct task_struct *t)
29. {
30. unsigned long long now = task_rq(t)->clock, delta = 0;
31. if (t->sched_info.last_queued) /* 如果被切换进来前在运行进程中排队 */
32. delta = now - t->sched_info.last_queued; /* 计算排队等待的时间长度 */
33. sched_info_reset_dequeued(t);  /* 因为进程将被切换进来运行，设定last_queued为0 */
34. t->sched_info.run_delay += delta; /* 更新进程在运行队列里面等待的时间 */
35. t->sched_info.last_arrival = now; /* 更新最后一次运行的时间 */
36. t->sched_info.pcount++; /* cpu上运行的次数加一 */
37. /* 更新rq中rq_sched_info中的对应的变量 */
38. rq_sched_info_arrive(task_rq(t), delta);
39. }

1. static inline void
2. context_switch(struct rq *rq, struct task_struct *prev,
3. struct task_struct *next)
4. {
5. struct mm_struct *mm, *oldmm;
6. prepare_task_switch(rq, prev, next);
7. trace_sched_switch(rq, prev, next);
8. mm = next->mm;
9. oldmm = prev->active_mm;
10. /*
11. * For paravirt, this is coupled with an exit in switch_to to
12. * combine the page table reload and the switch backend into
13. * one hypercall.
14. */
15. arch_start_context_switch(prev);
16. if (unlikely(!mm)) { /* 如果被切换进来的进程的mm为空 */
17. next->active_mm = oldmm; /* 将共享切换出去进程的active_mm */
18. atomic_inc(&oldmm->mm_count); /* 有一个进程共享，所有引用计数加一 */
19. /* 将per cpu变量cpu_tlbstate状态设为LAZY */
20. enter_lazy_tlb(oldmm, next);
21. } else  /* 如果mm不为空，那么进行mm切换 */
22. switch_mm(oldmm, mm, next);
23. if (unlikely(!prev->mm)) {  /* 如果切换出去的mm为空，从上面
24. 可以看出本进程的active_mm为共享先前切换出去的进程
25. 的active_mm,所有需要在这里置空 */
26. prev->active_mm = NULL;
27. rq->prev_mm = oldmm; /* 更新rq的前一个mm结构 */
28. }
29. /*
30. * Since the runqueue lock will be released by the next
31. * task (which is an invalid locking op but in the case
32. * of the scheduler it's an obvious special-case), so we
33. * do an early lockdep release here:
34. */
35. #ifndef __ARCH_WANT_UNLOCKED_CTXSW
36. spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
37. #endif
38. /* 这里切换寄存器状态和栈 */
39. switch_to(prev, next, prev);
40. barrier();
41. /*
42. * this_rq must be evaluated again because prev may have moved
43. * CPUs since it called schedule(), thus the 'rq' on its stack
44. * frame will be invalid.
45. */
46. finish_task_switch(this_rq(), prev);
47. }

1. static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
2. struct task_struct *tsk)
3. {
4. unsigned cpu = smp_processor_id();
5. if (likely(prev != next)) {
6. #ifdef CONFIG_SMP
7. /* 设置per cpu变量tlb */
8. percpu_write(cpu_tlbstate.state, TLBSTATE_OK);
9. percpu_write(cpu_tlbstate.active_mm, next);
10. #endif
11. /* 将要被调度运行进程拥有的内存描述结构
12. 的CPU掩码中当前处理器号对应的位码设置为1 */
13. cpumask_set_cpu(cpu, mm_cpumask(next));
14. /* Re-load page tables */
15. load_cr3(next->pgd); /* 将切换进来进程的pgd load到cr3寄存器 */
16. /* 将被替换进程使用的内存描述结构的CPU
17. 掩码中当前处理器号对应的位码清0 */
18. cpumask_clear_cpu(cpu, mm_cpumask(prev));
19. /*
20. * load the LDT, if the LDT is different:
21. */
22. if (unlikely(prev->context.ldt != next->context.ldt))
23. load_LDT_nolock(&next->context);
24. }
25. #ifdef CONFIG_SMP
26. else { /* 如果切换的两个进程相同 */
27. percpu_write(cpu_tlbstate.state, TLBSTATE_OK);
28. BUG_ON(percpu_read(cpu_tlbstate.active_mm) != next);
29. if (!cpumask_test_and_set_cpu(cpu, mm_cpumask(next))) {
30. /* We were in lazy tlb mode and leave_mm disabled
31. * tlb flush IPI delivery. We must reload CR3
32. * to make sure to use no freed page tables.
33. */
34. load_cr3(next->pgd);
35. load_LDT_nolock(&next->context);
36. }
37. }
38. #endif
39. }

1. #define switch_to(prev, next, last)                 \
2. do {                                    \
3. /*                              \
4. * Context-switching clobbers all registers, so we clobber  \
5. * them explicitly, via unused output variables.        \
6. * (EAX and EBP is not listed because EBP is saved/restored \
7. * explicitly for wchan access and EAX is the return value of   \
8. * __switch_to())                       \
9. */                             \
10. unsigned long ebx, ecx, edx, esi, edi;              \
11. \
12. asm volatile("pushfl\n\t"       /* save    flags */ \
13. "pushl %%ebp\n\t"      /* save    EBP   */ \
14. "movl %%esp,%[prev_sp]\n\t"    /* save    ESP   */ \
15. "movl %[next_sp],%%esp\n\t"    /* restore ESP   */ \
16. "movl $1f,%[prev_ip]\n\t"  /* save    EIP   */ \
17. /* 将next_ip入栈，下面用jmp跳转，这样
18. 返回到标号1时就切换过来了 */
19. "pushl %[next_ip]\n\t" /* restore EIP   */ \
20. __switch_canary                    \
21. "jmp __switch_to\n"    /* 跳转到C函数__switch_to，执行完后返回到下面的标号1处 */  \
22. "1:\t"                     \
23. "popl %%ebp\n\t"       /* restore EBP   */ \
24. "popfl\n"          /* restore flags */ \
25. \
26. /* output parameters */                \
27. : [prev_sp] "=m" (prev->thread.sp),     \
28. [prev_ip] "=m" (prev->thread.ip),     \
29. "=a" (last),                 \
30. \
31. /* clobbered output registers: */        \
32. "=b" (ebx), "=c" (ecx), "=d" (edx),      \
33. "=S" (esi), "=D" (edi)               \
34. \
35. __switch_canary_oparam               \
36. \
37. /* input parameters: */              \
38. : [next_sp]  "m" (next->thread.sp),     \
39. [next_ip]  "m" (next->thread.ip),     \
40. \
41. /* regparm parameters for __switch_to(): */  \
42. [prev]     "a" (prev),               \
43. [next]     "d" (next)                \
44. \
45. __switch_canary_iparam               \
46. \
47. : /* reloaded segment registers */         \
48. "memory");                  \
49. } while (0)

1. __notrace_funcgraph struct task_struct *
2. __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
3. {
4. struct thread_struct *prev = &prev_p->thread,
5. *next = &next_p->thread;
6. int cpu = smp_processor_id();
7. /* init_tss为一个per cpu变量 */
8. struct tss_struct *tss = &per_cpu(init_tss, cpu);
9. bool preload_fpu;
10. /* never put a printk in __switch_to... printk() calls wake_up*() indirectly */
11. /*
12. * If the task has used fpu the last 5 timeslices, just do a full
13. * restore of the math state immediately to avoid the trap; the
14. * chances of needing FPU soon are obviously high now
15. */
16. preload_fpu = tsk_used_math(next_p) && next_p->fpu_counter > 5;
17. __unlazy_fpu(prev_p); /* 保存FPU寄存器 */
18. /* we're going to use this soon, after a few expensive things */
19. if (preload_fpu)
20. prefetch(next->xstate);
21. /*
22. * 重新载入esp0：把next_p->thread.esp0装入对应于本地cpu的tss的esp0
23. * 字段；任何由sysenter汇编指令产生的从用户态
24. * 到内核态的特权级转换将把这个地址拷贝到esp寄存器中
25. */
26. load_sp0(tss, next);
27. /*
28. * Save away %gs. No need to save %fs, as it was saved on the
29. * stack on entry.  No need to save %es and %ds, as those are
30. * always kernel segments while inside the kernel.  Doing this
31. * before setting the new TLS descriptors avoids the situation
32. * where we temporarily have non-reloadable segments in %fs
33. * and %gs.  This could be an issue if the NMI handler ever
34. * used %fs or %gs (it does not today), or if the kernel is
35. * running inside of a hypervisor layer.
36. */
37. lazy_save_gs(prev->gs);
38. /*
39. * 装载每个线程的线程局部存储描述符：把next进程使用的线程局部存储(TLS)段
40. * 装入本地CPU的全局描述符表；三个段选择符保存在进程描述符
41. * 内的tls_array数组中
42. */
43. load_TLS(next, cpu);
44. /*
45. * Restore IOPL if needed.  In normal use, the flags restore
46. * in the switch assembly will handle this.  But if the kernel
47. * is running virtualized at a non-zero CPL, the popf will
48. * not restore flags, so it must be done in a separate step.
49. */
50. if (get_kernel_rpl() && unlikely(prev->iopl != next->iopl))
51. set_iopl_mask(next->iopl);
52. /*
53. * Now maybe handle debug registers and/or IO bitmaps
54. */
55. if (unlikely(task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV ||
56. task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT))
57. __switch_to_xtra(prev_p, next_p, tss);
58. /* If we're going to preload the fpu context, make sure clts
59. is run while we're batching the cpu state updates. */
60. if (preload_fpu)
61. clts();
62. /*
63. * Leave lazy mode, flushing any hypercalls made here.
64. * This must be done before restoring TLS segments so
65. * the GDT and LDT are properly updated, and must be
66. * done before math_state_restore, so the TS bit is up
67. * to date.
68. */
69. arch_end_context_switch(next_p);
70. if (preload_fpu)
71. __math_state_restore(); /* 恢复FPU寄存器 */
72. /*
73. * Restore %gs if needed (which is common)
74. */
75. if (prev->gs | next->gs)
76. lazy_load_gs(next->gs);
77. percpu_write(current_task, next_p);
78. return prev_p;
79. }

1. static inline void __unlazy_fpu(struct task_struct *tsk)
2. {
3. /* 如果进程使用了FPU/MMX/SSE或SSE2指令 */
4. if (task_thread_info(tsk)->status & TS_USEDFPU) {
5. __save_init_fpu(tsk); /* 保存相关的硬件上下文 */
6. stts();
7. } else
8. tsk->fpu_counter = 0;
9. }
10. /*
11. * These must be called with preempt disabled
12. */
13. static inline void __save_init_fpu(struct task_struct *tsk)
14. {
15. /* 如果CPU使用SSE/SSE2扩展 */
16. if (task_thread_info(tsk)->status & TS_XSAVE) {
17. struct xsave_struct *xstate = &tsk->thread.xstate->xsave;
18. struct i387_fxsave_struct *fx = &tsk->thread.xstate->fxsave;
19. xsave(tsk);
20. /*
21. * xsave header may indicate the init state of the FP.
22. */
23. if (!(xstate->xsave_hdr.xstate_bv & XSTATE_FP))
24. goto end;
25. if (unlikely(fx->swd & X87_FSW_ES))
26. asm volatile("fnclex");
27. /*
28. * we can do a simple return here or be paranoid :)
29. */
30. goto clear_state;
31. }
32. /* Use more nops than strictly needed in case the compiler
33. varies code */
34. alternative_input(
35. "fnsave %[fx] ;fwait;" GENERIC_NOP8 GENERIC_NOP4,
36. "fxsave %[fx]\n"
37. "bt $7,%[fsw] ; jnc 1f ; fnclex\n1:",
38. X86_FEATURE_FXSR,
39. [fx] "m" (tsk->thread.xstate->fxsave),
40. [fsw] "m" (tsk->thread.xstate->fxsave.swd) : "memory");
41. clear_state:
42. /* AMD K7/K8 CPUs don't save/restore FDP/FIP/FOP unless an exception
43. is pending.  Clear the x87 state here by setting it to fixed
44. values. safe_address is a random variable that should be in L1 */
45. alternative_input(
46. GENERIC_NOP8 GENERIC_NOP2,
47. "emms\n\t"      /* clear stack tags */
48. "fildl %[addr]",    /* set F?P to defined value */
49. X86_FEATURE_FXSAVE_LEAK,
50. [addr] "m" (safe_address));
51. end:
52. task_thread_info(tsk)->status &= ~TS_USEDFPU; /* 重置TS_USEDFPU标志 */
53. }

1. fork()
2. --->kernel/sched_fair.c:enqueue_task_fair()  新进程最后进入红黑树队列
3. kernel/sched.c:sched_tick()  被时钟tick中断直接调用
4. --->sched_class->task_tick()==>kernel/sched_fair.c:task_tick_fair()
5. --->kernel/sched_fair.c:entity_tick()  处理tick中断
6. --->update_curr()  更新当前进程的运行时统计信息
7. --->__update_curr()  更新进程的vruntime
8. --->calc_delta_fair()  计算负载权重值
9. --->kernel/sched.c:calc_delta_mine()  修正delta值
10. --->check_preempt_tick()  检测是否需要重新调度
11. --->kernel/sched.c:resched_task() 设置need_resched标志
12. --->include/linux/sched.h:set_tsk_need_resched(p)  完成设置工作
13. kernel/sched.c:schedule()  中断返回时调用，完成进程切换
14. --->include/linux/sched.h:clear_tsk_need_resched()  清除调度位
15. --->kernel/sched.c:deactivate_task()  删除切换出去的进程(pre进程)
16. --->dequeue_task()
17. --->kernel/sched_fair.c:dequeue_task_fair()  从红黑树中删除pre进程
18. --->dequeue_entity()
19. --->__dequeue_entity()
20. --->lib/rbtree.c:rb_erase()  删除pre进程
21. --->dec_nr_running()  递减nr_running
22. --->kernel/sched.c:put_prev_task()  将切换出去的进程插入到队尾
23. --->kernel/sched_fair.c:put_prev_task_fair()
24. --->put_prev_entity()
25. --->__enqueue_entity()
26. --->搜索红黑树，找到插入位置并插入
27. --->缓存最左边的节点进程
28. --->kernel/sched.c:pick_next_task()  选择下一个要运行的进程
29. --->kernel/sched_fair.c:pick_next_task_fair()
30. --->pick_next_entity()
31. --->__pick_next_entity()
32. --->include/linux/rbtree.h:rb_entry(left,...) 返回红黑树最左边的节点进程
33. --->include/linux/kernel.h:container_of()
34. --->kernel/sched_stats.h:sched_info_switch()  更新调度信息（rq相关变量）
35. --->sched_info_depart()
36. --->sched_info_arrive()
37. --->kernel/sched.c:context_switch()  切换进程上下文
38. --->arch/x86/include/asm/mmu_context.h:switch_mm()  切换内存页
39. --->设置新进程的CPU掩码位，重新加载页表等
40. --->arch/x86/include/asm/system.h:switch_to()  切换寄存器状态和栈
41. --->arch/x86/kernel/process_32.c:__switch_to()
42. --->arch/x86/include/asm/i387.h:__unlazy_fpu()  保存FPU寄存器
43. --->__save_init_fpu() 若使用了FPU/MMX/SSE或SSE2指令则保存相关硬件上下文
44. --->xsave()
45. --->arch/x86/include/asm/paravirt.h:load_sp0()  重新载入esp0
46. --->arch/x86/include/asm/paravirt.h:load_TLS()  加载线程的TLS段
47. --->__math_state_restore()  恢复FPU寄存器
48. --->kernel/sched.c:finish_task_switch()  完成切换后的清理工作
49. --->include/linux/sched.h:put_task_struct()  如果原来进程死亡（而不是运行超时）
50. 需要释放它的PCB
51. --->kernel/fork.c:__put_task_struct()
52. --->free_task()
53. -->free_task_struct()
54. --->kmem_cache_free()  释放原来进程的PCB

图1 Linux进程调度执行流程