安大大 + 原創(chuàng)作品轉(zhuǎn)載請注明出處 + 《Linux操作系統(tǒng)分析》MOOC課程

天下大事必作于細(xì)，天下難事必作于易

早期的計(jì)算機(jī)在沒有中斷的時候，只能執(zhí)行完一個程序之后，再執(zhí)行另外一個程序。有了中斷之后，就有了多道程序設(shè)計(jì)。當(dāng)一個中斷信號發(fā)生的時候，CPU把當(dāng)前的eip，esp，ebp都壓到一個叫內(nèi)核堆棧的另外一個堆棧里。然后把eip指向中斷處理程序的入口。即保存現(xiàn)場，執(zhí)行中斷處理程序。由CPU和內(nèi)核代碼共同實(shí)現(xiàn)了保存現(xiàn)場和恢復(fù)現(xiàn)場。

實(shí)驗(yàn)

cd LinuxKernel/linux-3.9.4
rm -rf mykernel
patch -p1 < ../mykernel_for_linux3.9.4sc.patch #打補(bǔ)丁
make allnoconfig
make #編譯內(nèi)核請耐心等待
qemu -kernel arch/x86/boot/bzImage

運(yùn)行起來的情形：

mymain.c文件內(nèi)容：

my_start_kernel之前都是硬件初始化的東西，從my_start_kernel函數(shù)開始，這就是操作系統(tǒng)的入口，開始啟動操作系統(tǒng)。每循環(huán)十萬次，打印一次"my_start_kernel here"，值改的越大，打印的速度就越慢。改完之后make一下。

myinterrupt.c文件的內(nèi)容：

每次時鐘中斷它都調(diào)用一次printk。怎樣獲取時鐘中斷，進(jìn)入始終中斷處理程序入口，linux內(nèi)核的代碼已經(jīng)處理好了。只需要在中斷發(fā)生的時候，做一些實(shí)際的中斷處理。

C代碼中嵌入?yún)R編代碼

語法格式 asm("匯編語句":"輸出部分":"輸入部分":"破壞描述部分");

例子程序，實(shí)現(xiàn)val1+val2=val3

#include <stdio.h>
int main()
{
    /* val1+val2=val3 */
    unsigned int val1 = 1;
    unsigned int val2 = 2;
    unsigned int val3 = 0;
    printf("val1:%d,val2:%d,val3:%d\n",val1,val2,val3);
    asm volatile(
    "movl $0,%%eax\n\t" /* clear %eax to 0*/
    "addl %1,%%eax\n\t" /* %eax += val1 */
    "addl %2,%%eax\n\t" /* %eax += val2 */
    "movl %%eax,%0\n\t" /* val2 = %eax*/
    //從輸出部分到輸入部分的變量，從零開始計(jì)，分別是%0，%1，%2，數(shù)字表示第幾個參數(shù)。
    : "=m" (val3) /* output =m mean only write output memory variable*/
    : "c" (val1),"d" (val2) /* input c or d mean %ecx/%edx*/
    );
    printf("val1:%d+val2:%d=val3:%d\n",val1,val2,val3);
    return 0;
}

在mykernel基礎(chǔ)上構(gòu)造一個簡單的OS內(nèi)核( 代碼分析在注釋當(dāng)中 )

mypcb.h 進(jìn)程控制塊

#define MAX_TASK_NUM 4 // max num of task in system
#define KERNEL_STACK_SIZE 1024*8

struct Thread {
    unsigned long       ip;//存儲eip 
    unsigned long       sp;//存儲esp 
};
typedef struct PCB{//定義進(jìn)程管理相關(guān)的數(shù)據(jù)結(jié)構(gòu)
    int pid;//進(jìn)程的id 
    volatile long state;//進(jìn)程的狀態(tài)    /* -1 unrunnable, 0 runnable, >0 stopped */
    char stack[KERNEL_STACK_SIZE];//當(dāng)前進(jìn)程的堆棧
    /* CPU-specific state of this task */
    struct Thread thread;
    unsigned long   task_entry;//入口 （指定的） 
    struct PCB *next;//進(jìn)程鏈表 
}tPCB;

void my_schedule(void);//調(diào)度器

mymain.c 內(nèi)核初始化和0號進(jìn)程啟動

#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/tty.h>
#include <linux/vmalloc.h>

#include "mypcb.h"

tPCB task[MAX_TASK_NUM];//PCB類型數(shù)組task
tPCB * my_current_task = NULL;//當(dāng)前task的指針
volatile int my_need_sched = 0;//是否需要調(diào)度 

void my_process(void);//函數(shù)聲明

