Linux内核分析,通过mykernel实验分析内核如何工作--第二周

通过mykernel实验分析内核如何工作

首先先上实验图：

本内核是在linux3.9.4修改而来

patch 地址 https://github.com/mengning/mykernel

运行方式：

qemu -kernel arch/x86/boot/bzImage

关与什么是qemu见：http://www.ibm.com/developerworks/cn/linux/l-qemu/

================================================================================================================

以下分析各代码

1.头文件，mypcb.h

#define MAX_TASK_NUM        4                   //最大的任务数
#define KERNEL_STACK_SIZE   1024*8              //每个进程堆栈的大小

/* CPU-specific state of this task */
struct Thread {
    unsigned long		ip;                //对应于eip
    unsigned long		sp;                 //对应于esp
};

typedef struct PCB{
    int pid;                     //进程id
    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;

2.入口函数

extern tPCB task[MAX_TASK_NUM];                        //进程空间
extern tPCB * my_current_task;                         //当前进程
extern volatile int my_need_sched;                     //
volatile int time_count = 0;
void __init my_start_kernel(void)
{
    int pid = 0;  // 初始进程id 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;//进程的入口和进程的eip都为my_process
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];//进程的esp大小为KERNEL_STACK_SIZE，初始化esp指向它的末尾
    task[pid].next = &task[pid]; //初始化进程的下个进程为自己
/*fork more process ，fork更多的进程 */ 
    for(i=1;i<MAX_TASK_NUM;i++) {
          memcpy(&task[i],&task[0],sizeof(tPCB)); //进程状态简单复制 
          task[i].pid = i; //进程pid
          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]; //汇编运行0号进程
      asm volatile(
                "movl %1,%%esp\n\t" /* set task[pid].thread.sp to esp 使用进程的堆地址，即esp指向进程的堆空间*/ 
                "pushl %1\n\t" /* push ebp 这里为什么是push ebp不懂了，理论上是压入了esp的地址（老师解释这里是由于栈是空的ebp等于esp）*/ 
                "pushl %0\n\t" /* push task[pid].thread.ip，压入eip地址，等待运行 */ 
               "ret\n\t" /* pop task[pid].thread.ip to eip，回顾上一周的课程可知，这里是把eip的地址指向了task[pid].thread.ip的地址了,并popl了一次*/ 
                "popl %%ebp\n\t" /*弹出ebp，整个进程空间释放了*/   
                 :
		 : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) /* input c or d mean %ecx/%edx*/);
	 } 
//下面是进程工作的代码，代码很简单就是 每10000000 来运行一次，相隔着来进行进程的调度切换，至于是否调度切换是有标志my_need_sched 来决定的。
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);
        }     
    }
}

3.调度函数my_schedule

用于进程间的切换，进程环境的保护和恢复

<pre name="code" class="cpp">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 ，保存当前进程的ebp，保存现场 */
        	"movl %%esp,%0\n\t" 	/* save esp ，保存当前进程的esp到 prev->thread.sp*/
        	"movl %2,%%esp\n\t"     /* restore  esp，读取下个进程的esp */
        	"movl $1f,%1\n\t"       /* save eip ，保存eip，即存储1 编号出的指针运行地址到prev->thread.eip中
*/	
        	"pushl %3\n\t"           /*压入下个进程的ip，注意如果进程运行过的话，这里的thread.ip指向的是标号1:的位置*/
        	"ret\n\t" 	            /* restore  eip ,运行下个进程，并popl掉%3 */
        	"1:\t"                  /* next process start here ，上个进程（ret的进程运行完了），恢复为原来进程*/
        	"popl %%ebp\n\t"        /*弹出ebp，恢复现场*/
        	: "=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，保存当前进程的ebp */
        	"movl %%esp,%0\n\t" 	/* save esp，保存当前进程的esp到 prev->thread.sp*/
        	"movl %2,%%esp\n\t"     /* restore  esp，读取下个进程的esp */
        	"movl %2,%%ebp\n\t"     /* restore  ebp ，赋值ebp，使得esp=ebp*/
        	"movl $1f,%1\n\t"       /* save eip ，保存eip，即存储1编号出的指针运行地址到prev->thread.eip中*/	
        	"pushl %3\n\t"           /*压入下个进程的ip*/
        	"ret\n\t" 	            /* restore  eip，运行下个进程 */
        	: "=m" (prev->thread.sp),"=m" (prev->thread.ip)
        	: "m" (next->thread.sp),"m" (next->thread.ip)
    	);          
    }   
    return;	
}

4.定时中断改变标志

//定时器中断，每 1000下进行 my_need_sched 的检查，如果不为1，则置其为1使其进程调度

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;  	
}

总结

从上文的简单的内核进程切换代码，可以看出系统运行，在各个进程间如何通过ebp和esp的改变和保存，来进行上下文切换的。另外系统通过时间中断来使得各个进程获得了切换的机会，这是个时分复用的内核机制。

在真正的系统，中断有很多种，例如时钟，各种硬件IO等，内核接收到这些中断后，进行对应的进程切换，使得系统进程可以进行各种对应的处理操作。