?鄭斌　　原創作品轉載請注明出處

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

第二周的實驗內容分析

?

1.實驗環境：實驗樓中執行。

2.程序代碼

整個程序主要由3個文件構成：

1）mypcb.h。 主要定義了進程結構體?

2）mymain.c。 主要定義了my_start_kernel初始化第一個進程的函數，和my_process實現進程運行輸出和調度。

3) ?myinterrupt.c。 ?主要定義了my_time_handler函數通過計時器設置進程是否需要調度，實現分時，my_schedule函數實現進程調度，完成上一個進程的現場保存和轉到下一個進程的功能。

?

具體代碼如下：

?

?

?

mypcb.h

?

/** linux/mykernel/mypcb.h** Kernel internal PCB types** Copyright (C) 2013 Mengning**/#define MAX_TASK_NUM 4 #define KERNEL_STACK_SIZE 1024*8/* 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

/** 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]; tPCB * my_current_task = NULL; volatile int my_need_sched = 0;void my_process(void);void __init my_start_kernel(void) {int pid = 0;int i;/* Initialize process 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;task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];task[pid].next = &task[pid];/*fork more process */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];}/* start process 0 by task[0] */pid = 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);} } }

?

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 1if(time_count%1000 == 0 && my_need_sched != 1){printk(KERN_NOTICE ">>>my_timer_handler here<<<\n");my_need_sched = 1;} time_count ++ ; #endifreturn; }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; }

?

?3.實驗過程。

進入實驗樓，在對應文件目錄下，把3個文件編輯到mykernel文件夾下，然后make編譯

?

4.程序代碼分析

為了方便說明，本文中把代碼中的進程根據下標叫為進程(pid)，如進程(0)即為剛開始的0號進程。

整個代碼部分，CPU從my_start_kernel開始執行

?

void __init my_start_kernel(void) {int pid = 0;int i;/* Initialize process 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;task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];task[pid].next = &task[pid];

?

先是初始化了進程(0)的信息。這里主要關注兩點：

1.task_entry=thread.ip=my_process。

我的理解是進程的eip，即執行內容為my_process函數.?前面加(unsigned?long)表示該函數執行的入口地址。

2.thread.sp?的賦值表達式是(unsigned?long)&task[i].stack[KERNEL_STACK_SIZE-1]

我們回顧在mypcb.h中定義PCB部分

?

所以進程(0)的sp是從stack字符串的末尾開始的，符合第一周課程中的棧地址從高地址向低地址。

然后是復制另外幾個進程的信息。

?

state?=?-1?表示開始未執行。

這里有個小細節挺有意思，開始乍一看我以為這樣寫沒有進程的下一個進程是進程(0)。

然后分析task[i].next?=?task[i-1].next;

????????task[i-1].next?=?&task[i];

這兩條語句，手寫模擬后發現其實不是那樣的，最后的數組next情況是

task.next[] task[0] task[1] task[2] task[3]

對應內容 ????task[1] task[2] task[3] ?task[0]

?

?

然后執行

?

關鍵字說明：

asm表示嵌入式匯編，其中%0，%1等表示下面的參數，可以簡單理解為函數參數，如此處%0表示task[pid].thread.ip，其他情況類似。

volatile表示編譯器不需要優化的代碼。

?

我們來觀察其中的匯編代碼部分。??注意當前的堆棧是進程(0)的堆棧空間

?

"movl %1,%%esp\n\t" /* set task[pid].thread.sp to esp，此時esp是進程(0)的thread.sp*/ "pushl %1\n\t" /* push ebp ，把進程(0)的thread.sp壓棧，因為當前進程(0)的棧為空，ebp跟esp指向相同，所以相當于把ebp壓棧*/ "pushl %0\n\t" /* push task[pid].thread.ip ，把進程(0)的thread.ip壓棧*/ "ret\n\t" /* pop task[pid].thread.ip to eip ，eip為進程(0)的thread.ip，接下來開始執行my_process函數。*/ "popl %%ebp\n\t" //我覺得這句代碼并沒有被執行 : : "c" (task[pid].thread.ip),"d" (task[pid].thread.sp)

下面來看my_process函數。

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);} } }

?

這段代碼中定義了變量i初始值為0，然后一個循環體while(1)中i每次加1，當i為10000000才倍數時，輸出“this?is?process?+進程標號”

若變量my_need_sched為1，把my_need_sched值置為0，然后執行my_schedule函數(該函數將在后面分析)?變量my_need_sched初始值為0，用來標記是否需要進行進程切換，0表示不用，1表示要切換。

?

?

再來看myinterrupt.c文件里的代碼內容。

開頭的變量定義有

extern tPCB task[MAX_TASK_NUM]; extern tPCB * my_current_task; extern volatile int my_need_sched; volatile int time_count = 0;

