裸机与启动代码：内核入口与保护模式切换

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

启动流程概述

搬家的第一步，不是打包行李，而是先搞清楚“现在住在哪、要去哪”。计算机的启动也是如此——CPU 上电的那一刻，它并不知道自己身处何方，一切都要从一段固定的地址开始。这就好比清晨你从床上爬起来，闭着眼睛也能摸到卫生间——因为你的身体记住了那条固定的路径。BIOS（基本输入输出系统）就是那个“身体记忆”，它被固化在主板上的只读存储器里，上电后 CPU 会固定从 0xFFFF0 这个地址取第一条指令，这就是所有故事的起点。

BIOS 完成自检后，会去硬盘的第一个扇区（引导扇区）寻找引导代码。这段代码只有 512 字节，小得可怜，但它肩负着一个重大使命：把更大、更复杂的引导程序甚至内核加载到内存中。此时 CPU 运行在实模式下，也就是我们的“小平房”——所有的段寄存器、地址计算规则都是最简单的那一套。引导代码会先做一些基础检查，然后把后续的启动代码搬进内存，最后跳转过去。

这个阶段的本质是“准备搬家”。实模式下的代码通常比较简单，它们不会用到高级的保护机制，因为这时候大楼的图纸（GDT）还没画好，电梯（保护模式）还没通电。整个启动流程就像一个精心设计的多级火箭：BIOS 是第一级，引导扇区是第二级，后续的引导代码是第三级，每一级都把控制权交给更强大的下一级，直到内核接管一切。

搬家前你要做的第一件事，是确认新家的楼层图已经设计好、搬家公司的车已经到场。同理，当引导代码完成这些准备工作时，真正的“换房时刻”就要来临了。

实模式寻址

在实模式下，CPU 通过“段：偏移”的方式访问内存。这里的“段”就像是小平房里的“房间号”，而“偏移”则是房间内的具体位置。因为地址总线只有 20 根，所以最多只能访问 2 的 20 次方，也就是 1MB 的空间——这就是小平房只有 1MB 面积的原因。

计算物理地址的方法很简单：把段寄存器的值乘以 16（也就是左移 4 位），再加上偏移量。打个比方：你要找一本书，先知道它在“3 号书架”，书架从走廊的 0x30000 厘米处开始，书在这个书架上往右 0x1234 厘米处——那么书的实际位置就是 0x30000 + 0x1234 = 0x31234。这里的“3 号书架”就是段值 0x3000，左移 4 位变成 0x30000，再加上偏移 0x1234。

这种“段×16+偏移”的寻址方式有一个明显的问题：段和偏移是重叠的。比如 0x1000:0x1234 和 0x1123:0x0004 实际上指向上同一个物理地址 0x11234。这就像同一间房有多个门牌号，容易造成混淆。另一个限制是，一个段最大只能有 64KB——因为偏移量是 16 位的，最多表示 65536 个字节。

在实模式下过日子，你只能在这个 1MB 的小平房里转悠，虽然拥挤，但规则简单。然而，内核要管理大量的内存、进程、权限，这间小平房显然不够用。是时候考虑搬到那栋 4GB 的摩天大楼里去了。

控制寄存器

搬家最关键的一步，是打开新大楼的总电源。在 x86 体系里，这个“总闸”就是控制寄存器 CR0 的第 0 位——PE（Protection Enable，保护模式允许）位。CR0 是一个 32 位的控制寄存器，里面的每一位都像配电箱里的一个开关，控制着 CPU 的某种运行状态。

要把 CR0 的 PE 位置 1，通常先用 mov eax, cr0 把 CR0 的值读出来，然后用 or eax, 1 把第 0 位置 1，最后用 mov cr0, eax 写回去。这一读一改一写，就像你去配电房：先看清总闸现在的状态，把电闸推上去，再合上开关。然而，仅仅把 PE 位置 1 是不够的——CPU 虽然进入了保护模式，但它内部的段寄存器（CS、DS 等）还保留着实模式下的残留值，这些值在保护模式下是无效的，甚至可能是非法的。

这就是为什么在设置 CR0 之后，必须立刻执行一条长跳转指令（far jump）。长跳转会强制 CPU 用新的段选择子重新加载 CS 寄存器，相当于搬家时迈入新楼的第一步——只有这一步踩实了，你才算真正进了新家。这一步之后，CPU 就彻底告别实模式，进入保护模式的运行方式了。

