linux实验三：基于mykernel 2.0编写一个简单的操作系统内核

最新推荐文章于 2022-07-03 16:25:59 发布

F-A-DD

最新推荐文章于 2022-07-03 16:25:59 发布

阅读量334

点赞数

文章标签： linux 内核操作系统

本文链接：https://blog.csdn.net/qq_37254846/article/details/115359750

版权

实验内容

按照https://github.com/mengning/mykernel的说明配置mykernel 2.0，熟悉Linux内核的编译；基于mykernel 2.0编写一个操作系统内核，参照https://github.com/mengning/mykernel 提供的范例代码

实验要求

（1）完成一个简单的时间片轮转多道程序内核代码；

（2）分析进程的启动和进程的切换机制

（3）简要分析操作系统内核核心功能及运行工作机制

实验过程

（1）配置并编译mykernel 2.0 （Ubuntu 18.04）

wget https://raw.github.com/mengning/mykernel/master/mykernel-2.0_for_linux-5.4.34.patch
sudo apt install axel
axel -n 20 https://mirrors.edge.kernel.org/pub/linux/kernel/v5.x/linux-5.4.34.tar.xz
xz -d linux-5.4.34.tar.xz
tar -xvf linux-5.4.34.tar   # or tar -xvf linux-5.4.34.tar.gz
cd linux-5.4.34
patch -p1 < ../mykernel-2.0_for_linux-5.4.34.patch
sudo apt install build-essential libncurses-dev bison flex libssl-dev libelf-dev
make defconfig # Default configuration is based on 'x86_64_defconfig'
make -j$(nproc) # 编译的时间比较久
sudo apt install qemu # install QEMU
qemu-system-x86_64 -kernel arch/x86/boot/bzImage

从qemu窗口中可以看到my_start_kernel在执行，同时my_timer_handler时钟中断处理程序周期性执行。

（2）编写一个简单的os代码

mykernel目录下有mymain.c、myinterrupt.c两个文件。当前有一个CPU执行C代码的上下文环境，同时具有中断处理程序的上下文环境，我们通过Linux内核代码模拟了一个具有时钟中断和C代码执行环境的硬件平台。只要在mymain.c基础上继续写进程描述PCB和进程链表管理等代码，在myinterrupt.c的基础上完成进程切换代码，就可以完成一个简单的时间片轮转多道程序内核代码。

将完成的 mypcb.h mymain.c myinterrupt.c 放入mykernel目录下，输入以下命令重新编译：

make clean
make
qemu-system-x86_64 -kernel arch/x86/boot/bzImage

运行结果截图：图中可以看到进程间正常的切换过程
在这里插入图片描述

代码分析

mykernel目录下新建mypcb.h 头文件，用来定义进程控制块PCB，即进程结构体的定义。
三个文件：mypcb.h 、mymain.c 、myinterrupt.c

mypcb.h

头文件，定义了一些结构体等内容

/*
 *  linux/mykernel/mypcb.h
 *  Kernel internal PCB types
 *  Copyright (C) 2013  Mengning
 */

/**宏定义 定义进程的最大数量和内核栈的大小 **/
#define MAX_TASK_NUM        4  //定义了最大任务数
#define KERNEL_STACK_SIZE   1024*2 //定义了堆栈内核大小
/* CPU-specific state of this task */

//堆栈结构体： 存储ip,sp
struct Thread {
    unsigned long        ip; //指令指针
    unsigned long        sp; //堆栈指针
};
// 进程控制块PCB结构体（关键）：
typedef struct PCB{
    int pid;    //进程的id-----表示进程号，是进程的标识符
    volatile long state;    /* 定义进程状态: -1 unrunnable不可运行, 0 runnable可运行, >0 stopped */
    unsigned long stack[KERNEL_STACK_SIZE];  //进程堆栈  ----- 表示进程的堆栈空间
    /* CPU-specific state of this task */
    struct Thread thread;  //----- 表示进程的线程信息，包含ip、sp指针（目前一个进程只包含一个线程）
    unsigned long    task_entry;      //进程入口点
    struct PCB *next;    //指向下一个进程控制块PCB的指针
}tPCB;
};

//调度函数的函数声明。此函数在myinterrput.c中定义，mymain.c中的进程会依据一个全局变量来决定是否调用此函数，来实现进程的调度切换。
void my_schedule(void);

mymain.c

