从一个简单的内核看操作系统的工作

操作系统的工作过程很复杂，涉及到很多东西。本文并不是一点一滴的介绍其整个工作原理，而是通过一个简单的内核小程序，大致解析os工作过程。

一、计算机的三大法宝

之前介绍过计算机的三大法宝中的前两个：存储程序计算机和堆栈。现在介绍第三个--中断机制。

众所周知，处理器的速度跟外围硬件设备的速度往往不在一个数量级上，因此，如果内核采取让处理器向硬件发出一个请求，然后专门等待回应的办法，显然降低内核效率。中断使得硬件得以与处理器进行通信。中断本质是一种特殊的电信号，由硬件设备发向处理器。处理器接受到中断后，会马上向操作系统反映此信号的到来，然后就由os负责处理这些新到来的数据。硬件设备生成中断的时候并不考虑与处理器的时钟同步——换句话说就是中断随时可以产生。因此，内核随时可能因为新到来的中断而被打断。

总之，CPU执行完每条指令时，都会去检查一个中断标志位，这就是中断的本质。

二、OS工作过程概述

下面是对一个简单内核小程序的分析过程，旨在对OS有概述性了解。 先看看实验效果的截图：

具体分析程序：

/*mypcb.h*/

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

/*mymain.c*/

pid = 0;    /*start process 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)
    {
        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);
        }     
    }
}

 
这段代码可以看做是内核的main函数。不同于用户态，这里以my_process()相当于系统的main()函数。my_process()只做很简单的事：打印进程号，并检查my_need_sched状态。如果my_need_sched==1，就会产生一个时钟中断，切换进程。这个时钟中断是我们设定好的，每隔固定时间将my_need_sched置为1。

0号进程启动后，可以fork产生更多的进程。0号进程启动关键处在于对上面这段内嵌式汇编的理解。（内嵌式汇编基本语法请参考这篇文章：点击打开链接）

第4-8句汇编运行效果描述：首先将0号进程的sp赋给esp，也就是把esp指向当前进程。由于初始栈空，esp、ebp指向同一个位置。然后再把当前进程ip放入堆栈，当ret的时候，0号进程就启动了，最后ebp出栈。

        一旦0号进程启动后，，就一直运行，直到有中断产生，切换到下一个进程。

        下面就来看看中断程序和进程是如何切换的。

/*
 * Called by timer interrupt.
 * it runs in the name of current running process,
 * so it use kernel stack of current running process
 */
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;  	
}

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

着重介绍调度函数my_schedule()。

        如果当前系统中只有一个运行的进程，进程切换时，要切换到新进程。假定当前系统只有两个进程0、1号。正在运行的为0号，而下一个1号进程从未运行。这时1号在等待处理机调度。57-63行代码含义：首先保存0号进程栈基址和栈顶，而后设置1号进程的esp、ebp。$1f是一个固定位置，在这里是42行标号1位置。将1位置处地址保存到0进程的ip中。最后通过pushl、ret，启动了1号进程。

若系统所有进程都被启动，接下来就执行35-46这几行代码。因为所有进程构成了一个循环单链表，$1f位置储存了当前进程ip。ret之后，接着下个进程被调度，程序跳转到my_process（）。当链表所有进程都运行一遍，程序回到标号1处，弹出ebp。接着再次循环。注意，$1f是个人为设定的地址，目的是将所有将要切换进程的ip保存到该位置。

三、OS工作过程的个人看法

Linux是一个多进程的操作系统，所以，其他的进程必须等到正在运行的进程空闲CPU后才能运行。当正在运行的进程

等待其他的系统资源时，Linux内核将取得CPU的控制权，并将CPU分配给其他正在等待的进程，这就是进程切换。

进程中最重要的数据结构就是PCB，它是一个进程的标志。有状态、性质、资源、组织等信息。