Norlit OS —— 自制操作系统 第2章 保护模式_hlt instruction with if=0!

2.1         何为保护模式

Q：保护模式是神马玩意儿？好吃吗？多少钱一斤？

A：好吃，10元一斤，蓝色品质，预购从速，先到先得！

我们先不开玩笑了，切入正题。电脑加点以后进入的模式是实模式。实模式最高只能访问1MB内存，16位寄存器。而我们现在用的都至少有32位的处理器，甚至64位，内存也上G，可不能浪费了！如何才能利用这些呢？答案是保护模式。

顾名思义，保护模式为系统提供了强有力的保护机制，所有的权力都被中央集权，为操作系统所掌控。最重要的是，我们不再需要段+偏移才能达到1MB，而是一个寄存器就有4GB的寻址能力！你心动了吗，那还就赶快拨打电话订购吧！

不过，电话是多少呢？哦，不，如何进入保护模式呢？我们得先来看看枯燥的概念GDT。

 

2.2         全局描述符（GDT）

图 2.2.1 段描述符结构

 

这就是一个段描述符。其中，段基址总长32位，段界限总长20位，还有剩余的12位。我们先来介绍一下这12位。

G：Granularity，颗粒度标志，如果这位为1，则段界限以4KB为单位，否则以1字节为单位。这个标志位非常重要，我们的4GB寻址能力需要它！

D/B：指明这个段中操作的长度。如果这位被设置，那么这个段是32位段，否则是16位段。这个标志也很重要！

L：64位标志，只在IA-32e模式中使用，现在我们大可不管它。

AVL：Available，可用位，可以为操作系统软件使用。

P：Present，存在位，如果为0表示该段不在内存中。

S：为1是代码数据段，否则是系统段。

DPL：Descriptor Privilege Level，特权级标志。

TYPE：最复杂的东西，涉及到段的类型，不过可以读protect.inc里的注释来了解。

段描述符虽然被Intel大叔搞得乱七八糟，但还是非常有用的。通过基址和界限，我们可以确定一个内存区域并使得代码只在这个区域内寻址，达到保护其他内存地址的作用。这就是“保护模式”的来历。对了，描述全局的短描述符叫做GDT。

可是这个东西放在哪里呢？这个64位长的怪东西塞不进16位的段寄存器，所以我们把它放在内存里，用一个指针来访问它。不过，指针也是32位的，仍然塞不进段寄存器。这时候Intel大叔发明了一个寄存器叫Gdtr，存放指针，而段寄存器则作为索引，相当于构造了一个数组。不过，Gdtr里的内容并不完全是指针。它是一个6字节的数据结构，包含了一个基址和一个界限。

图 2.2.2 GDTR

 

图 2.2.3 段寄存器的新用途

 

;=====================================================

; SegementDescriptor(u32 base, u20 limit, u12attr);初始化段描述符

;-----------------------------------------------------

; Entry:

;   - arg0 -> 段基址

;   - arg1 -> 段界限

;   - arg2 -> 属性

; Exit:

;   - 填充一个段描述符

%macroSegementDescriptor 3

    dw %2 & 0FFFFh                         ; 段界限第16位

    dw %1 & 0FFFFh                         ; 段基址第24位

    db (%1 >> 16) & 0FFh                   ; 同上

    dw ((%2 >> 8) & 0F00h) | (%3 & 0F0FFh) ; 扩展字节

    db (%1 >> 24) & 0FFh                   ; 段基址高8位

代码 2.2.1 宏(chapter2/a/boot/include/protect.inc)

 

哈哈，以后我们只需要用“SegmentDescriptor 基址,界限,属性”就可以访问了。不过，我们还得定义一些常量。

;=====================================================

; 段选择子属性常量Segment Selector Attribute, SSA

;-----------------------------------------------------

SSA_RPL0    EQU 0  ;RPL = 0

SSA_RPL1    EQU 1  ;RPL = 1

SSA_RPL2    EQU 2  ;RPL = 2

SSA_RPL3    EQU 3  ;RPL = 3

 

SSA_TIG     EQU 0  ;TI = GDT

SSA_TIL     EQU 4  ;TI = LDT

;-----------------------------------------------------

 

;=====================================================

; 段描述符属性常量Segment Descriptor Attribute，SDA

;-----------------------------------------------------

SDA_D       EQU 4000h  ; D/B 位设置为32位