void __init my_start_kernel(void)//初始化 
{
    int pid = 0;
    /* Initialize process 0 初始化0號進(jìn)程的數(shù)據(jù)結(jié)構(gòu)*/
    task[pid].pid = pid;
    task[pid].state = 0;//狀態(tài)是正在運(yùn)行 /* -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;//起點(diǎn)，入口，my_process實(shí)際上是my_start_kernel
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
    task[pid].next = &task[pid];//剛啟動，指向自己，系統(tǒng)里只有0號進(jìn)程，沒有其他進(jìn)程 
    /*fork more process 創(chuàng)建更多的進(jìn)程*/ 
    for(i=1;i<MAX_TASK_NUM;i++)
    {
        memcpy(&task[i],&task[0],sizeof(tPCB));//把0號進(jìn)程的狀態(tài)copy過來
        task[i].pid = i;
        task[i].state = -1;
        task[i].thread.sp = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-1];//每個進(jìn)程都有它自己的堆棧
        task[i].next = task[i-1].next;//新fork的進(jìn)程加到進(jìn)程列表的尾部 
        task[i-1].next = &task[i];
    }
    /* start process 0 by task[0] 啟動0號進(jìn)程，使0號進(jìn)程開始執(zhí)行*/
    pid = 0;
    my_current_task = &task[pid];//當(dāng)前的進(jìn)程就是0號進(jìn)程
    asm volatile(
        "movl %1,%%esp\n\t" /* set task[pid].thread.sp to esp 把第一號參數(shù)task[pid].thread.sp放入esp */
        "pushl %1\n\t" /* push ebp 當(dāng)前棧是空的，esp=ebp，所以直接push了1號參數(shù)sp*/
        "pushl %0\n\t" /* push task[pid].thread.ip push當(dāng)前的ip*/
        "ret\n\t" /* pop task[pid].thread.ip to eip ,pop的eip,my_process的頭部*/
        "popl %%ebp\n\t"http:// ret之后0號進(jìn)程正式啟動了,這幾句匯編就按照0號進(jìn)程設(shè)定的堆棧和0號進(jìn)程的入口構(gòu)建起來了CPU的運(yùn)行環(huán)境
        :
        : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)    /* input c or d mean %ecx/%edx*/
        //到這里my_start_kernel的工作就做完了，內(nèi)核的初始化工作完成，并且啟動了0號進(jìn)程
);
}
void my_process(void)
{
    int i = 0;
    while(1)
    {
        i++;
        if(i%10000000 == 0)//循環(huán)1000萬次判斷一下是否需要調(diào)度 
        {
            printk(KERN_NOTICE "this is process %d -\n",my_current_task->pid);//主動調(diào)度 
            if(my_need_sched == 1)
            {
                my_need_sched = 0;
                my_schedule();  
            }
            printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);
        }
    }
}//end of my_process

myinterrupt.c

#include <linux/types.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/tty.h>
#include <linux/vmalloc.h>
#include "mypcb.h"

extern tPCB task[MAX_TASK_NUM];
extern tPCB * my_current_task;
extern volatile int my_need_sched;
volatile int time_count = 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
    // make sure need schedule after system circle 100 times.
    if(time_count%100 == 0 && my_need_sched != 1)//設(shè)置時間片的大小，時間片用完時設(shè)置一下調(diào)度標(biāo)志 
    {
        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 there no task running or only a task ,it shouldn't need schedule
    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;//當(dāng)前進(jìn)程是prev
    if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */
    {//save current scene
         my_current_task = next; 
        printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);  
     /* switch to next process */
     asm volatile(  //兩個正在運(yùn)行的進(jìn)程之間做進(jìn)程上下文切換 
         "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  $1f是指接下來的標(biāo)號1：的位置*/
         "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)
     );
  }
    else//新的進(jìn)程，從來沒有執(zhí)行過
    {
        next->state = 0;//把這個進(jìn)程置為運(yùn)行時狀態(tài) 
        my_current_task = next;//這個進(jìn)程做為當(dāng)前的進(jìn)程 
        printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);
     /* switch to new process 切換到一個新進(jìn)程*/
     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 從來沒有執(zhí)行過，所以esp和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; 
}//end of my_schedule

把mypcb.h,mymain.c,myinterrupt.c放到mykernel目錄下，重新make

運(yùn)行成功：

難點(diǎn)分析：
理解和運(yùn)行mykernel，它是提供初始化好的CPU從my_start_kernel開始執(zhí)行，并提供了時鐘中斷機(jī)制周期性執(zhí)行my_time_handler中斷處理程序，執(zhí)行完后中斷返回總是可以回到my_start_kernel中斷的位置繼續(xù)執(zhí)行。當(dāng)然中斷保存現(xiàn)場恢復(fù)現(xiàn)場的細(xì)節(jié)都處理好了，mykernel就是一個邏輯上的硬件平臺，具體怎么做到的一般不必深究。
能運(yùn)行mykernel后就可以寫一個自己的時間片輪轉(zhuǎn)調(diào)度內(nèi)核了，自己寫還是很難的，只需到mykernel的github版本庫找到代碼復(fù)制過來重新編譯Linux3.9.4的源代碼，能按視頻的效果跑起來，這都不難。
難點(diǎn)是理解基于mykernel實(shí)現(xiàn)的時間片輪轉(zhuǎn)調(diào)度代碼。
往往系統(tǒng)都有很多進(jìn)程比較復(fù)雜，我們假定當(dāng)前系統(tǒng)只有兩個進(jìn)程0和1，第一次調(diào)度是從0切換到1，也就是prev=0，next=1，第二次調(diào)度正好相反。
這時再看myinterrupt.c中的匯編代碼，保存prev的進(jìn)程（0）上下文，下次調(diào)度是next進(jìn)程就是0了，反之進(jìn)程1是next那它肯定之前作為prev被調(diào)度出去過。理解進(jìn)程上下文的保存和恢復(fù)極為關(guān)鍵。
$1f就是指標(biāo)號1:的代碼在內(nèi)存中存儲的地址
再來看特殊一點(diǎn)代碼切換到一個新的進(jìn)程，也就是next沒有被保存過進(jìn)程上下文，它從沒有被執(zhí)行過，這時稍特殊一點(diǎn)即else部分的匯編代碼。