《Linux核心分析》 之 作業系統是如何工作的。2

《Linux核心分析》 之 作業系統是如何工作的
第一講 函式呼叫堆疊

1. 計算機是如何工作的？（總結）——三個法寶
   1,儲存程式計算機工作模型，計算機系統最最基礎性的邏輯結構；
   2,函式呼叫堆疊，高階語言得以執行的基礎，只有機器語言和組合語言的時候堆疊機制對於計算機來說並不那麼重要，但有了高階語言及函式，堆疊成為了計算機的基礎功能；
   enter
   pushl %ebp
   movl %esp,%ebp
   leave
   movl %ebp,%esp
   popl %ebp
   函式引數傳遞機制和區域性變數儲存
   3,中斷，多道程式作業系統的基點，沒有中斷機制程式只能從頭一直執行結束才有可能開始執行其他程式。

堆疊是c語言程式執行時必須的一個記錄呼叫路徑和引數的空間
-函式呼叫框架
-傳遞引數
-儲存返回地址
-提供區域性變數空間

堆疊相關的暫存器
-esp，堆疊指標(stack pinter)
-ebp，基址指標（base pointer)（高地址）
堆疊操作
-push
棧頂地址減少4個位元組（32位）
-pop
棧頂地址增加4個位元組
ebp在C語言中用作記錄當前函式呼叫基址
其他關鍵暫存器
-cs:eip:總是指向下一條的指令地址
2.引數傳遞過程
下面的程式碼中有引數傳遞過程：
#include 
void p1(char c)
{
printf("%c",c);
}
int p2(int x,int y)//重點關注這裡的區域性變數
{
return x+y;
}
int main(void)
{
char c ='a';
int x,y;
x =1;
y =2;
p1(c);
z = p2(x,y);//重點關注這裡的引數傳遞過程
printf("%d = %d+%d",z,x,y);
}

第二講 藉助Linux核心部分原始碼模擬儲存程式計算機工作模型及時鐘中斷
mykernel實驗指導（作業系統是如何工作的）
使用實驗樓的虛擬機器開啟shell
cd LinuxKernel/linux-3.9.4
qemu -kernel arch/x86/boot/bzImage
然後cd mykernel 您可以看到qemu視窗輸出的內容的程式碼mymain.c和myinterrupt.c
使用自己的Linux系統環境搭建過程參見mykernel,其中也可以找到一個簡單的時間片輪轉多道程式核心程式碼
實驗要求：
• 完成一個簡單的時間片輪轉多道程式核心程式碼，程式碼見視訊中或從mykernel找。
• 詳細分析該精簡核心的原始碼並給出實驗截圖，撰寫一篇署名部落格，並在部落格文章中註明“真實姓名（與最後申請證書的姓名務必一致） + 原創作品轉載請註明出處 + 《Linux核心分析》MOOC課程http://mooc.study.163.com/course/USTC-1000029000 ”，部落格內容的具體要求如下：
o 題目自擬，內容圍繞作業系統是如何工作的進行；
o 部落格中需要使用實驗截圖
o 部落格內容中需要仔細分析程式的啟動和程式的切換機制
o 總結部分需要闡明自己對“作業系統是如何工作的”理解。
實驗截圖

參看實驗程式碼：
•檢視mymain.c

第三講 在mykernel基礎上構造一個簡單地作業系統核心
1.C程式碼中嵌入彙編程式碼的寫法

• 截圖

• 2.一個簡單的作業系統核心原始碼
1.mypcb.h//標頭檔案
10 #define MAX_TASK_NUM 4
11 #define KERNEL_STACK_SIZE 1024*8
12

13 /* CPU-specific state of this task */
14 struct Thread {
15 unsigned long ip;
16 unsigned long sp;
17 };
18

19 typedef struct PCB{
20 int pid;
21 volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped /
22 char stack[KERNEL_STACK_SIZE];
23 / CPU-specific state of this task /
24 struct Thread thread;
25 unsigned long task_entry;
26 struct PCB next;
27 }tPCB;
28

29 void my_schedule(void);
2.mymain.c
16 #include "mypcb.h"
17

18 tPCB task[MAX_TASK_NUM];
19 tPCB * my_current_task = NULL;
20 volatile int my_need_sched = 0;
21

22 void my_process(void);
23
24

