作業系統—在內核中重新載入GDT和堆棧

摘要

用BIOS方式啟動電腦後,BIOS先讀取引導扇區,引導扇區再從外部存儲設備中讀取載入器,載入器讀取內核。進入內核後,把載入器中建立的GDT複製到內核中。

這篇文章的最大價值也許在末尾,對C語言指針的新理解。

是什麼

在BOOT(引導扇區)載入LOADER(載入器)。

在LOADER中初始化GDT、堆棧,把Knernel(內核)讀取到記憶體,然後開啟保護模式,最後進入Knernel並開始執行。作業系統正式開始運行了。

GDT是CPU在保護模式下記憶體定址必定會使用的元素,在Kernel執行過程中也需要用到。

在內核中重新載入GDT和堆棧,是指,把存儲於LOADER所使用的記憶體中的GDT數據和堆棧中的數據複製到Kernel所使用的記憶體中。關鍵點不是Kernel和LOADER所使用的記憶體,而是變數。換句話說,把存儲在LOADER中的變數中的GDT數據和堆棧中的數據複製到Kernel變數中的GDT和堆棧。

LOADER是用彙編寫的,「彙編中的變數」,不知道這種表述是否準確。

為什麼

理由很簡單。LOADER是用彙編語言寫的,Kernel主要用C語言開發。在Kernel中使用GDT,若使用LOADER中定義的那個GDT變數(或者叫標號),光想一想就覺得很混亂。

用一句解釋:C語言中使用C語言中的變數更方便。

怎麼做

流程

  1. 在kernel中聲明變數unsigned short gdt_ptr,存儲GDT的記憶體地址。
  2. 使用sgdt指令把GDT的內地址複製到gdt_ptr中。
  3. 在kernel中創建結構體gdt,存儲GDT。
  4. 使用記憶體複製函數把GDT從LOADER中設置的記憶體位置複製到kernel中的變數gdt表示的記憶體中。

memcpy

它是記憶體複製函數。

這樣實現它:

  1. 原型是:memcpy(void *dst, void *src, int size)
  2. 核心是,把數據從[ds:esi]移動到[es:edi]
  3. 以位元組為單位來複制數據,複製size次。
  4. jmp實現循環,不用loop
  5. 循環終止條件是:size = 0。
memcpy:
		push	ebp
		mov		ebp,	esp
		
		push	edi
		push	esi
		push	ecx
		push	eax
		push	ds
		push	es
		
		mov		es,		[ebp + 12] ;dst
		mov		ds,		[ebp + 8]	; src
		mov		size,	[ebp + 4]	; size
		
		mov		edi,	0
		mov		esi,	0
		mov		ecx,	size
		
.1:
		cmp		ecx,	0
		jz		.2
		mov		al,		[ds:esi]
		mov		[es:edi],		al
		inc		esi
		inc		edi
		dec		ecx
.2:	
		pop		es
		pop		ds
		pop		eax
		pop		ecx
		pop		esi
		pop		edi
		pop		ebp
		ret

gdt

typedef struct {
  	unsigned  short  limitLow;
  	unsigned  short  baseAddressLow;
  	unsigned	char	 baseAddressMid;
  	unsigned	char	 attribute1;
  	unsigned	char	 attribute_limit;
  	unsigned	char	 baseAddressHigh;
}Descriptor;

Descriptor gdt[128];

堆棧

[SECTION .bss]
StackSpace		resb			2 * 1024
StackTop:

mov		esp,	StackTop

不理解。

程式碼

C語言

// 聲明一個char數組,存儲GDT的記憶體地址
unsigned	char	gdt_ptr[6];

nasm彙編

; 使用C語言中聲明的變數gdt_ptr
extern gdt_ptr
; 把暫存器gdtr中的數據複製到變數gdt_ptr中
sgdt	[gdt_ptr]

然後在C語言中把LOADER中的GDT複製到C語言中的gdt變數中。

memcpy(&gdt, 
       (void *)((*)(int *)(&gdt_ptr[2])), 
       (*)((int *)(&gdt_ptr[0]))
      );
short *gdt_limit = &gdt_ptr[0];
int	*gdt_base = &gdt_ptr[2];

*gdt_limit = 128 * sizeof(Descriptor) - 1;
*gdt_base = (int) &gdt;

難點解讀

memcpy的參數

上面的那段程式碼,理解起來難度不小。

memcpy(&gdt, 
       (void *)((*)(int *)(&gdt_ptr[2])), 
       (*)((short *)(&gdt_ptr[0]))+1
      );

