Linux内核分析 第二次作业

实验环境：ubuntu14.10 + linux内核3.9.4

实验过程：
进行环境配置

sudo apt-get install qemu # install QEMU
sudo ln -s /usr/bin/qemu-system-i386 /usr/bin/qemu
wget https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.9.4.tar.xz # download Linux Kernel 3.9.4 source code
wget https://raw.github.com/mengning/mykernel/master/mykernel_for_linux3.9.4sc.patch # download mykernel_for_linux3.9.4sc.patch
xz -d linux-3.9.4.tar.xz
tar -xvf linux-3.9.4.tar
cd linux-3.9.4
patch -p1 < ../mykernel_for_linux3.9.4sc.patch
make allnoconfig
make

mymain.c

void __init my_start_kernel(void)
{
    int i = 0;
    while(1)
    {
        i++;
        if(i%100000 == 0)
            printk(KERN_NOTICE "my_start_kernel here  %d \n",i);

    }
}

myinterrupt.c

#define CREATE_TRACE_POINTS
#include <trace/events/timer.h>

void my_timer_handler(void)
{
        printk(KERN_NOTICE "\n>>>>>>>>>>>>>>>>>my_timer_handler here<<<<<<<<<<<<<<<<<<\n\n");
}

环境配置成功后，运行QEMU

qemu -kernel arch/x86/boot/bzImage

从qemu窗口中可以看到my_start_kernel在执行，同时my_timer_handler时钟中断处理程序周期性执行。

从github下载源码，用mykernel1.1替换mykernel，重新编译，运行QEMU
(mykernel源码包 http://download.youkuaiyun.com/detail/hy2011303497/8503969)

make allnoconfig
make
qemu -kernel arch/x86/boot/bzImage

从qemu窗口中可以看到进程链表管理，在myinterrupt.c的基础上完成进程切换代码，一个可运行的小OS kernel！

代码分析：

初始化0号进程

    int pid = 0;
    /* Initialize process 0*/
    task[pid].pid = pid;
    task[pid].state = 0;/* -1 unrunnable, 0 runnable, >0 stopped */
    // set task 0 execute entry address to my_process
    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];

初始化所有进程

for(pid=1;pid<MAX_TASK_NUM;pid++)
    {
        memcpy(&task[pid],&task[0],sizeof(tPCB));
        task[pid].pid = pid;
        task[pid].state = -1;
        task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
        task[pid].priority=get_rand(PRIORITY_MAX);
    }

启动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)  

（将eip指向函数myprocess）

进程启动

if(my_need_sched == 1){
        my_need_sched = 0;
        sand_priority();
        my_schedule();  
}

（判断是否需要主动调动，并重置进程优先度）

主动调度

if(next->state == 0){
     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;//switch to the next task
     printk(KERN_NOTICE "                switch from %d process to %d process\n                >>>process %d running!!!<<<\n\n",prev->pid,next->pid,next->pid);

  }
    else
    {
        next->state = 0;
        my_current_task = next;
        printk(KERN_NOTICE "                switch from %d process to %d process\n                >>>process %d running!!!<<<\n\n\n",prev->pid,next->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)
     );

（若eip指向的进程已被调度，那么保存现场，恢复eip指向进程的现场；若进程从未被调度过，则首先重置进程状态，保存现场，再启动进程。）

另外，与视频中有所不同的是，作业代码中使用优先度来决定下一个主动调度的进程

hig_pri=my_current_task;
    for(i=0;i<MAX_TASK_NUM;i++)
        if(task[i].priority<hig_pri->priority)  
            hig_pri=&task[i];

总结：
操作系统通过中断机制使得优先度高的进程能够首先执行，堆栈则保存了当前进程的状态和数据，使得进程间可以顺利切换。

火杨 原创作品转载请注明出处
《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000