作業系統—在內核中重新載入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]。

VirMach 便宜 VPS

QNews

QNews