基于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 <linux/sfi.h>

include <linux/shmem_fs.h>

include <linux/slab.h>

include <linux/perf_event.h>

include <linux/file.h>

include <linux/ptrace.h>

include <linux/blkdev.h>

include <linux/elevator.h>

include <asm/io.h>

include <asm/bugs.h>

include <asm/setup.h>

include <asm/sections.h>

include <asm/cacheflush.h>

ifdef CONFIG_X86_LOCAL_APIC

include <asm/smp.h>

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

3 修改myinterrupt.c文件

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

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

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

include <linux/types.h>

include <linux/string.h>

include <linux/ctype.h>

include <linux/tty.h>

include <linux/vmalloc.h>

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为核心态

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