01 · 上电与取指:第一条指令是一条远跳
咱们按下电源键的那一刻,机器眼里没有程序、没有函数、没有类型,只有一大片可以按字节寻址的数组。这句话不是笔者编的,它出自一本讲系统的书(CS:APP 2e,书页 161):机器码看待内存的方式,就是“a large, byte-addressable array”。书里的数组和结构体,到了机器码这一层,只是一串挨在一起的字节。
可咱们接下来要问的是:这串字节算什么呢?同一串字节放在那儿,换个谁来读,答案就换一个。这一篇就从这儿进,一路走到机器吐出它的第一条指令。
咱们这一路从机器里读出来的每一屏,都是模拟器里的 QEMU 加上它自带的 SeaBIOS 给出的,不是哪一台真正的机器上的样子。至于 od、objdump、readelf、gcc 那些屏,它们是咱们开发它的电脑上的工具给出的,跟模拟器无关。
五个字节,三种读法
咱们自己捏五个字节,拿来当题目:
printf '\xb8\x00\x7c\xcd\x10' > five.bin # 读者自己捏的 5 个字节咱们拿 od -A x -t x1 -t x2 按两种宽度看一眼,b8 00 这几个字节,按字节读是两格,按十六位小端读出来是 0x00b8:
000000 b8 00 7c cd 10
00b8 cd7c 0010
000005咱们再把同一份文件交给 objdump,只换一下“按哪一代读”的眼睛:
$ objdump -D -b binary -m i386:x86-64 -Mintel five.bin
0000000000000000 <.data>:
0: b8 00 7c cd 10 mov eax,0x10cd7c00
$ objdump -D -b binary -m i8086 -Mintel five.bin
00000000 <.data>:
0: b8 00 7c mov ax,0x7c00
3: cd 10 int 0x10咱们看这串字节,它一格都没动,同一个 objdump 换一副眼睛,一种读法得到一条指令,另一种读法得到两条。mov eax,0x10cd7c00 和 mov ax,0x7c00 后面跟着 int 0x10,说的是同一串字节。
边界一错,后面全线错位
五个字节短,够不上真正要命的地方。咱们把题目换成系统自带的真码,从 /bin/true 入口处取 32 个字节。入口地址是 readelf -h 报的,把它交给 dd 就能截出这一段。入口地址和开头这几个字节都随发行版与 glibc 版本变,下面这一屏是本机 /bin/true 的样子:
ENTRY=$(readelf -h /bin/true | sed -n 's/.*Entry point address: *//p') # 本机 0x2590
dd if=/bin/true of=true-entry.bin bs=1 skip=$((ENTRY)) count=32 status=none截出来的东西,咱们就靠 xxd 看一眼形状:
$ xxd true-entry.bin
00000000: f30f 1efa 31ed 4989 d15e 4889 e248 83e4 ....1.I..^H..H..
00000010: f050 5445 31c0 31c9 488d 3dd1 feff ffff .PTE1.1.H.=.....咱们按六十四位读,它从 endbr64 起一路顺下去,十一条指令各归各位。屏上的原文咱们只引十行,略去的是原文 6: 那一行,字节是 49 89 d1,它把 rdx 的值搬到另一个寄存器:
$ objdump -D -b binary -m i386:x86-64 -Mintel true-entry.bin
0000000000000000 <.data>:
0: f3 0f 1e fa endbr64
4: 31 ed xor ebp,ebp
9: 5e pop rsi
a: 48 89 e2 mov rdx,rsp
d: 48 83 e4 f0 and rsp,0xfffffffffffffff0
11: 50 push rax
12: 54 push rsp
13: 45 31 c0 xor r8d,r8d
16: 31 c9 xor ecx,ecx
18: 48 8d 3d d1 fe ff ff lea rdi,[rip+0xfffffffffffffed1] # 0xfffffffffffffef0咱们再换十六位那副眼睛读同一串字节,50 54 45 31 c0 一下子变成四条:
11: 50 push ax
12: 54 push sp
13: 45 inc bp
14: 31 c0 xor ax,ax
16: 31 c9 xor cx,cx
18: 48 dec ax
19: 8d 3d lea di,[di]
1b: d1 fe sar si,1六十四位那边 50 是 push rax、54 是 push rsp、45 31 c0 是一条 xor r8d,r8d,三条。十六位这边:50 54 45 31 c0 五个字节切成四条,块里从 18 往后接着往下列的是 dec ax、lea di,[di]、sar si,1,再往后的字节就念不出完整指令了。助记符的名字也换了,可咱们真正要打起精神的地方是指令的边界。边界一错,后面全线错位。
字节是什么,取决于谁在解释它
/bin/true 的开头四个字节也是文件身份。咱们从它头上截 32 个字节另存一份,单看开头:
head -c 32 /bin/true > head32.bin # 系统自带真码的头 32 字节$ head -c 32 /bin/true | xxd
00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000 .ELF............
00000010: 0300 3e00 0100 0000 9025 0000 0000 0000 ..>......%......咱们看它开头这一串,7f 45 4c 46,人人认得那是 \x7fELF。现在把这一小截当码看,六十四位那副眼睛念出来的是这些:
$ objdump -D -b binary -m i386:x86-64 -Mintel head32.bin # /bin/true 的头 32 字节
0: 7f 45 jg 0x47
2: 4c rex.WR
3: 46 02 01 rex.RX add r8b,BYTE PTR [rcx]
6: 01 00 add DWORD PTR [rax],eax
...
10: 03 00 add eax,DWORD PTR [rax]
12: 3e 00 01 ds add BYTE PTR [rcx],al
15: 00 00 add BYTE PTR [rax],al
17: 00 90 25 00 00 00 add BYTE PTR [rax+0x25],dl
1d: 00 00 add BYTE PTR [rax],al
...咱们再换十六位那副眼睛读同一小截:
$ objdump -D -b binary -m i8086 -Mintel head32.bin
0: 7f 45 jg 0x47
2: 4c dec sp
3: 46 inc si
4: 02 01 add al,BYTE PTR [bx+di]
6: 01 00 add WORD PTR [bx+si],ax
...
10: 03 00 add ax,WORD PTR [bx+si]
12: 3e 00 01 add BYTE PTR ds:[bx+di],al
15: 00 00 add BYTE PTR [bx+si],al
17: 00 90 25 00 add BYTE PTR [bx+si+0x25],dl
1b: 00 00 add BYTE PTR [bx+si],al
1d: 00 00 add BYTE PTR [bx+si],al
...文件解析器读它,得到“这是一个 ELF 文件”,反汇编器读它,同一串字节就成了一堆谁也用不上的算术。机器自己不认识文件头,它只认识字节。这串字节是数据还是指令、属于哪一代的那一套,全都是解释的人加上去的:CPU 里的译码器算一个解释器,objdump 算一个,咱们写代码时心里那套类型也算一个。
eip 那几个数,是从哪儿读来的
复位是一个有确切数值的状态。咱们让模拟器跑起来,用 GDB 连上去,在复位那一刻读三个寄存器:
cs 0xf000 61440
eip 0xfff0 0xfff0
cr0 0x60000010 [ CD NW ET ]
cs:ip 折成的线性地址(cs*16+ip)= 0xffff0cr0 的最低位是 0,也就是保护模式没开,咱们看到机器确实停在实模式里。咱们拿它报出的三个数去对 Intel 手册 Vol 3A 的 Table 9-1,一格不差:那页写着 EIP=0000FFF0H、CR0=60000010H,还写着处理器停在“real-address mode with paging disabled”。手册 §9.1.4 接着说,复位后头一条被取到并执行的指令落在物理地址 FFFFFFF0H,在处理器最高物理地址往下 16 个字节的位置。
GDB 的 $pc 是线性地址
在复位那一刻,笔者拿 x/8i $pc 去看指令,屏幕上排出来八行一模一样的 add %al,(%eax),像内存里全是零。同一次会话里,咱们把段也折进去再读一次,读到的才是真东西。下面两行是同一处内存、两个读法:
0xfff0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0xffff0: 0xea 0x5b 0xe0 0x00 0xf0 0x30 0x36 0x2f$pc 在这里是线性地址的口径,它只拿了 eip 那个 0xfff0 去读,而 cs 是 0xf000,真正要读的地方得把段折进去(x/8i $cs*16+$eip)。咱们在模拟器上想读 CS:IP 指着的那块,得自己把段补上。这次会话里 GDB 给出的指令原文不可信:0xffff0 的五个字节 ea 5b e0 00 f0 是一条远跳,它却解成了七个字节的 ljmp $0x3630,$0xf000e05b。要引指令原文,咱们引 QEMU 自己的日志,它的 -d in_asm 才是模拟器自己的说法。
机器自己报出来的复位态:选择子与隐藏基址
咱们要知道,QEMU 的 monitor 是它自带的那个控制台,不是新工具,顺手教两手就够:info registers 打寄存器,xp /8xb <地址> 按字节看物理内存。冻在复位那一点上,它报出来的头几行是这样的:
EIP=0000fff0 EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0000 00000000 0000ffff 00009300
CS =f000 ffff0000 0000ffff 00009b00CS 后面跟着四格:选择子 f000、隐藏基址 ffff0000、限长 ffff,最后一格把访问权限的几个字节打包在一起。选择子乘十六只有 0x000f0000,而它此刻的基址写的是 0xffff0000。咱们看看手册那两段是怎么交代这个特例的:CS 分成可见的选择子和隐藏的基址两部分,实模式里基址通常由选择子左移四位得来,可复位那一次选择子装的是 F000H、基址装的是 FFFF0000H,起点就这么加出来(FFFF0000 + FFF0H = FFFFFFF0H)。模拟器报的这一行,跟手册一个字一个字对得上。
同一屏还白送咱们一件事,模拟器把固件映像映在了两个地方:
fffffff0: 0xea 0x5b 0xe0 0x00 0xf0 0x30 0x36 0x2f
000ffff0: 0xea 0x5b 0xe0 0x00 0xf0 0x30 0x36 0x2f上面那行原样是 fffffff0: 0xea 0x5b 0xe0 0x00 0xf0 0x30 0x36 0x2f(这里省掉的是原行末尾的回车)。0xfffffff0 与 0x000ffff0 两个物理地址读出八个一模一样的字节,这既回答了“为什么手册把第一条指令记在 FFFFFFF0”,也告诉咱们这串字节在低端另有一份。在模拟器这边,低端映出来的就是它自带的 SeaBIOS。
取指循环,落到肉眼上是一串数在动
咱们看书上把取指循环说得多直白(CS:APP 2e,书页 9):从上电到下电,处理器反复执行程序计数器指着的指令,再把程序计数器更新到下一条。“读取、解释、执行”这个模型,拼的是书页 9 上的原话。
咱们造一个 512 字节的裸扇区,让它进模拟器里跑,自己拿 GDB 单步十次,每一步都看 eip 落在哪儿:
si0 : cs=0000 eip=7c00 线性=0x07c00 => 0x7c00: ljmp $0xb8,$0x7c05
si1 : cs=0000 eip=7c05 线性=0x07c05 => 0x7c05: mov $0xd88e0000,%eax
si2 : cs=0000 eip=7c08 线性=0x07c08 => 0x7c08: mov %eax,%ds
si3 : cs=0000 eip=7c0a 线性=0x07c0a => 0x7c0a: mov %eax,%ss
si4 : cs=0000 eip=7c0c 线性=0x07c0c => 0x7c0c: mov $0xbb7c00,%esp
si5 : cs=0000 eip=7c0f 线性=0x07c0f => 0x7c0f: mov $0x1b97c00,%ebx
si6 : cs=0000 eip=7c12 线性=0x07c12 => 0x7c12: mov $0x2ba0001,%ecx
si7 : cs=0000 eip=7c15 线性=0x07c15 => 0x7c15: mov $0xca010002,%edx
si8 : cs=0000 eip=7c18 线性=0x07c18 => 0x7c18: add %ecx,%edx
si9 : cs=0000 eip=7c1a 线性=0x07c1a => 0x7c1a: mov $0x4b,%al
si10: cs=0000 eip=7c1c 线性=0x07c1c => 0x7c1c: mov $0xf4ee00e9,%edx这一屏咱们只看左半边的偏移:7c00 到 7c05 跨了五格,7c05 到 7c08 跨三格,再往后是两格、两格、三格,剩下几步也都在两格到三格之间。每一步的跨度,正好是上一条指令的长度。取指循环这件事,落到能看见的层面上,就是这串数在一格一格往前挪。右边那半截指令原文别信,理由上一节交代过了。
那段 512 字节的源码,咱们自己写起来也就这么长:
.code16
.global _start
_start:
ljmp $0x0000, $flat
flat:
movw $0x0000, %ax
movw %ax, %ds
movw %ax, %ss
movw $0x7c00, %sp
movw $0x7c00, %bx
movw $0x0001, %cx
movw $0x0002, %dx
addw %cx, %dx
movb $0x4b, %al
movw $0x00e9, %dx
outb %al, %dx
1: hlt
jmp 1b入口处 _start 下面那行 ljmp 一次把段和偏移一起换掉,是条远跳。段寄存器咱们这一篇只认到这儿:cs 就是那个指着代码所在段起点的寄存器,它换的时候,取指的地方跟着换。段:偏移那一套怎么在别处用起来,下一篇接着看。块里末尾那句 outb %al, %dx 送去的是端口 0x00e9。那是模拟器自己开的一个调试口,写进去的字节落进它的终端,或者 -debugcon file:… 指的那个文件。
第一条指令是远跳,而且它跨得很远
咱们把镜头挪回上电那一刻。模拟器带上 -d in_asm,cpu 跑起来,复位后取到的第一条指令逐字是这样:
IN:
0xfffffff0: ea 5b e0 00 f0 ljmpw $0xf000:$0xe05b这行是模拟器自己写的,它记下那次远跳的方式就是“段:偏移”:段 0xf000、偏移 0xe05b。咱们再看它下面的寄存器块,CS 那一行逐字是 CS =f000 ffff0000 0000ffff 00009b00,也就是选择子 f000、隐藏基址 ffff0000。
跳过去之后咱们再看下一块,CS 那一行变了:
EIP=0000e05b EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
CS =f000 000f0000 0000ffff 00009b00选择子还是 f000,基址却从 ffff0000 变成了 000f0000。手册 §9.1.4 第二段把这件事写死了。硬件复位之后,CS 头一次装进新值的那一刻,处理器就回到实模式那套寻常算法上,手册给出的原话是“CS base address = CS segment selector * 16”。同一条 ×16 的老算术,咱们看着它复位那一刻不成立、跳一下之后就成立。代码就落在低端的 F000:E05B,不重装 CS 到不了那里,远跳干的正是这件事,而能改动 CS 的只有段间转移这类指令,以及中断。手册那一段还留了另一条路:固件要是打算一直待在复位基址上,它的代码里就不能出现远跳、远调用,也不能让中断发生。模拟器带的固件选了前者,于是咱们在上电之后很快就遇到了一次远跳。
在跳过去的那些块里,咱们还能捞到一条:QEMU 一次翻译的不止一条指令,它是成块翻的。不带调试器的同一趟运行,日志长这样:
0x00007c05: b8 00 00 movw $0, %ax
0x00007c08: 8e d8 movw %ax, %ds
0x00007c0a: 8e d0 movw %ax, %ss
----------------
IN:
0x00007c0c: bc 00 7c movw $0x7c00, %sp
----------------
IN:
0x00007c0f: bb 00 7c movw $0x7c00, %bx
0x00007c12: b9 01 00 movw $1, %cx
0x00007c15: ba 02 00 movw $2, %dx
0x00007c18: 01 ca addw %cx, %dx
0x00007c1a: b0 4b movb $0x4b, %al
0x00007c1c: ba e9 00 movw $0xe9, %dx
0x00007c1f: ee outb %al, %dx头一块并了三条,后面一块并了七条,两边还正好在 mov %ax,%ss 之后断开。这里断开的理由在手册 §6.8.3:写 SS 的指令连同它后面一条,中间要把中断(包括 NMI)、数据断点和单步陷阱一并推迟到下一条指令的边界之后,实现只好在这里断块,才守得住。两件事咱们分开看:推迟中断是架构定下的,在哪儿断块是模拟器自己的做法。同一枚镜像、同一次运行,挂了调试器就变成一条一块,所以引这一屏的时候得说清这是没挂调试器的那一趟。也请别把模拟器的块说成 CPU 的流水线,它是 QEMU 翻译指令的单位,再往下编就不在这几篇的范围里了。
指令集和实现,是两层
书上把这两层分开说(CS:APP 2e,书页 10):描述每条机器码指令效果的那一层叫指令集架构(ISA),描述处理器实际怎么实现的那一层叫微架构。书页 160 还给了个说法:大多数 ISA 描述程序行为的方式,是“as if each instruction is executed in sequence […]”,像是一条做完才轮到下一条。咱们把“像”这个字眼看住,它就是上一段那几块日志的注脚。
咱们拿同一份源码编给两个目标,最能看清变的是什么。源码就三个函数,咱们把它存成 isa.c:
long Add(long a, long b) { return a + b; }
long Sum3(long a, long b, long c) { return a + b + c; }
int Widen(short s) { return s * 2; }咱们手上还是同一个 isa.c,换一个目标就换一副指令。下面两半都只截了其中几段:
$ gcc -m32 -O2 -S -o isa32.s isa.c
Add:
movl 8(%esp), %eax
addl 4(%esp), %eax
ret
...
$ gcc -m64 -O2 -S -o isa64.s isa.c
Add:
leaq (%rdi,%rsi), %rax
ret
Widen:
movswl %di, %eax
...咱们看源码,一个字都没改。变的头一件是寄存器名(%esp 换成了 %rdi、%rsi),第二件是参数从哪儿取(栈上取变成了寄存器里取),Widen 里的 movswl,两个目标编出来都有,变的只是源操作数从栈上换成了 %di。gcc 那个 -m32 与 -m64 的差别到底涉及哪几层,这一篇只用到目标决定指令这一层,两套调用约定的细活留给往后。
readelf -h 里那一行 Machine,记录的就是咱们这枚产物编给哪一代机器。目标文件是编出来的:
gcc -m32 -O2 -S -o isa32.s isa.c ; gcc -m64 -O2 -S -o isa64.s isa.c
gcc -m32 -O2 -c -o isa32.o isa.c ; gcc -m64 -O2 -c -o isa64.o isa.c
readelf -h isa32.o | grep Machine ; readelf -h isa64.o | grep Machine-c 出的是可重定位的目标文件,咱们编完再问它们的 Machine 字段:
Machine: Intel 80386
Machine: Advanced Micro Devices X86-64更能说明同一个指令集、机器身份却可以不同的,是咱们把同一份 512 字节镜像交给四种型号的模拟 CPU 去跑。镜像里只做一件事:念 CPUID,把结果吐出来。
-cpu qemu64 -> AuthenticAMD 00060fb1 QEMU Virtual CPU version 2.5+
-cpu max -> AuthenticAMD 00000663 QEMU TCG CPU version 2.5+
-cpu 486 -> GenuineIntel 00000480
-cpu pentium3 -> GenuineIntel 00000673镜像一个字节没改,四台“机器”都跑得动,各自报出自己是谁,厂商串、型号号和品牌串都是 CPUID 指出来的一串字节。四张脸各不相同,486 和 pentium3 报出来的只有厂商串和型号号,品牌串一栏空着,那是它们的 CPUID 扩展叶还没到那么远,能问的问题本身也随机器代际变。这几串具体的值都是模拟器这一趟的偶然结果,随 QEMU 版本就变,咱们别把它们当成 x86 的什么常数。
双视角锚点:同一片内存的两种读法
**内存是一大串字节。**应用程序员看过去,内存里是有类型的:数组、结构体,他关心 sizeof 是多少、字段有没有对齐,写下一个 for 循环,心里知道机器会照着他的意思跑完。这是书里的散文口径,到了内核作者这边,复位向量 0xFFFFFFF0 那里就是一串字节,咱们前面读出来的 ea 5b e0 00 f0 里没有任何类型,它是条指令还是个地址,得看谁在读。往内存里写之前,他得自己担着“我按几格写进去、就按几格读回来”这件事。
**剩下的事,机器只做一件。**应用程序员写完 while,心安理得地相信 CPU 在执行他的语句,书页 9 也是这个口径:PC 指着下一条,从上电到下电反复执行。内核作者看到的是另一幕:他在模拟器里盯着 eip 停在 0xfff0,第一条指令是一条 ljmpw $0xf000:$0xe05b,除了“下一条在哪儿、那儿的字节是什么”,机器不欠他任何解释。咱们内核作者这边还得心里有数:“看起来一条一条”是架构给的承诺,实现有自己的切法。
哪些是手册定的,哪些只是 QEMU 的做法
这一篇里的机器行为,咱们都是在模拟器上看的。其中复位基址 FFFF0000、第一条指令落在 FFFFFFF0,这是 Intel 手册写明的内容,模拟器照着它们兑现,所以您在一台真正的机器上也应当见到同样的数。固件映像另在低端映一份、SeaBIOS 按 0000:7C00 交棒,这两件事就属于 QEMU 配 SeaBIOS 自己的做法了,别的固件未必这么干,咱们手上也没有一台真正的机器去对照。
保护模式和长模式这一篇一步都没进,cr0 里的 PE 位只是读到、没有写过。真正的机器上,物理内存的映射长什么样,这一篇也没法给您看,咱们手上的模拟器给不了那一层底细。真处理器之间的微架构差异(计时、流水线、缓存),这篇同样做不了,CPUID 那一屏证的是机器自报的身份不同,它证不了谁快谁慢。CS:IP 折出来的线性地址怎么落到物理内存上,咱们下一篇接着看。