25 void __init my_start_kernel(void)
26 {
27 int pid = 0;
28 int i;
29 /* Initialize process 0*/
30 task[pid].pid = pid;
31 task[pid].state = 0;
32 task[pid].task_entry = task[pid].thread.ip = (unsigned long)my_process;
33 task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
34 task[pid].next = &task[pid];

35 /fork more process /
36 for(i=1;i<MAX_TASK_NUM;i++)
37 {
38 memcpy(&task[i],&task[0],sizeof(tPCB));
39 task[i].pid = i;
40 task[i].state = -1;
41 task[i].thread.sp = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-1];
42 task[i].next = task[i-1].next;
43 task[i-1].next = &task[i];
44 }

45 /* start process 0 by task[0] /
46 pid = 0;
47 my_current_task = &task[pid];
48 asm volatile(
49 "movl %1,%%esp\n\t" / set task[pid].thread.sp to esp /
50 "pushl %1\n\t" / push ebp /
51 "pushl %0\n\t" / push task[pid].thread.ip /
52 "ret\n\t" / pop task[pid].thread.ip to eip /
53 "popl %%ebp\n\t" //彈出來ebp,核心初始化工作完成
54 :
55 : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp) / input c or d mean %ecx/%edx*/
56 );
57 }

58 void my_process(void)
59 {
60 int i = 0;
61 while(1)
62 {
63 i++;
64 if(i%10000000 == 0)
65 {
66 printk(KERN_NOTICE "this is process %d -\n",my_current_task->pid);
67 if(my_need_sched == 1) //執行10 000 000次才判斷一次是否需要排程
68 {
69 my_need_sched = 0;
70 my_schedule();
71 }
72 printk(KERN_NOTICE "this is process %d +\n",my_current_task->pid);
73 }
74 }
75 }
3.myinterrupt.c 排程機制
15 #include "mypcb.h"
16

17 extern tPCB task[MAX_TASK_NUM];
18 extern tPCB * my_current_task;
19 extern volatile int my_need_sched;
20 volatile int time_count = 0;
21

22 /*
23 * Called by timer interrupt.
24 * it runs in the name of current running process,
25 * so it use kernel stack of current running process
26 */
27 void my_timer_handler(void)
28 {
29 #if 1
30 if(time_count%1000 == 0 && my_need_sched != 1)
31 {
32 printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");
33 my_need_sched = 1;
34 }
35 time_count ++ ;
36 #endif
37 return;
38 }
39

40 void my_schedule(void)
41 {
42 tPCB * next;
43 tPCB * prev;
44

45 if(my_current_task == NULL
46 || my_current_task->next == NULL)
47 {
48 return;
49 }
50 printk(KERN_NOTICE ">>>my_schedule<<<\n");

51 /* schedule */
52 next = my_current_task->next;
53 prev = my_current_task;

54 if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped / //在兩個正在執行的程式之間做上下文切換
55 {
56 / switch to next process /
57 asm volatile(
58 "pushl %%ebp\n\t" / save ebp /
59 "movl %%esp,%0\n\t" / save esp /
60 "movl %2,%%esp\n\t" / restore esp /
61 "movl $1f,%1\n\t" / save eip / //$1f就是指標號1:的程式碼在記憶體中儲存的地址
62 "pushl %3\n\t"
63 "ret\n\t" / restore eip /
64 "1:\t" / next process start here */
65 "popl %%ebp\n\t"
66 : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
67 : "m" (next->thread.sp),"m" (next->thread.ip)
68 );
69 my_current_task = next;
70 printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid
71 }

72 else
73 {
74 next->state = 0;
75 my_current_task = next;
76 printk(KERN_NOTICE ">>>switch %d to %d<<<\n",prev->pid,next->pid);
77 /* switch to new process /
78 asm volatile(
79 "pushl %%ebp\n\t" / save ebp /
80 "movl %%esp,%0\n\t" / save esp /
81 "movl %2,%%esp\n\t" / restore esp /
82 "movl %2,%%ebp\n\t" / restore ebp /
83 "movl $1f,%1\n\t" / save eip /
84 "pushl %3\n\t"
85 "ret\n\t" / restore eip */
86 : "=m" (prev->thread.sp),"=m" (prev->thread.ip)
87 : "m" (next->thread.sp),"m" (next->thread.ip)
88 );
89 }
90 return;
91 }

總結：

通過本星期的學習我瞭解了計算機工作的三法寶。
回想上一學期學的作業系統知識，更深人的瞭解了程式的中斷和切換。

轉自【朱國慶原創作品 轉載請註明出處 《Linux核心分析》MOOC課程http://mooc.study.163.com/course/USTC-1000029000】