魏昊卿 + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000
一、课程笔记
进程的切换和系统的一般执行过程
（一）进程切换的关键代码switch_to分析
进程调度与进程调度的时机分析
1. 不同类型的进程有不同的调度需求
2.进程可以有以下几种分类：
- I/O-bound和CPU-bound
- 批处理进程、实时进程、交互式进程。
不同的进程，需要不同的进程调度策略
3.调度策略：一组规则，它们决定什么时候以怎样的方式选择一个新进程运行。
4.Linux的进程根据优先级排队。
- 根据特定的算法计算出进程的优先级，用一个值表示。
- 这个值表示把进程如何适当的分配给CPU。
5.Linux中的优先级是动态的。
调度程序会根据进程的行为周期性的调整进程的优先级。
—— 较长时间未分配到CPU的进程，通常提升优先级
—— 已经在CPU上运行了较长时间的进程，通常降低优先级
6.进程调度的时机
- 中断处理过程（包括时钟中断、I/O中断、系统调用和异常）中，直接调用schedule()，或者返回用户态时根据need_resched标记调用schedule()；
- 内核线程可以直接调用schedule()进行进程切换，也可以在中断处理过程中进行调度，也就是说内核线程作为一类的特殊的进程可以主动调度，也可以被动调度；（内核线程是只有内核态没有用户态的特殊进程）
- 用户态进程无法实现主动调度，仅能通过陷入内核态后的某个时机点进行调度，即在中断处理过程中进行调度。（用户态进程只能被动调度）
schedule函数：
schedule函数实现调度目的：在运行队列中找到一个进程，把COU分配给它
调用方法：
-- 直接调用schedule（）
-- 松散调用，根据need_resched标记
进程上下文切换相关代码分析
1.进程切换
- 为了控制进程的执行，内核必须有能力挂起正在CPU上执行的进程，并恢复以前挂起的某个进程的执行，这叫做进程切换、任务切换、上下文切换；
- 挂起正在CPU上执行的进程，与中断时保存现场是不同的，中断前后是在同一个进程上下文中，只是由用户态转向内核态执行；
- 进程上下文包含了进程执行需要的所有信息
- 用户地址空间：包括程序代码，数据，用户堆栈等
- 控制信息：进程描述符，内核堆栈等
- 硬件上下文（注意中断也要保存硬件上下文只是保存的方法不同）
schedule()函数选择一个新的进程来运行，并调用context_switch进行上下文的切换，这个宏调用switch_to来进行关键上下文切换
/linux-3.18.6/kernel/sched/core.c
2865 asmlinkage __visible void __sched schedule(void)
2866{
2867 struct task_struct *tsk = current;
2868
2869 sched_submit_work(tsk);
2870 __schedule();
2871}
- next = pick_next_task(rq, prev);//进程调度算法都封装这个函数内部
/linux-3.18.6/kernel/sched/core.c
2824 next = pick_next_task(rq, prev);//选择一个新的进程来运行
2825 clear_tsk_need_resched(prev);
2826 clear_preempt_need_resched();
2827 rq->skip_clock_update = 0;
- context_switch(rq, prev, next);//进程上下文切换
/linux-3.18.6/kernel/sched/core.c
2335 static inline void2336 context_switch(struct rq *rq, struct task_struct *prev,
2337 struct task_struct *next)
2338{
2339 struct mm_struct *mm, *oldmm;
2340
2341 prepare_task_switch(rq, prev, next);//提前准备
2342
2343 mm = next->mm;
2344 oldmm = prev->active_mm;
2345 /*
2346 * For paravirt, this is coupled with an exit in switch_to to
2347 * combine the page table reload and the switch backend into
2348 * one hypercall.
2349 */
2350 arch_start_context_switch(prev);
2351
2352 if (!mm) {
2353 next->active_mm = oldmm;
2354 atomic_inc(&oldmm->mm_count);
2355 enter_lazy_tlb(oldmm, next);
2356 } else
2357 switch_mm(oldmm, mm, next);
2358
2359 if (!prev->mm) {
2360 prev->active_mm = NULL;
2361 rq->prev_mm = oldmm;
2362 }
2363 /*
2364 * Since the runqueue lock will be released by the next
2365 * task (which is an invalid locking op but in the case
2366 * of the scheduler it's an obvious special-case), so we
2367 * do an early lockdep release here:
2368 */
2369 spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
2370
2371 context_tracking_task_switch(prev, next);
2372 /* Here we just switch the register state and the stack. */
2373 switch_to(prev, next, prev);//切换寄存器状态
2374
2375 barrier();
2376 /*
2377 * this_rq must be evaluated again because prev may have moved
2378 * CPUs since it called schedule(), thus the 'rq' on its stack
2379 * frame will be invalid.
2380 */
2381 finish_task_switch(this_rq(), prev);
2382}
- switch_to利用了prev和next两个参数：prev指向当前进程，next指向被调度的进程
1. 31#define switch_to(prev, next, last) \
2. 32do { \
3. 33 /* \
4. 34 * Context-switching clobbers all registers, so we clobber \
5. 35 * them explicitly, via unused output variables. \
6. 36 * (EAX and EBP is not listed because EBP is saved/restored \
7. 37 * explicitly for wchan access and EAX is the return value of \
8. 38 * __switch_to()) \
9. 39 */ \
10. 40 unsigned long ebx, ecx, edx, esi, edi; \
11. 41 \
12. 42 asm volatile("pushfl\n\t" /* save flags */ \
13. 43 "pushl %%ebp\n\t" /* save EBP */ \//把当前进程的堆栈基址压栈
14. 44 "movl %%esp,%[prev_sp]\n\t" /* save ESP */ \//把当前的栈顶保存起来
15. 45 "movl %[next_sp],%%esp\n\t" /* restore ESP */ \ //从堆栈来看这两步完成内核堆栈的切换，以后都是操作下一个进程的内核堆栈中
16. 46 "movl $1f,%[prev_ip]\n\t" /* save EIP */ \ //保存当前进程的EIP，next_ip一般是$1f，对于新创建的子进程是ret_from_fork
17. 47 "pushl %[next_ip]\n\t" /* restore EIP */ \//下一个进程的起点压栈，下一个进程的栈顶就是起点
18. 48 __switch_canary \
19. 49 "jmp __switch_to\n" /* regparm call */ \ //通过寄存器传递参数，返回1f
20. 50 "1:\t" \ //执行下一进程的第一条指令，从EIP的角度21. 51 "popl %%ebp\n\t" /* restore EBP */ \
22. 52 "popfl\n" /* restore flags */ \
23. 53 \
24. 54 /* output parameters */ \
25. 55 : [prev_sp] "=m" (prev->thread.sp), \//内核堆栈的栈顶
26. 56 [prev_ip] "=m" (prev->thread.ip), \//当前进程的EIP
27. 57 "=a" (last), \
28. 58 \
29. 59 /* clobbered output registers: */ \
30. 60 "=b" (ebx), "=c" (ecx), "=d" (edx), \
31. 61 "=S" (esi), "=D" (edi) \
32. 62 \
33. 63 __switch_canary_oparam \
34. 64 \
35. 65 /* input parameters: */ \
36. 66 : [next_sp] "m" (next->thread.sp), \//下一个进程的内核堆栈的栈顶
37. 67 [next_ip] "m" (next->thread.ip), \//下一个进程执行的起点
38. 68 \
39. 69 /* regparm parameters for __switch_to(): */ \
40. 70 [prev] "a" (prev), \
41. 71 [next] "d" (next) \
42. 72 \
43. 73 __switch_canary_iparam \
44. 74 \
45. 75 : /* reloaded segment registers */ \
46. 76 "memory"); \
47. 77} while (0)
（二）linux系统的一般执行过程
linux系统的一般执行过程分析
最一般的情况：正在运行的用户态进程X切换到运行用户态进程Y的过程
- 正在运行的用户态进程X
- 发生中断——save cs:eip/esp/eflags(current) to kernel stack（x的内核堆栈）,then load cs:eip（中断服务程序的起点）(entry of a specific ISR) and ss:esp（内核堆栈）(point to kernel stack).
- SAVE_ALL //保存现场
- （执行中断服务）中断处理过程中或中断返回前（如果有进程调度的时机）调用了schedule()，其中的switch_to做了关键的进程上下文切换
- 标号1之后开始运行用户态进程Y（的内核部分）(这里Y曾经通过以上步骤被切换出去过因此可以从标号1继续执行)
- （从Y进程的中断中）restore_all //恢复现场
- iret - pop cs:eip/ss:esp/eflags from （Y进程）kernel stack
- 继续运行用户态进程Y
关键点：中断和中断返回中有CPU上下文的切换，进程调度的过程中有进程上下文的切换，此时切换了两个进程间的堆栈。
linux系统执行过程中的几个特殊情况（针对内核线程）
- 通过中断处理过程中的调度时机，用户态进程与内核线程之间互相切换和内核线程之间互相切换，与最一般的情况非常类似，只是内核线程运行过程中发生中断没有进程用户态和内核态的转换；
- 内核线程主动调用schedule()，只有进程上下文的切换，没有发生中断上下文的切换，与最一般的情况略简略；
- 创建子进程的系统调用在子进程中的执行起点及返回用户态，如fork；（如果下一个进程是尚未被调用过的进程，它的执行的起点是ret_from_fork，nexp_ip=ret_from_fork）
- 加载一个新的可执行程序后返回到用户态的情况，如execve；(修改中断时保存的信息)
内核与舞女
X86下的地址空间有4G，0~3G用户态、内核态可以访问，3G以上只有内核态可以访问。
内核相当于出租车，进程相当于客人，对所有进程都一样。
内核是各种中断处理过程和内核线程的集合。
（三）linux系统架构和系统执行过程概览
操作系统的基本概念
典型地linux操作系统结构
最简单也最复杂的操作——执行ls命令
从CPU和内存的角度看linux系统的执行
从CPU的角度
从内存的角度
二、实验部分
使用gdb跟踪分析一个schedule()函数。
- 根据前面对代码的分析，我们已经知道schedule中调用next = pick_next_task(rq, prev);实行进程调度算法，其后调用context_switch(rq, prev, next);进行进程上下文切换，其中context_switch(rq, prev, next)中的宏switch_to起着关键作用，我们现在依照这个思路进行gdb跟踪。
1.环境搭建
2.在schedule处设置断点，运行，并用list展开函数
3.单步运行，直至__schedule（）
4.在pick_next_task处设立断点，执行
5.在context_switch处设立断点，执行
三、总结
这个星期学习了“进程调度的时机和进程切换进行”的相关知识，我们知道了进程调度时机出现在中断处理程序和返回用户态时，并且主要是通过schedule函数，也学习了进程切换的大致流程，对关键代码代码有了一定理解：schedule中调用next = pick_next_task(rq, prev);实行进程调度算法，其后调用context_switch(rq, prev, next);进行进程上下文切换，其中context_switch(rq, prev, next)中的宏switch_to起着关键作用。
这门课程即将结束，通过这八周的学习我收获颇丰，同时配合相关课本的学习，我对linux内核机制的理解变得更加细致。