利用my_process函数模拟一个个进程的运行，这里采用的是进程运行完一个时间片后主动让出CPU的方式。
进程运行过程中是怎么知道时间片消耗完了呢？
这就需要时钟中断处理过程中记录时间片。对myinterrupt.c中修改my_timer_handler用来记录时间片。

/*
 *  linux/mykernel/mymain.c
 *
 *  Kernel internal my_start_kernel
 *  Change IA32 to x86-64 arch, 2020/4/26
 *
 *  Copyright (C) 2013, 2020  Mengning
 *  
 */
#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/tty.h>
#include <linux/vmalloc.h>


#include "mypcb.h"

tPCB task[MAX_TASK_NUM];     //声明tPCB类型的数组
tPCB * my_current_task = NULL;    //声明当前task的指针
volatile int my_need_sched = 0;     //判断是否需要调度

void my_process(void);

/** 从my_start_kernel开始执行,实际的内核入口是init/main.c中的start_kernel(void)函数
     my_start_kernel是系统启动后，第一个调用的函数。在这个函数中，首先初始化了0号进程： **/
void __init my_start_kernel(void)
{
    int pid = 0;
    int i;
    /* Initialize process 0*/
    task[pid].pid = pid;      //初始化0号进程
    task[pid].state = 0;/* -1 unrunnable, 0 runnable, >0 stopped  设置进程状态为可运行状态*/
    task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;   //设置进程的入口地址为my_process函数
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
    task[pid].next = &task[pid];
    /*
    ======= fork more process =======
    Linux创建子进程时,也是使用fork复制进程,然后改变一些关键信息,比如进程PID等
    */
    // 在for循环中创建了3个进程，pid分别为1、2、3，并把PCB用指针链接。
    for(i=1;i<MAX_TASK_NUM;i++)   
    {
        memcpy(&task[i],&task[0],sizeof(tPCB));
        task[i].pid = i;
        task[i].thread.sp = (unsigned long)(&task[i].stack[KERNEL_STACK_SIZE-1]);
        task[i].next = task[i-1].next;
        task[i-1].next = &task[i];
    }
    /* start process 0 by task[0] */
    pid = 0;
    my_current_task = &task[pid];
    // 然后打开0号进程。由内嵌汇编代码实现：
    asm volatile(
        "movq %1,%%rsp\n\t"         /* set task[pid].thread.sp to rsp */
        "pushq %1\n\t"             /* push rbp */
        "pushq %0\n\t"            /* push task[pid].thread.ip */
        "ret\n\t"                /* pop task[pid].thread.ip to rip */
        : 
        : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)    /* input c or d mean %ecx/%edx*/
    );
} 

int i = 0;

/**  my_process函数 进程运行体:用来作为进程的代码模拟一个个进程
     这里采用的是进程运行完一个时间片后主动让出CPU的方式，没有采用中断的时机完成进程切换，
     因为中断机制实现起来较为复杂，等后续部分再逐渐深入。 **/
// 这个函数的功能是在检查全局变量 my_need_sched ，当其值为1时，就调用my_schedule()进行进程调度切换。
void my_process(void)
{    
    while(1)
    {
        i++;
        if(i%10000000 == 0)
        {
            printk(KERN_NOTICE "this is process %d -\n",my_current_task->pid);
            if(my_need_sched == 1)    //判断是否需要调度
            {
                my_need_sched = 0;
                my_schedule();
            }
            printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);
        }     
    }
}

在for循环中创建了3个进程，pid分别为1、2、3，并把PCB用指针链接。

// i 从1开始
task[i].next = task[i-1].next;
task[i-1].next = &task[i];

在这里插入图片描述
myinterrupt.c

/*
 *  linux/mykernel/myinterrupt.c
 *
 *  Kernel internal my_timer_handler
 *  Change IA32 to x86-64 arch, 2020/4/26
 *
 *  Copyright (C) 2013, 2020  Mengning
 *
 */
#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/tty.h>
#include <linux/vmalloc.h>

#include "mypcb.h"

/* 代码中首先定义/声明了一些全局变量：
 * task:任务队列  此变量在mymain.c文件中定义，此处为外部声明
 * my_current_task:当前运行的进程 此处为外部声明
 * my_need_sched:调度标示 此处为外部声明
 * time_count:计数器 此处定义了一个全局变量，用来模拟时间片
 */
