20135201李辰希 《Linux内核分析》第八周 进程的切换和系统的一般执行过程

标签：

李辰希 原创作品转载请注明出处 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

一. 进程切换的关键代码switch_to的分析

　　　　1.进程调度与进程调度的时机分析

1. 进程分类
   1. 
      
      1. I/O-bound：等待I/O
      2. CPU-bound：大量占用CPU进行计算
   2.
   1. 交互式进程（shell）
   2. 实时进程
   3. 批处理进程
2. 进程调度策略
   • 一组决定何时以何种方式选择进程的规则
   • Linux的调度基于分时和优先级策略：
     1. 进程根据优先级（系统根据特定算法计算出来）排队；
     2. 这个优先级的值表示如何适当分配CPU；
     3. 调度程序会根据进程的运行周期动态调整优先级；
     4. 比如nice等系统调用，可以手动调整优先级
   • 调度策略本质上是一种算法，这些算法从实现的角度看仅仅是从运行队列中选择一个新进程，选择的过程中运用了不同的策略而已
   • 内核中的调度算法相关代码使用了类似OOD中的策略模式
3. 进程调度的时机
   • 中断处理过程（包括时钟中断、I/O中断、系统调用和异常）中，直接调用schedule()，或者返回用户态时根据need_resched标记调用schedule()（也就是说，用户态进程只能被动地调度）；
   • 内核线程可以直接调用schedule()进行进程切换，也可以在中断处理过程中进行调度，也就是说内核线程作为一类的特殊的进程可以主动调度，也可以被动调度；

   • 用户态进程无法实现主动调度，仅能通过陷入内核态后的某个时机点进行调度，即在中断处理过程中进行调度。

     2.进程切换上下文的相关代码

     1.概念：

• 为了控制进程的执行，内核必须有能力挂起正在CPU上执行的进程，并恢复以前挂起的某个进程的执行，这叫做进程切换（挂起正在CPU上执行的进程，与中断时保存现场是不同的，中断前后是在同一个进程上下文中，只是由用户态转向内核态执行）
• 进程上下文包含了进程执行需要的所有信息
  • 用户地址空间：包括程序代码，数据，用户堆栈等
  • 控制信息：进程描述符，内核堆栈等
  • 硬件上下文（中断也要保存硬件上下文只是保存的方法不同，中断是通过压栈来解决的，而这里是通过schedule函数）

schedule()函数代码分析

1.创建一些局部变量

struct task_struct *prev, *next;//当前进程和一下个进程的进程结构体
unsigned long *switch_count;//进程切换次数
struct rq *rq;//就绪队列
int cpu;

 2.关闭内核抢占，初始化一部分变量

need_resched:
preempt_disable();//关闭内核抢占
cpu = smp_processor_id();
rq = cpu_rq(cpu);//与CPU相关的runqueue保存在rq中
rcu_note_context_switch(cpu);
prev = rq->curr;//将runqueue当前的值赋给prev

 3.选择next进程

next = pick_next_task(rq, prev);//挑选一个优先级最高的任务排进队列
clear_tsk_need_resched(prev);//清除prev的TIF_NEED_RESCHED标志。
clear_preempt_need_resched();

 4.完成进程的调度

next = pick_next_task(rq, prev);//挑选一个优先级最高的任务排进队列
clear_tsk_need_resched(prev);//清除prev的TIF_NEED_RESCHED标志。
clear_preempt_need_resched();

 5.schedule()函数选择一个新的进程来运行

next = pick_next_task(rq, prev);
clear_tsk_need_resched(prev);
clear_preempt_need_resched();
rq->skip_clock_update = 0;

 6.通过context_switch完成进程上下文切换

2336context_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;

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    }

2369    spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
2370
2371    context_tracking_task_switch(prev, next);

2373    switch_to(prev, next, prev);
2374
2375    barrier();

2381    finish_task_switch(this_rq(), prev);
2382}

二、Linux系统的一般执行过程

Linux系统的一般执行过程分析

一般情况：当前系统正在进行，有一个用户态进程X，需要切换到用户态进程Y（进程策略决定）：

　　1.正在运行的用户态进程X

　　2.发生中断——save cs:eip/esp/eflags(current) to kernel stack,then load cs:eip(entry of a specific ISR（中断服务例程的入口，对于系统调用就是system_call）) and ss:esp(point to kernel stack).//这些保存和加载都是CPU自动完成

　　3.SAVE_ALL //保存现场

