20233808《Linux内核原理分析与设计》第九周作业

最新推荐文章于 2024-09-12 20:58:18 发布

20233808

最新推荐文章于 2024-09-12 20:58:18 发布

阅读量70

点赞数

文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/qq_53616927/article/details/134460476

版权

1.与chatgpt的对话

https://chat.openai.com/share/cc3cf444-4776-4258-9053-f15e7dff2a69

2.实验楼

在内核代码中搜索 schedule()函数

有两种搜索方式

//这个命令会递归搜索指定路径下的所有文件，查找包含 schedule( 的行
grep -r 'schedule(' /path/to/linux/kernel/source
//ack 是一个递归搜索的强大工具，可以更方便地查找源代码
ack 'schedule\(' /path/to/linux/kernel/source

`schedule()`函数选择一个新的进程来运行，并调用context_switch进行上下文的切换，这个宏调用`switch_to` 来进行关键上下文切换
`next = pick_next_task(rq, prev); ` //包装了某种进程调度策略
`context_switch(rq, prev, next); ` //进程上下文切换
`switch_to(pre,next,prev)` //切换寄存器的状态和堆栈。利用了prev和next两个参数：prev指向当前进程，next指向被调度的进程

使用 gdb 跟踪分析一个 schedule()函数

由于内核无法克隆所以手动添加函数

添加exec函数

int Exec(int argc, char *argv[])
{
    int pid;
    /* fork another process */
    pid = fork();
    if (pid < 0) 
    { 
        /* error occurred */
        fprintf(stderr,"Fork Failed!");
        exit(-1);
    } 
    else if (pid == 0) 
    {
        /*     child process     */
        printf("This is Child Process!\n");
        execlp("/hello","hello",NULL);
    } 
    else 
    {     
        /*     parent process     */
        printf("This is Parent Process!\n");
        /* parent will wait for the child to complete*/
        wait(NULL);
        printf("Child Complete!\n");
    }
}

修改main函数

MenuConfig("exec","Execute a program",Exec);

help命令可以看到添加了exec函数

设置断点在schedule、context_switch、pick_next_task、switch_to

指令c跟踪调试

分析 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)

这段代码实现了进程上下文的切换机制，从一个进程（prev）切换到另一个进程（next）

保存当前进程上下文：

pushfl 指令保存当前进程的标志寄存器（flags）

pushl %%ebp 指令保存当前进程的堆栈基址（ebp 寄存器)

保存当前进程堆栈指针和下一条指令地址：

movl %%esp, %[prev_sp] 将当前进程的堆栈指针保存在 [prev_sp] 变量中。

movl $1f, %[prev_ip] 将当前进程的下一条指令地址（标签 1:）保存在 [prev_ip] 变量中。

更新堆栈指针和设置下一个进程的执行起点：

movl %[next_sp], %%esp 更新堆栈指针，将下一个进程的堆栈指针加载到 esp 寄存器中。

pushl %[next_ip] 将下一个进程的执行起点地址（next_ip）压入堆栈。

跳转到切换处理代码：

jmp __switch_to 跳转到 __switch_to 标签，该标签通常包含处理堆栈切换的汇编代码。