SDA_G       EQU 8000h  ; G位颗粒度设置为 4KB

SDA_P       EQU 80h    ; P位设置为存在

SDA_S       EQU 10h    ; S为设置为代码数据段

;-----------------------------------------------------

; 特权级

;-----------------------------------------------------

SDA_DPL0    EQU 00h   ; DPL = 0

SDA_DPL1    EQU 20h   ; DPL = 1

SDA_DPL2    EQU 40h   ; DPL = 2

SDA_DPL3    EQU 60h   ; DPL = 3

;-----------------------------------------------------

; 存储段描述符类型值说明

;-----------------------------------------------------

SDA_A       EQU 1h ;已访问

SDA_R_W     EQU 2h  ;可写数据段/可读代码段

SDA_CO      EQU 4h ;一致代码段/向下扩展数据段

SDA_C       EQU 8h ;可执行（代码段）

; 组合说明

; 数据段：必须能读,不允许设置SDA_C，SDA_R_W控制是否能写，SDA_CO控制是否是向下扩展。

; 代码段：必须能执行，必须设置SDA_C，SDA_R_W控制是否能读，SDA_CO控制是否一致。

SDA_FLAT_C  EQU SDA_G|SDA_D|SDA_P|SDA_S|SDA_C|SDA_R_W; 平坦代码段

代码 2.2.2 要用到的常量(chapter2/a/boot/include/protect.inc)

 

说了这么多，我们也得开始行动了。我们将在LOADER中进入保护模式。

;=====================================================

; GDTPointer(u32 base, u16 limit);初始化GDT指针

;-----------------------------------------------------

; Entry:

;   - arg0 -> GDT基址

;   - arg1 -> GDT界限

; Exit:

;   - 填充一个GDT指针

%macro GDTPointer 2

    dw %2 - 1                          ; GDT界限

    dd %1                              ; GDT基址

代码 2.2.3 初始化GDT指针的宏(chapter2/a/boot/include/protect.inc)

 

2.3         保护模式降临

需要进入保护模式，我们需要首先打开A20。在Intel80386之前的电脑上，地址线只有20位，超过的话就会发生卷回，从0开始重新寻址。这严重干扰了我们的32位寻址能力。因此，我们使用键盘控制器上的第20根线来控制，这就是A20。不过键盘控制器又复杂又慢，所以Intel大叔们又创造了另外两种方式来控制它，就是BIOS A20和Fast A20。

         我们使用Fast A20，这种方式不是万能的，但是对于如今的电脑来说都是管用的。

FastA20使用第0x92号端口的第1位来控制A20地址线。所以我们只要：

    in      al, 92h

    or     al, 010b

代码 2.3.1 开启A20(chapter2/a/boot/loader.asm)

 

就可以打开A20地址线。接下来要进行的是GDT的初始化操作。我们只初始化5个GDT，第0个留空，剩下两个系统用代码数据段和两个用户级别的代码数据段。

align 64 ;8字节对齐

 

GDT_EMPTY:     SegmentDescriptor 0,0,0                ;空描述符

GDT_FLAT_C:    SegmentDescriptor 0,0xFFFFF,SDA_FLAT_C;平坦系统代码段

GDT_FLAT_D:    SegmentDescriptor 0,0xFFFFF,SDA_FLAT_D ;平坦系统数据段

GDT_FLAT_C_USR:SegmentDescriptor 0,0xFFFFF,SDA_FLAT_C|SDA_DPL3

;平坦用户级代码段

GDT_FLAT_D_USR:SegmentDescriptor 0,0xFFFFF,SDA_FLAT_D|SDA_DPL3

;平坦用户及数据段

 

GdtPtr:

GDTPointer GDT_EMPTY + LOADER_SEGPHYADDR, $ - GDT_EMPTY

 

SEL_FLAT_C      EQU GDT_FLAT_C - GDT_EMPTY

SEL_FLAT_D      EQU GDT_FLAT_D - GDT_EMPTY

SEL_FLAT_C_USR  EQU GDT_FLAT_C_USR - GDT_EMPTY + SSA_RPL3

代码 2.3.2 数据初始化(chapter2/a/boot/loader.asm)

对了，其中SEL_开头的是段寄存器中要填充的内容，我们把它称作选择子。

好了，一切准备工作已经就绪，我们现在就要打开保护模式的开关，进入新大陆。

    mov    eax, cr0

    or     eax, 1

