从mykernel分析linux任务调度

罗冲 + 原创 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

程序源代码分析

整个任务代码分为两部分：mymain.c与myinterrupt.c两部分，这里不列出全部的代码（详细代码参见孟宁老师的github:https://github.com/mengning/mykernel）

void __init my_start_kernel(void)
{
    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;
    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++)
    {
           //初始化数组
           ... ... 
    }
    /* 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*/
    );
}   
void my_process(void)
{
    int i = 0;
    while(1)
    {
        ... 切换部分... 
            if(my_need_sched == 1)
            {
                my_need_sched = 0;
                my_schedule();
            }
        ... ... 
        }     
    }
}

代码分析：
对于mymain.c来说，它分为两个部分my_start_kernel与my_process，其中my_start_kernel的主要工作为初始化task数组与启动task[0]
my_process的主要工作: task执行的动作，以及监控my_need_sched 信号量以判断是否需要进行程序切换

myinterrupt.c的代码：

void my_timer_handler(void)
{
#if 1
    if(time_count%1000 == 0 && my_need_sched != 1)
    {
        ... ... 切换信号量控制
         my_need_sched = 1;
    } 
    time_count ++ ;  
#endif
    return;     
}

void my_schedule(void)
{
     ... 程序切换... 
    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)
        ); 
        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; 
}

myinterrupt.c也分为两个部分：
1）my_timer_handler： 时间片调度，系统在每个时间片到来时执行一次
2）my_schedule : 程序切换代码，由两个汇编程序来执行。
下面按顺序来进行分析
其执行图如下：

调度分析

程序初次启动分析

当启动内核的时候，会首先调用void __init my_start_kernel(void)函数。在这个函数可以分为三个部份：
1） 实始化task[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;
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
    task[pid].next = &task[pid];

2)实始化task[]数组

    /*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];
    }

3)启动task[0]

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

对照程序堆栈图：

而ret后面的代码因为eip指针已经移动到my_process()地方，因此在第一次执行的时候popl %%ebp是无法执行到的。

第一次切换时

当myinterrupt.c的时间片次数到达设定值时，会修改my_need_sched 的值 ，从而导致mymain.c中调用到函数my_schedule()，导致第一次时间片切换。
即从task[0]切换到task[1]。

    next = my_current_task->next;
    prev = my_current_task;

my_current_task为task[0]，而task[0]->next为task[1]，因此在这里，我们可以简单的将next理解为task[1]，prev为task[0]。
在接下来的判断中：

    if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */
    {
        /* switch to next process */
        ... ...     
    }
    else
    {
        next->state = 0;
        my_current_task = next;
        ... ...         
    }   

此时task[1]->state的值为-1，因此，可以知道此时应该进入else分支。下面重点分析else中的汇编语言：

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

前三句的汇编程序比较好理解，其对应的堆栈示意图如下：

简单来说，它就是将task[0]对应的堆栈位置保存到prev.sp这个内存中，然后再次task[1].sp的值压栈
接下来执行

"movl $1f,%1\n\t"       /* save eip */ 

这句话比较难以理解。不过可以通过查询其汇编得到答案。使用objdump获取汇编码，

其对应的为：

  a1:  c7 86 08 20 00 00 b2 movl $0xb2,0x2008(%esi)
  a8:  00 00 00 
  ab:  ff b3 08 20 00 00 pushl 0x2008(%ebx)
  b1:  c3 ret 
  b2:  5d pop %ebp

其中0x2008(%esi), 对应就是prev->thread.ip内存地址。它的意思是将0xb2这个地址保存到prev->thread.ip，其中0xb2是一个相对偏移地址，它对应的汇编代码就是:

 b2:  5d pop %ebp

也就是prev->thread.ip中保存的是pop %ebp对应的代码段地址。
接下来的2句，就是设置eip的地址，将eip的代码段指针指向task[1]。从而task[1]开始执行。

当从task[3]切换到task[0]切换时

当所有的task都运行后，此时所有的state的值都为0， 此时再次进入调度时，就是执行if里面的代码，即：

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

因为所有的工作都是在汇编中完成，只对汇编程序进行分析。在这之前需要先确认一下：

    next = my_current_task->next;
    prev = my_current_task;

my_current_task为task[3]，而task[3].next的值为task[0]。与task[1]第一次切换运相比，此时只是少了一行

    "movl %2,%%ebp\n\t"     /* restore ebp */

而这一行的作用就是保存ebp，即后面开始不保存ebp，因为所有的数据都保存在PCB中，所以就不在push了。

  6e:  55 push %ebp
  6f:  89 a6 0c 20 00 00 mov %esp,0x200c(%esi) 
  75:  8b a3 0c 20 00 00 mov 0x200c(%ebx),%esp 
  7b:  8b ab 0c 20 00 00 mov 0x200c(%ebx),%ebp 
  81:  c7 86 08 20 00 00 b2 movl $0xb2,0x2008(%esi) ;movl $1f 0x2008(%esi) 
  88:  00 00 00 
  8b:  ff b3 08 20 00 00 pushl 0x2008(%ebx) "pushl %3\n\t" 
  91:  c3 ret ret
  92:  eb 8a jmp 1e <my_schedule+0x1e>

 94:  55 push %ebp 95:  89 a6 0c 20 00 00 mov %esp,0x200c(%esi) 9b:  8b a3 0c 20 00 00 mov 0x200c(%ebx),%esp a1:  c7 86 08 20 00 00 b2 movl $0xb2,0x2008(%esi) a8:  00 00 00  ab:  ff b3 08 20 00 00 pushl 0x2008(%ebx) b1:  c3 ret  b2:  5d pop %ebp

因为之前已经保存了eip的值，因此此时再次获取出来。从而接着继续执行原来的程序。

结论：

与程序中的函数调用相比， 程序调度是通过PCB保存相应的指针数据，而程序调用是通过堆栈保存