（2023-2024-1）20232830《Linux内核原理分析与设计》第九周作业

（2023-2024-1）20232830《Linux内核原理分析与设计》第九周作业

1. Linux 系统中进程调度的时机

在Linux系统中，进程调度的时机是由调度器决定的，它负责根据一些策略和算法来选择下一个要执行的进程。进程调度可能在以下几种情况下发生：

1. 当前进程主动释放CPU：如果当前进程主动调用了让出CPU的系统调用（如yield()），或者等待某个事件（如IO操作），它会放弃CPU的使用权，调度器会选择下一个可执行的进程来运行。
2. 当前进程阻塞或等待：如果当前进程需要等待某个事件的发生（如等待IO完成），它会被阻塞并暂时从可执行状态移除。调度器会选择下一个可执行的进程来运行。
3. 当前进程执行时间片用完：调度器通常会为每个进程分配一个时间片（一段时间），当进程执行完时间片后，调度器会将其暂停，并选择下一个可执行的进程来运行。
4. 新进程创建：当一个新进程被创建时，调度器会在适当的时机将其加入调度队列，并决定何时运行它。
5. 中断处理：当系统发生硬件中断或软件中断时，调度器可能会根据中断的优先级来决定是否切换到中断处理程序执行。

schedule()函数是Linux内核中进程调度的核心函数，负责选择下一个要运行的进程。
调用schedule函数的方法有两种：

1. 进程主动调用schedule函数：当进程主动调用阻塞的系统调用等待外设响应或主动进入睡眠状态时，最终会在内核中调用到schedule函数。这是进程自愿放弃CPU使用权的情况。
2. 松散调用：内核代码中可以在任意时刻调用schedule函数，以使当前运行的内核路径让出CPU。此外，内核还会根据need_resched标记进行进程调度。在适当的时机，内核会检测need_resched标记，决定是否调用schedule函数进行进程切换。这种方式可以被视为内核对进程进行强制调度的情况。

2. 实验八：使用 gdb 跟踪分析一个 schedule()函数

2.1 配置运行MenuOS系统

相关命令如下：

cd LinuxKernel
rm -rf menu  # 无法克隆，可使用侧边栏上传代码将代码压缩包传入实验楼环境中
cd menu
mv test_exec.c test.c
make rootfs

2.2 配置gdb

远程调试并设置断点；

cd ..
qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img -s -S
gdb  # 打开另一个终端，使用gdb调试
file linux-3.18.6/vmlinux
target remote:1234
b schedule
b context_switch
b switch_to
b pick_next_task

按c继续执行，停在schedule函数断点处，发现调用了schedule()，即发生了进程调度；

按c继续执行到pick_next_task断点处：发现在这里使用了某种调度策略选择下一个进程来切换；

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

单步调试进入switch_to内部，如图所示：

在进程上下文切换（context switch）的过程中，通常会涉及到一系列操作。其中，context_switch函数首先会调用switch_mm函数来切换CR3寄存器的值，然后再调用宏switch_to来进行硬件上下文切换。

具体来说，switch_mm函数用于切换进程的页全局目录（Page Global Directory，PGD）指针，即将当前进程的PGD指针切换为下一个进程的PGD指针。这是为了确保在进程切换后，CPU使用正确的页表来进行地址转换。

接下来，switch_to宏用于进行实际的硬件上下文切换操作。它会保存当前进程的寄存器状态，并加载下一个进程的寄存器状态，以实现进程之间的切换。这包括保存和恢复通用寄存器、段寄存器、堆栈指针等。

总的来说，context_switch函数通过调用switch_mm和switch_to来完成进程上下文切换的两个关键步骤：切换页全局目录和进行硬件上下文切换。这样可以确保下一个进程能够正确地运行，并使用自己的地址空间和寄存器状态。

3. 分析 switch_to 中的汇编代码

汇编代码：