代码 2.3.3扳机(chapter2/a/boot/loader.asm)

 

其中cr0是控制寄存器，它的第0位就是我们的扳机。

CR0的第0位称为CR0.PE，保护模式使能位。

不过，我们现在在32位模式了，我们的段寄存器还未更新。而且CPU的指令预取也需要更新。这时候直接对cs操作很危险，我们还需要一个远跳转来完成这一切。

 

代码 2.3.4 Fire!!! (chapter2/a/boot/loader.asm)

 

这里需要注意我们要加上LOADER_SEGPHYADDR因为接下来的地址不再分段，而是平坦的了，这个值在loader.inc下被定义为0x90000。下面，我们就可以加上[BITS 32]然后进入我们的保护模式世界了。

        

2.4         题外话：保护模式下的显示

我们进入保护模式以后，BIOS中断就不能再用了。实际上，在我们初始化IDT（以后会讲）之前，所有中断都会对我们的操作系统致命。所以我们不能再用显示服务来显示文字了。那怎么办的？答案是写显存。在文本模式下，显存被映射到了0xB8000处。我们只需要操作那里就可以了。

在那之前，我们先初始化段寄存器。

LABEL_START_PM:

    mov     ax,SEL_FLAT_D_USR

    mov    gs, ax

    mov    ax, SEL_FLAT_D

    mov    ds, ax

    mov    es, ax

    mov    ss, ax

   

    mov    esi,LOADER_SEGPHYADDR + String

    call   DispStrPM

   

代码 2.4.1 加载段寄存器(chapter2/a/boot/loader.asm)

 

初始化完后，这个DispStrPM就是我们关注的内容。

DispPosdd (80*0+0)*2+0xB8000   ;在Data中的定义

……

[Section Bit32]

[BITS 32]

……

;=====================================================

; DispStrPM(char* addr);显示字符串

;-----------------------------------------------------

; Entry:

;   - ESI -> 要显示的字符串

; registers changed:

;   - ESI, EAX

DispStrPM:

    push   ebp

 

    mov    ebp, [DispPosPM] ; 获得当前显示位置

    mov    ah, 0Fh           ; 字体颜色

.loop:

    mov    al, [esi]         ; 取1字节

    inc    esi                ; 指针移动到下一字节

    or     al, al               ; if(al==0)?

    jz     .end               ; 退出循环

    cmp    al, 13             ; 回车？

    je     .13

    cmp    al, 10             ; 换行？

    je     .10

    mov    [ebp], ax         ; 填充字符

    inc    ebp

    inc    ebp

    jmp    .loop

.13:

    push   bx

   

    mov    eax, ebp

    sub    eax, 0xB8000

    mov    bl, 160

    div    bl

    movzx   eax, ah

    sub    ebp, eax

   

    pop    bx

    mov    ah, 0Fh

    jmp    .loop

.10:

    add    ebp, 160

    jmp    .loop

.end:

    mov    [DispPosPM], ebp

    pop    ebp

    ret

   

; Data

代码 2.4.2 显示文字(chapter2/a/boot/loader.asm)

 

这其中还特地处理了回车和换行。好了，我们运行一下看看。

图 2.4.1 成功显示文字！

不仅出现了实模式输出的字样，而且还成功在保护模式下写入显存并成功显示文字！这是我们的新突破！

 

2.5         保护模式的终极法宝

其实刚才我们讲的那么多只是保护模式的分段机制而已，但实际上分段机制在大多数现代操作系统中是不被使用的。这里面有兼容性问题，而且，我们还有终极法宝——分页。

我们在这节中先不会讲分页机制，而我们需要先得到可用内存的分布情况。在动手之前，我们先看一下1MB一下的内存分布情况。由于兼容性原因，这部分内存的分布在各电脑上都是一致的。

图 2.5.1 内存分布表

 

接下来就涉及到如何获得高端内存分布的问题了。随着电脑的不同，这些分布也完全不同。我们不可能直接写死在代码里。这里，我们的BIOS同志又要登场了。

这次登场的是15H中断。不同于DOS中读取磁带的中断，BIOS的15H中断，是杂碎的系统服务以及高级电源管理。

我们这里使用它的E820h号功能，获得内存地址描述符表。

 

表 2.5.1 E820h号功能

 

其中，ARDS(AddressRange Descriptor Structure)是个20字节的数据结构。

