2019-2020-1 20199308《Linux内核原理与分析》第九周作业

《Linux内核分析》

第八章 可执行程序工作原理进程的切换和系统的一般执行过程

8.1 知识点

进程调度的时机

  • ntel定义的中断类型主要有以下几种
    • 硬中断(Interrupt)
    • 软中断/异常(Exception)
      • 故障(Fault)
      • 退出(Abort)
      • 陷阱(Trap)
  • schedule()函数选择一个新的进程来运行,并调用context_switch进行上下文的切换,这个宏调用switch_to来进行关键上下文切换
    • next = pick_next_task(rq, prev);//进程调度算法都封装这个函数内部
    • context_switch(rq, prev, next);//进程上下文切换
    • switch_to利用了prev和next两个参数:prev指向当前进程,next指向被调度的进程
  • Linux系统的一般执行过程
    • 最一般的情况:正在运行的用户态进程X切换到运行用户态进程Y的过程
      • 1.正在运行的用户态进程X
      • 2.发生中断——save cs:eip/esp/eflags(current) to kernel stack,then load cs:eip(entry of a specific ISR) and ss:esp(point to kernel stack).
      • 3.SAVE_ALL //保存现场
      • 4.中断处理过程中或中断返回前调用了schedule(),其中的switch_to做了关键的进程上下文切换
      • 5.标号1之后开始运行用户态进程Y(这里Y曾经通过以上步骤被切换出去过因此可以从标号1继续执行)
      • 6.restore_all //恢复现场
      • 7.iret - pop cs:eip/ss:esp/eflags from kernel stack
      • 8.继续运行用户态进程Y
  • 几种特殊情况
    • 通过中断处理过程中的调度时机,用户态进程与内核线程之间互相切换和内核线程之间互相切换,与最一般的情况非常类似,只是内核线程运行过程中发生中断没有进程用户态和内核态的转换;
    • 内核线程主动调用schedule(),只有进程上下文的切换,没有发生中断上下文的切换,与最一般的情况略简略;
    • 创建子进程的系统调用在子进程中的执行起点及返回用户态,如fork;
    • 加载一个新的可执行程序后返回到用户态的情况,如execve;
    • ch_to利用了prev和next两个参数:prev指向当前进程,next指向被调度的进程

2019-2020-1 20199308《Linux内核原理与分析》第九周作业_第1张图片
2019-2020-1 20199308《Linux内核原理与分析》第九周作业_第2张图片

8.2 核心代码分析

context_switch代码

static inline void 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);

    if (!mm) {    //如果被切换进来的进程的mm为空切换,内核线程mm为空
        next->active_mm = oldmm;  //将共享切换出去的进程的active_mm
        atomic_inc(&oldmm->mm_count);  //有一个进程共享,所有引用计数加一
        enter_lazy_tlb(oldmm, next);  //普通mm不为空,则调用switch_mm切换地址空间
    } else
        switch_mm(oldmm, mm, next);

    if (!prev->mm) {
        prev->active_mm = NULL;
        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:
     */
    spin_release(&rq->lock.dep_map, 1, _THIS_IP_);

    context_tracking_task_switch(prev, next);
    // 这里切换寄存器状态和栈 
    switch_to(prev, next, prev);

    barrier();
    /*
     * this_rq must be evaluated again because prev may have moved
     * CPUs since it called schedule(), thus the 'rq' on its stack
     * frame will be invalid.
     */
    finish_task_switch(this_rq(), prev);
}

switch_to代码

#define switch_to(prev, next, last) //prev指向当前进程,next指向被调度的进程                                   
do {                                                                              
                                                        
         unsigned long ebx, ecx, edx, esi, edi;
                                  
         asm volatile("pushfl\n\t"  //把prev进程的flag保存到prev进程的内核堆栈中
                      "pushl %%ebp\n\t" //把prev进程的基址ebp保存到prev进程的内核堆栈中
           
                      "movl %%esp,%[prev_sp]\n\t"//保存ESP
                      "movl %[next_sp],%%esp\n\t"//更新ESP,将下一栈顶保存到ESP中 
                      
                      "movl $1f,%[prev_ip]\n\t"//保存当前进程EIP*  
                      "pushl %[next_ip]\n\t"//把next进程起点压入next进程的内核堆栈栈顶 
                      __switch_canary                                        
                      "jmp __switch_to\n"//prev进程中设置next进程堆栈
                                         //jmp不同于call,是通过寄存器传递参数,而不是通过堆栈传递参数,所以ret时弹出的是之前压入栈顶的next进程起点
                                         //wancheng EIP的切换
                      "1:\t"                                                    
                      "popl %%ebp\n\t"   
                      "popfl\n"                         
                                                                                
                      /* output parameters */                                   
                      : [prev_sp] "=m"(prev->thread.sp),     //保存prev进程的esp
                        [prev_ip] "=m"(prev->thread.ip),     //保存prev进程的eip
                        "=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进程内核堆栈栈顶地址,即esp
                        [next_ip]  "m" (next->thread.ip),      //next进程的原eip
                                                                                   
                      /* regparm parameters for __switch_to():*/  
                      //jmp通过eax寄存器和edx寄存器传递参数
                        [prev]     "a" (prev),                                   
                        [next]     "d" (next)                                    
                                                                                     
                        __switch_canary_iparam                             
                                                                                    
                      : /* 重新加载段寄存器            
                     "memory");                                           
} while (0)  

8.3 实验

  • 克隆menu,编译内核,启动gdb
    2019-2020-1 20199308《Linux内核原理与分析》第九周作业_第3张图片
    2019-2020-1 20199308《Linux内核原理与分析》第九周作业_第4张图片
    2019-2020-1 20199308《Linux内核原理与分析》第九周作业_第5张图片
    2019-2020-1 20199308《Linux内核原理与分析》第九周作业_第6张图片

  • 在schedule(),context_switch(),pick_next_task()打入断点
    2019-2020-1 20199308《Linux内核原理与分析》第九周作业_第7张图片

  • 按c执行,停在schedule函数处
    2019-2020-1 20199308《Linux内核原理与分析》第九周作业_第8张图片

  • 按c继续执行到pick_next_task断点处
    2019-2020-1 20199308《Linux内核原理与分析》第九周作业_第9张图片

  • 按c继续执行到context_switch断点处,用来实现进程的切换。

总结

一次一般的进程切换过程,其中必须完成的关键操作是:切换地址空间、切换内核堆栈、切换内核控制流程,加上一些必要的寄存器保存和恢复。这里,除去地址空间的切换,其他操作要强调“内核”一词。这是因为,这些操作并非针对用户代码,切换完成后,也没有立即跑到next的用户空间中执行。用户上下文的保存和恢复是通过中断和异常机制,在内核态和用户态相互切换时才发生的。schedule()是内核和其他部分用于调用进程调度器的入口,选择哪个进程可以运行,何时将其投入运行。就如switch_to中的方法,通过压栈出栈交换prev_ip和next_ip。然后返回,从而完成进程调度。而用哪个作为下来的进程,则通过优先级的算法和进程调度算法来决定。

你可能感兴趣的:(2019-2020-1 20199308《Linux内核原理与分析》第九周作业)