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

一 、配置mykernel 2.0

　　实验环境：VMware+虚拟机Ubuntu 18.04.1 LTS amd64

　　使用如下的配置命令：

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 sudo apt-get install build-essential gcc-multilib
sudo sudo apt install qemu # install QEMU
sudo sudo apt-get install libncurses-dev bison flex libssl-dev libelf-dev
make make defconfig # Default configuration is based on 'x86_64_defconfig'
make make -j$(nproc)
qemu-system-x86_64 -kernel arch/x86/boot/bzImage

Note: make -j$(nproc)操作命令

1. make -j后面跟着处理器的逻辑cpu个数，在编译的时候直接使用$(nproc)很方便，如果想具体了解核心数，可以在命令行输入：echo $(nproc)，然后将显示出来的数字填入即可。

2.知道了nproc的具体含义之后就可以通过proc文件系统查看cpu具体信息了，输入如下命令即可。

• make allnoconfig配置编译内核，能完成mykernel实验并节约时间,但是其configuration is based on ‘i386_defconfig’，此时如果你使用system-x86_64 -kernel arch/x86/boot/bzImage启动的话会出错的

• make defconfig # Default configuration is based on 'x86_64_defconfig'

• 具体：我们分别用这两种方式编译之后，可以打开顶层目录的.config文件，其配置信息中有一个CONFIG_ARCH_DEFCONFIG字段的内容是不一样的

将上述操作弄完之后，我们的编译及其QEMU的运行结果如下：

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

在Linux-5.3.34内核源代码根目录下进入mykernel目录,可以看到QEMU窗口输出的内容的代码mymain.c和myinterrupt.c,当前有一个虚拟的CPU执行C代码的上下文环境,可以看到mymain.c中的代码在不停地执行。同时有一个中断处理程序的上下文环境,周期性地产生的时钟中断信号,能够触发myinterrupt.c中的代码。这样就通过Linux内核代码模拟了一个具有时钟中断和C代码执行环境的硬件平台。您只要在mymain.c的基础上继续写进程描述PCB和进程链表管理等代码,在myinterrupt.c的基础上完成进程切换代码,就可以完成一个可运行的小OS kernel.其mymain.c的代码如下

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 
#include 


#ifdef CONFIG_X86_LOCAL_APIC
#include 
#endif


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

二、 修改内核

1 添加mypcb.h头文件

首先,在mykernel目录下增加一个mypcb.h头文件,用来定义进程控制块(Process ControlBlock) ,也就是进程结构体的定义,在Linux内核中是structtast_struct结构体。

• Thread结构体模拟指令指针与堆栈指针

• PCB结构体实现进程控制块，主要包含进程句柄，状态，栈，线程信息，进程函数等，next以链表形式链接进程

  `struct Thread {
  unsigned long ip;//指令指针
  unsigned long sp;//堆栈指针
  };

  typedef struct PCB{
  int pid;//进程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);`

2 修改mymain.c文件

mymain.c是mykernel内核代码的入口,负责初始化内核的各个组成部分。在Linuxp核源代码中,实际的内核入口是init/main.中的start_kernel(void)函数。

mymain.c里面void __init my_start_kernel(void)函数对内核进行初始化，首先初始化一个进程，然后fork出更多的进程，最后通过任务0启动0号进程。void my_process(void)函数主要是模拟进程运行，我们模拟的进程类似于时间片轮转的方式。我们将进程加到一个数的时间设置为一个时间片，当进程运行了一个时间片之后就会主动让出cpu，这里并没有采用中断方式实现进程切换，因为中断实现切换更复杂，需要考虑很多东西。

#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;ipid);
            if(my_need_sched == 1)
            {
                my_need_sched = 0;
                my_schedule();
            }
            printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);
        }     
    }
}

3 修改myinterrupt.c文件

进程运行过程中是怎么知道时间片消耗完了呢?

这就需要时钟中断处理过程中记录时间片。对myinterrupt.c中修改my-timer-handler用来记录时间片。在myinterrupt.c中创建my_timer_handler()函数用来记录时间片，当进程等待时间到，进程就会打印一行信息，并且将自己的需要调度置1，表示进程需要调度。

后面创建了进程调度my_schedule()函数用来模拟进程调度，该函数首先检查进程是否可以调度，当进程调度条件满足后，就通过汇编代码进行进程切换。

#include 
#include 
#include 
#include 
#include 

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

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

到这里，我们的mykernel就编写结束了。

重新编译后运行结果如下图：

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

1 内核核心功能

内核是计算机上配置的底层软件，是操作系统最基本、最核心的部分。

实现操作系统内核功能的那些程序就是内核程序。

• 时钟管理：实现计时功能
• 中断处理：负责实现中断机制
• 原语：是一种特殊的程序处于操作系统最底层，是最接近硬件的部分这种程序的运行具有原子性——其运行只能一气呵成，不可中断运行时间较短、调用频繁
• 系统资源管理：
  • 进程管理
  • 存储器管理
  • 设备管理

2 运行工作机制

有的指令“人畜无害”。比如：加、减、乘、除 这些普通的运算指令。
有的指令有很高的权限。比如：内存清零指令。如果用户程序可以使用这个指令，就意味着一个用户可以将其他用户的内存数据随意清零，这样显然是很危险的。为了解决这个问题，把指令分为特权指令和非特权指令

• 两种指令：
  • 特权指令：如内存清零指令（不允许用户程序使用）
  • 非特权指令：如普通运算指令

问题：CPU如何判断当前是否可以执行特权指令？

• 两种处理器状态：
  • 核心态(管态)：此时特权指令、非特权指令都可执行
  • 用户态(目态)：此时CPU只能执行非特权指令

用程序状态字寄存器（PSW）中的某标志位来标识当前处理器处于什么状态。如：0为用户态，1为核心态

• 两种程序
  • 内核程序：操作系统的内核程序是系统的管理者，既可执行特权指令，也可以执行非特权指令，运行在核心态。
  • 应用程序：为了保证系统能安全运行，普通应用程序只能执行非特权指令，运行在用户态。