当 PE 位翻转为 1 的瞬间，CPU 就像接通了新大楼的电源，电梯可以运行了，楼层标识牌也换成了全新的格式。但此刻你还在旧楼的走廊里，得迈出那一步——长跳转——才能真正走进新楼。

全局描述符

在实模式的小平房里，“房间号”就是段寄存器，直接用它乘以 16 就能算出地址。进了保护模式的摩天大楼，规矩变了：段寄存器不再直接存储基地址，而是变成了一个“索引号”，指向一张全局的楼层分布图——全局描述符表（GDT，Global Descriptor Table）。

GDT 是一张存放在内存中的表，表的每一项（称为段描述符）占 8 字节，详细描述了一个段的各种属性。这就像大楼物业贴出的一张楼层说明表：每一行写明了某层楼的起始位置（基地址）、这层楼有多大（段界限）、有没有权限进入（访问权限）、是办公区还是居住区（段类型，代码段/数据段）。

要把这张表告诉 CPU，需要用 LGDT 指令把表的地址和大小加载到 GDTR 寄存器中。GDTR 就像你递给物业经理的那张图纸——上面画了表在哪里、表有多长。在切换保护模式之前，引导代码必须确保 GDT 已经在内存中就位，并且 GDTR 已经正确加载。否则，长跳转的时候 CPU 拿着一个失效的索引去查一张不存在的表，系统会直接崩溃——这就是所谓的“三重故障”。

GDT 这张楼层分布图必须在搬家前就画好并张贴在大厅里（内存中），这样电梯（CPU）在运行的时候才能随时查阅每层楼的规则。没有它，CPU 寸步难行。

内核入口

万事俱备，只欠东风。当 GDT 加载完毕、CR0.PE 置位之后，执行长跳转的那一刻，就是踏入保护模式新世界的瞬间。长跳转 jmp 0x08:entry 中的 0x08 是一个段选择子，它告诉 CPU：“在 GDT 表里查索引 1，那是我要进入的新段落（代码段）。”

跳转的同时，CPU 会把这个选择子加载进 CS 寄存器，并自动从 GDT 中读出对应的段描述符，得到代码段的基地址和权限属性。这就像你走进摩天大楼，在前台报出你的门牌号，前台在楼层分布图上找到你对应的楼层，然后电梯直接把你送到那一层——整个过程一气呵成，不需要你手动参与。

进入保护模式后，第一件事是同步更新数据段寄存器。CS 已经通过长跳转刷新了，但 DS、ES、SS 这些寄存器里还残留着实模式下的旧值，它们在保护模式下是无效甚至危险的。所以内核入口代码会立即用新的数据段选择子（通常是 0x10，指向 GDT 中的索引 2）加载 DS、ES、FS、GS，以及栈段 SS。这就像搬进新家后，你不仅要拿到大门钥匙（CS），还得把各个房间的门锁（DS/ES/SS）全部换成新钥匙。

这些准备工作完成后，内核的入口函数（如 Linux 中的 start_kernel）才被正式调用。从这一刻起，操作系统开始了它的漫漫征程：初始化内存管理、创建第一个进程、启动调度器……启动代码的使命到此圆满完成，它把接力棒交到了内核手中。

长跳转是整场搬家最有仪式感的一步：你从旧楼的走廊迈进了新楼的大堂，身后的小平房从此成为历史。此后的一切，都将在新的规则下运行。

常见问题排查

即使图纸画得再仔细，搬家过程中也难免出岔子。在裸机启动的实操中，有几个经典“翻车点”几乎是每个开发者都会遇到的。

A20 地址线问题是最早也最著名的坑。在实模式下，物理地址可能超过 1MB，比如 0xFFFF:0xFFFF 计算出 0x10FFEF，超过了 20 根地址线能表达的 0xFFFFF（1MB）。早期 PC 为了兼容性，默认把 20 位以上的地址线强制置 0，导致地址“回绕”到 0 附近——这就像你把一个 21 层的楼顶标号错误地当成了 1 层来用。进入保护模式之前，必须通过键盘控制器或 BIOS 中断打开 A20 地址线，否则访问 1MB 以上内存时数据会错乱。

GDT 加载错误是另一个高频故障。如果 GDT 的基地址算错、界限写错，或者段描述符的访问权限位设置不当，CPU 加载 CS 时会抛出异常。最严重的情况下会触发三重故障（Triple Fault），导致 CPU 复位重启——系统像一只受了惊的猫，直接缩回起点。

