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

一. 实验要求

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

---

二. 实验环境
vmvare Workstation pro 15+ubuntu 18.04

---

三. 实验步骤

1. 配置mykernel 2.0,熟悉Linux内核的编译
   安装Linux内核源码，安装命令如下：

   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
   

   从qemu窗口中您可以看到my_start_kernel在执行，同时my_timer_handler时钟中断处理程序周期性执行。
   这是因为myinterrupt.c不断产生时间中断信号，请求CPU进行处理。运行结果如图：
   

2. 基于mykernel 2.0编写一个操作系统内核，参照https://github.com/mengning/mykernel 提供的范例代码

   1. 在mymain.c基础上继续写进程描述PCB和进程链表管理等代码

      
      #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; /* -1 unrunnable, 0 runnable, >0 stopped */
          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进程控制块的数据结构：
      1. pid表示的是进程号
      2. state代表的是进程的状态，其中-1就绪状态，0代表运行状态，大于0代表阻塞状态
      3. stack代表的是进程运行所需的栈空间。最大为KERNEL_STACK_SIZE
      4. thread代表的是当前正在执行的线程信息
      5. task_entry代表的是进程的入口函数
      6. next指针指向下一个进程。因为进程可以形成链表结构

   2. 在myinterrupt.c的基础上完成进程切换代码

      1. 对mymain.c中的my_start_kernel函数进行修改，并在mymain.c中实现了my_process函数，my_process用一个死循环
         来不断产生进程，模拟时间片轮转调度的过程。主要的原理是myinterrupt.c，他会周期性的产生中断信号、通过中断信号
         将全局变量my_need_sched的值修改为1，当my_need_sched值变为1后，就进行进程的调度，完成进程的切换，如此往复。

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

      2. 对myinterrupt.c的修改，my_timer_handler用来记录时间片，时间片消耗完之后完成调度。
         并在该文件中完成，my_schedule(void)函数的实现。进程切换主要的原理为：
         1. 保存了前一个进程的rbp和rsp，其中rbp保存在栈中，rsp保存在pcb.sp中
         2. 更换了进程栈，原本rsp指向前一个进程的栈，步骤3后指向了后一个进程的栈
         3. 将$1f 保存到了前一个线程的pcb.ip中（可以看做是保存当前进程的ip）
         4. 修改当前rip寄存器的值，相当于原来rip的内容为前一个进程的指令地址，现在为后一个进程的指令4地址
         5. 将rbp寄存器的值修改为下一个进程的栈底

         #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.
          */
         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;
         }
         

   3. 重新make并运行mykernel，可以看见进程的切换