第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 的参数,而要能解释:

  1. 为什么 Boot Sector 只能承担 Stage 1?
  2. Stage 1 和 Stage 2 有什么区别?
  3. 为什么程序必须从磁盘加载到 RAM 才能执行?
  4. ES:BX 为什么能够表示目标物理地址?
  5. BIOS 为什么通过 DL 告诉我们启动磁盘?
  6. CHS 是什么?
  7. 为什么 sector number 从 1 开始?
  8. CF 为什么可以表示 BIOS 调用失败?
  9. jmp 0:0x8000 到底改变了 CPU 什么?
  10. 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 最核心的“加载”含义。

&nbsp;

下一课:从 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?

评论

暂无评论