Linux内核分析实验（一）——基于mykernel 2.0编写一个操作系统内核

一、实验内容

基于mykernel 2.0编写一个操作系统内核

1. 按照https://github.com/mengning/mykernel 的说明配置mykernel 2.0，熟悉Linux内核的编译；
2. 基于mykernel 2.0编写一个操作系统内核，参照https://github.com/mengning/mykernel 提供的范例代码
3. 简要分析操作系统内核核心功能及运行工作机制

二、实验过程

（一）实验环境配置

1、下载mykernel-2.0_for_linux-5.4.34.patch

1 wget https://raw.github.com/mengning/mykernel/master/mykernel-2.0_for_linux-5.4.34.patch

2、下载安装多线程下载工具axel并使用axel下载内核源代码

1 sudo apt install axel
2 axel -n 20 https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/linux-5.4.34.tar.xz

3、解压内核源代码

1 xz -d linux-5.4.34.tar.xz
2 tar -xvf linux-5.4.34.tar
3 cd linux-5.4.34

4、给mykernel-2.0_for_linux-5.4.34.patch打补丁

1 patch -p1 < ../mykernel-2.0_for_linux-5.4.34.patch

打补丁主要修改了如上图的几个文件。

5、安装开发工具

1 sudo apt install build-essential libncurses-dev bison flex libssl-dev libelf-dev
2 sudo apt install qemu # install QEMU

6、编译

1 make defconfig
2 make -j$(nproc)

7、运行内核

1 qemu-system-x86_64 -kernel arch/x86/boot/bzImage

8、运行结果及分析

由运行结果可以看出，my_start_kernel在不停执行，my_timer_handler时钟中断周期性触发。

（二）编写一个操作系统内核

1、主要过程：

基于mykernel2.0编写一个操作系统内核主要就是在linux-5.4.34/mykernel下新增一个mypcb.h文件、修改linux-5.4.34/mykernel下的mymain.c文件、修改linux-5.4.34/mykernel下的myinterrypt.c文件。

2、新增mypcb.h文件

//mypcb.h
 1 #define MAX_TASK_NUM        4
 2 // 最大进程数设为4
 3 #define KERNEL_STACK_SIZE   2048
 4 // 每个进程分配堆栈大小设为2048
 5 /* CPU-specific state of this task */
 6 struct Thread {
 7     unsigned long        ip;
 8     unsigned long        sp;
 9 };
10 
11 typedef struct PCB{
12     int pid;
13     volatile long state;    /*进程运行状态： -1 unrunnable, 0 runnable, >0 stopped */
14     unsigned long stack[KERNEL_STACK_SIZE]; // 给进程分配的堆栈，为long类型数组
15     /* CPU-specific state of this task */
16     struct Thread thread;
17     unsigned long    task_entry;
18     struct PCB *next; // 指向下一个进程PCB的指针
19 }tPCB;
20 
21 void my_schedule(void);

3、修改mymain.c文件

未修改前的mymain.c文件内容如下，让cpu进入my_kernel这个函数，模拟cpu循环取指令执行的过程

 //未修改的mymain.c
 1 void __init my_start_kernel(void)
 2 {
 3     int i = 0;
 4     while(1)
 5     {
 6         i++;
 7         if(i%100000 == 0)
 8             pr_notice("my_start_kernel here  %d \n",i);
 9             
10     }
11 }

对mymain.c进行修改，系统从my_start_kernel处最先执行，对进程列表task进行初始化，设置进程运行状态，每个进程入口都指向my_process的起始地址，栈顶指针为数组的最高地址，栈向下增长。

循环初始化其他进程，给每个进程分配各自的空间并用链表链接起来。

启动进程0，让rsp寄存器指向进程0的栈顶地址，push rbp，由于程序员无法直接操作rip寄存器所以先将ip入栈，再将ip出栈到rip寄存器，跳转到程序入口运行进程。

执行my_process函数，这个函数通过判断my_need_sched的值决定是否需要切换进程。

 //修改后的mymain.c
 1 #include 
 2 #include string.h>
 3 #include 
 4 #include 
 5 #include 
 6 
 7 
 8 #include "mypcb.h"
 9 
