linux操作系统分析——基于mykernel完成多进程的简单内核

作者：毕宗泽012
原创作品转载请注明出处 + https://github.com/mengning/linuxkernel/

---

  本实验主要是参考mykernel代码，完成一个简单的时间片轮转多道程序内核代码。
  代码部分由博主注释，

实验楼mykernel实验

  使用实验楼的虚拟机打开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

  最终结果：

  不难发现，在pid为19700000的my_start_kernel之后产生了中断，并执行了pid为19800000的my_start_kernel，然后再返回，现在我们详细分析一下这个简单的内核代码。
 

mykernel内核代码详析

  mykernel进行时间片轮转的主要文件分为三个：

• mymain.c
• myinterrupt.c
• mymain.c

  我们首先分析最重要的mymai.c。
 

mymain.c

void __init my_start_kernel(void)   // run this func first while run all task(program)

  整个mykernel初始化时，由__init可知，最先启动的应该是my_start_kernel函数，关于__init的具体用法，可以点击这里。my_start_kernel内部构造如下：
 

    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;     // load entry(address) of my_process into ip(register) & task_entry of PCB
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];     // let sp point to the top of stack, grow downward
    task[pid].next = &task[pid];    // link to the next task(program)
    /*fork more process */

 
  首先建立第一个PCB控制块，其pid当然为0，该PCB的函数入口及ip均为my_process，my_process为函数名，也就代表着函数的地址，回忆C语言中的数组，这和数组名可以作为数组的首地址是一样的。线程的堆栈段指针首先指向stack[KERNEL_STACK_SIZE-1]，这是因为堆栈段是向下增长的。看接下来的一段代码：
 

for(i=1;i<MAX_TASK_NUM;i++)
    {
        memcpy(&task[i],&task[0],sizeof(tPCB)); // copy the content of task[0] to any(one in loop) task, i.e. initialize ith PCB
        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;  // linkList operation
        task[i-1].next = &task[i];
    }

 
  对新的进程进行fork时候，采用的主要方法就是复制PCB[0]，代码中的memcpy功能为内存拷贝，然后将新进程与上一个进程的PCB以链表形式链接起来。再看接下来一段代码：
 

/* 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*/

 

 
  这段采用了asm内嵌汇编代码， 具体语法可点击这里。主要功能是运行my_process函数。让我们看看my_process的主要功能：
 

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

 

&nbsp
  可以看出，my_process定期通过判断i和my_need_sched调用my_schedule函数，然后打印出当前程序的pid。上面的代码中对于my_need_sched的条件语句是my_need_sched == 1，但是整个文件的开始my_need_sched赋值为0，故该条件语句永远也不可能为真，那么该如何调用my_schedule呢？让我们接着往下看。
 

myinterrupt.c

  由上文知道，我们需要修改my_need_sched来运行my_process，这修改的方式就在于my_timer_handler这个函数。

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

  my_timer_handler被内核注册，因此会定期的运行，每到一定的时间后，就会修改my_need_sched，使得my_process运行起来，并通过my_process调用my_schedule函数。

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

 

 
  正是这一段代码实现了进程切换的关键步骤。先将上个进程的esp返回内存之中其PCB块中，再通过movl %2,%%esp实行进程间的切换，注意这样的切换是持续不断进行的，故形成一个时间片的轮转。
 

总结

  初看mykernel的代码确实很多地方看不懂，my_timer_handler明明没有在任何函数中调用，为何还能起到定时器的作用，嵌入式汇编代码又如何通过堆栈段实现进程间的切换？不得不说，mykernel通过一个简单的时间片轮转多道程序的代码，悄然揭示了系统在进程管理中的本质，即使还没有添加任何优先级，或者使用任何优化算法，但巧妙的构思仍勾起我对最初OS设计场景的好奇。