#define switch_to(prev, next, last)                    
do {                                 
  /*                              
 1. Context-switching clobbers all registers, so we clobber  
 2. them explicitly, via unused output variables.     
 3. (EAX and EBP is not listed because EBP is saved/restored  
 4. explicitly for wchan access and EAX is the return value of   
 5. __switch_to())                     
   */                                
  unsigned long ebx, ecx, edx, esi, edi;                
                                  
  asm volatile("pushfl\n\t"      /* 保存当前进程flags */   
           "pushl %%ebp\n\t"        /* 当前进程堆栈基址压栈*/ 
           "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进程的栈顶为起点*/    
         
            //完成EIP的切换
             __switch_canary    
            //next_ip一般是$1f，对于新创建的子进程时ret_from_fork               
           "jmp __switch_to\n"  /*prev进程中，设置next进程堆栈*/ 
            //jmp不同于call是通过寄存器传递参数
           "1:\t"                //next进程开始执行
           "popl %%ebp\n\t"       
           "popfl\n"         
                                  
           /*输出变量定义*/                
           : [prev_sp] "=m" (prev->thread.sp),     //[prev_sp]定义内核堆栈栈顶
             [prev_ip] "=m" (prev->thread.ip),     //[prev_ip]当前进程EIP  
             "=a" (last),                 
                                  
             /* 要破坏的寄存器: */     
             "=b" (ebx), "=c" (ecx), "=d" (edx),      
             "=S" (esi), "=D" (edi)             
                                       
             __switch_canary_oparam                
                                  
            /* 输入变量: */                
           : [next_sp]  "m" (next->thread.sp),     //[next_sp]下一个内核堆栈栈顶    
             [next_ip]  "m" (next->thread.ip),     
           //[next_ip]下一个进程执行起点，，一般是$1f，对于新创建的子进程是ret_from_fork 
   
             /* regparm parameters for __switch_to(): */  
             [prev]     "a" (prev),              
             [next]     "d" (next)               
                                  
             __switch_canary_iparam                
                                 
           : /* 重新加载段寄存器 */           
          "memory");                  
} while (0)

1. 首先，定义了需要保存的寄存器变量：ebx、ecx、edx、esi、edi。
2. 使用asm volatile指令开始内联汇编代码块。
3. pushfl：将当前进程的标志寄存器（flags）压入栈中，保存当前进程的标志位。
4. pushl %%ebp：将当前进程的基址指针（ebp）压入栈中，保存当前进程的堆栈基址。
5. movl %%esp,%[prev_sp]：将当前栈顶指针（esp）保存到prev_sp中，以保存当前进程的堆栈栈顶。
6. movl %[next_sp],%%esp：将next_sp中保存的下一个进程的堆栈栈顶赋值给esp，以更新堆栈指针。
7. movl $1f,%[prev_ip]：将标号1:的地址保存到prev_ip中，以保存当前进程的指令指针（eip）。
8. pushl %[next_ip]：将next_ip中保存的下一个进程的起始地址（一般为标号1:）压入堆栈，作为下一个进程的栈顶，即设置下一个进程的初始执行点。
9. __switch_canary：这部分代码用于检查和保护堆栈，确保在进行切换时不会破坏堆栈的完整性。
10. jmp __switch_to：跳转到__switch_to标号处，继续执行下一个进程的代码。
11. 1:：下一个进程开始执行的标号。
12. popl %%ebp：将之前压入栈中的基址指针（ebp）弹出，恢复下一个进程的堆栈基址。
13. popfl：将之前压入栈中的标志寄存器（flags）弹出，恢复下一个进程的标志位。
14. 通过输出变量和输入变量的方式，将需要保存和恢复的寄存器状态以及相关的进程结构体指针传递给汇编代码。
15. memory：表示该汇编代码块可能会对内存进行读写操作，以保证内存的一致性。

整个代码块是一个do-while循环，while (0)的作用是使整个代码块只执行一次。这段代码的目的是在上下文切换时保存当前进程的上下文，并加载下一个进程的上下文，实现进程的切换。

4. 实验总结

进程调度函数：schedule函数是Linux中进程调度的核心函数。它负责在合适的时机选择下一个要执行的进程，并进行进程切换。

选择下一个进程：pick_next_task函数是schedule函数中的重要组成部分，它根据调度策略和调度算法来选择下一个要执行的进程。这个函数会考虑进程的优先级、时间片等因素，以确定下一个应该被调度的进程。

进程切换：进程切换是指从当前正在执行的进程切换到下一个要执行的进程。在Linux中，进程切换是通过context_switch函数实现的。该函数会保存当前进程的上下文信息，包括寄存器状态、堆栈指针等，并加载下一个进程的上下文信息，以确保下一个进程能够正确运行。

进程调度的时机：在Linux中，进程的调度可以在多个时机发生。对于用户态进程来说，它们无法主动进行调度，只能在进入内核态的时机点进行调度。这些时机点可以是中断处理过程中或内核线程中。因此，用户态进程需要等待中断或其他内核事件的发生，才能由内核进行调度切换。

分时和优先级调度：Linux的进程调度是基于分时和优先级的。分时调度意味着每个进程都会被分配一个时间片，在时间片用完后，会被调度器切换到下一个进程。优先级调度则是根据进程的优先级来确定调度顺序，具有更高优先级的进程会优先被调度。

总的来说，Linux中的进程调度是通过schedule函数实现的，其中通过pick_next_task函数选择下一个要执行的进程，然后通过context_switch函数进行进程切换。进程调度的时机可以在中断处理过程中或内核线程中，而用户态进程则需要等待进入内核态的时机点才能被调度。调度策略基于分时和优先级，确保公平地分配CPU时间片并根据优先级进行调度。