表 2.5.2 ARDS结构

BootParamAddrSeg  equ 0x50

ARDSNum            equ 0x0

代码 2.5.1 用来保存ARDS地址定义(chapter2/b/boot/include/loader.inc)

    mov    ax,BootParamAddrSeg

    mov    es, ax                     ; !!!!!!!ES=ARDSAddrSeg=0x50

    mov    di,ARDSAddrOffset

   

    mov    dword[es:ARDSNum],0

   

    mov    ebx, 0

.loop:

    mov    edx, 0x534D4150

    mov    eax, 0xE820

    mov    ecx, 20

    int    15h

    jc     .fail

    add    di, 20

    inc    dword[es:ARDSNum]

    or     ebx, ebx

    jnz    .loop

    jmp    .ok

.fail:

    mov    si,MemChkFail  ;显示出错信息

    call   DispStr

    cli                    ;停止系统运行

    hlt

代码 2.5.2 轻松得到ARDS结构(chapter2/b/boot/loader.asm)

 

Get it! 不过，麻烦来了。我们如何才能看到这些数据呢？不用怕，我们使用带有调试功能的bochs。Linux下带有调试功能的Bochs需要自己编译，使用Linux的读者可以自己去网上搜索一下。Windows用户则比较容易，只需要右键单击配置好的bochsrc.bxrc（这个文件可以运行bochs配置好后按save保存），选择Debugger就可以了。

然后我们先输入c让它执行，

<bochs:1>c

等到

00014105176i[CPU0] WARNING: HLT instruction with IF=0!

出现后按下Ctrl+C组合键调出：

<bochs:2>

这时候我们输入：

<bochs:2> x 0x500

[bochs]:

0x0000000000000500<bogus+       0>:   0x00000006

可以看到0x500出的内容为6，即我们有6条记录，即20字节，5个双字。所以再输入：

<bochs:3> x /30 0x504

[bochs]:

0x0000000000000504<bogus+       0>:   0x00000000     0x00000000      0x0009f000      0x00000000

0x0000000000000514<bogus+      16>:   0x00000001     0x0009f000     0x00000000      0x00001000

0x0000000000000524<bogus+      32>:   0x00000000     0x00000002     0x000e8000      0x00000000

0x0000000000000534<bogus+      48>:    0x00018000     0x00000000     0x00000002      0x00100000

0x0000000000000544<bogus+      64>:   0x00000000     0x01ef0000     0x00000000      0x00000001

0x0000000000000554<bogus+      80>:   0x01ff0000     0x00000000     0x00010000      0x00000000

0x0000000000000564<bogus+      96>:   0x00000003     0xfffc0000     0x00000000      0x00040000

0x0000000000000574<bogus+     112>:   0x00000000      0x00000002

我们可以就这些信息来制成一张表：

表 2.5.3 笔者Bochs内存分布表

 

关于ACPI是啥子，笔者在往后几章有可能会将到。目前就将它当做Reserved的不可使用区间吧。对了，Type=4表示预留为睡眠用区间，不可随意使用，Type=5表示这部分内存不存在，都不可以使用。其他的都必须被操作系统认为是AddressRangeReserved。

除了被保留的内存和不存在的内存，其他内存的最大可访问大小加上1就是电脑内存大小了。这么看来这么看来这个电脑的内存大小为0x2000000。好吧。不过每天查看内存是不可能的，我们应该还写一下显示数字的代码。不过，在那之前……

 

2.6         调用与约定与模块化

模块化是操作系统编写过程中重要的思想。模块化可以有效的减少bug的产生，又有助于阅读。所以我们可以把那些函数都提取到一个lib.inc文件中去。提取完毕以后，我们得讲一讲调用约定。

一般来说，我们会将参数压栈以后call目标函数。但我们都知道寄存器操作远远快于内存操作。所以前辈们发明了一种快速调用方法fastcall。Fastcall将部分参数放在寄存器中，额外的参数压栈然后再call。不幸的是，每个编译器对fastcall的处理方式完全不同。所以我们甚至无法利用fastcall加速汇编和C的相互调用（除非编译器使我们自己写的）。

一般地，我们在C语言和汇编链接的时候使用ASMLINKAGE调用约定，即C调用约定，不使用寄存器传参。而内核中C程序的调用使用FASTCALL调用约定，使用寄存器来加速。汇编内部的调用则随便来，只要不要忘记保存以后用到的寄存器即可。这也是我为什么在汇编函数下面写上registers changed的原因。

 