extern tPCB task[MAX_TASK_NUM];
extern tPCB * my_current_task;
extern volatile int my_need_sched;
volatile int time_count = 0;

/* 模拟时钟中断 
   此函数的功能是当时间片为1000的整数倍时，就将全局变量my_need_sched的值置为1，
   这样mymain.c中的my_process函数就可以调用my_schedule函数来进行进程切换了。*/
void my_timer_handler(void)
{
    if(time_count%1000 == 0 && my_need_sched != 1)   //控制时间片的大小，设置调度的标志
    {
        printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");
        my_need_sched = 1;
    } 
    time_count ++ ;  
    return;      
}
/* 进程切换
	代码中定义了两个PCB指针：
	
 */
void my_schedule(void)   
{
	/*定义了两个PCB指针：
		tPCB * next，指向下一个PCB
		tPCB * prev，指向当前PCB
	 */
    tPCB * next;
    tPCB * prev;

    if(my_current_task == NULL 
        || my_current_task->next == NULL){
        return;
    }
    printk(KERN_NOTICE ">>>my_schedule<<<\n");
    /* schedule */
    next = my_current_task->next;
    prev = my_current_task;
    if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped 根据下一个进程的状态来判断是否切换*/
    {        
        my_current_task = next; 
        printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);  
        /* switch to next process 
         如果下 一个进程的state是runable，那么就切换到下一个进程*/
       // 以下代码的功能是切换进程堆栈，保存当前进程的上下文、切换到另一进程的上下文。
        asm volatile(    
            "pushq %%rbp\n\t"         /* save rbp of prev */
            "movq %%rsp,%0\n\t"     /* save rsp of prev */
            "movq %2,%%rsp\n\t"     /* restore  rsp of next */
            "movq $1f,%1\n\t"       /* save rip of prev ,%1f指接下来的标号为1的位置*/    
            "pushq %3\n\t" 
            "ret\n\t"                 /* restore  rip of next */
            "1:\t"                  /* next process start here */
            "popq %%rbp\n\t"
            : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
            : "m" (next->thread.sp),"m" (next->thread.ip)
        ); 
    }  
    return;    
}

内嵌汇编语法分析

分析操作系统内核核心功能及运行工作机制

启动执行第一个进程的关键汇编代码分析

// 由于启动的第一个进程是我们自己初始化好的0号进程，所以这里代码的task[pid].thread.ip和 task[pid].thread.sp分别为0号进程ip和sp。
asm volatile(
    "movq %1,%%rsp\n\t" /* 将进程原堆栈栈顶的地址存入RSP寄存器 */  //将RSP寄存器指向进程0的堆栈栈底
    
    "pushq %1\n\t"   /* 将当前RBP寄存器值压栈 */ 
    /* 本来应该压栈当前进程的RBP，因为是空栈，所以RSP与RBP相同，这里简化起见，直接使用进程的		
    堆栈栈顶的值task[pid].thread.sp，之后RSP = RSP - 8(堆栈地址空间从高到低，位数为64位) */
    
    "pushq %0\n\t"   /* 将当前进程的RIP压栈 
                     将当前进程的RIP（这里是初始化的值my_process(void)函数的位置）入栈，RSP = RSP - 8 */
                     
    "ret\n\t"           /* ret命令正好可以让压栈的进程RIP保存到RIP寄存器中 */
    /*将栈顶位置的task[0].thread.ip，也就是my_process(void)函数的地址放入RIP寄存器中，
      RSP = RSP + 8，修改IP的内容，从而实现近转移。*/
    :
    : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)
);

进程上下文切换的关键代码分析

为了简便，假设系统只有两个进程，分别是进程0和进程1。进程0由内核启动时初始化执行，然后需要进程调度和进程切换，然后开始执行进程1。进程切换过程中进程0和进程1的堆栈和相关寄存器的变化过程大致如下：