10 tPCB task[MAX_TASK_NUM];
11 tPCB * my_current_task = NULL;
12 volatile int my_need_sched = 0;
13 
14 void my_process(void);
15 
16 
17 void __init my_start_kernel(void)
18 {
19     int pid = 0;
20     int i;
21     /* Initialize process 0*/
22     task[pid].pid = pid;
23     task[pid].state = 0;/* -1 unrunnable, 0 runnable, >0 stopped */
24     task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;
25     task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
26     task[pid].next = &task[pid];
27     /*fork more process */
28     for(i=1;i)
29     {
30             memcpy(&task[i],&task[0],sizeof(tPCB));
31             task[i].pid = i;
32         task[i].thread.sp = (unsigned long)(&task[i].stack[KERNEL_STACK_SIZE-1]);
33             task[i].next = task[i-1].next;
34             task[i-1].next = &task[i];
35     }
36     /* start process 0 by task[0] */
37     pid = 0;
38     my_current_task = &task[pid];
39     asm volatile(
40         "movq %1,%%rsp\n\t"     /* set task[pid].thread.sp to rsp */
41         "pushq %1\n\t"             /* push rbp */
42         "pushq %0\n\t"             /* push task[pid].thread.ip */
43         "ret\n\t"                 /* pop task[pid].thread.ip to rip */
44         : 
45         : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)    /* input c or d mean %ecx/%edx*/
46     );
47 } 
48 
49 int i = 0;
50 
51 void my_process(void)
52 {    
53     while(1)
54     {
55         i++;
56         if(i%10000000 == 0)
57         {
58             printk(KERN_NOTICE "this is process %d -\n",my_current_task->pid);
59             if(my_need_sched == 1)
60             {
61                 my_need_sched = 0;
62             my_schedule();
63         }
64       printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);
65         }     
66     }
67 }

4、修改myinterrypt.c

未修改前的myinterrypt.c文件内容如下，没有循环，只是一行输出，但是由于周期性的产生时钟中断，所以myinterrypt.c也在周期性的运行。

//未修改的myinterrupt.c
1 void my_timer_handler(void)
2 {
3     pr_notice("\n>>>>>>>>>>>>>>>>>my_timer_handler here<<<<<<<<<<<<<<<<<<\n\n");
4 }

对myinterrupt.c进行修改，其中my_shedule函数实现了进程的切换，切换过程如下：

（1）将rbp寄存器的值压入栈中，保存当前进程的栈底地址

（2）将rsp值保存在当前进程的sp字段，保存当前进程的栈顶

（3）将下一个进程的sp字段放入rsp中

（4）将1f存放到当前进程的ip字段中

（5）将下一个进程的ip字段放到指令寄存器ip中

（6）将下一个进程的栈顶弹出到栈基址寄存器rbp中

//修改后的myinterrupt.c
 1 #include 
 2 #include string.h>
 3 #include 
 4 #include 
 5 #include 
 6 
 7 #include "mypcb.h"
 8 
 9 extern tPCB task[MAX_TASK_NUM];
10 extern tPCB * my_current_task;
11 extern volatile int my_need_sched;
12 volatile int time_count = 0;
13 
14 /*
15  * Called by timer interrupt.
16  * it runs in the name of current running process,
17  * so it use kernel stack of current running process
18  */
19 void my_timer_handler(void)
20 {
21     if(time_count%1000 == 0 && my_need_sched != 1)
22     {
23         printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");
24         my_need_sched = 1;
25     } 
26     time_count ++ ;  
27     return;      
28 }      
29 
30 void my_schedule(void)
31 {
32     tPCB * next;
33     tPCB * prev;
34 
35     if(my_current_task == NULL 
36         || my_current_task->next == NULL)
37     {
38         return;
39     }
40     printk(KERN_NOTICE ">>>my_schedule<<<\n");
41     /* schedule */
42     next = my_current_task->next;
43     prev = my_current_task;
44     if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */
45     {        
46         my_current_task = next; 
47         printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);  
48         /* switch to next process */
49         asm volatile(    
50             "pushq %%rbp\n\t"         /* save rbp of prev */
51             "movq %%rsp,%0\n\t"     /* save rsp of prev */
52             "movq %2,%%rsp\n\t"     /* restore  rsp of next */
53             "movq $1f,%1\n\t"       /* save rip of prev */    
54             "pushq %3\n\t" 
55             "ret\n\t"                 /* restore  rip of next */
56             "1:\t"                  /* next process start here */
57             "popq %%rbp\n\t"
58             : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
59             : "m" (next->thread.sp),"m" (next->thread.ip)
60         ); 
61     }  
62     return;    
63 }

5、运行结果

重新编译运行程序结果如下：

三、总结

经过此次实验对进程切换、管理和中断等Linux内核中的核心功能有了更加深入的了解。