2.7         显示数字

;=====================================================

; DispInt(int num);十六进制显示数字

;-----------------------------------------------------

; Entry:

;   - EAX -> 要显示的数字

; registers changed:

;   - ESI, EAX

DispInt:

    mov    esi, IntBufEPM-1

    call   .putDigit

    call   .putDigit

    call   .putDigit

    call   .putDigit

    call   .putDigit

    call   .putDigit

    call   .putDigit

    call   .putDigit

    dec    esi

    call   DispStrPM

    ret

.putDigit:

    push   eax

    and    al, 0x0F

    cmp    al, 0xA

    jnl    .hex

    add    al, '0'

    jmp    .ret

.hex:

    add    al, 'A'-0xA

.ret:

    mov    [esi],al

    dec    esi

    pop    eax

    shr    eax, 4

代码 2.7.1 显示数字的函数(chapter2/c/boot/include/lib.inc)

 

IntBuf  db "0x00000000"

IntBufE db 0

IntBufPM  equ IntBuf+LOADER_SEGPHYADDR

代码 2.7.2 定义变量(chapter2/c/boot/include/loader.inc)

 

         笔者又擅自加上了一个NewLine换行函数，由于过于简单，就不放出来了，读者可以自己看看。有了显示数字的函数，我们就可以打印信息了：

    mov    ecx, [BootParamPhyAddr+ARDSNum]

    mov    ebp,BootParamPhyAddr+ARDSAddrOffset

DispMemBlock:

    call   NewLine

    mov    eax, [ebp]

    call   DispInt

    add    ebp, 4

    mov    eax, [ebp]

    call   DispInt

    add    dword[DispPosPM],2

    add    ebp, 4

    mov    eax, [ebp]

    call   DispInt

    add    ebp, 4

    mov    eax, [ebp]

    call   DispInt

    add    dword[DispPosPM],2

    add    ebp, 4

    mov    eax, [ebp]

    call   DispInt

    add    ebp, 4

代码 2.7.3 别看重复，但是快速！(chapter2/c/boot/loader.asm)

 

如果成功的话，应该在别的虚拟机下面也能运行。试试。

哦，我们的judgement.sh发出了警报，超过512字节了。我们把loader.inc里的LOADER_SIZE_SECT改为0x2，judgement.sh中的值改为1024，Makefile中的dd命令的count改为count=2。好了，再make image一次。

放在Hyper-V下运行试试：

图 2.7.1 成功显示ARDS

 

内存结构都知道了，我们现在就应该学习一下分页机制。

 

2.8         分页机制

分页机制说好懂好懂，说难懂难懂。所以为了保证大家100%弄懂，我们先来讲述一下三个概念。

逻辑地址（Logical Address）是与段相关的偏移地址部分。在编程过程中，所有的地址都是逻辑地址，它是相对于你当前进程数据段的地址，不和绝对物理地址相干。在Intel实模式下，逻辑地址和物理地址相等（因为没有分段或分页机制，不进行自动地址转换）。我们由于将GDT设置为平坦的段，因此逻辑地址等于线性地址。

线性地址（Linear Address）是逻辑地址到物理地址变换之间的中间层。逻辑地址加上相应段的基地址就生成了一个线性地址。如果启用了分页机制，那么线性地址能再经变换以产生一个物理地址。若没有启用分页机制，那么线性地址直接就是物理地址。

物理地址（Physical Address）是指出目前CPU外部地址总线上的寻址物理内存的地址信号，是地址变换的最终结果地址。如果启用了分页机制，那么线性地址会使用页目录和页表中的项变换成物理地址。如果没有启用分页机制，那么线性地址就直接成为物理地址了。

我之所以到现在才讲这几个概念，是因为我们之前的编写过程中，这些地址是等价的。我们没有启动分页，分段又是走形式，所以不会引起任何问题。不过现在我们要打开分页机制，所以只能把这三个概念补上。

 

CPU的页式内存管理单元，负责把一个线性地址，转换为物理地址。由于内存数量有限，不可能一一对应，所以从管理和效率的角度出发，线性地址被分为以固定长度的块，称为页(page)，例如一个32位的机器，线性地址最大可为4G，可以用4KB为一个页来划分，所以一共有2的20个次方个页。这些页的数量还是很多，而且占用空间很多，于是我们又将这些页继续分成1024组。

