03 · 保护模式与长模式预览:同一只段寄存器,从查表到不算数
上一篇收尾的时候,机器停在实模式里,段寄存器那半截隐藏基址,一句 × 16 就能算出来。咱们这一篇沿着“按下电源之后机器发生了什么”再往前挪一步:把 CR0 的最低位翻过去,让机器从实地址模式抬进保护模式,同一只 16 位寄存器里装的东西就换了身份。它不再是一个地址的一半,而是一个要拿去查表的编号。等查表这件事立住,咱们再让机器走到 64 位,看那套刚查出来的基址怎么变成不算数。
咱们这一篇读到的机器行为,还是模拟器给的:info registers、xp、screendump 都是模拟器自己的控制台在报数。屏幕另一边还有几屏是 xxd、objdump 给的,那是咱们开发它的电脑上的工具在读磁盘上的文件,读的不是模拟器里的机器。界线主要有两种,这一篇里要反复用,咱们看见一屏读数,得问一句它是谁给的。
咱们这一趟要让同一只 DS 报出两个不同的数:一枚镜像里是 00010000,换一枚镜像报出 000b8000。两个数都出自咱们自己写的代码,没有一个是笔误,它们对不上,因为同一个寄存器在这里有两套解释规则。
同一只 DS,两屏读数
咱们搓两枚 512 字节的裸扇区,用的还是 as 加 ld 那一套。两个源码文件由咱们自己写,名字也由咱们自己定。一个叫 rm16.S,装第一枚。一个叫 prot32.S,装第二枚。两枚的源码就是这一篇要用的东西,下面整份印出来。产物搁在咱们自己建的 build/ 目录里(这个目录得存在,不然模拟器打开镜像时会报一句打不开文件就退出),两枚分别叫 build/rm16.bin 与 build/prot32.bin。配方一共这几行,链接脚本用下面印出来的 tiny.ld:
$ mkdir -p build
$ as --32 rm16.S -o build/rm16.o && ld -m elf_i386 -T tiny.ld --oformat binary -o build/rm16.bin build/rm16.o
$ as --32 prot32.S -o build/prot32.o && ld -m elf_i386 -T tiny.ld --oformat binary -o build/prot32.bin build/prot32.otiny.ld 也一并印出来,省得您回头去翻:
ENTRY(_start)
SECTIONS
{
. = 0x7c00;
.text : { *(.text) }
. = 0x7c00 + 510;
.sig : { SHORT(0xAA55) }
/DISCARD/ : { *(.note*) *(.comment) *(.eh_frame*) }
}第一枚 rm16.S 里咱们只做一件事:把 DS 装成 0x1000,读一个字让这个段有个用处,然后停在那儿。整份长这样(行末那些注释是咱们自己加的,方便对着看):
.code16
.section .text
.global _start
_start:
cli
ljmp $0x0000, $flat
flat:
movw $0x0000, %ax
movw %ax, %ss
movw $0x7c00, %sp
movw $0x1000, %ax /* DS = 0x1000 */
movw %ax, %ds
movw $0x0000, %si
movw (%si), %bx /* 读一个字,让 DS 有个用处 */
movb $0x52, %al /* 'R' */
movw $0x00e9, %dx
outb %al, %dx
1: hlt
jmp 1b第二枚 prot32.S 里,咱们接着往下走:装一张 GDT,把 CR0 的最低位 PE 置 1,远跳到 32 位代码段,再用“描述符里的基址”去碰显存。整份长这样(注释同样是咱们自己加的,那一句 movw (%si), %bx 只为让 DS 有个用处,读到的值不用,所以 SI 没设初值):
展开代码收起代码共 63 行
.code16
.section .text
.global _start
_start:
cli
ljmp $0x0000, $flat
flat:
movw $0x0000, %ax
movw %ax, %ds
movw %ax, %ss
movw $0x7c00, %sp
movw $0x1000, %ax /* DS = 0x1000 */
movw %ax, %ds
movw (%si), %bx /* 读一个字,让 DS 有个用处 */
movb $0x52, %al /* 'R' */
movw $0x00e9, %dx
outb %al, %dx
xorw %ax, %ax
movw %ax, %ds /* lgdt 的地址要按 DS=0 去取 */
lgdt gdt_desc
movl %cr0, %eax
orl $1, %eax
movl %eax, %cr0
.byte 0x66, 0xea /* ljmp $0x08, $pm32 */
.long pm32
.word 0x0008
.code32
pm32:
movw $0x0010, %ax /* 0x10 = 基址 0xB8000 的那个数据描述符 */
movw %ax, %ds
movw %ax, %es
movw %ax, %fs
movw %ax, %gs
movw %ax, %ss
movl $0x7c00, %esp
movl $0x00a0, %edi /* 第 2 行行首 = 80*2 */
movb $0x50, %al /* 'P' */
movb $0x0a, %ah /* 亮绿 */
movw %ax, (%edi)
movw $0x00e9, %dx
outb %al, %dx
movl $0x00a2, %edi
movb $0x4d, %al /* 'M' */
movb $0x0a, %ah
movw %ax, (%edi)
1: hlt
jmp 1b
.org 0x100 /* 载入后落在 0x7D00 */
gdt:
.quad 0x0000000000000000 /* 0x00 空描述符 */
.quad 0x00cf9a000000ffff /* 0x08 32 位代码,基址 0,限长 4G */
.quad 0x0040920b8000ffff /* 0x10 数据,基址 0xB8000(显存),会被装进 DS */
.quad 0x00cf92000000ffff /* 0x18 数据,基址 0,限长 4G */
.quad 0x0040920b8000ffff /* 0x20 与 0x10 一字不差,但没人装载它(对照) */
.quad 0x00cffa000000ffff /* 0x28 DPL=3 代码:本枚镜像里定义了但没用到,特权级那一段换另一枚镜像 */
.quad 0x00cff2000000ffff /* 0x30 DPL=3 数据:同上 */
gdt_end:
gdt_desc:
.word gdt_end - gdt - 1
.long gdt两枚镜像各自冻住之后,咱们问模拟器同一句话。下面两块开头那行 ### 是采集脚本自己打的报幕,不是模拟器的输出:
### 第一枚镜像:实模式,DS=0x1000
DS =1000 00010000 0000ffff 00009300
GDT= 00000000 00000000
IDT= 00000000 000003ff
CR0=00000010 CR2=00000000 CR3=00000000 CR4=00000000### 第二枚镜像:同一份代码继续走,切到 32 位保护模式,DS=0x10
DS =0010 000b8000 0000ffff 00409300 DPL=0 DS [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
GDT= 00007d00 00000037
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000咱们把两屏的 DS 那一行并排读。实模式里,选择子是 0x1000,隐藏基址写着 0x00010000,而 0x1000 × 16 正好就是这个数,值本身就是地址的一半。切到保护模式之后,选择子换成 0x10,基址报 0x000b8000,可 0x10 × 16 只有 0x100,跟 0xb8000 一点关系都没有。同一个寄存器,两套规则,这就是咱们要并排看的那件事。
咱们来问一句:保护模式里那个数是怎么来的。手册写得很干脆(Intel SDM Vol 3A §3.4.2,页眉 3-7):
A segment selector is a 16-bit identifier for a segment […]. It does not point directly to the segment, but instead points to the segment descriptor that defines the segment. A segment selector contains the following items:
Index (Bits 3 through 15) — Selects one of 8192 descriptors in the GDT or LDT. The processor multiplies the index value by 8 (the number of bytes in a segment descriptor) and adds the result to the base address of the GDT or LDT […].
换成人话就是走三步:选择子右移三位得到索引,索引乘 8 得到表内偏移,拿这个偏移到 GDTR 指着的描述符表里读出描述符,描述符里的 base 再跟偏移相加。咱们拿 0x10 走一遍:0x10 >> 3 是 2,2 × 8 是 0x10,GDT 里第 2 项就是基址 0x000b8000 的那一项。这套换算规则是架构定义的,模拟器只是照着兑现。
还有一处得提醒您:monitor 报的段寄存器那一行是四格,最后一格不是 GDT 里的 8 个字节。它是模拟器把 flags 与 access 两个字节抽出来重排的,0x00409300 就是 flags 0x40 左移 16 位,加上 access 0x93 左移 8 位。要看描述符原件,得用 xp 去读内存,咱们到 xxd 与 xp 对读的那一段就用它。
把机器抬进保护模式的两拍
CR0 的最低位 PE 决定处理器处在哪一边。模拟器刚复位那一刻,它报的是 CR0=60000010,最高两位 CD、NW 立着,PE 是 0,机器停在实地址模式。等它自带的固件交棒、把控制权递到 7C00 的时候,CD 与 NW 已经清掉,同一个寄存器报的是 CR0=00000010,PE 还是 0。手册给的复位值 60000010H 说的是前一个时刻(SDM §9.1.1:“This places the processor is in real-address mode with paging disabled”)。谁把 PE 置成 1,这一篇里是咱们自己的引导扇区。
这一拍看着只有一条 mov,可是它得拆成两拍看。起机器的时候带上 -S,它复位后会停在第一条指令之前。咱们再用 GDB 连上去,在 mov %eax, %cr0 这个位置上落一个断点,continue 跑过去,然后单步两次,每次读 cr0 与 cs:
S1 before mov cr0: cr0=0x10
cs=0 pc=0x7c2d ds=0 ss=0
S2 after mov cr0: cr0=0x11 cs=0 pc=0x7c30
S3 after far jmp: cr0=0x11 cs=0x8 pc=0x7c38S2 那一行是这一屏最要紧的地方:那次 mov 执行完,cr0 已经是 0x11,PE 确实置上了,可 cs 还是 0。也就是说,处理器此刻已经处在保护模式里,而 CS 里装的还是实模式留下的缓存描述符。少了下一拍,后面取到的每一条指令都会按旧的段来算。S3 是远跳之后:cs 变成 0x8,这才是咱们 GDT 里第 1 项那个 32 位代码段的选择子。置位与远跳,两拍缺一不可。
还有一件事得说明:这几行是 GDB 打出来的,而 GDB 经 -gdb tcp:127.0.0.1:1531 连过来(端口挑一个空闲的就行,两头对上即可),它只是咱们这边的一个前端,读到的 cr0、cs 全是模拟器里那个 CPU 的值。咱们开发它的电脑上,并没有一个叫 cr0 的东西可以读。另外 GDB 在这边报的是 $pc,可前面那一篇里用的 $eip 在这个前端上照样能读能写,p $eip 报 0xfff0,set $eip = 0x7c00 也照样认。换到 qemu-system-x86_64 那个前端连不上,是整场架构对不上,跟寄存器叫什么名字无关。
56 个字节,两个来源
这一屏是这一篇里最值得并排看的。同一段 56 字节,咱们让两个来源各读一遍:一个是 xxd,它是咱们开发它的电脑上的工具,读的是磁盘上那枚镜像文件。另一个是模拟器的 xp,读的是模拟出来的机器的物理内存。
$ xxd -s 0x100 -l 56 build/prot32.bin
00000100: 0000 0000 0000 0000 ffff 0000 009a cf00 ................
00000110: ffff 0080 0b92 4000 ffff 0000 0092 cf00 ......@.........
00000120: ffff 0080 0b92 4000 ffff 0000 00fa cf00 ......@.........
00000130: ffff 0000 00f2 cf00 ........文件里那 56 个字节就是 7 项 GDT,每项 8 个字节。模拟器里跑起来之后,它报的 GDT 基址是 0x7d00、限长是 0x37,咱们到那个地址上再读一遍同样 56 个字节:
GDT= 00007d00 00000037
(qemu) xp /7gx 0x7d00
00007d00: 0x0000000000000000 0x00cf9a000000ffff
00007d10: 0x0040930b8000ffff 0x00cf92000000ffff
00007d20: 0x0040920b8000ffff 0x00cffa000000ffff
00007d30: 0x00cff2000000ffff限长 0x37 是 55,也就是 7 项乘 8 减 1,这个数可以当场算给读者看。您把两屏对齐着读:文件里第 2 项与第 4 项都写着 …92…,内存里第 2 项已经变成 …93…,第 4 项还是 …92…。差的是 access 字节的最低一位 Accessed,模拟器里的 CPU 把选择子 0x10 装进 DS 的时候,把它写回了内存。第 4 项在源码里与第 2 项一字不差,可从来没人装载过它,所以它一动不动。
笔者在这里要把话收窄一点:这一屏能支持的只有“装载过的那一项多了 Accessed 位”。同一次读数里,CS 那一项(0x7d08)的 A 位并没有被写回,所以咱们不能把它推成“凡是装载描述符都会写回”。描述符表不是只读的,它是内存,CPU 会往上写,写到哪一项、写回什么值,得看那一趟的实际读数。
上面从文件里读出来的那 56 个字节,每一项写了什么,咱们拿刚才那套换算法一项一项读。选择子落到第几项已经会算了,每一项那 8 个字节怎么分成字段,同样是架构定下的固定摆法:开头两格是限长的低 16 位,接着两格是基址的低 16 位,再一格是基址的中 8 位,再一格是权限字节(P 与 DPL 都在这里),再一格的低四位是限长的高四位、高四位是标志(G 与 D/B、L 都在这里),最后一格是基址的最高 8 位。下面这些读数就是照这个摆法读出来的:
# 第二枚镜像里那 56 个字节,从偏移 0x100 起,逐项读出来
[0] 0x0000000000000000
选择子 0x00 | 基址 0x00000000 | 限长 0x0 (G=0) | DPL=0 P=0 | 系统 L=0 D/B=0 | 系统类型 0x0
[1] 0x00cf9a000000ffff
选择子 0x08 | 基址 0x00000000 | 限长 0xffffffff (G=1) | DPL=0 P=1 | 代码/数据 L=0 D/B=1 | 代码 执行/读
[2] 0x0040920b8000ffff
选择子 0x10 | 基址 0x000b8000 | 限长 0xffff (G=0) | DPL=0 P=1 | 代码/数据 L=0 D/B=1 | 数据 读写
[3] 0x00cf92000000ffff
选择子 0x18 | 基址 0x00000000 | 限长 0xffffffff (G=1) | DPL=0 P=1 | 代码/数据 L=0 D/B=1 | 数据 读写
[4] 0x0040920b8000ffff
选择子 0x20 | 基址 0x000b8000 | 限长 0xffff (G=0) | DPL=0 P=1 | 代码/数据 L=0 D/B=1 | 数据 读写
[5] 0x00cffa000000ffff
选择子 0x28 | 基址 0x00000000 | 限长 0xffffffff (G=1) | DPL=3 P=1 | 代码/数据 L=0 D/B=1 | 代码 执行/读
[6] 0x00cff2000000ffff
选择子 0x30 | 基址 0x00000000 | 限长 0xffffffff (G=1) | DPL=3 P=1 | 代码/数据 L=0 D/B=1 | 数据 读写咱们看这几项:0x08 是 32 位代码段,0x10 是基址落在 0xB8000 的数据段,0x18 是平数据。0x28 与 0x30 两项 DPL=3,在这一枚镜像里没人装载它们,ring3 那一段用的是另一枚镜像、另一张表,咱们到那边再说。开保护模式真的不需要一张大表,空项加一个代码段加一个数据段就够撑起来了。0x20 那一项与 0x10 一个字都不差,专门留着当对照。
门、TSS 与真的会被抓的动作
要说清“特权级为什么存在”,光有段还不够,得让模拟器里的 CPU 真的拦一次人。这一段咱们换一枚 ring3 用的镜像。它带的表 6 项,0x08 是 ring0 代码,0x10 是 ring0 平数据,0x18 与 0x20 换成 ring3 的代码与数据,0x28 是 TSS,再加开头那个空项。同一个选择子换到前面两张表里,指的就是别的东西了。咱们建三样东西 GDT、IDT 和 TSS,然后从 ring0 压一个 iret 帧掉到 CPL=3,再看 ring3 里能干什么。
门就是一个 8 字节的描述符,和 GDT 项用的是同一套拆法。咱们给 #GP(0x0D 号)填的那 8 个字节是:
00005068: 0x0e 0x7d 0x08 0x00 0x00 0x8e 0x00 0x00
目标偏移 0x00007d0e | 目标选择子 0x0008 | IST=0 | DPL=0 P=1 | 类型 0x0e = 32 位中断门 | 长度 8 字节目标偏移的低 16 位在头两个字节、高 16 位在末两个字节,拼起来是 0x00007d0e。目标选择子是 0x0008,按咱们 GDT 里的第 1 项就是 32 位代码段。类型字节 0x8e 说的是 P=1、DPL=0、32 位中断门。门不玄,它就是“跳到哪个段、哪个偏移、什么权限”三件事的编码。同一屏里 IDT= 00005000 000007ff,限长 0x7ff 是 256 格乘 8 减 1,您可以当场算一遍。
掉到 ring3 这件事需要两样东西配合。一样是带 DPL=3 的代码段与数据段选择子,装载时选择子的 RPL 也得是 3,所以咱们压进帧里的是 0x1b 和 0x23,也就是 0x18 与 0x20 各带上 RPL=3。另一样是 TSS,它替 CPU 记着“从 ring3 掉回 ring0 时该换哪个栈”:
TR =0028 00004000 00000067 00008900 DPL=0 TSS32-avl
00004000: 0x00 0x00 0x00 0x00 0x00 0x70 0x00 0x00
00004008: 0x10 0x00 0x00 0x00 0x00 0x00 0x00 0x000x4000 起的这两行是咱们自己写进去的,00 70 00 00 是 esp0 = 0x7000,10 00 是 ss0 = 0x10。异常投递到 ring0 之后,模拟器里的处理程序跑在 CS=0008、ESP=00006fe8 上,那就是换过栈之后的值。模拟器里的 ring3 也没白跑,它往内存里留了物证:
00000900: 0x52 0x49 0x4e 0x33 0x1b 0x00 0x46 0x0052 49 4e 33 是字符串 RIN3,紧跟的 0x001b 是它当时自己的 CS 选择子,选择子的 RPL 两位正好是 3。咱们从这 8 个字节里读到的这个 3,不依赖 monitor 报的栏位,它是一段代码亲手写下来的。
然后是最有意思的一拍。同一份源码,咱们只换 ring3 里的一条指令,四种编法各跑一趟。下面印出三趟,第四趟到本节末尾只说结果。头一趟是把 CR0 读到 eax:
EIP=00007d3e EFL=00000012 [----A--] CPL=0 II=0 A20=1 SMM=0 HLT=1
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
GE00000000P00007d02C001b第二趟,咱们让它执行 cli:
EIP=00007d3c EFL=00000012 [----A--] CPL=0 II=0 A20=1 SMM=0 HLT=1
GE00000000P00007d02C001b第三趟,咱们往端口 0xE9 写,不带 I/O 位图的那一版:
EIP=00007d10 EFL=00000046 [---Z-P-] CPL=3 II=0 A20=1 SMM=0 HLT=0
CS =001b 00000000 ffffffff 00cffa00 DPL=3 CS32 [-R-]
UX前两趟都被抓了。那串 GE… 是从调试口里出来的:G 是处理程序的招呼,E 后面跟错误码 0,P 后面跟出事时的 EIP,C 后面跟出事时的 CS。咱们两趟都停在 CS=0008、CPL=0,异常把机器从 ring3 拉回了 ring0。两串里的地址恰好都是 0x00007d02。咱们把两枚变体在同一个偏移上各反汇编一次(工具是 objdump -D -b binary -m i386 -Mintel,看的是咱们自己那两枚镜像):
# 读 CR0 的那一枚
00000102 <.data+0x102>:
102: 0f 20 c0 mov eax,cr0
# 执行 cli 的那一枚
102: fa cli两条指令长度不同,却装在同一地址上,所以出事时那个 EIP 撞成了同一个数。咱们要是只盯着调试口那一串,很容易把两趟当成同一枚镜像跑出来的。
换到端口 I/O 这一趟,说法就得变了。同一份源码里,ring3 执行 out 到端口 0xE9,两个字符 UX 都从调试口出去了,模拟器里的机器停在 CS=001b、CPL=3,没被抓。那个 U 是 ring3 打的,X 是紧接着“没被拦才会出现”的确认,咱们在调试口上看到的就是 UX 两个字。
这里咱们要把两种说法分开。书上是这么写的(OSTEP 第 36 章,书页 8):
Such instructions are usually privileged. The OS controls devices, and the OS thus is the only entity allowed to directly communicate with them.
而在模拟器上,笔者看到的是另一回事:mov %cr0 与 cli 都被拦了,out 没有。为了排除“特权级放行”这个解释,咱们把状态也读了出来:ring3 存下的 EFLAGS = 0x00000046,其中 IOPL 两位是 0(0x46 & 0x3000 == 0)。再补一版,把 TSS 的 I/O 权限位图填成一张全 1 的表(限长 0x87,0x68 到 0x87 全是 0xFF),再跑一次,UX 照样出来。两个前端、-cpu qemu64 与 max 也都试过,结果一致。
所以这一篇讲“特权级会拦人”,现场只用 mov %cr0 与 cli 两个动作。端口 I/O 那一句“用户态碰不了设备端口”,咱们只能标成书上的口径,不能写成在模拟器上试过被拦。至于它为什么没拦,咱们只走到本机实测这一层,手册里 I/O 权限位图那段逐字咱们没核到,所以不解释原因,也不下定性,这一点留到收尾记。
长模式:同一个选择子,两个落点
保护模式讲完,咱们把机器再往前推一程。进 64 位长模式要的东西一件都不能少:CR4.PAE=1,然后 CR3 指向一张 PML4,再把 EFER 的 bit 8 置 1(MSR 0xC0000080,走 rdmsr/wrmsr),接着 CR0.PG=1,最后远跳到 L=1 的代码段。咱们用三张页表加一个 2MB 大页把物理头 2MB 恒等映射,够跑起来。
进长模式之前,咱们再换一枚镜像。长模式这一枚的表也是 6 项,内容跟前两张又不同:0x08 是 32 位代码,0x10 是平数据,0x18 是基址落在 0xB8000 的数据段,0x20 是 64 位代码(L=1),0x28 是 ring3 数据,再加开头那个空项。屏幕上 DS=0x18 与 CS=0x20 两格读数,得对着这一枚的表才读得通。
这一屏是 A/B 对照,咱们让两边只差“模拟器里的机器处在哪个模式”:同一个选择子 0x18,它的描述符里写着基址 0xb8000,同一个偏移 0x0A00,在 32 位里写一次,进了长模式再写一次。
CS =0020 0000000000000000 ffffffff 00af9a00 DPL=0 CS64 [-R-]
DS =0018 00000000000b8000 0000ffff 00409300 DPL=0 DS [-WA]
CR0=80000011 CR2=0000000000000000 CR3=0000000000001000 CR4=00000020
EFER=0000000000000500
(qemu) xp /8xb 0xa00
00000a00: 0x41 0x42 0x43 0x44 0x00 0x00 0x00 0x00
(qemu) xp /8xb 0xb8a00
000b8a00: 0x33 0x0e 0x32 0x0e 0x20 0x07 0x20 0x070xb8a00 那一行是 32 位那一趟留下的,咱们看:33 0e 是黄字黑底的字符 3,32 0e 是字符 2,落点正好是显存里第 17 行的行首两格(第 1、2 格),屏幕上看得见。进了长模式之后,DS 还是 0x18,描述符里那个基址一点没变,可同一个偏移 0x0A00 这次落在 0x00000A00,41 42 43 44 就是 ABCD。同一段代码、同一个选择子、同一个偏移,两个落点,差了 0xb8000 那个基址。
这里咱们得把一句话说清:看这一屏的判据只能用“同一个偏移落到哪”,不能用 monitor 的 DS 那一栏。进了长模式,模拟器照样把 0xb8000 印出来,因为它报的是“缓存描述符里存着多少”,不是“参与计算的是多少”。手册把这件事写死了(SDM Vol 3A §3.4.4,页眉 3-9):
Because ES, DS, and SS segment registers are not used in 64-bit mode, their fields (base, limit, and attribute) in segment descriptor registers are ignored […]. Address calculations that reference the ES, DS, or SS segments are treated as if the segment base is zero.
所以“段已名存实亡”这句,落到这一屏就是:寄存器还在,描述符里的基址也还在,只是算地址的时候不算它了。同一屏里还有几格能跟这一句对上。CS 那一项被模拟器标成 CS64,描述符里 L=1, D/B=0 就是 64 位代码段的标志。CR0=80000011 说明 PG 与 PE 都立着,CR3 指到 0x1000,那是咱们自己写的页表根,CR4 里的 0x20 是 PAE 位,EFER=0000000000000500 让 bit 8 与 bit 10 都立着。0x500 这个数是本机实测,它们叫什么名字、定义怎么写,手册逐字咱们没核到,这一点也留到收尾记。
长模式这件事还有一条来自机器外面的旁证。/proc/cpuinfo 的 flags 里列着 lm 与 pae,那是咱们开发它的电脑自己的 CPU 支持长模式。它不是模拟器里的特性位,跟上面那屏长模式读数不是同一台机器上的事,咱们只把它当旁证看。
0xb8000 那块地方到底是什么,这一篇只当对照用。往它按内存写,屏幕上就会出现字,咱们这一屏里那几个黄色字符就是这么来的。它是 VGA 文本缓冲,不是一个普通变量所在的内存,下一篇咱们再展开它。
长模式跑不起来的三个症状
长模式这一段比前面几屏都容易折,咱们按遇到的概率把三个症状摆出来。
模拟器警告 TCG 不支持 lm,模拟器里的机器停在 BIOS 里,EFER=0000000000000000。 咱们遇到这个症状时,病根在前端:qemu-system-i386 这个前端的 TCG 就是 32 位的,-cpu qemu64 或 max 都补不出 lm 位。处置办法是换 qemu-system-x86_64 前端,这一篇长模式那一屏用的就是它,而且这一组咱们只用 monitor,不挂 GDB。
置了 PE 与 PG 之后模拟器里的机器立刻复位,调试口反复打同一个字符。 咱们遇到的这一类通常是分页没建好:CR3 指错,页表没对齐到 4KB,或者三张表没清干净。处置办法是把三张表用 rep stosl 清零,再写 PML4[0]=0x2003、PDP[0]=0x3003、PD[0]=0x83,并且留意长模式的表项是 8 字节,高 4 字节别落下。
64 位代码里 mov %eax, 0x0a00 编出的地址不对。 64 位下的绝对地址要走 32 位有符号扩展的 disp32,GAS 会把它编成 SIB 形式的绝对地址(89 04 25 …)。您要是自己改成别的形式,落到哪儿就得自己重新算一遍。
双视角锚点:同一只寄存器,两个人各算各的
咱们让两个人分头来看这一篇里的几件事。
**地址。**应用程序员拿起 &x,打出来就是一个数,心里那是一片平坦的地址空间。轮到内核作者,同一个寄存器咱们得看两遍:实模式里它的值是地址的一半,保护模式里它的值是一个编号,得右移三位、乘八、查 GDTR 指着的描述符表,才能把基址取出来。到了 64 位,取出来的基址还不算数了。地址在内核作者手里不是数,是一套得自己算的规则。
**权限。**应用程序员写代码的时候,权限两个字他一般只在文件上见过,在他的世界里,调一个函数就调了,没人拦。轮到内核作者,权限是会被抓的:mov %cr0 与 cli 从 ring3 执行,模拟器里的机器当场进 #GP 门、错误码 0,栈换成 TSS 里写的那个,这一篇里咱们看着它发生。同一段代码里的 out 在模拟器上却没被抓,书上的口径与本机的读数是两回事,咱们把两个说法都留着。
**64 位。**应用程序员在 64 位里写指针、写数组,平坦地址空间用得更顺手,他不知道段寄存器此刻还在不在。轮到内核作者,咱们知道它还在:同一只 DS、同一个偏移 0x0A00,32 位里落到 0xB8A00,64 位里落到 0x00000A00,描述符里那个 0xb8000 被无视了。段寄存器没有消失,它只是从计算里退了出去。
模拟器的读数,和没核到逐字的那几处
这些读数咱们都是在模拟器上看来的,真正的机器上一件都没跑过,所以像 GDT= 00007d00 这个落点、CPL=3 的 out 不被拦、EFER=0x500 里的具体位数,都是模拟器这一趟的读数,别的机器与别的 QEMU 版本都可能不同。稳的只有关系本身:选择子右移三位得索引,限长等于项数乘八减一,64 位里 DS 的基址不参与计算。
有几样咱们这一篇明确没还。端口 I/O 为什么在模拟器上没被抓,咱们只报了实测,TSS 的 I/O 权限位图那段手册逐字没核到,所以不解释原因,也不下定性。CR0.PE 的手册逐字同样没核到,咱们走的是复位值加本机 0x10 与 0x11 两个读数。EFER 的 LME 与 LMA 两个名字的手册逐字也没核到,正文只报实测的 0x500,没写它们的定义。
还有三样是范围问题,不是漏做。显存 0xB8000 对用户态是什么权限,归分页管,这一篇没碰,咱们也没把它跟端口那一次混成一句。中断门的 DPL 与用户态主动 int n 调内核这个动作没做,这一篇的门是 DPL=0 的中断门,异常从 ring3 投递过来不走 DPL 检查,两条路别混。长模式的地址翻译细目咱们也没展开,三张页表加一个 2MB 大页够跑,不够讲四级页表、地址宽度与 canonical form 这些,64 位下的中断与系统调用同样留着。缓存一致性、内存屏障这几样在这几篇的边界外,这一篇只留一句:想往下走,得去翻教科书里讲内存序的那部分。
下一篇咱们从那块 0xB8000 接着往下,看设备是怎么掺进地址空间里来的。