Linux kernel 3.10内核源码分析--进程上下文切换

1. /*
   
2.   * 上下文切换，在schedule中调用，current进程调度出去，当该进程被再次调度到时，重新从__switch_to后面开始执行
   
3.   * prev:被替换的进程
   
4.   * next:被调度的新进程
   
5.   * last:当切换回原来的进程(prev)后，被替换的另外一个进程。
   
6.   */
   
7. #define switch_to(prev, next, last)    \
   
8. do {    \
   
9. /*    \
   
10. * Context-switching clobbers all registers, so we clobber    \
    
11. * them explicitly, via unused output variables.    \
    
12. * (EAX and EBP is not listed because EBP is saved/restored    \
    
13. * explicitly for wchan access and EAX is the return value of    \
    
14. * __switch_to())    \
    
15. */    \
    
16. unsigned long ebx, ecx, edx, esi, edi;    \
    
17. \
    
18. asm volatile("pushfl\n\t"    /* save flags */    /*将eflags寄存器值压栈*/\
    
19.     "pushl %%ebp\n\t"    /* save EBP */    /*将EBP压栈*/\
    
20. /*将当前栈指针(内核态)保存到prev进程的thread.sp中*/
    
21.     "movl %%esp,%[prev_sp]\n\t"    /* save ESP */ \
    
22.     /*将next进程的栈指针(内核态)装载到ESP寄存器中*/
    
23.     "movl %[next_sp],%%esp\n\t"    /* restore ESP */ \
    
24.     /*保存"标号1"的地址到prev进程的thread.ip，以便当prev进程重新被调度运行时，可以从"标号1处"重新开始执行*/
    
25.     "movl $1f,%[prev_ip]\n\t"    /* save EIP */    \
    
26.     /*
    
27.          * 将next进程的IP(通常都是"标号1"的地址，因为通常都是经历过这里的调度过程的，上一行代码中即保存了这个IP)
    
28.    * 压入当前的(即next进程的)堆栈中。结合后面的jmp指令(注意:不是call指令)一起理解，当__switch_to执行完ret返回时，
    
29.    * 会自动从当前的堆栈中弹出该地址作为函数的返回地址接着执行，如此即可实现新进程的运行。
    
30.                        */
    
31.     "pushl %[next_ip]\n\t"    /* restore EIP */    \
    
32.     __switch_canary    \
    
33.     /*
    
34.          *jmp到__switch_to函数执行，当此函数返回时，自动跳转到[next_ip]开始执行，实现新进程的调度。注意不是call，jmp指令
    
35.          * 不会自动将当前地址压栈，call会自动压栈
    
36.          */
    
37.     "jmp __switch_to\n"    /* regparm call */    \
    
38.     /*当prev进程再次被调度到时，从这里开始执行*/
    
39.     "1:\t"    \
    
40.     /*恢复EBP*/
    
41.     "popl %%ebp\n\t"    /* restore EBP */    \
    
42.     /*恢复eflags*/
    
43.     "popfl\n"    /* restore flags */    \
    
44. \
    
45.     /* output parameters */    \
    
46.     /*输出参数*/
    
47.     : [prev_sp] "=m" (prev->thread.sp),    \
    
48.       [prev_ip] "=m" (prev->thread.ip),    \
    
49.       "=a" (last),    \
    
50. \
    
51.       /* clobbered output registers: */    \
    
52.       "=b" (ebx), "=c" (ecx), "=d" (edx),    \
    
53.       "=S" (esi), "=D" (edi)    \
    
54.       \
    
55.       __switch_canary_oparam    \
    
56. \
    
57.       /* input parameters: */    \
    
58.       /*输入参数*/
    
59.     : [next_sp] "m" (next->thread.sp),    \
    
60.       [next_ip] "m" (next->thread.ip),    \
    
61.       \
    
62.       /* regparm parameters for __switch_to(): */    \
    
63.       /*将prev和next分别存入ecx和edx，然后作为参数传入到__switch_to函数中*/
    
64.       [prev] "a" (prev),    \
    
65.       [next] "d" (next)    \
    
66. \
    
67.       __switch_canary_iparam    \
    
68. \
    
69.     : /* reloaded segment registers */    \
    
70. "memory");    \
    
71. } while (0)

1. /*入参通过寄存器eax和edx从switch_to宏中传入*/
   
