Linux內核設計（第二周）——操作系統工作原理

by蘇正生

原創作品轉載請注明出處

《Linux內核分析》MOOC課程http://mooc.study.163.com/course/USTC-1000029000

一、學習筆記總結

1.函數調用堆棧

（1）、函數調用堆棧。

堆棧是C語言程序運行時必須的一個記錄調用路徑和參數的空間。
cpu內部已經集成好的功能，pop，push，enter……

1. 函數調用構架

2. 傳遞參數，通過堆棧

3. 保存返回值，%eax

4. 提供局部變量空間
   ……

C語言編譯器對堆棧的使用有一套自己的規則，功能相同，指令有區別。

（2）、深入理解函數調用堆棧

1. 堆棧相關的寄存器：

   %esp——堆棧指針
   %ebp——基址指針

2. 堆棧操作

   push——棧頂地址減少
   pop——相反

3. %ebp在C語言中用作記錄當前函數調用基址

4. 其他關鍵寄存器
   CS：eip：總是指向下一條的指令地址
   順序執行、跳轉|分支（cs：eip的值會根據程序的需求更改）、call、ret、發生中斷時。

5. 調用函數
   call指令：

（1） 將eip中下一條指令的地址A保存在棧頂；
（2） 設置eip指向被調用程序代碼開始處。
ret（return）指令：將地址A恢復到eip中

（3）、傳遞參數與局部變量

方法：gcc-g生成可執行文件，用objdump -S獲得反匯編文件。

2.利用Ｌｉｎｕｘ內核部分源代碼分析存儲程序計算機工作模型及時鍾中斷

（1）．ｍｙｋｅｒｎｅｌ實驗平台涉及的思想

三大法寶：

1. 存儲程序計算機

2. 函數調用堆棧

3. 中斷

當中斷發生時，由ＣＰＵ和內核代碼共同實現了保存現場和恢復現場。
把ｅｉｐ指向中斷處理程序的入口，保存現場。

二．利用ｍｙｋｅｒｎｅｌ實驗模擬計算機硬件平台

1.實驗過程

使用實驗樓的虛擬機打開shell

cd LinuxKernel/linux-3.9.4
qemu -kernel arch/x86/boot/bzImage

然后cd mykernel 您可以看到qemu窗口輸出的內容的代碼mymain.c和myinterrupt.c

mymain.c文件關鍵代碼部分

myinterrupt.c文件關鍵代碼部分

2.代碼分析

（1）mymain.c

/* * linux/mykernel/mymain.c * * Kernel internal my_start_kernel * * Copyright (C) 2013 Mengning * */
#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數組
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;  
    int i;
    /* 初始化 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;  /* 實際上是my_process*/
    task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
    task[pid].next = &task[pid];  // 定義堆棧的棧頂
    /*創建更多的子進程*/
    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];
    }
    /* 從0號進程開始啟動 */
    pid = 0;
    my_current_task = &task[pid];
    asm volatile( "movl %1,%%esp\n\t" /* 設置 esp 的值*/ "pushl %1\n\t" /* 將 ebp 壓棧（此時esp=ebp）,%1相當於task[pid].thread.sp*/ "pushl %0\n\t" /* 將 eip 壓棧，%0相當於task[pid].thread.ip*/ "ret\n\t" /* 相當於 eip 出棧 */ "popl %%ebp\n\t" /* 0號進程正是啟動 */ : : "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);
        }     
    }
}

（2）myinterrupt.c

/* * linux/mykernel/myinterrupt.c * * Kernel internal my_timer_handler * * Copyright (C) 2013 Mengning * */
#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
    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 */
    {
        /* 進程切換跳轉到下一進程 */
        asm volatile(   
            "pushl %%ebp\n\t"       /* 保存當前ebp */
            "movl %%esp,%0\n\t"     /* 保存當前esp */
            "movl %2,%%esp\n\t"     /* 重新記錄要跳轉進程的 esp，%2為 next->thread.sp*/
            "movl $1f,%1\n\t"       /* 保存當前 eip ，%1為prev->thread.ip*/   
            "pushl %3\n\t" 
            "ret\n\t"               /* 記錄要跳轉進程的 eip，%3為 next->thread.ip*/
            "1:\t"                  /* 下一個進程開始執行 */
            "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"       /* 保存當前 ebp */
            "movl %%esp,%0\n\t"     /* 保存當前 esp */
            "movl %2,%%esp\n\t"     /* 重新記錄要跳轉進程的 esp ，%2為 next->thread.sp*/
            "movl %2,%%ebp\n\t"     /* 重新記錄要跳轉進程的 ebp，%2為 next->thread.sp */
            "movl $1f,%1\n\t"       /* 保存當前 eip ，%1為prev->thread.ip，%1f就是指標號1:的代碼在內存中存儲的地址*/   
            "pushl %3\n\t" 
            "ret\n\t"               /* 重新記錄要跳轉進程的 eip，%3為 next->thread.ip */
            : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
            : "m" (next->thread.sp),"m" (next->thread.ip)
        );          
    }   
    return; 
}

#三、總結
本周從計算機操作系統對於程序的調用學起，結合了以前學習的匯編、C語言的知識，對於計算機內部對於中斷的處理和進程切換有新的認識。有一些不明白的內容老師也在課堂上已經做出了詳細的解答，很形象生動。本周因為一些個人因素進度有些太慢，這種情況應該有所規避，以后要改正。