安大大 + 原創作品轉載請注明出處 + 《Linux操作系統分析》MOOC課程

天下大事必作于細，天下難事必作于易

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

實驗

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

運行起來的情形：

mymain.c文件內容：

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

myinterrupt.c文件的內容：

每次時鐘中斷它都調用一次printk。怎樣獲取時鐘中斷，進入始終中斷處理程序入口，linux內核的代碼已經處理好了。只需要在中斷發生的時候，做一些實際的中斷處理。

C代碼中嵌入匯編代碼

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

例子程序，實現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*/
    //從輸出部分到輸入部分的變量，從零開始計，分別是%0，%1，%2，數字表示第幾個參數。
    : "=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基礎上構造一個簡單的OS內核( 代碼分析在注釋當中 )

mypcb.h 進程控制塊

#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{//定義進程管理相關的數據結構
    int pid;//進程的id 
    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 內核初始化和0號進程啟動

#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類型數組task
tPCB * my_current_task = NULL;//當前task的指針
volatile int my_need_sched = 0;//是否需要調度 

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

void __init my_start_kernel(void)//初始化 
{
    int pid = 0;
    /* Initialize process 0 初始化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;//起點，入口，my_process實際上是my_start_kernel
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
    task[pid].next = &task[pid];//剛啟動，指向自己，系統里只有0號進程，沒有其他進程 
    /*fork more process 創建更多的進程*/ 
    for(i=1;i<MAX_TASK_NUM;i++)
    {
        memcpy(&task[i],&task[0],sizeof(tPCB));//把0號進程的狀態copy過來
        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;//新fork的進程加到進程列表的尾部 
        task[i-1].next = &task[i];
    }
    /* start process 0 by task[0] 啟動0號進程，使0號進程開始執行*/
    pid = 0;
    my_current_task = &task[pid];//當前的進程就是0號進程
    asm volatile(
        "movl %1,%%esp\n\t" /* set task[pid].thread.sp to esp 把第一號參數task[pid].thread.sp放入esp */
        "pushl %1\n\t" /* push ebp 當前棧是空的，esp=ebp，所以直接push了1號參數sp*/
        "pushl %0\n\t" /* push task[pid].thread.ip push當前的ip*/
        "ret\n\t" /* pop task[pid].thread.ip to eip ,pop的eip,my_process的頭部*/
        "popl %%ebp\n\t"http:// ret之后0號進程正式啟動了,這幾句匯編就按照0號進程設定的堆棧和0號進程的入口構建起來了CPU的運行環境
        :
        : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)    /* input c or d mean %ecx/%edx*/
        //到這里my_start_kernel的工作就做完了，內核的初始化工作完成，并且啟動了0號進程
);
}
void my_process(void)
{
    int i = 0;
    while(1)
    {
        i++;
        if(i%10000000 == 0)//循環1000萬次判斷一下是否需要調度 
        {
            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);
        }
    }
}//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)//設置時間片的大小，時間片用完時設置一下調度標志 
    {
        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;//當前進程是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(  //兩個正在運行的進程之間做進程上下文切換 
         "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是指接下來的標號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//新的進程，從來沒有執行過
    {
        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 從來沒有執行過，所以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

運行成功：

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