这样我们得到了1024个大数组。这个大数组我们称之为页目录表。页目录表里的每一项又指向一个包含1024页的表，这个含有1024页的表我们称为页表。页表和页目录表都要沿4KB对齐，也就是放在一个页里。

一个二级管理模式的机制就是分页机制。文字描述太累，看图省眼：

图 2.8.1 分页机制描述图

分页单元中，页目录表是唯一的，它的地址放在CPU的cr3寄存器中，是进行地址转换的基础。

每一个32位的线性地址被划分为三部份，页目录表索引(10位)，页表索引(10位)，偏移(12位) 依据以下步骤进行转换：

(1)     从cr3中取出页目录表的地址。

(2)     根据线性地址前十位，在页目录表中，找到对应的索引项，得到页表的地址。

(3)     根据线性地址的中间十位，在页表中找到页的起始地址。

(4)     将页的起始地址与线性地址中最后12位相加，得到最终我们想要的物理地址。

怎么样，说复杂复杂，说简单也简单吧。

对了，还没说这页目录表和页表中的一项是什么呢。这一项被称为页目录项和页表项。每一项都是4字节的。

 

图 2.8.2 复杂的页表项（CR4.PAE=0）

既然这个表出来的，那我也只好解释一下了。

Ignored：表示这些位被CPU忽略，操作系统自行决定用途。

P：Present，第0位表示其存在位，如果不存在的话所有其他位都会无效。

R/W：Read/Write，读写权限，R（0）只读，W（1）可写。

U/S：User/System，特权级，0为系统级（Ring0-2），1为用户级（Ring3）。如果CR0.WP没有被置位，系统级程序可以写入用户级的只读页。

PCD：表示这个页面的缓冲策略。1则禁止对该页面进行缓冲。

PWD：PCD位被设置时，1表示写入高速缓存的同时必须写入内存。

A：Accessed，访问位，表示该页或页表是否已被访问。

D：Dirty，脏位，表示该页是否已被写。

PAT：Page Attribute Table，页表属性，部分处理器不支持，我们留0。

G：Global，全局位，如果G位被设置，而且CR4.PGE（CR4第7位）被设置，那么这个也不会在TLB（Translation Lookaside Buffer）中被无效。

PS：Page Size，页大小。页目录表的第七位。如果CR4.PSE（PageSize Extension页面大小扩展，CR4第四位）置位并且这个位置位表示这个页目录表是4MB[1]的页表，并且不含有下级页表。

         差不多了解了，那么我们可以开始写了。

我们先简单地把整个内存等位值映射吧。我们把页目录表放在0x2000~0x3000处的位置，使用4MB的页面好了(简单方便)。初始化后，将CR0的最高位，即PG分页使能位打开。

PagingOn:

    mov    ebx, PDEAddr

    mov    eax, 10000011b ;PS,P,R/W被设置

    mov    ecx, 1024

.loop:

    mov    [ebx], eax

    add    ebx, 4

    add    eax, 0x400000

    loop   .loop

   

    mov    eax, PDEAddr

    mov    cr3, eax

   

    mov    eax, cr4

    or     eax, 10000b

    mov    cr4, eax

   

    mov    eax, cr0

    or     eax, 0x80000000

    mov    cr0, eax

    jmp    .ret

.ret:

    nop

代码 2.8.1 分页启动！(chapter2/c/boot/include/lib.inc)

 

PDEAddr是我定义在loader.inc中的常量，选用了一个空的空间。不过运行以后啥事都没有发生……不用担心，这是正常的，我们还什么都没做呢。那我们就利用保护模式干点什么吧。

;add    eax, 0x400000

;注释掉以后就可以模拟回卷，即所有线性页都映射到第一个物理页

……

.ret:

    nop

   

    mov    dword[0x600], 0x1234

    mov    eax, dword[0x400600]

    call   DispInt

代码 2.8.2 测试分页机制(chapter3/c/boot/include/libtest.inc[2])

 

 

图 2.8.3 成功了！

 

0x1234! 太好了，我们的分页机制也在正常地运行！我们成功掌握了分页机制！

 待って[3]，我们还没有掌握多级页表的技术呢，刚才只是偷了个懒跳过了多级分页而已。

;=====================================================

; PagingOn();分页机制使能（2级）只映射了4MB以下内存

;-----------------------------------------------------

; registers changed:

