基于mykernel完成时间片轮转多道程序内核
学号093 原创作品，转载请注明出处。
本实验资源来自 https://github.com/mengning/linuxkernel/
实验目的
- 分析进程的启动和进程的切换机制
- 理解操作系统是如何工作
实验环境
- 实验楼
实验步骤
- cd LinuxKernel/linux-3.9.4
- rm -rf mykernel
- patch -p1 < ../mykernel_for_linux3.9.4sc.patch #打补丁
- make allnoconfig
- make #编译
- qemu -kernel arch/x86/boot/bzImage #从qemu窗口中可以看到my_start_kernel在执行，同时my_timer_handler时钟中断处理程序周期性执行。
- cd mykernel #可以看到qemu窗口输出的内容的代码mymain.c和myinterrupt.c
至此，我们已经初始化好了系统环境。下面就让我们开始编写内核实现时间片轮转多道程序。
内核分析
从孟宁老师的主页上获取源码 https://github.com/mengning/mykernel
下载mymain.c ，myinterrupt.c 和 mypcb.h三个文件。
重新编译。#重新编译之前要make clean
mypcb.h
#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 1024*2 定义了堆栈的内核大小
Thread结构体里的ip用来存储当前指令，sp用来存储栈顶位置。
PCB结构体里面存储了进程的id，状态，以及next指针，可以形成pcb链。
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\n\t" /* set task[pid].thread.sp to esp */ "pushl %1\n\t" /* push ebp */ "pushl %0\n\t" /* push task[pid].thread.ip */ "ret\n\t" /* 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 -\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_start_kernel
该函数首先初始化了一个id为0的进程，状态为可运行状态，设置进程的入口地址为my_process函数的地址，thread.sp指向stack[]的尾地址，最后将next指向自己。
接下来for循环创建了pid为1，2，3的三个进程。并且将这4个进程连在一起。
接下来就是最重要的内嵌汇编代码
asm volatile( "movl %1,%%esp\n\t" /* set task[pid].thread.sp to esp */ "pushl %1\n\t" /* push ebp */ "pushl %0\n\t" /* push task[pid].thread.ip */ "ret\n\t" /* pop task[pid].thread.ip to eip */ : : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) /* input c or d mean %ecx/%edx*/ );
首先把第一个输入赋给esp寄存器，即task[pid].thread.sp 的值给esp 。
然后 task[pid].thread.sp 压栈，因为是空栈，esp的值和ebp的值相同。
接着 task[pid].thread.ip 压栈
最后，把ip出栈赋值给eip
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<<<\n"); 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<<<\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( "pushl %%ebp\n\t" /* save ebp */ "movl %%esp,%0\n\t" /* save esp */ "movl %2,%%esp\n\t" /* restore esp */ "movl $1f,%1\n\t" /* save eip */ "pushl %3\n\t" "ret\n\t" /* restore eip */ "1:\t" /* next process start here */ "popl %%ebp\n\t" : "=m" (prev->thread.sp),"=m" (prev->thread.ip) : "m" (next->thread.sp),"m" (next->thread.ip) ); } return; }
定义了两个函数my_timer_handler()函数和my_schedule()函数
my_time_handler()就是时间为1000时将my_need_sched设置为1，这样就可以使my_process函数调用my_schedule函数来切换进程。
让我们看啊可能my_schedule函数中的内嵌汇编代码
asm volatile( "pushl %%ebp\n\t" /* save ebp */ "movl %%esp,%0\n\t" /* save esp */ "movl %2,%%esp\n\t" /* restore esp */ "movl $1f,%1\n\t" /* save eip */ "pushl %3\n\t" "ret\n\t" /* restore eip */ "1:\t" /* next process start here */ "popl %%ebp\n\t" : "=m" (prev->thread.sp),"=m" (prev->thread.ip) : "m" (next->thread.sp),"m" (next->thread.ip) );
首先明白一个概念，当 当前进程变为下一个进程时，那么下一个进程就变成当前进程，当前进程变为下一个进程。就好似老师上课说的，再捡一个孩子也是不乖的。
理解这个概念后，汇编代码就好理解了，保存下一条指令的地址，切换到另一个栈，然后执行，当切换回来时，把保存的指令弹出，这样就可以做到进程之间的切换。
总结
操作系统是如何工作的？
-
-
- 存储程序计算机
- 函数调用堆栈
- 中断
-
通过实验了解了汇编语言的基本指令，以及对计算机的进程切换有了大致了解。