2. __notrace_funcgraph struct task_struct *
   
3. __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
   
4. {
   
5. /*取prev进程的上下文信息*/
   
6. struct thread_struct *prev = &prev_p->thread,
   
7. *next = &next_p->thread;
   
8. /*取当前CPU*/
   
9. int cpu = smp_processor_id();
   
10. /*获取当前CPU的TSS对应的tss_struct*/
    
11. struct tss_struct *tss = &per_cpu(init_tss, cpu);
    
12. fpu_switch_t fpu;
    
13. 
    
14. 
    
15. /* never put a printk in __switch_to... printk() calls wake_up*() indirectly */
    
16. 
    
17. 
    
18. fpu = switch_fpu_prepare(prev_p, next_p, cpu);
    
19. 
    
20. 
    
21. /*
    
22. * Reload esp0.
    
23. */
    
24. /*
    
25.  * 由于Linux的具体实现中，TSS不是针对每进程，而是针对每CPU的，即每个CPU对应一个tss_struct，那在进程上下文切换时，
    
26.  * 需要考虑当前CPU上TSS中的内容的更新，其实就是内核栈指针的更新，更新后，当新进程再次进入到内核态执行时，
    
27.  * 才能确保CPU硬件能从TSS中自动读取到正确的内核栈指针(sp0)的值，以保证从用户态切换到内核态时，相应的堆栈切
    
28.  * 换正常。
    
29.  */
    
30. /*将next进程的内核栈指针(next->thread->sp0)值更新到当前CPU的TSS中*/
    
31. load_sp0(tss, next);
    
32. 
    
33. 
    
34. /*
    
35. * Save away %gs. No need to save %fs, as it was saved on the
    
36. * stack on entry. No need to save %es and %ds, as those are
    
37. * always kernel segments while inside the kernel. Doing this
    
38. * before setting the new TLS descriptors avoids the situation
    
39. * where we temporarily have non-reloadable segments in %fs
    
40. * and %gs. This could be an issue if the NMI handler ever
    
41. * used %fs or %gs (it does not today), or if the kernel is
    
42. * running inside of a hypervisor layer.
    
43. */
    
44. lazy_save_gs(prev->gs);
    
45. 
    
46. 
    
47. /*
    
48. * Load the per-thread Thread-Local Storage descriptor.
    
49. */
    
50. /*
    
51.  * 将next_p进程使用的线程局部存储(TLS)段装入本地CPU的全局描述符表.
    
52.  */
    
53. load_TLS(next, cpu);
    
54. 
    
55. 
    
56. /*
    
57. * Restore IOPL if needed. In normal use, the flags restore
    
58. * in the switch assembly will handle this. But if the kernel
    
59. * is running virtualized at a non-zero CPL, the popf will
    
60. * not restore flags, so it must be done in a separate step.
    
61. */
    
62. if (get_kernel_rpl() && unlikely(prev->iopl != next->iopl))
    
63. set_iopl_mask(next->iopl);
    
64. 
    
65. 
    
66. /*
    
67. * Now maybe handle debug registers and/or IO bitmaps
    
68. */
    
69. if (unlikely(task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV ||
    
70.     task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT))
    
71. __switch_to_xtra(prev_p, next_p, tss);
    
72. 
    
73. 
    
74. /*
    
75. * Leave lazy mode, flushing any hypercalls made here.
    
76. * This must be done before restoring TLS segments so
    
77. * the GDT and LDT are properly updated, and must be
    
78. * done before math_state_restore, so the TS bit is up
    
79. * to date.
    
80. */
    
81. /*架构相关处理，半虚拟化中使用*/
    
82. arch_end_context_switch(next_p);
    
83. 
    
84. 
    
85. /*
    
86. * Restore %gs if needed (which is common)
    
87. */
    
88. if (prev->gs | next->gs)
    
89. lazy_load_gs(next->gs);
    
90. 
    
91. 
    
92. switch_fpu_finish(next_p, fpu);
    
93. /*将current_task per-CPU变量值更新为next进程信息*/
    
94. this_cpu_write(current_task, next_p);
    
95. /*
    
96.  * 这里需要仔细理解。return到哪里?
    
97.  * switch_to宏中，jmp到__switch_to函数之前将"next_ip"压入了当前堆栈，那通常情况下，这里return后，
    
98.  * 会自动从堆栈中弹出next_ip开始执行，而next_ip通常为switch_to宏中保存的"标号1"的地址，即
    
99.  * 这里通常会返回到switch_to宏中__switch_to函数之后的标号1处开始执行。
    
100.  * 但有例外:对于没有产生过进程切换,而是第一次开始执行的进程(刚完成fork开始执行)来说.
     
101.  * 由于没有通过switch_to宏保存next_ip，所以并不会跳回switch_to，而是跳转到ret_from_fork函数的超始
     
102.  * 地址开始执行，因为在fork新进程时，即设置好了该进程的thread.eip设置成了ret_from_fork(参见
     
103.  * copy_thread函数)。
     
104.  */
     
105. return prev_p;
     
106. }

