基于mykernel 2.0的操作系统内核

1.搭建虚拟的x86-64 CPU实验平台mykernel

实验平台：Ubuntu18.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
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

测试：

在mykernel目录下，可以看到mymain.c和myinterrupt.c，mymain.c中的代码在不停地执行，同时有一个中断处理程序的上下文环境，周期性地产生时钟中断信号，能够触发myinterrupt.c中的代码。

2.mypcb.h头文件

#define MAX_TASK_NUM        4
#define KERNEL_STACK_SIZE    (1024 * 8)

/* CPU-specific state of this task */
struct Thread {
    unsigned long ip; 
    unsigned long sp;
};

typedef struct PCB{
    int pid;
    volatile long state; 
    char stack[KERNEL_STACK_SIZE];
    /* CPU-specific state of this task */
    struct Thread thread;
    unsigned long task_entry;
    struct PCB *next;
}tPCB;

void my_schedule(void);

 此文件用来定义进程控制块PCB。其中ip和sp为进程中线程的ip和sp，PCB中包括进程号、进程状态、栈、线程、入口函数、下一个进程的PCB。

3.对mymain.c进行修改

1）修改入口函数：修改前的文件代码：这是mykernel内核代码的入口。负责初始化内核的各个组成部分。

 修改代码：

#include "mypcb.h"

tPCB task[MAX_TASK_NUM], *my_current_task = NULL;
volatile int my_need_sched = 0;

static void my_process(void);

void __init my_start_kernel(void)
{
    int pid = 0;
    int i;
    /* Initialize process 0*/
    task[pid].pid = pid;
    task[pid].state = 0;/* -1 unrunnable, 0 runnable, >0 stopped */
    task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
    task[pid].next = &task[pid];
    /*fork more process */
    for(i=1;i<MAX_TASK_NUM;i++)
    {
        memcpy(&task[i],&task[0],sizeof(tPCB));
        task[i].pid = i;
        task[i].state = -1;
        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];
    asm volatile(
        "movq %1,%%rsp\n\t" /* 将进程原堆栈栈顶的地址存入RSP寄存器 */
        "pushq %1\n\t" /* 将当前RBP寄存器值压栈 */
        "pushq %0\n\t" /* 将当前进程的RIP压栈 */
        "ret\n\t" /* 让压栈的进程RIP保存到RIP寄存器 */
        :
        : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)
    );
    }

首先初始化0号进程，将进程状态设置为就绪。在启动进程0时，首先将RSP寄存器指向进程0的堆栈栈底；然后将当前RBP寄存器的值压栈，此时RSP与RBP相等；再将当前进程的RIP入栈，此时RSP = RSP - 8；最后将my_process(void)函数的地址放入RIP寄存器，RSP = RSP + 8。完成进程0的启动，开始执行my_process(void)函数。

2）添加my_process函数：用来作为进程的代码模拟一个进程。进程运行完一个时间片后主动让出CPU，没有采用中断。

void my_process(void)
{
    int i = 0;
    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);
        }
    }
}

 

4.对myinterrupt.c进行修改

1)修改my_timer_handler用来记录时间片

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;
}

2）增加进程切换代码my_schedule()函数

void my_schedule(void)
{
    tPCB *next, *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) {
        my_current_task = next;
        printk(KERN_NOTICE ">>>switch from %d to %d<<<\n",prev->pid, next->pid);
                /* switch to next process */
        asm volatile(
            "pushq  %%rbp\n\t"    /* save rbp of prev */    
            "movq    %%rsp, %0\n\t"    /* save rsp */
            "movq    %2, %%rsp\n\t"    /* restore  rsp */
            "movq    $1f, %1\n\t"    /* save rip */
            "pushq    %3\n\t"
            "ret\n\t"
            "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)
        );
    } else {
        next->state = 0;
        my_current_task = next;
        printk(KERN_NOTICE ">>>switch to new process %d<<<\n",next->pid);
    }
}

当两个进程切换时首先将当前进程0的RBP值和RSP值分别保存在堆栈和prev->thread.sp；然后将进程1的栈顶地址放在RSP寄存器，此时完成了进程0和进程1的堆栈切换；进程在执行过程中，当时间片用完需要进行进程切换时，需要先保存当前的进程上下文环境，下次进程被调度执行时，需要恢复进程上下文环境，就这样通过虚拟化的进程概念实现了多道程序在同⼀个物理CPU上并发执行。

5.结果测试

重新编译后测试结果如下：