Linux内核分析（二）：操作系统如何工作

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

一、计算机系统是怎么样工作
计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
进程的首要特点是系统进行资源分配及调度的一个单位，这里的资源指的就是计算机的硬件和系统资源。比如这个进程需要运行的内存空间，系统中负责指向运行指令的IP指针，运算需要用到的一些寄存器，系统的调度等。但是计算机有很多进程，不能让一个进程一直在占用CPU，这里就需要用到调度。最简单的方式就是轮流使用CPU，即所谓的时间片轮转法的调度。
不同进程运行需要不同的内存空间，就像是每个函数都有自己的堆栈。所以在进程切换时候首先需要将进程当前执行到的位置（一个内存的地址——CS：IP）保存起来。以便调度结束以后可以返回原来的位置执行。

二、代码分析（以mykernel为例）
mykernel代码实现了一个基于时间片轮转的系统调度，其代码结构如下：

上述代码中我们看到mykernel包括了三个文件，mypcb.h、mymain.c、myinterrupt.c。下面我们来分析这段代码中的以一个部分：头文件mypcb.h主要代码如下：

#define MAX_TASK_NUM        4
#define KERNEL_STACK_SIZE   1024*2 # unsigned long
/* CPU-specific state of this task */
struct Thread {
    unsigned long       ip;
    unsigned long       sp;
};

typedef struct PCB{
    int pid;
    volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
    unsigned long stack[KERNEL_STACK_SIZE];
    /* CPU-specific state of this task */
    struct Thread thread;
    unsigned long   task_entry;
    struct PCB *next;
}tPCB;

void my_schedule(void);

mypcb.h中定义了两个结构体以及声明了一个函数。首先就是Thread结构体里面存放了两个用于存放地址的变量，一个是堆栈指针sp，一个是指令指针ip。另一个结构体PCB用于存放进程的相关信息（Process Control Block）包括进程的标志ID，进程状态，进程堆栈大小，一个线程，一个任务入口地址，还有一个指向下一个PCB的指针。
下面我们分析mymain.c中的代码
首先是startkernel函数

tPCB task[MAX_TASK_NUM];
tPCB * my_current_task = NULL;
volatile int my_need_sched = 0;

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++)
    {
        memcpy(&task[i],&task[0],sizeof(tPCB));
        task[i].pid = i;
        task[i].thread.sp = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-1];
    *(task[i].thread.sp - 1) = task[i].thread.sp;
    task[i].thread.sp -= 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];
    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*/
    );
}   

首先新建了一个任务数组，里面都是PCB结构体。新建了一个任务进程控制块）并给里面的属性赋值。然后利用一个for循环新建了一些基本一样进程（一共MAX_TASK_NUM这么多，实际上就是4个）并连接成链表。之后进入启动0号进程。实际上就是将它ip赋值给esp寄存器然后保存自己的sp（基地址->ebp）和ip，然后就返回。新进程的创建是首先从复制0号进程的内容，然后对其进行修改（事实上，Linux的fork函数也是这样做的——首先复制父进程的PCB，然后改变子进程PCB的内容以使其与父进程区分开来——当然这个过程更为复杂）；

0号进程启动过程分析（汇编代码）：
0号进程的堆栈指针压入esp寄存器；
0号进程的ebp压入栈中（初始情况下栈为空，栈顶指针与栈底指针指向同一个位置）；
0号进程的ip赋给eip寄存器。由于eip中保存的是将要执行的下一条指令的地址，从而CPU开始执行0号进程；
恢复ebp，当该条语句运行时，栈中唯一的元素将会被弹出来，栈成为空的初始状态（栈的操作应对应起来，有多少push就有多少pop）

下面是process()函数

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

下面我们来看最重要的部分就是进程调度的代码分析，这段代码在myinterrupt.c中。首先是时间中断，my_time_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;     
}

这是一个产生调度时机的函数。就是所谓的产生了时间片，每当他执行的时候就是一个进程调度的时机。后面的实验截图中我们可以看到。它的运行说明进程已经用完了自己的时间片需要保存自己的运行现场信息然后让其他的进程使用CPU。my_timer_handler定义了时间片中断函数，通过time_count来统计时间片的长度，my_need_sched！=1，我们可以通过修改if条件来改变该process的运行时间。

下面的代码是调度的关键代码my_schedule(void)。

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

代码中我们看到首先是两个指向PCB的指针，之后有一个判断：如果当前链表是空的则返回。然后输出打印信息说明开始进行调度了。调度的时候有两种情况，一种是调度一个已经运行过的进程，另一种情况就是调度一个新的未运行过得进程。

首先是if块——运行过的进程：

当前进程的栈底指针入栈保存；
当前进程的栈顶指针保存到PCB中；
新进程的栈顶指针赋给esp寄存器
标注”1：”的跳转地址保存到当前进程的ip中，这是为了当进程再次被切换回来的时候能够正确地继续执行。
新进程的ip赋给eip寄存器，从而使得CPU开始执行新的进程。
当进程切换回来的时候进行栈的弹出工作，恢复进程的ebp并对栈的操作进行平衡

这段汇编代码实际上将my_schedule函数一分为二，其分界点就在ret指令。执行这条指令之前，当前进程保存自己的状态，特别是将来被切换回来之后需要执行的那条指令的地址。当ret执行完毕之后，CPU就切换到新进程继续执行，再次切换回原来的进程的时候，CPU就从第21行的指令继续向下执行。注意与else块进行比较，并没有针对新进程的ebp的操作，这是因为对于已经运行过的进程，它的堆栈是已经建立过的。这也是为什么虽然my_schedule函数同时对两个不同进程的栈进行了操作，但是对于单独的一个进程来说，依旧符合前一篇文章所描述的执行过程。

最后是else块——从未运行过的进程：

当前进程栈底指针入栈保存；
当前进程的栈顶指针保存到PCB中；
新进程的栈顶指针赋给esp寄存器；
新进程的栈底指针赋给ebp寄存器；
新进程的ip赋给eip寄存器，从而使CPU转向新进程执行。

三、实验截图

控制台界面

修改代码后的重新编译内核

QEMU界面