Linux 内核分析 第二次作业 完成一个简单的时间片轮转多道程序内核代码

侯君
原创作品转载请注明出处

《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-100002900

实验要求：

完成一个简单的时间片轮转多道程序内核代码，代码见视频中或从mykernel找。

详细分析该精简内核的源代码并给出实验截图，撰写一篇署名博客，并在博客文章中注明“真实姓名（与最后申请证书的姓名务必一致） + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000 ”，博客内容的具体要求如下：

题目自拟，内容围绕操作系统是如何工作的进行；

博客中需要使用实验截图

博客内容中需要仔细分析进程的启动和进程的切换机制

总结部分需要阐明自己对“操作系统是如何工作的”理解。

3）请提交博客文章URL到网易云课堂MOOC平台Linux内核分析MOOC课程，编辑成一个链接可以直接点击打开。

<span style="font-size:12px;">/* 
 *  linux/mykernel/mypcb.h 
 * 
 *  Kernel internal PCB types 
 * 
 *  Copyright (C) 2013  Mengning 
 * 
 */ 
 
 
 #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); 
</span>

mypcb.h定义了两个结构体分别表示Thread和PCB

<span style="font-size:12px;">/* 
 *  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].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( 
     	"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 */ 
     	"popl %%ebp\n\t" 
     	:  
     	: "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); 
         }      
     } 
 } 
</span>

mymain.c实现内核的启动，通过my_start_kernel()来初始化进程，my_process作为每个进程的入口地址传入结构体中的ip，再将ip压栈后ret，将地址pop给eip，将系统引导至myprocess开始运行。

<span style="font-size:12px;">/* 
 *  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 */ 
     { 
     	/* 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) 
     	);  
     	my_current_task = next;  
     	printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);   	 
     } 
     else 
     { 
         next->state = 0; 
         my_current_task = next; 
         printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid); 
     	/* switch to new process */ 
     	asm volatile(	 
         	"pushl %%ebp\n\t" 	    /* save ebp */ 
         	"movl %%esp,%0\n\t" 	/* save esp */ 
         	"movl %2,%%esp\n\t"     /* restore  esp */ 
         	"movl %2,%%ebp\n\t"     /* restore  ebp */ 
         	"movl $1f,%1\n\t"       /* save eip */	 
         	"pushl %3\n\t"  
         	"ret\n\t" 	            /* restore  eip */ 
         	: "=m" (prev->thread.sp),"=m" (prev->thread.ip) 
         	: "m" (next->thread.sp),"m" (next->thread.ip) 
     	);           
     }    
     return;	 
 } 
</span>

myintrrupt.c对时间片轮转的一个调度实现了，通过my_timer_handler()来记录时间，触发调度。通过my_schedule()来完成调度，保护现场。

运行结果如上图所示。

本次试验最重要的是进程的切换，进程执行过程中，当时间片用完需要进行进程切换时，需要先将当前的进程执行环境进行保存，下次进程被调度时，需要恢复进程的执行环境。这样实现多道进程的执行。