基于mykernel完成时间片轮询多道进程的简单内核
学号：282
原创作品转载请注明出处 + https://github.com/mengning/linuxkernel/
一、实验目的
基于mykernel，完成一个简单的时间片轮转多道程序内核代码并分析。
二、实验步骤
1. 环境搭建
环境为 Linux QEMU，实验楼网站中直接打开即可食用。
-
在实验楼终端中执行下列命令对内核进行打补丁操作
cd LinuxKernel/linux-3.9.4 rm mykernel -rf patch -p1 < ../mykernel_for_linux3.9.4sc.patch -
编译源码
make allnoconfig make -
编译成功后，使用QEMU工具来显示代码执行过程。内核成功启动！
2. 基于mykernel实现时间片轮询多道进程
通过上面的步骤，我们将孟宁老师GitHub上面myinterrput.c和mymain.c 替换掉mykernel中的文件，将mypcb.h移动到相同文件夹下。
-
git克隆源码
git clone https://github.com/mengning/mykernel.git
-
替换原代码
-
重新编译和运行
3. 源码分析
-
mypcb.h, 此头文件主要用于定义进程控制块
/* * linux/mykernel/mypcb.h * * Kernel internal PCB types * * Copyright (C) 2013 Mengning * */ #define MAX_TASK_NUM 4 #define KERNEL_STACK_SIZE (unsigned long)1024*2 /* CPU-specific state of this task */ struct Thread { unsigned long ip; unsigned long sp; }; typedef struct PCB{ // 进程号 int pid; // -1 unrunnable, 0 runnable, >0 stopped volatile long state; // 进程堆栈 unsigned long stack[KERNEL_STACK_SIZE]; // CPU-specific state of this task struct Thread thread; // 入口事件 unsigned long task_entry; // 下一个pcb块的位置 struct PCB *next; }tPCB; void my_schedule(void);由代码可知，mypcb.h主要通过结构体的方式定义了进程的基本信息：进程状态、进程id以及进程的堆栈信息等，其余信息已在注释中表明。
-
myinterrupt.c
/* * linux/mykernel/myinterrupt.c * * Kernel internal my_timer_handler * * Copyright (C) 2013 Mengning * */ #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; /* * 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 1 if(time_count%1000 == 0 && my_need_sched != 1) { printk(KERN_NOTICE ">>>my_timer_handler here<<< "); my_need_sched = 1; } time_count ++ ; #endif 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<<< "); /* 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<<< ",prev->pid,next->pid); /* switch to next process */ asm volatile( "pushl %%ebp " /* save ebp */ "movl %%esp,%0 " /* save esp */ "movl %2,%%esp " /* restore esp */ "movl $1f,%1 " /* save eip */ "pushl %3 " "ret " /* restore eip */ "1: " /* next process start here */ "popl %%ebp " : "=m" (prev->thread.sp),"=m" (prev->thread.ip) : "m" (next->thread.sp),"m" (next->thread.ip) ); } return; }由以上代码可知，myinterrupt.c主要实现两个函数：my_time_handler和my_schedule。
- my_time_handler(), 每1000毫秒产生一个时钟中断，同时设置my_need_sched=1，mymain.c中的函数就会调用my_schedule()以执行进程切换的操作。
- my_schedule()，用于进程的切换操作。
- 声明next，pre指针执行下一个需要调度的进程和上一个进程
- 判断下一个需要调度的进程的状态值，为0则切换
- 通过汇编实现进程的切换。保存现场，将当前线程相关内容入栈，上一线程相关内容出栈，然后切换线程ip；
-
mymain.c,
/* * linux/mykernel/mymain.c * * Kernel internal my_start_kernel * * Copyright (C) 2013 Mengning * */ #include <linux/types.h> #include <linux/string.h> #include <linux/ctype.h> #include <linux/tty.h> #include <linux/vmalloc.h> #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].stack[KERNEL_STACK_SIZE-1] - 1) = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-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( "movl %1,%%esp " /* set task[pid].thread.sp to esp */ "pushl %1 " /* push ebp */ "pushl %0 " /* push task[pid].thread.ip */ "ret " /* pop task[pid].thread.ip to eip */ : : "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 - ",my_current_task->pid); if(my_need_sched == 1) { my_need_sched = 0; my_schedule(); } printk(KERN_NOTICE "this is process %d + ",my_current_task->pid); } } }mymain.c中，主要是进程的初始化并负责启动进程：
- 初始化一个进程 。为其分配进程编号、进程状态state、进程堆栈、线程、任务实体等，并将其next指针指向自己。
- 初始化更多的进程 。根据第一个进程的部分资源，包括内存拷贝函数的运用，将0号进程的信息进行了复制，修改pid等信息。
- 设置当前进程 。因为是初始化，所以当前进程就决定给0号进程了，通过执行嵌入式汇编代码，开始执行mykernel内核。
- my_process函数。每10000000次，打印当前进程的pid，全局变量my_need_sched，通过对my_need_sched进行判断，若为1，则通知正在执行的进程执行调度程序，然后打印调度后的进程pid。
三、实验总结
操作系统是指控制和管理整个计算机系统的硬件和软件资源，并合理地组织调度计算机的工作和资源的分配，以提供给用户和其他软件方便的接口和环境的程序集合。
通过本次实验：
- 为什么要进行处理机调度？
在多道程序系统中，进程的数量往往多于处理机的个数，进程争用处理机的情况在所难免。处理机调度是对处理机进行分配，按照一定的算法选择一个进程并将处理机分配给它运行，以实现进程并发执行。 - 什么时时间片轮转调度算法？
系统将所有就绪进程按到达时间的先后次序排成一个队列，进程调度总是选择就绪队列中的第一个进程执行，即先来先服务，但仅能运行一个时间片，如100ms。在使用完一个进程片后，即使进程还未完成，它也必须释放处理机给下一个就绪的进程，然会回到就绪队列的末尾重新排队。 - 操作系统（内核）是如何工作的？
- Linux是一个多进程的操作系统，所以，其他的进程必须等到正在运行的进程空闲CPU后才能运行。
- 进程是动态执行的实体，内核是进程的管理者。进程不但包括程序的指令和数据，而且包括程序计数器和CPU的所有寄存器以及存储临时数据的进程堆栈。
- 系统有一个进程控制表（process table），一个进程就是其中的一项。