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

一、实验要求

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

二、实验内容及分析

1.实验环境搭建

使用VMware创建 Ubuntu 18.04 虚拟机，将下载好的 mykernel-2.0_for_linux-5.4.34.patch 以及 linux-5.4.34.tar.xz 拖入虚拟机中，解压后打上补丁，安装相关程序后编译内核并安装 qemu虚拟机：

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.3.34.patch
sudo apt install build-essential gcc-multilib
sudo apt install qemu # install QEMU
sudo apt install libncurses5-dev bison flex libssl-dev libelf-dev
make defconfig # Default configuration is based on 'x86_64_defconfig'
make -j4

内核编译完成后启动qemu模拟器：

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

可以看到，该操作系统已经跑起来了，每100000和200000计数会打印一些东西，打开mymain.c和myinterrupt.c两个源代码可以看到，mymain.c中每100000计数输出my_start_kernel here，myinterrupt.c每200000计数输出my_timer_handler here。当前有一个CPU执行C代码的上下文环境，同时具有中断处理程序的上下文环境，我们通过Linux内核代码模拟了一个具有时钟中断和C代码执行环境的硬件平台。

void __init my_start_kernel(void)
{
    int i = 0;
    while(1)
    {
        i++;
        if(i%100000 == 0)
            pr_notice("my_start_kernel here  %d \n",i);
            
    }
}

void my_timer_handler(void)
{
    pr_notice("\n>>>>>>>>>>>>>>>>>my_timer_handler here<<<<<<<<<<<<<<<<<<\n\n");
}

2.基于mykernel 2.0编写一个操作系统内核，实现一个简单的时间片轮转多道程序

我们需要在mymain.c基础上继续写进程描述PCB和进程链表管理等代码，在myinterrupt.c的基础上完成进程切换代码。

2.1 新建文件mypch.h，定义进程控制块PCB：

#define MAX_TASK_NUM 4
#define KERNEL_STACK_SIZE 1024*2
/* CPU-specific state of this task */
struct Thread {
    unsigned long ip;
    unsigned long sp;
};

typedef struct PCB{
    int pid;
    volatile long state;    
　　/* -1 unrunnable, 0 runnable, >0 stopped */
    unsigned long 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);

定义了最大进程数MAX_TASK_NUM为4
定义了堆栈空间大小KERNEL_STACK_SIZE为2048
定义了 Thread 结构体来表示线程的ip指令指针和sp堆栈指针

PCB的结构体定义中：

pid表示进程号
state表示进程状态，初始化值是-1，表示不可运行，0表示可运行，其他值表示停止
stack[KERNEL_STACK_SIZE]表示进程使用的堆栈空间
thread表示当前正在执行的线程信息，包含了ip和sp
task_entry为进程入口函数
next为PCB的指针，指向下一个进程的PCB

函数声明 my_schedule，在my_interrupt.c中被定义，在mymain.c中的各个进程函数会根据一个全局变量的状态来决定是否调用它，从而实现进程的切换。

2.2 修改mymain.c，使其支持时间片进程切换

#include "mypcb.h"

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

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].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" /* 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;

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

my_current_task为指向当前进程的指针
my_need_sched表示进程调度状态，初始化为0，表示不需要进程切换，1表示需要进程切换

mymain.c的功能是进行所有进程的初始化并运行0号进程。

首先初始化0号进程，设置其状态为0，表示可运行，进程的入口和线程thread的指令指针都指向my_process，线程的栈顶指针指向分配的堆栈空间的最高地址处，将下一个进程控制块的指针指向自己。

接着初始化其余所有进程，利用拷贝函数将0号进程的信息拷贝至其余进程，为其余进程设置线程的栈顶指针，为其分配堆栈空间，然后将各个进程以链表的形式链接起来。

接下来的汇编代码用来启动进程，将当前进程指向0号进程，ecx寄存器存入thread.ip，edx寄存器存入Thread.sp，0号进程的栈顶指针的值赋给esp寄存器，将栈顶地址sp、线程指令指针ip入栈，然后将thread.ip出栈保存至esp寄存器，跳转至进程入口函数开始运行0号进程。

my_process函数是用来循环打印输出进程编号，并通过my_need_sched判断是否需要进行进程切换，0不需要切换，1需要进程切换就会调用my_schedule函数并将my_need_sched重新置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*/
);

这是启动第一个进程的汇编代码

movq %1,%%rs　　将进程原堆栈栈顶的地址存入RSP寄存器
pushq %1　　　　将当前RBP寄存器值压栈
pushq %0　　　　将当前进程的RIP压栈
ret　　　　　　　 ret命令正好可以让压栈的进程RIP保存到RIP寄存器中

2.3 修改myinterrupt.c，使其完成进程切换

#include "mypcb.h"

extern tPCB task[MAX_TASK_NUM];
extern tPCB *my_current_task;
extern volatile int my_need_sched;
volatile int time_count = 0;

/*
 * Called by timer interrupt.
 * it runs in the name of current running process,
 * so it use kernel stack of current running process
 */
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;
}

void my_schedule(void)
{
    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 */
        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 */
            "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;
}

my_timer_handler函数每1000次计数就会将my_need_sched置1，开始进行进程切换。
my_schedule函数用于进程的切换，next指向下一个进程，prev指向上一个进程。将当前运行进程指向下一个进程，若下一个进程状态为0，则执行进程切换。

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 */
            "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)
);

这是进程调度的关键汇编代码

pushq %%rbp 保存prev进程当前RBP寄存器的值到堆栈
movq %%rsp,%0 保存prev进程当前RSP寄存器的值到prev->thread.sp，这时RSP寄存器指向进程的栈顶地址，实际上就是将prev进程的栈顶地址保存；%0、%1...指这段汇编代码下面输入输出部分的编号
movq %2,%%rsp 将next进程的栈顶地址next->thread.sp放入RSP寄存器，完成了进程0和进程1的堆栈切换
movq $1f,%1 　保存prev进程当前RIP寄存器值到prev->thread.ip
pushq %3 　　把即将执行的next进程的指令地址next->thread.ip入栈
ret 　　将压入栈中的next->thread.ip放入RIP寄存器
1: 　　标号1是一个特殊的地址位置，该位置的地址是$1f
popq %%rbp 将next进程堆栈基地址从堆栈中恢复到RBP寄存器中

2.4 内核重新编译, 运行

三、总结

本次实验编写了一个简单的操作系统内核，最主要是完成进程的切换。进程在执行过程中，当时间片用完需要进行进程切换时，需要先保存当前的进程执行上下文环境，下次进程被调度时，需要恢复进程的上下文环境，这样实现多道程序的并发执行。需要利用堆栈，通过esp堆栈指针寄存器、ebp基址指针寄存器和cs:eip寄存器等关键寄存器来保存和恢复现场。

posted @ 2020-05-11 11:47 grsgth 阅读(168) 评论(0) 收藏举报

刷新页面返回顶部