第3课:Boot Sector 为什么装不下内核?自己写第二阶段 Loader
文章目录
好,我们接着刚才的 CPU 状态模型往下走。
上一节已经把这几件事真正落到 CPU 上了:
BIOS 把启动扇区装到 0x7C00
↓
我们初始化 DS / ES / SS
↓
建立 SP
↓
可以安全使用 stack
↓
可以开始调用函数
接下来就进入 Bootloader 真正关键的一步:
Lesson 03:Boot Sector 为什么装不下内核?自己写第二阶段 Loader
现在我们的 boot.bin 有一个非常现实的问题:
整个 Boot Sector
=
512 bytes
其中最后两个字节还必须留给:
55 AA
实际上能自由使用的空间只有:
510 bytes
这个限制来自传统 BIOS 启动扇区本身:第一个扇区为 512 字节,最后两个字节是启动签名。
显然,一个真正的内核不可能只有几百字节。
所以真正的启动过程必须变成:
BIOS
↓
boot sector 512 bytes
↓
加载 loader
↓
loader 加载 kernel
↓
kernel
这也正是我们最开始规划里的第二阶段:
BIOS
↓
boot sector
↓
load second-stage loader
↓
read kernel from disk
↓
enable A20
↓
build GDT
↓
enter Protected Mode
↓
jump kernel
一、为什么需要 Stage 2?
目前:
Disk
sector 0
┌──────────────────────┐
│ boot sector │
│ │
│ <= 510 bytes code │
│ 55 AA │
└──────────────────────┘
我们未来还要做:
读取磁盘
A20
GDT
保护模式
内存探测
加载 kernel
错误处理
510 字节很快就不够。
所以最合理的设计是:
sector 0
┌──────────────────┐
│ stage1 │
│ 极小 │
│ 只负责加载 stage2│
└──────────────────┘
sector 1 ~ N
┌──────────────────┐
│ stage2 loader │
│ │
│ 真正的 loader │
└──────────────────┘
Stage 1 的任务以后应该极度简单:
把 Stage 2 从磁盘搬进内存,然后跳过去。
二、这时候必须理解“磁盘”和“内存”是两回事
这是学习 OS 时一个非常重要的节点。
目前你的代码最开始存在于:
disk
不是:
RAM
CPU 不能直接:
EIP = 磁盘某个扇区
CPU 执行的是:
memory
里的机器指令。
所以启动过程本质上一直在做:
Disk
↓
读取
↓
RAM
↓
CPU execute
Boot Sector 是 BIOS 帮我们完成的:
disk sector 0
↓
BIOS
↓
RAM 0x7C00
但是之后的 loader 和 kernel:
BIOS 不会自动帮我们全部加载。
从现在开始,要我们自己读磁盘。
三、BIOS INT 13h
上一节我们已经用过:
int 0x10
它提供显示服务。
BIOS 还提供:
INT 13h
也就是磁盘服务。你现有材料里也明确把 INT 13h 作为之后加载内核时要使用的 BIOS 服务。
第一版我们不急着碰 IDE 控制器,不自己直接操作 ATA 端口。
因为我们还在:
16-bit Real Mode
现在 BIOS 可以替我们完成底层磁盘读取。
于是:
我们的 bootloader
↓
INT 13h
↓
BIOS
↓
磁盘控制器
↓
sector
↓
RAM
这正好让我们先学“启动过程”,而不是立刻陷入硬盘驱动。
四、先设计内存布局
必须先回答:
Stage 2 加载到哪里?
我们的 Stage 1:
0x7C00
附近已经被占用。
所以先给 Stage 2 一个固定地址,例如:
0x8000
第一版内存布局:
低地址
0x00000
BIOS / IVT / low memory
...
0x07C00
+-----------------------+
| Stage 1 boot sector |
+-----------------------+
0x07E00
0x08000
+-----------------------+
| Stage 2 Loader |
| |
| |
+-----------------------+
...
高地址
所以:
Stage 1
load disk sector 1...
↓
RAM 0x8000
↓
jmp 0x8000
这一步非常关键,因为它第一次把几个概念分开:
磁盘位置
≠
内存地址
≠
代码逻辑地址
以后 ELF Loader 会把这个问题扩展得更深。
五、工程目录开始变化
我们可以改成:
handos/
├── Makefile
├── boot/
│ ├── boot.asm
│ └── loader.asm
└── build/
├── boot.bin
├── loader.bin
└── os.img
其中:
boot.asm
是:
Stage 1
而:
loader.asm
是:
Stage 2
最终磁盘镜像:
os.img
布局:
sector 0
boot.bin
sector 1...
loader.bin
后面
kernel.bin
六、先写最简单的 Stage 2
先不要加载 kernel。
我们的 Stage 2 只做一件事情:
如果成功被 Stage 1 加载,
打印:
Hello from loader
boot/loader.asm:
org 0x8000
bits 16
loader_start:
mov si, loader_msg
.print:
lodsb
test al, al
jz .halt
mov ah, 0x0e
int 0x10
jmp .print
.halt:
cli
hlt
jmp .halt
loader_msg:
db "Hello from loader", 0
注意:
org 0x8000
不是让 CPU 自动跳到 0x8000。
它的含义仍然和上一阶段一样:
告诉 NASM,这份代码未来会被放在
0x8000。
这一点与 org 0x7C00 的原理完全相同:org 影响地址计算,而不是执行加载动作。
真正把它加载到:
0x8000
的是 Stage 1。
七、Stage 1 开始读磁盘
先看核心代码,再拆。
boot.asm 可以逐渐改成:
org 0x7c00
bits 16
LOADER_ADDR equ 0x8000
start:
cli
xor ax, ax
mov ds, ax
mov es, ax
mov ss, ax
mov sp, 0x7c00
sti
; 保存 BIOS 传进来的启动盘编号
mov [boot_drive], dl
; ES:BX = 加载目标地址
xor ax, ax
mov es, ax
mov bx, LOADER_ADDR
; BIOS INT 13h, AH=02h
mov ah, 0x02
; 读取 1 个扇区
mov al, 1
; cylinder = 0
mov ch, 0
; sector = 2
mov cl, 2
; head = 0
mov dh, 0
; drive
mov dl, [boot_drive]
int 0x13
jc disk_error
jmp 0x0000:LOADER_ADDR
disk_error:
mov si, disk_error_msg
.print:
lodsb
test al, al
jz .halt
mov ah, 0x0e
int 0x10
jmp .print
.halt:
cli
hlt
jmp .halt
boot_drive:
db 0
disk_error_msg:
db "Disk read error", 0
times 510 - ($ - $$) db 0
dw 0xaa55
现在开始逐行理解。
八、为什么要保存 DL?
这句非常重要:
mov [boot_drive], dl
BIOS 启动我们的 Boot Sector 时,会通过:
DL
告诉我们:
“你是从哪个驱动器启动的。”
例如传统约定里:
软盘
硬盘
会有不同的 drive number。
关键点不是具体数字,而是:
不要自己凭空猜启动磁盘。
BIOS 已经把信息放在 DL 里了。
但后面我们会大量修改:
DX
所以要先保存:
boot_drive:
db 0
然后:
mov [boot_drive], dl
此时:
BIOS
↓
DL
↓
boot_drive
这其实已经出现了一个 OS 开发中非常重要的思想:
firmware 给 bootloader 传参数。
以后会变成:
Bootloader
↓
kernel parameters
↓
Kernel
九、为什么目标地址是 ES:BX?
BIOS 的磁盘读取接口需要告诉它:
把读出来的数据写到哪里?
传统 INT 13h 读取接口使用:
ES:BX
作为目标缓冲区。
因此:
xor ax, ax
mov es, ax
mov bx, 0x8000
意味着:
ES:BX
=
0000:8000
物理地址:
0 × 16 + 0x8000
=
0x8000
于是:
Disk sector
↓
INT 13h
↓
RAM 0x8000
又一次使用了上一节学过的:
segment:offset
所以你会发现:
学 Bootloader 最好的地方,就是实模式知识不是抽象概念,而是真的每天都在用。
十、AH = 02h 是什么意思?
核心:
mov ah, 0x02
int 0x13
意思大致是:
BIOS disk service
function = read sectors
但 BIOS 还需要很多参数。
可以把寄存器粗略想成一个“调用参数结构”:
AH = 功能号
AL = 读取多少 sector
CH = cylinder
CL = sector
DH = head
DL = drive
ES:BX = destination buffer
于是我们的:
mov ah, 0x02
mov al, 1
mov ch, 0
mov cl, 2
mov dh, 0
mov dl, [boot_drive]
int 0x13
就是:
从启动磁盘
读取
Cylinder 0
Head 0
Sector 2
读取 1 sector
写到
0000:8000
十一、为什么是 Sector 2?
这里非常容易出现经典 bug。
人类通常从:
0
开始数。
但是传统 CHS 接口里的 sector number:
从 1 开始
所以:
Sector 1
才是磁盘第一个扇区,也就是:
boot sector
因此 Stage 2 放在紧跟其后的扇区:
Sector 2
所以:
mov cl, 2
不是:
mov cl, 1
这就是典型的:
磁盘 LBA 思维
和:
CHS BIOS 接口
之间的差异。
十二、第一次认识 CHS
这里出现:
C = Cylinder
H = Head
S = Sector
传统磁盘可以抽象成:
Cylinder
↓
Head
↓
Sector
即:
CHS
早期 BIOS 磁盘访问就是通过这样的地址。
你现在先不用深入物理硬盘机械结构。
阶段目标只是理解:
CHS
是 BIOS 描述磁盘位置的一种方式。
以后我们会更倾向使用:
LBA
也就是:
Logical Block Address
这种方式更加自然:
block 0
block 1
block 2
block 3
...
但是第一版 Stage 1 用 CHS 很适合教学。
十三、Carry Flag 开始有实际意义了
执行:
int 0x13
之后:
jc disk_error
什么意思?
JC
=
Jump if Carry
这里 BIOS 使用:
CF
告诉我们调用是否成功。
成功:
CF = 0
失败:
CF = 1
于是:
int 0x13
jc disk_error
可以粗略理解成:
if (bios_disk_read(...) != 0) {
disk_error();
}
这已经非常接近高级语言函数返回值的概念。
只不过 BIOS API 不是:
int read(...);
而是:
寄存器传参数
INT
FLAGS / 寄存器返回结果
十四、读取成功之后最关键的一跳
jmp 0x0000:LOADER_ADDR
即:
jmp 0x0000:0x8000
现在 CPU 开始:
CS = 0
IP = 0x8000
物理地址:
0x0000 × 16 + 0x8000
=
0x8000
然后 CPU 在:
0x8000
取第一条指令。
整个过程终于变成:
BIOS
↓
0x7C00
↓
Stage 1
↓
INT 13h
↓
Disk Sector 2
↓
RAM 0x8000
↓
far jump
↓
Stage 2
这一步非常重要。
因为它已经是最原始版本的:
程序加载器。
十五、什么叫“加载程序”?
很多人在 Linux 下会觉得:
./hello
就是“程序执行了”。
但是现在我们开始看到真正的底层过程。
程序原本只是:
disk bytes
要运行,至少需要:
找到程序
↓
读取磁盘
↓
搬进内存
↓
找到入口地址
↓
设置 CPU 状态
↓
把控制权转移过去
Stage 1 对 Stage 2 所做的事,其实已经和以后:
exec()
加载 ELF 有一点哲学上的相似性。
以后 exec() 会:
找到 ELF
↓
读取文件
↓
建立地址空间
↓
加载 segment
↓
建立 stack
↓
设置 EIP = e_entry
↓
进入新程序
现在只是一个极简版。
十六、生成磁盘镜像
现在:
boot.bin
loader.bin
是两个独立文件。
但是 QEMU 需要一块“磁盘”。
所以我们制作:
os.img
布局:
offset 0
+--------------------------+
| boot.bin |
| 512 bytes |
+--------------------------+
offset 512
+--------------------------+
| loader.bin |
| <= 512 bytes 当前版本 |
+--------------------------+
最简单可以:
cat build/boot.bin build/loader.bin > build/os.img
然后:
qemu-system-i386 \
-drive format=raw,file=build/os.img
如果一切正确,你应该看到:
Hello from loader
这时候意义已经和上一课完全不同。
因为:
Hello HandOS
是 BIOS 直接加载的代码打印的。
而:
Hello from loader
是:
我们自己的 Boot Sector 从磁盘加载出来的程序打印的。
这就是第一次由我们自己的代码完成程序加载。
十七、Makefile 也可以升级
可以变成:
BUILD_DIR := build
BOOT_SRC := boot/boot.asm
LOADER_SRC := boot/loader.asm
BOOT_BIN := $(BUILD_DIR)/boot.bin
LOADER_BIN := $(BUILD_DIR)/loader.bin
IMAGE := $(BUILD_DIR)/os.img
.PHONY: all run debug clean
all: $(IMAGE)
$(BUILD_DIR):
mkdir -p $(BUILD_DIR)
$(BOOT_BIN): $(BOOT_SRC) | $(BUILD_DIR)
nasm -f bin $(BOOT_SRC) -o $(BOOT_BIN)
$(LOADER_BIN): $(LOADER_SRC) | $(BUILD_DIR)
nasm -f bin $(LOADER_SRC) -o $(LOADER_BIN)
$(IMAGE): $(BOOT_BIN) $(LOADER_BIN)
cat $(BOOT_BIN) $(LOADER_BIN) > $(IMAGE)
run: $(IMAGE)
qemu-system-i386 \
-drive format=raw,file=$(IMAGE)
debug: $(IMAGE)
qemu-system-i386 \
-drive format=raw,file=$(IMAGE) \
-S -s
clean:
rm -rf $(BUILD_DIR)
现在:
make
make run
就可以启动。
十八、但是这里有一个隐藏 Bug
这就是为什么我们一直强调:
不要只求“跑起来”。
如果:
loader.bin
只有:
100 bytes
那么:
cat boot.bin loader.bin > os.img
最终镜像只有:
512 + 100
=
612 bytes
但是 BIOS 的:
read 1 sector
想读取:
512 bytes
这时候严格来说,我们最好保证 loader.bin 本身占完整 sector。
所以可以在 loader.asm 最后加:
times 512 - ($ - $$) db 0
于是 Stage 2 第一版也是:
512 bytes
注意:
Stage 2 不需要
0xAA55。
为什么?
因为 BIOS 只检查:
启动扇区
也就是:
sector 0
Stage 2 是我们的 Stage 1 自己读取的。
CPU 根本不知道:
AA55
是“启动签名”。
这个结论和你之前做的删除 0xAA55 实验是完全一致的:检查启动签名的是 BIOS,而不是 CPU。
十九、现在用 GDB 做真正关键的实验
这次我们设置两个断点:
b *0x7c00
b *0x8000
c
第一次停:
0x7C00
说明:
BIOS → Stage 1
然后:
c
第二次停:
0x8000
说明:
Stage 1 → Stage 2
这是非常漂亮的一次实验。
你亲眼看到了:
CPU control flow
BIOS
↓
7C00
↓
8000
二十、停在 INT 13h 后检查内存
最值得做的是:
在读取 Stage 2 之前:
x/16xb 0x8000
记住内容。
单步执行:
int 0x13
之后再次:
x/16xb 0x8000
你会发现:
0x8000
附近的 RAM 已经改变了。
也就是说,你亲眼看见:
disk
↓
BIOS
↓
RAM
发生。
然后在宿主机:
xxd build/loader.bin
比较:
loader.bin 开头字节
和:
GDB 看到的 0x8000 字节
它们应该对应。
这一刻你会真正理解:
“加载程序”本质上首先就是一次数据复制。
二十一、到这里先建立一个非常重要的抽象
现在可以把 Bootloader 分成三个世界:
Disk
|
| read
v
Memory
|
| CS:IP
v
CPU
操作系统后面很多事情,本质上一直围绕这三个世界:
disk
memory
CPU
比如:
程序启动:
disk ELF → memory → EIP
缺页:
disk/swap → page → memory → retry instruction
文件读取:
disk block → buffer cache → process buffer
上下文切换:
memory 中保存 context → CPU registers
所以现在这个小小的 Stage 2 Loader,其实已经触碰到了 OS 的核心思想。
二十二、这一课完成以后,你应该能回答这些问题
这一课不要只记 INT 13h 的参数,而要能解释:
- 为什么 Boot Sector 只能承担 Stage 1?
- Stage 1 和 Stage 2 有什么区别?
- 为什么程序必须从磁盘加载到 RAM 才能执行?
ES:BX为什么能够表示目标物理地址?- BIOS 为什么通过
DL告诉我们启动磁盘? - CHS 是什么?
- 为什么 sector number 从 1 开始?
CF为什么可以表示 BIOS 调用失败?jmp 0:0x8000到底改变了 CPU 什么?org 0x8000和jmp 0x8000到底有什么区别?
如果这 10 个问题能自己讲清楚,我们就可以进入真正的重要节点了。
二十三、 是哪个时候或者哪句代码,把磁盘上的程序加载到内存中的某个位置的?
就是 **int 0x13**** 这一句真正触发了“从磁盘读数据到内存”**。
你前面的这段代码里:
; ES:BX = 加载目标地址
xor ax, ax
mov es, ax
mov bx, LOADER_ADDR
; BIOS INT 13h, AH=02h
mov ah, 0x02
; 读取 1 个扇区
mov al, 1
; CHS 地址
mov ch, 0
mov cl, 2
mov dh, 0
; 启动盘
mov dl, [boot_drive]
int 0x13
真正执行磁盘读取的是最后这句:
int 0x13
前面的代码只是在给 BIOS 准备参数。
其中:
AH = 0x02
表示“读磁盘扇区”,而:
AL = 1
表示读取 1 个 sector。
CH / CL / DH / DL
告诉 BIOS“从磁盘什么位置读”。
最关键的是:
mov es, ax
mov bx, 0x8000
这里指定了读出来以后放到内存哪里。
因为 BIOS 的这个磁盘读取接口规定:
ES:BX = 目标内存地址
我们这里:
ES = 0x0000
BX = 0x8000
所以目标物理地址就是:
physical
=
ES × 16 + BX
=
0x0000 × 16 + 0x8000
=
0x8000
因此整个过程实际上是:
磁盘 sector 2
│
│ int 0x13
▼
BIOS
│
│ 把读取出来的 512 bytes 写入
▼
物理内存 0x8000
也就是说,这几句的分工要分清:
mov bx, 0x8000
不是“加载”。
它只是告诉 BIOS:
待会把数据放到 0x8000。
mov cl, 2
也不是“加载”。
它只是告诉 BIOS:
我要读 sector 2。
而真正让 BIOS 开始去访问磁盘、读取数据并写入 RAM 的,是:
int 0x13
可以把它粗略想成:
bios_read_sector(
disk = boot_drive,
sector = 2,
count = 1,
destination = 0x8000
);
然后下一句:
jmp 0x0000:0x8000
也不是加载。
这一句只是:
数据已经在 0x8000 了,现在让 CPU 去执行它。
所以完整顺序一定要分成两个动作:
第一步:加载
int 0x13
磁盘
↓
内存 0x8000
第二步:执行
jmp 0:0x8000
CPU
↓
开始从 0x8000 取指令
这个区别非常重要。
再往前一步,其实你的整个启动过程里一共发生了两次“磁盘 → 内存”。
第一次不是我们写的,是 BIOS 帮我们做的:
磁盘 sector 1
↓
BIOS
↓
内存 0x7C00
也就是 Boot Sector 被加载到 0x7C00。这个过程发生在我们的第一条指令执行之前。
第二次才是我们自己主动做的:
磁盘 sector 2
↓
int 0x13
↓
内存 0x8000
所以可以记成:
BIOS 加载 Stage 1:
不是我们代码做的
Stage 1 加载 Stage 2:
int 0x13 做的
这就是 Bootloader 最核心的“加载”含义。
下一课:从 16 位世界进入 32 位世界
接下来将第一次发生巨大的 CPU 状态变化:
16-bit Real Mode
↓
A20
↓
GDT
↓
GDTR
↓
CR0.PE = 1
↓
far jump
↓
32-bit Protected Mode
这正是整个项目早期的第一个核心节点:自己建立 GDT,修改 CR0,从实模式进入 32 位保护模式。
下一步我们就从一个最基础的问题开始:
为什么 32 位 CPU 上电以后,居然还只能像 8086 一样工作?以及为什么进入保护模式之前还要先处理 A20?

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论