作者:毕宗泽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);
}
}
}
 
可以看出,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设计场景的好奇。