CS 刷新失效也比较常见。有些开发者设置了 CR0.PE 后，只用普通的 near jump（近跳转）来“刷新”，却发现系统依然表现异常。原因在于近跳转不会改变 CS，只有远跳转才能把新的段选择子加载进 CS。

排查启动问题就像搬家公司做质检：先检查货车轮胎（A20），再核对楼层图纸（GDT），最终确认迈出的每一步都踩在了正确的位置上（远跳转）。把这三个关键点逐个验证，大部分“玄学”启动故障都能水落石出。

AI 应用场景

Python 演示

#!/usr/bin/env python3"""Simulate the core steps of mode transition from real mode to protected mode."""  class GDTR:    """A small representation of the GDTR register and GDT table."""     def __init__(self):        self.base = 0x0000        self.limit = 0        self.table = []  # each entry is (base, limit, rpl)     def load_gdt(self, table):        """Load the GDT table and update GDTR."""        self.table = table        self.base = 0x10000  # pretend the table is placed at 0x10000        self.limit = len(table) * 8 - 1        print(f"[GDTR] base={self.base:#x}, limit={self.limit:#x}")     def query(self, selector):        """Look up a segment descriptor by selector index."""        index = (selector >> 3) & 0x1FFF        if index >= len(self.table):            raise IndexError(f"GDT index {index} out of range")        return self.table[index]  class CPU:    """Minimal CPU simulator with CR0 and segment registers."""     def __init__(self):        self.cr0 = 0x00000000        self.cs = 0x0000        self.ds = 0x0000        self.ss = 0x0000        self.esp = 0x7C00        self.gdtr = GDTR()     def set_pe_bit(self):        """Set CR0.PE to 1 to enter protected mode."""        old = self.cr0        self.cr0 |= 0x00000001        print(f"[CR0] {old:#010x} -> {self.cr0:#010x} (PE=1)")     def far_jump(self, selector, entry):        """Simulate far jump that refreshes CS with a new selector."""        desc = self.gdtr.query(selector)        self.cs = selector        print(f"[CS  ] selector={selector:#06x}, entry=0x{entry:08x}")        print(f"[GDT ] {desc}")     def load_data_segments(self, selector):        """Load data segments with a new selector."""        desc = self.gdtr.query(selector)        self.ds = selector        self.ss = selector        self.esp = 0xFFE0        print(f"[DS/SS] selector={selector:#06x}, esp={self.esp:#06x}")        print(f"[GDT ] {desc}")     def call_kernel(self, name="start_kernel"):        """Enter the kernel entry function."""        print(f"[KERNEL] {name}() is now running")        print("[DONE] Protected mode active, kernel took over!")  def boot_sequence():    """Run the complete boot sequence from real mode to kernel entry."""    gdt = [        (0x00000000, 0x00000, 0x00),  # null descriptor        (0x00000000, 0xFFFFF, 0x9A),  # code segment: base=0, limit=1M, code R        (0x00000000, 0xFFFFF, 0x92),  # data segment: base=0, limit=1M, data RW    ]    print("=== Boot sequence: real mode -> protected mode ===")    cpu = CPU()    cpu.gdtr.load_gdt(gdt)     # step 1: enable A20 (simplified)    print("[A20 ] A20 line enabled")    # step 2: set CR0.PE    cpu.set_pe_bit()    # step 3: far jump to protected mode entry    cpu.far_jump(0x08, 0x00100000)    # step 4: reload data segments    cpu.load_data_segments(0x10)    # step 5: call kernel entry    cpu.call_kernel()  if __name__ == "__main__":    boot_sequence()

1. gdt = [(0x00000000, 0xFFFFF, 0x9A), ...]定义 GDT 表，每项描述符包含基址、段界限和访问权限，第 0 项必须是空描述符（这是硬件强制要求）
2. cpu.gdtr.load_gdt(gdt)加载 GDT 到“内存”，并更新 GDTR 的基址和界限值，模拟 LGDT 指令的效果
3. self.cr0 |= 0x00000001将 CR0 的第 0 位（PE 位）置 1，模拟 mov cr0, eax 指令序列的效果
4. cpu.far_jump(0x08, 0x00100000)用选择子 0x08（索引 1，指向代码段）模拟长跳转，强制刷新 CS 寄存器
5. cpu.load_data_segments(0x10)用选择子 0x10（索引 2，指向数据段）刷新 DS 和 SS，建立保护模式下的数据与栈环境

常见误区

面试题