memcpy的第一個參數是目標記憶體地址,是一個指針類型變數,賦值應該是一個記憶體地址,所以用&取得變數gdt的記憶體地址。

  1. 理解(void *)((*)(int *)(&gdt_ptr[2]))
    1. 第二個參數是源數據的記憶體地址,是GDT的物理地址。
    2. 它存儲在gdt_ptr的後6個位元組中。
    3. &gdt_ptr[2]獲取gdt_ptr的第3個元素gdt_ptr[2]的物理地址。
    4. 前面的(int *)將這段物理地址強制類型轉換為一個指針,這個指針的數據類型是int *
    5. 數據類型是int *有三層含義:
      1. 這個數據是一個指針。
      2. 這個數據的值是一個記憶體地址。
      3. 這個記憶體地址是一個4位元組(int類型佔用4位元組)記憶體區域的初始地址。
    6. &gdt_ptr[2]是一個記憶體地址,用(int *)將它包裝成或強制轉換成指針類型。
    7. 再用*運算符,是獲取這個記憶體地址指向的記憶體區域中的數據。
    8. 這個數據是int類型,佔用4個位元組。這4個位元組的初始地址是&gdt_ptr[2]。這是最關鍵的一句。
    9. 為什麼最後還要用void *
      1. 因為,這4個位元組中存儲的那個int數據又是一個記憶體地址,因此,需要再次包裝成一個指針。
      2. 因為,memcpy對參數的數據類型要求是void *
      3. 究竟是哪個原因,我也不知道。
  2. 理解:(*)((short *)(&gdt_ptr[0]))+1
    1. 為什麼要加1?gdt_ptr的低2位保存的是GDT的位元組偏移量的最大值,是GDT的長度減1。
    2. &gdt_ptr[0])gdt_ptr[0])的記憶體地址AD。
    3. (short *)&gdt_ptr[0])用AD創建一個指針變數。
      1. 這個指針變數指向一塊記憶體。
      2. 這塊記憶體佔用2個位元組。
      3. 這塊記憶體的初始地址是&gdt_ptr[0]),即gdt_ptr[0])的記憶體地址。
      4. (short *)&gdt_ptr[0])實質是指代&gdt_ptr[0]、&gdt_ptr[1]這兩小塊記憶體。
    4. (*)((short *)(&gdt_ptr[0]))&gdt_ptr[0]、&gdt_ptr[1]這兩小塊記憶體中的值,即gdt_ptr[0]、gdt_ptr[1]
    5. 為什麼不需要像第二個參數一樣在前面再加上一個(void *)
      1. 因為,第4步的結果是一個short類型的整型數(short能稱之為整型嗎?),不是記憶體地址,不需要強制類型轉換。

其他

short *gdt_limit = &gdt_ptr[0];
int	*gdt_base = &gdt_ptr[2];

*gdt_limit = 128 * sizeof(Descriptor) - 1;
*gdt_base = (int) &gdt;
short *gdt_limit = &gdt_ptr[0];
int	*gdt_base = &gdt_ptr[2];

這段程式碼創建了兩個變數並賦值,獲取了GDT的界限和地址。可是緊接著又有下面兩句,是對GDT的界限重新賦值。

*gdt_limit = 128 * sizeof(Descriptor) - 1;
*gdt_base = (int) &gdt;

這兩段程式碼的功能重複了嗎?

讓我們先看另外一段程式碼。

#include <stdio.h>

int main(int argc, char **argv)
{
        int b = 8;
        printf("b = %d\n", b);
        int *a = &b;
        *a = 9;
        printf("b = %d\n", b);

        return 0;
}

執行結果是:

MacBook-Pro:my-note-book cg$ ./test
b = 8
b = 9

第8行*a = 9;修改*a的值,同時也修改了b的值,因為第7行int *a = &b;

再回頭看

short *gdt_limit = &gdt_ptr[0];
int	*gdt_base = &gdt_ptr[2];

*gdt_limit = 128 * sizeof(Descriptor) - 1;
*gdt_base = (int) &gdt;

*gdt_base指向gdt_ptr[2]為初始地址的4個位元組的連續的記憶體空間AD,修改*gdt_base,實質是修改AD中的數據。int *gdt_base = &gdt_ptr[2];的作用是讓*gdt_base指向AD;*gdt_base = (int) &gdt;是修改AD中的數據,從業務邏輯的角度看,是把gdt的記憶體地址寫入AD中。為什麼要這樣做?回憶一下我們的目的是什麼?把存儲了GDT的C語言中變數的記憶體地址存儲到gdt_ptr中。

意外收穫

在理解上面那個比較複雜的指針參數的過程中,我對指針有了新的理解。

int a;,要求CPU(不知道執行者是CPU還是作業系統)為a分配四個位元組的記憶體空間,存儲數據。

int *a;,要求CPU為a分配四個位元組(第一片四位元組記憶體空間,記作A),在這四個位元組中存儲一個記憶體地址,這個記憶體地址指向另外一個四位元組的記憶體區域(記作B)。int *a的含義是,指向B中的int類型數據。

char days[5];
(short *)(&days[2]);

(short *)(&days[2]);的含義是:

  1. 指向一片記憶體區域addr,這片記憶體區域的長度是連續的2個位元組(short是2個位元組)。
  2. addr的初始地址是days[2]的記憶體地址,所以,這片記憶體是&days[2],&days[3]