　　4.中断处理过程中或中断返回前调用了schedule()，其中的switch_to做了关键的进程上下文切换

　　5.标号1之后开始运行用户态进程Y(这里Y曾经通过以上步骤被切换出去过，就是next以前做过prev，因此可以从标号1继续执行)

　　6.restore_all //Y进程从它的中断中恢复现场

　　7.iret - pop cs:eip/ss:esp/eflags from kernel stack//从Y进程的内核堆栈中弹出

　　8.继续运行用户态进程Y//执行发生中断时间点的下一条指令

关键：中断上下文的切换（中断和中断返回时CPU进行上下文切换）和进程上下文的切换（进程调度过程中，从一个进程的内核堆栈切换到另一个进程的内核堆栈）

Linux系统执行过程中的几个特殊情况

　　1.通过中断处理过程中的调度时机，用户态进程与内核线程之间互相切换和内核线程之间互相切换，与最一般的情况非常类似，只是内核线程运行过程中发生中断没有进程用户态和内核态的转换；

　　2.内核线程主动调用schedule()，只有进程上下文的切换，没有发生中断上下文的切换，与最一般的情况略简略；//用户态进程不能主动调用

　　3.fork：创建子进程的系统调用在子进程中的执行起点（next_ ip = ret_ from_ fork）返回用户态，进程返回不是从标号1开始执行，直接跳转到ret_ from_fork执行然后返回到用户态；

　　4.加载一个新的可执行程序后返回到用户态的情况，如execve，只是中断上下文在execve系统调用内部被修改了；

地址切换:

1. 进程的地址空间一共有4G，其中0——3G是用户态可以访问，3G以上只有内核态可以访问
2. 内核相当于出租车，可以为每一个“招手”的进程提供内核态到用户态的转换。
3. 没有进程需要“承载”的时候，内核进入idle0号进程进行“空转”。当用户进程有需求时，内核发生中断，帮助用户进程完成请求，然后再返回到用户进程。就好像Taxi将用户载了一圈之后又把用户放下来。
4. 3G以上的部分就是这样的“出租车”，是所有进程共享的，在内核态部分切换的时候就比较容易
5. 内核是各种中断处理程序和内核线程的集合。

三. LINUX 系统架构和执行过程概述

1.执行ls命令

 1.涉及中断、终端控制台设备驱动的概念。

2.过程：shell分析-->调用系统调用fork生成一个shell本身拷贝-->调用exec系统调用将ls可执行文件装入内存-->从系统调用返回

2.CPU和内存的角度看Linux系统的执行

1. 执行gets()函数；
2. 执行系统调用，陷入内核；
3. 等待输入，CPU会调度其他进程执行，同时wait一个I/O中断；
4. 敲击ls，发I/O中断给CPU，中断处理程序进行现场保存、压栈等等；
5. 中断处理程序发现X进程在等待这个I/O（此时X已经变成阻塞态），处理程序将X设置为WAKE_UP;
6. 进程管理可能会把进程X设置为next进程，这样gets系统调用获得数据，再返回用户态堆栈
7. 从内存角度看，所有的物理地址都会被映射到3G以上的地址空间：因为这部分对所有进程来说都是共享的

四.实验

1.搭建环境：

cd LinuxKernel   
rm menu -rf
git clone https://github.com/mengning/menu.git
cd menu
mv test_exec.c test.c
make rootfs

2.gdb调试

qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img -s -S

gdb
file ../linux-3.18.6/vmlinux
target remote:1234

设置断点：
b schedule
b pick_next_task
b context_switch
b switch_to

实验步骤

1.自行调试schedule函数

1. 进入实验楼虚拟机环境；
2. 启动内核，并进入调试状态

• 

• 

3. 在schedule处设置断点，点击c运行。【可以看到此时被冻结的内核开始运行直到schedule处】
   • 
4.list查看断点所在代码段。可以与上图对照，发现schedule()函数
• 
c之后按n单步执行，直到遇到__schedule函数，进入其中查看

• 

继续执行，直到发现context_switch函数

•  

  

• 

五.总结

Linux系统一般执行过程:

1.进程调度算法只是一种抽象，着重理解进程的调度时机与进程的切换机制。

2.Linux系统的一般执行过程：当前系统正在进行，有一个用户态进程X，需要切换到用户态进程Y（进程策略决定）

20135201李辰希 《Linux内核分析》第八周 进程的切换和系统的一般执行过程

标签：

原文地址：http://www.cnblogs.com/20135201lcx2/p/5399157.html