基于mykernel的简单时间片轮转多道程序内核代码分析

学号后三位：181
原创作品转载请注明出处 + https://github.com/mengning/linuxkernel/
一、初始实验——使用环境
本实验使用实验楼的环境。
第一步：在实验楼的shell里输入

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_timer_handler here <<<<< 和 my_start_kernel here
截图如下所示

第二步：查看代码
关闭QEMU窗口，输入cd mykernel 查看mymain.c 和myinterrupt.c

在mymain.c中，我们可以发现有一个my_start_kernel函数，他是一个循环，不停的输出 my_start_kernel here。

在myinterrupt.c中，有一个被时钟中断周期调用的函数my_timer_handler ，输出>>>>>my_timer_handler here <<<<< 字符串。

通过以上实验我们可以发现，mykernel在启动之后，系统调用my_start_kernel函数，并周期性调用my_timer_handler函数。

二、简单时间片轮转多道程序

1. 源码

   实验源码来自孟老师的GIthub——https://github.com/mengning/mykernel
   主要是三个文件mymain.c，myinterrupt.c和mypcb.h

2. 操作
   将三个文件复制进mykernel文件夹，覆盖原来的mymain.c，myinterrupt.c文件，再重新编译内核

3. 输出
   
   从图中发现进程在切换

4. 代码分析
   mypcb.h ： 此文件主要定义了一个PCB结构体，也就是所谓的进程管理块，用来记录进程的有关信息。
   mymain.c： 该文件就是完成了内核的初始化工作，并且创建了4个进程，进程从0号开始执行，并且根据标志位判断进程是否需要调度，当标志位为1时表示进程需要调度，此时会执行my_schedule()方法来完成相应的调度。
   myinterrupt.c：此文件主要是产生时钟中断，用一个时间计数器周期性的检查循环条件，当条件满足时便会产生中断，并将进程调度标志位置1，当标志位为1时，进程便会执行my_schedule()方法，首先将当前进程的信息通过嵌入式汇编语句保存到堆栈当中，然后将下一个进程的地址赋给当前运行程序的指针，完成调度。

mypcb.h

/*
 *  linux/mykernel/mypcb.h
 *
 *  Kernel internal PCB types
 *
 *  Copyright (C) 2013  Mengning
 *
 */
 
#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;
};//定义了一个结构体用来保存当前ip和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; //一个Thread类型的结构体变量thread
    unsigned long	task_entry;//程序入口
    struct PCB *next;//用来将PCB链接起来的链表
}tPCB;
 
void my_schedule(void);//声明进程调度函数

分析：
这段代码主要实现三部分的功能，分别是：
（1）代码(line15——line18)定义thread数据结构，包含ip和sp两个变量，分别代表指令指针和堆栈指针。
（2）代码(line20——line29)定义PCB进程控制块，用于标注进程的进程ID号，进程状态信息（-1,0，>0），申请的进程堆栈大小，进程的入口地址以及指向下一个进程控制块的程序入口地址指针。
（3）代码(line31)声明进程调度函数my_schedule（int pid）。这段代码定义了mykernel运行过程中的框架结构，使得每个程序中每个进程的运行结构都是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];//定义了一个类型为PCB的task数组
	tPCB * my_current_task = NULL;//定义了一个PCB类型的指针变量并且初值为空
	volatile int my_need_sched = 0;  //进程是否需要调度的标志位
 
	void my_process(void);
 
 
	void __init my_start_kernel(void)//对内核进行初始化
	{
		int pid = 0;//定义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;//定义了0号进程的入口为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*/
		);//将0号进程交给cpu进行处理
	}   
	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;//将标志位置0
					my_schedule(); //执行my_schedule()方法
				}
				printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);
			}     
		}
	}

这段代码展示mymain.c的结构。
首先是新建了一个PCB结构的任务数组，初始化一个进程0（PID初始化为0，state初始化为0，紧接着初始化ip，sp等），for循环这段代码是继续创建上下的进程，总共创建了4个进程（MAX_TASK_NUM=4）。
然后把这4个PCB结构的控制块连接成链表结构。
初始化EIP，EBP，ESP寄存器，使得进程0能够直接被执行。然后先将堆栈指针sp赋给了ESP寄存器，然后将堆栈指针sp内容压栈，之后将指令指针ip的内容也压栈，下一条指令是ret，它是将当前栈中ESP所指的内容出栈到EIP中，当前ESP所指的内容就是前一条指令压栈进去的ip的值，现在使得EIP寄存器的内容就是进程0的入口地址（ip内容），从而使得进程0能够被执行。

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");//如果计数器为1000并且标志位不等于1那么执行此条语句
        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)
    	); //嵌入式汇编保存了当前进程的PCB信息用来为进程调度做准备
        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;	
}

这是函数是一个时间调度函数。#if 1表示需要编译器编译后面的容，#endif表示结束#if的约束控制。每当这段代码执行时，这段程序都要进行编译。
然后定义了两个PCB结构的指针prec和next，之后判断能否进行调度。这里分为两种情况，一种是调度一个已经运行过的进程，另一种情况是调度一个新的未运行过得进程。

总结：
操作系统是如何工作的？
操作系统首先初始化内核相关的进程，然后开始循环运行这些进程，进程间进行切换时，则利用内核堆栈所保存的每个进程的sp,ip即所对应的%esp,%eip寄存器中的值，对当前的进程的sp,ip即对应%esp,%eip寄存器的值进行保存(中断上下文)，并用下一个进程的sp,ip的值赋值给%esp,%eip寄存器（进程间切换)。

计算机三大法宝：

1. 函数调用堆栈：记录调用的路径和参数的空间
2. 存储程序计算机：冯诺依曼结构
3. 中断机制：由CPU和内核代码共同实现了保存现场和恢复现场，把ebp,esp,eip寄存器的数据push到内核堆栈中。再把eip指向中断程序的入口，保存现场。