pushq %3：
ret：
1:：
popq %%rbp：

    printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);  
        /* switch to next process */
        asm volatile(   
            "pushq %%rbp\n\t"       /* save rbp of prev  保存0号进程的rbp，rsp = rsp - 8(x86向下增长)*/
            "movq %%rsp,%0\n\t"     /* save rsp of prev 把0号进程的rsp保存在prev->thread.sp变量中*/
            "movq %2,%%rsp\n\t"     /* restore  rsp of next   rsp指向1号进程的栈顶*/
            "movq $1f,%1\n\t"       /* save rip of prev  
                                     其中的$1f是magic number，指的是下面的1:的地址，
                                     这句的作用是prev->thread.ip = $1f*/  
                                     
            "pushq %3\n\t"  
            /*把即将执行的next进程的指令地址next->thread.ip入栈，这时的next->thread.ip可能是进程1的起点my_process(void)函数，
             也可能是$1f（标号1）。第一次被执行从头开始为进程1的起点my_process(void)函数，其余的情况均为$1f（标号1），
             因为next进程如果之前运行过那么它就一定曾经也作为prev进程被进程切换过 */
             
            "ret\n\t"               /* restore  rip of next 
            就是将压入栈中的next->thread.ip放入RIP寄存器，为什么不直接放入RIP寄存器呢？
            因为程序不能直接使用RIP寄存器，只能通过call、ret等指令间接改变RIP寄存器。使用ret从而实现近转移。*/
            
            "1:\t"                  /* next process start here  标号1是一个特殊的地址位置，该位置的地址是$1f。*/
            
            /*像这段代码的第一句pushq %%rbp一样，进程切换时会把当前栈的基址RBP保存在栈顶。
              所以本条命令的作用就是将1号进程堆栈基地址从堆栈中恢复到RBP寄存器中，
              从而完成进程的切换，即RBP和RSP都指向了进程1的堆栈。*/
            "popq %%rbp\n\t"
            : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
            : "m" (next->thread.sp),"m" (next->thread.ip)
        );

实验过程报出的错误及解决方法：

在修改完代码后执行make会出现以下错误：

mykernel/mymain.c: Assembler messages:
mykernel/mymain.c:48: 错误： bad register name `%rsp'
mykernel/mymain.c:49: 错误： unsupported instruction `push'
mykernel/mymain.c:50: 错误： unsupported instruction `push'
scripts/Makefile.build:265: recipe for target 'mykernel/mymain.o' failed
make[1]: *** [mykernel/mymain.o] Error 1
Makefile:1691: recipe for target 'mykernel' failed
make: *** [mykernel] Error 2

看到错误的第一反应该是寄存器的位数不支持，所以我就把上述代码中的所有rsp、rbp寄存器改成了32位的esp、ebp寄存器。pushq和movq都改成了pushl和movl，然后使用make再重新编译。make成功，qemu正常启动，但是却一直卡在了Booting from ROM…

试了一个博主的做法make clean和两次make还是一直失败，最后把原本的mykernel文件夹里边的Makefile拿出来，把文件夹删了重建把 Makefile放进去，把 mymain.c myinterrupt.c mypcb.h这三个文件重建（感觉这一步应该不用做，主要还是下面的问题）

试了查到的一个ubuntu18.04 在编译内核时报错解决方案。
ubuntu18.04在编译时报错，主要是安装包问题，将下面安装包重新安装一下即可解决。执行了下面的代码重新安装

sudo apt-get install libncurses5-dev libssl-dev

sudo apt-get install build-essential openssl

sudo apt-get install zlibc minizip

sudo apt-get install libidn11-dev libidn11

sudo apt-get install bison

sudo apt-get install flex

编译完的config可通过make clean或者make mrproper或者make distclean来进行清除
建议用make clean / make distclean ,

用了 make mrproper 这一句结果把上面编译mykernel 2.0也给清除了
重新执行下面的命令，结果成功了！！！

make defconfig 
make -j$(nproc) # 编译的时间比较久哦
make
qemu-system-x86_64 -kernel arch/x86/boot/bzImage

参考链接：
https://www.jianshu.com/p/f85db36ab2d1
https://blog.csdn.net/qwei19951126/article/details/88428613
https://blog.csdn.net/a20132848/article/details/82802925

F-A-DD

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
linux实验三：基于mykernel 2.0编写一个简单的操作系统内核

实验内容按照https://github.com/mengning/mykernel的说明配置mykernel 2.0，熟悉Linux内核的编译；基于mykernel 2.0编写一个操作系统内核，参照https://github.com/mengning/mykernel 提供的范例代码实验要求（1）完成一个简单的时间片轮转多道程序内核代码；（2）分析进程的启动和进程的切换机制（3）简要分析操作系统内核核心功能及运行工作机制实验过程（1）配置并编译mykernel 2.0 （Ubuntu 18
复制链接

扫一扫