extern表示引用了其他地方（這里為mymain.c）定義了的變量。

?

函數my_timer_handler分析：

這里我簡單理解為代碼執行后，內核的定時器也是自動執行的，即my_timer_handler也是自動開始執行。

?

該函數的功能為每次計時器走一次，即該函數執行一次，time_count變量加1。當time_count為1000的倍數并且my_need_sched為0時候，輸出">>>my_timer_handler?here<<<"，并把my_need_sched值置為1.表示當前進程需要被調度（這里體現了系統進程調度的分時處理思想）。

?

?

then是其中一個非常重要的調度函數my_schedule()。下面我們來進行代碼分析。

?

void my_schedule(void) { //申明兩個進程指針 prev和next，用來標記當前進程的pid和下一個進程的pidtPCB * 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; //next指向當前進程的下一個進程prev = my_current_task; //prev指向當前進程/*這里的if將在所有進程（這里是4個）都運行了才執行，前3次都跳轉到else的代碼部分，所以可以先看下面的else部分的分析后再回到這里*/ 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); }/*程序初始狀態只有進程(0)的state為0，其他進程都為-1（見初始化部分），所以if判斷的前3次都將執行此部分，依次運行進程(1)、進程(2)、進程(3)并state都標記為0*/ 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)的state為0，其他進程都為-1（見初始化部分），所以當

前3次調用?my_schedule函數時，if判斷的都將執行else{}部分，依次運行進程(1)、進程(2)、進程(3)并state都標記為0。

接下來調用?my_schedule函數時，if判斷都執行if(next->state?==?0){}部分的代碼。

?

我們先看來if判斷中else{}部分的代碼。以程序第一次調用my_schedule函數為例，此時進程(0)正在運行。所以棧空間是進程(0)的堆棧空間。

prev為task[0]，即進程(0)，next為task[1]，即進程(1)

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，把ebp壓棧 */"movl %%esp,%0\n\t" /* save esp，保存進程(0)的thread.sp為esp*/"movl %2,%%esp\n\t" /* restore esp ，置當前esp為進程(1)的esp*/"movl %2,%%ebp\n\t" /* restore ebp ，進程(1)未開始執行，ebp和ebp指向相同，置當前ebp為進程(1)的ebp */"movl $1f,%1\n\t" /* save eip ，保存進程(0)的eip為指向標記1：部分的下一條指令，在if的嵌入式匯編代碼塊中，至此進程(0)的ebp入棧，并保存了esp和eip*/"pushl %3\n\t" /*把進程(1)的thread.ip壓棧*/"ret\n\t" /* restore eip ，eip指向進程(1)的thread.ip，開始執行進程(1)*/: "=m" (prev->thread.sp),"=m" (prev->thread.ip): "m" (next->thread.sp),"m" (next->thread.ip)); }

?

?

我們以第四次執行my_schedule函數時為例，將調用if(next->state?==?0){}部分的代碼，且接下來每次調用my_schedule函數時為例，都將調用if(next->state?==?0){}部分的代碼。

prev為task[3]，即進程(3)，next為task[0]，即進程(0)。

?

if(next->state == 0)/* -1 unrunnable, 0 runnable, >0 stopped */{/* switch to next process */asm volatile( "pushl %%ebp\n\t" /* save ebp ，保存進程(3)的ebp*/"movl %%esp,%0\n\t" /* save esp ，保存進程(3)的thread.sp為esp*/"movl %2,%%esp\n\t" /* restore esp，置esp為進程(0)的thread.sp，恢復進程(0)現場的esp */"movl $1f,%1\n\t" /* save eip ，保存進程(3)的eip為指向標記1：部分的下一條指令
　　　　　　　　　　　　　　　　　　　　　　至此進程(3)的ebp入棧，并保存了進程(3)的esp和eip*/"pushl %3\n\t" /*把進程(0)的thread.ip入棧*/"ret\n\t" /* restore eip ，eip指向進程(0)的thread.ip，開始恢復執行進程(0)，查看上面分析可以看到即為從下面的匯編指令部分開始執行*/"1:\t" /* next process start here */"popl %%ebp\n\t" /*進程(0)開始恢復執行的第一句，先把ebp出棧，這里提現了不同進程有各種工作的堆棧空間*/: "=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); }

?

?

至此代碼分析結束，接下來為進程的循環調度工作。

?

?

總結：

進程啟動運行，會有自己的數據存儲空間和堆棧空間。

內核會有定時器自動啟動用以實現分時功能。

進程之間的切換要保存現場，包括esp,eip,ebp等。

轉載于:https://www.cnblogs.com/terrry/articles/4333236.html

總結

以上是生活随笔為你收集整理的一个简单的时间片轮转多道程序内核代码分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。