;   - EAX, EBX, ECX

PagingOn:

    mov    ebx, PTEAddr

    mov    eax, 00000011b

    mov    ecx, 1024

.loop:

    mov    [ebx], eax

    add    ebx, 4

    add    eax, 0x1000

    loop   .loop

   

    mov    ebx, PDEAddr

    mov    eax, PTEAddr+00000011b

    mov    ecx, 1024

.loop1:

    mov    [ebx], eax

    add    ebx, 4

    loop   .loop1

   

    mov    eax, PDEAddr

    mov    cr3, eax

   

    mov    eax, cr4

    or     eax, 0x10      ; CR4.PSE=1, 4MB页表使能

    mov    cr4, eax       ; 在这里这三句可以省略

   

    mov    eax, cr0

    or     eax, 0x80000000 ;CR0.PG=1, 分页机制使能

    mov    cr0, eax

    jmp    .ret

.ret:

    nop

   

    mov    dword[0x600], 0x1234

    mov    eax, dword[0x400600]

    call   DispInt

   

代码 2.8.3 二级分页(chapter2/c/boot/include/lib2.inc)

 

运行后没有任何变化，证明我们成功攻破了二级分页机制！

 

2.9         冲刺PAE（Physical Address Extension，物理地址扩展）

我们在上一节中已近学会了2级分页，现在我们就要冲刺3级分页了。

         还是老样子，先学习理论，不多说，直接上图。

图 2.9.1 PAE模式下的分页机制

现在，每一个32位的线性地址被划分为四部份，页目录指针表索引(2位)，页目录表索引(9位)，页表索引(9位)，偏移(12位) 依据以下步骤进行转换：

(1)       从cr3中取出页目录指针表的地址。

(2)       根据线性地址前两位，在页目录指针表中，找到对应的索引项，得到页目录表的地址。

(3)       根据线性地址29-21位，在页目录表中，找到对应的索引项，得到页表的地址。

(4)     根据线性地址20-12位，在页表中找到页的起始地址。

(5)     将页的起始地址与线性地址中最后12位相加，得到最终我们想要的物理地址。

页目录表和页表的其他特性都没有变，只是扩展到了64位以支持更大的物理内存（注意，线性地址只有32位！）

其实这个页目录表也没啥指针表也没啥特殊的，和页目录表和页表很相似，不过只有4项，占用32字节，而且也要在内存中沿32字节对齐。另外，PS置位不再是4MB，而是2MB的略小的大页表了。我们还要将CR4.PAE（第5位）置位。

没啥奥秘的，对吧，我们开始写源代码。

;=====================================================

; PagingOn();分页机制使能（3级）只映射了4MB以下内存

;-----------------------------------------------------

; registers changed:

;   - EAX, EBX, ECX

PagingOn:

    mov    ebx, PTEAddr

    mov    eax, 00000011b ; PS,P,R/W被设置

    mov    ecx, 512       ; 注意是512了，变成8字节了。

.loop:

    mov    [ebx], eax

    mov    dword[ebx+4], 0 ; 高位填充0，我们不用

    add    ebx, 8

    add    eax, 0x1000

    loop   .loop

   

    mov    ebx, PDEAddr

    mov    eax, PTEAddr+00000011b

    mov    ecx, 512

.loop1:

    mov    [ebx], eax     ; 所有内存都映射在0-4MB处

    mov    dword[ebx+4], 0

    add    ebx, 8

    loop   .loop1

   

    mov    ebx, PDPTEAddr ; 所有内存都映射在0-4MB处

    mov    eax, PDEAddr+1

    mov    ecx, 4

.loop2:

    mov    [ebx], eax

    mov    dword[ebx+4], 0

    add    ebx, 8

    loop   .loop2

   

    mov    eax, PDPTEAddr

    mov    cr3, eax

   

    mov    eax, cr4

    or     eax, 0x30      ; CR4.PSE=CR4.PAE=1, 4MB页表使能,PAE使能

    mov    cr4, eax

   

    mov    eax, cr0

    or     eax, 0x80000000 ;CR0.PG=1, 分页机制使能

    mov    cr0, eax

    jmp    .ret

.ret:

    nop

   

    mov    dword[0x600], 0x1234

    mov    eax, dword[0x400600]

    call   DispInt

   

代码 2.9.1 页表级数越来越多。。。。(chapter2/c/boot/include/lib3.inc)