1. do_fork->copy_process->copy_thread
   
2. int copy_thread(unsigned long clone_flags, unsigned long sp,
   
3. unsigned long arg, struct task_struct *p)
   
4. {
   
5. struct pt_regs *childregs = task_pt_regs(p);
   
6. struct task_struct *tsk;
   
7. int err;
   
8. 
   
9. 
   
10. p->thread.sp = (unsigned long) childregs;
    
11. p->thread.sp0 = (unsigned long) (childregs+1);
    
12. /*内核线程单独处理，其上下文信息单独填写*/
    
13. if (unlikely(p->flags & PF_KTHREAD)) {
    
14. /* kernel thread */
    
15. memset(childregs, 0, sizeof(struct pt_regs));
    
16. p->thread.ip = (unsigned long) ret_from_kernel_thread;
    
17. task_user_gs(p) = __KERNEL_STACK_CANARY;
    
18. childregs->ds = __USER_DS;
    
19. childregs->es = __USER_DS;
    
20. childregs->fs = __KERNEL_PERCPU;
    
21. childregs->bx = sp;    /* function */
    
22. childregs->bp = arg;
    
23. childregs->orig_ax = -1;
    
24. childregs->cs = __KERNEL_CS | get_kernel_rpl();
    
25. childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_BIT1;
    
26. p->fpu_counter = 0;
    
27. p->thread.io_bitmap_ptr = NULL;
    
28. memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
    
29. return 0;
    
30. }
    
31. /*将当前进程(父进程)的寄存器上下文信息赋给子进程，即子进程此后的上下文信息跟父进程保持一致了。*/
    
32. *childregs = *current_pt_regs();
    
33. childregs->ax = 0;
    
34. if (sp)
    
35. childregs->sp = sp;
    
36. /*
    
37.  * 子进程的IP指向ret_from_fork，fork创建的新进程，都要经历这个过程，在调度的上下文切换时，
    
38.  * 其返回到ret_from_fork(entry_32.S汇编代码)中处理，这跟普通进程调度时上下文切换不一样，普通
    
39.  * 进程的IP是在上次上下文切换时(switch_to)中保存的。
    
40.  */
    
41. p->thread.ip = (unsigned long) ret_from_fork;
    
42. task_user_gs(p) = get_user_gs(current_pt_regs());
    
43. 
    
44. 
    
45. p->fpu_counter = 0;
    
46. p->thread.io_bitmap_ptr = NULL;
    
47. tsk = current;
    
48. err = -ENOMEM;
    
49. 
    
50. 
    
51. memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
    
52. 
    
53. 
    
54. if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
    
55. p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
    
56. IO_BITMAP_BYTES, GFP_KERNEL);
    
57. if (!p->thread.io_bitmap_ptr) {
    
58. p->thread.io_bitmap_max = 0;
    
59. return -ENOMEM;
    
60. }
    
61. set_tsk_thread_flag(p, TIF_IO_BITMAP);
    
62. }
    
63. 
    
64. 
    
65. err = 0;
    
66. 
    
67. 
    
68. /*
    
69. * Set a new TLS for the child thread?
    
70. */
    
71. if (clone_flags & CLONE_SETTLS)
    
72. err = do_set_thread_area(p, -1,
    
73. (struct user_desc __user *)childregs->si, 0);
    
74. 
    
75. 
    
76. if (err && p->thread.io_bitmap_ptr) {
    
77. kfree(p->thread.io_bitmap_ptr);
    
78. p->thread.io_bitmap_max = 0;
    
79. }
    
80. return err;
    
81. }

原文地址： http://blog.chinaunix.net/uid-14528823-id-4740294.html