Polaris内核启动初始化全解析:GDT、IDT与早期引导代码逐行解读

原创2026-11-15 22:50:471,997 阅读

Polaris内核启动初始化全解析:GDT、IDT与早期引导代码逐行解读

Polaris 是一个用 Rust 编写的 64 位类 UNIX 操作系统内核。本文深入剖析其内核启动初始化全流程,从 Limine 引导加载器传递的硬件信息开始,逐步解读 GDT 段表设置、IDT 中断描述符表、内存管理初始化以及 SMP 多核引导的完整链路,帮助读者理解一个现代操作系统内核从零到一的关键步骤。

🚀 项目概览与启动架构

Polaris 采用 Limine 引导加载器完成从 BIOS/UEFI 到内核的跳转。在 limine.conf 中定义了启动参数:

  • 内核镜像路径:/boot/polaris
  • 用户模块路径:/boot/user.elf
  • 禁用 KASLR(内核地址空间布局随机化)

整个构建由 Makefile 驱动,核心命令为:

cargo +nightly build -Zbuild-std=core,alloc -Zbuild-std-features=compiler-builtins-mem --target=toolchain/x86_64-kernel.json

最终打包为 polaris.iso 启动镜像,同时支持 BIOS 和 UEFI。

内核源码按功能模块组织在 src/ 目录下:

模块 职责
src/arch/x86_64/ 架构相关代码(GDT、IDT、SMP、APIC 等)
src/mm/ 内存管理(物理分配、虚拟地址空间、slab 分配器)
src/sched/ 进程调度与线程管理
src/syscall/ 系统调用分发
src/ipc/ 进程间通信
src/locks/ 自旋锁与互斥锁

📡 早期引导:Limine 请求与帧缓冲初始化

一切始于 src/main.rs 中的 _start 函数:

#[unsafe(no_mangle)]
unsafe extern "C" fn _start() {
    arch::entry::arch_entry();
}

arch_entry() 定义在 src/arch/x86_64/entry.rs,它是整个内核初始化的"总调度器"。在此之前,Limine 通过链接段 .requests 接收内核的硬件请求声明:

pub static REQUESTS_START: RequestsStartMarker = RequestsStartMarker::new();
pub static BASE_REVISION: BaseRevision = BaseRevision::new();
pub static STACK: StackSizeRequest = StackSizeRequest::new(65536);
static FRAMEBUFFER: FramebufferRequest = FramebufferRequest::new();
pub static MEMMAP: MemmapRequest = MemmapRequest::new();
pub static HHDM: HhdmRequest = HhdmRequest::new();
pub static EXEC_ADDR: ExecutableAddressRequest = ExecutableAddressRequest::new();
pub static RSDP: RsdpRequest = RsdpRequest::new();
pub static MP_REQUEST: MpRequest = MpRequest::new(1);
pub static MODULES_REQUEST: ModulesRequest = ModulesRequest::new();
pub static REQUESTS_END: RequestsEndMarker = RequestsEndMarker::new();

每个请求都通过 #[unsafe(link_section = ".requests")] 属性放置在固定链接段中,Limine 在加载内核时解析并填充响应。

帧缓冲:内核的第一次"说话"

arch_entry() 的第一步就是初始化帧缓冲:

if let Some(resp) = FRAMEBUFFER.response()
    && let Some(fb) = resp.framebuffers().first()
{
    fbcon::fbcon_init(fb.address(), fb.width, fb.height, fb.pitch, ...);
}

帧缓冲参数传入 src/fbcon.rs 中的 fbcon_init,内部使用 flanterm 终端渲染库(flanterm-rs/)在原始帧缓冲上绘制字符。之后 log! 宏即可在屏幕上输出文本——这正是你在内核启动时看到的第一行 Hello x86_64! 的来源。

日志输出通过 src/log.rs 实现,使用自旋锁保证多核安全,同时向帧缓冲和调试端口写入。

🧠 内存管理初始化:PMM 与 HHDM

紧接帧缓冲之后,arch_entry() 调用 src/arch/x86_64/mminit.rs 中的 init() 函数,完成内核最关键的内存基础设施搭建:

mminit::init(
    MEMMAP.response().expect("...").entries(),   // 物理内存布局
    HHDM.response().expect("...").offset,        // 高半区直接映射偏移
    EXEC_ADDR.response().expect("...").physical_base,  // 内核物理基址
    EXEC_ADDR.response().expect("...").virtual_base,   // 内核虚拟基址
);

初始化流程可分为四个阶段:

① 构建物理页帧数据库(PFNDB)

从 Memmap 中找到最大连续可用区域,将每页 64 位的 Page 结构(含 usage 和 reference_count)顺序写入,形成覆盖全部物理内存的页帧元数据数组。

② 位图分配器

紧跟 PFNDB 之后放置一个位图(bitmap),每 bit 对应一个页帧的占用状态。初始全部置 1(已用),再按 Memmap 将可用区域置 0(空闲)。

③ 建立高半区直接映射(HHDM)

x86_64 的 48 位地址空间中,0xFFFF_8000_0000_0000 以上为高半区。内核将每个 2MB 物理页通过 map_large 映射到对应虚拟地址,使内核在任意位置都可以通过 phys_addr + HHDM_OFFSET 直接访问物理内存。

④ 映射内核自身段

利用链接脚本导出的 __start_text、__stop_data 等符号,将 .text、.rodata、.data 段分别以不同保护标志(只读/可写/不可执行)映射到内核虚拟地址空间。

最终将 AddressSpace 通过 mov cr3 装入 CR3 寄存器,完成页表切换。

📌 核心常量定义在 src/arch/x86_64/mod.rs:PAGE_SIZE = 4096、PFN_DATABASE = 0xFFFF_FA80_0000_0000

📐 GDT 详解:段描述符与 TSS

GDT(Global Descriptor Table)是 x86 架构的段表,Polaris 在 src/arch/x86_64/gdt.rs 中实现。

段选择子规划

选择子常量 值 用途
SEL_KERNEL_CODE 0x08 内核代码段(DPL=0)
SEL_KERNEL_DATA 0x10 内核数据段(DPL=0)
SEL_USER_DATA 0x1B 用户数据段(DPL=3)
SEL_USER_CODE 0x23 用户代码段(DPL=3)
SEL_TSS 0x2B 任务状态段

注意用户选择子带了 RPL=3(低两位 | 3),确保用户态访问时特权级检查正确。

GDT 布局

偏移 0x00: 空描述符(null)
偏移 0x08: 内核代码段(access=0b10011010, granularity=0b00100000 → 4GB, 可执行)
偏移 0x10: 内核数据段(access=0b10010010, 不可执行)
偏移 0x18: 用户数据段(access=0b11110010, DPL=3)
偏移 0x20: 用户代码段(access=0b11111010, DPL=3, 可执行)
偏移 0x28: TSS 描述符

每个描述符 8 字节,GdtDesc 结构体精确匹配硬件格式。TSS 描述符使用 0b10001001 标志位标识为 64 位 TSS。

加载流程:CpuGdt::load()

每个 CPU 拥有独立的 CpuGdt 实例(含独立 TSS),加载时执行四步:

  1. 写入 TSS 基址:将 TSS 结构体地址拆分填入描述符的 base_low/mid/hi/upper32
  2. lgdt:将 GDT 指针装入 GDTR
  3. 远跳重载代码段:
    push 0x08        ; 选择子
    lea tmp, [rip+2f] ; 目标地址
    push tmp
    retfq             ; 远跳转,同时重载 CS
    2:
    
    这是 x86 上重载 CS 的唯一正确方式(直接 mov cs, 0x08 不会刷新缓存的描述符)。
  4. 重载数据段 + ltr:mov ds/es/fs/gs/ss, 0x10,然后 ltr 0x2B 加载 TSS

TSS 中预配置了三个 IST(Interrupt Stack Table)槽位,分别用于 IPI(中断号 32)、NMI(中断号 8)和双故障(中断号 2),确保嵌套中断时有干净的栈可用。

⚡ IDT 详解:中断描述符表构建

IDT(Interrupt Descriptor Table)在 src/arch/x86_64/idt.rs 中实现,共 256 项,每项 16 字节。

描述符格式

struct IdtEntry {
    base0: u16,        // 目标地址低 16 位
    selector: u16,     // 段选择子 → SEL_KERNEL_CODE
    ist: u8,           // IST 索引
    attributes: u8,    // 0x80 | DPL<<5 | 门类型
    base1: u16,        // 目标地址中间 16 位
    base2: u32,        // 目标地址高 32 位
    reserved: u32,
}

门类型为 0xE(64 位中断门),DPL=0(仅内核可触发)。

批量初始化

利用 seq_macro 在编译期展开 256 个 interrupt_stub~N 函数地址:

seq_macro::seq!(N in 0..256 {
    (*&raw mut IDT_TABLE).entries[N] =
        IdtEntry::init(interrupt_stub~N as *const () as usize as u64, 0, GateType::Interrupt, 0);
});

随后为三个特殊中断项分配 IST:

entries[32].ist = 1;  // 定时器中断 → IST[0]
entries[8].ist  = 2;  // NMI → IST[1]
entries[2].ist  = 3;  // 双故障 → IST[2]

加载 IDT

idt::load() 构造 IdtRegister { limit, base } 结构体后执行 lidt 指令。注意 Idt 结构体标注了 #[repr(align(0x1000))](4KB 对齐),避免跨页。

🔀 中断处理:从 Stub 到 Handler

中断处理的核心逻辑在 src/arch/x86_64/intr.rs 中,分为三层:

第一层:256 个入口 Stub

seq_macro::seq!(N in 0..256 {
    #[unsafe(naked)]
    pub unsafe extern "C" fn interrupt_stub~N() {
        naked_asm!(
            // 不推送错误码的中断(如 #DE=8, #NM=10~14 等)需手动补 0
            ".if (N == 8 || (N >= 10 && N <= 14) || N == 17 || ...)",
            ".else",
            "push 0",
            ".endif",
            "push N",
            "jmp interrupt_stub_internal",
        );
    }
});

硬件中断会自动压入 RIP/CS/RFLAGS(及 SS/RSP 如果特权级变化),部分异常会额外压入错误码。对于没有错误码的中断,stub 手动 push 0 保持栈帧一致。

第二层:interrupt_stub_internal

push rax ~ r15          ; 保存全部通用寄存器
cld
xor rbp, rbp
test byte ptr [rsp + cs_offset], 3  ; 检查返回 CS 的 RPL
jz 1f
swapgs                  ; 用户态进入 → 交换 GS(指向当前 CPU 的 Prcb)
1:
mov rdi, rsp
call idt_handler
jmp interrupt_return

swapgs 是用户态与内核态切换的关键:内核态 GS=0,用户态 GS 指向 MSR_GS_BASE 中保存的 Prcb(Per-CPU Run Control Block)指针。

第三层:idt_handler — Rust 世界的大门

pub unsafe extern "C" fn idt_handler(context: *mut Context) {
    let isr = context.isr as u8;
    match isr {
        0x0E => page_fault_handler(context),     // 缺页异常
        0x02 => { /* NMI 处理 */ }
        0x20 => {                                 // 定时器中断 → 调度
            let next = sched::schedule(*context);
            apic::Lapic::eoi();
            match next {
                Some(t) => { prcb.set_kernel_stack(...); load_context(&t.context()); }
                None    => load_context(context),
            }
        }
        0x00..0x1F => panic!("Unhandled exception"),
        _ => todo!()
    }
}

中断号 0x20 是 LAPIC 定时器中断,触发 sched::schedule() 进行线程切换——如果调度器返回新线程,则通过 load_context 将其栈帧恢复到寄存器并 iretq 返回,完成一次完整的上下文切换。

返回路径:interrupt_return

pop r15 ~ rax           ; 恢复通用寄存器
add rsp, 0x10           ; 跳过错误码 + ISR 号
test byte ptr [rsp+8], 3
jz 1f
swapgs                 ; 回到用户态
1:
iretq                  ; 弹出 RIP/CS/RFLAGS/SS/RSP

🖥️ 系统调用入口:Syscall Stub

系统调用走的是 syscall/sysretq 快速路径(比中断快得多),实现在 src/arch/x86_64/syscall_entry.rs:

swapgs
mov gs:user_stack, rsp   ; 暂存用户栈
mov rsp, gs:kernel_stack  ; 切换到内核栈
; ... 压入全部寄存器,构造 Context ...
sti
call syscall_handler
; ... 恢复寄存器 ...
pop rcx          ; 恢复 R11(syscall 会覆盖 RCX 和 R11)
add rsp, 8
pop r11
pop rsp
swapgs
sysretq

MSR 配置在 SMP 初始化阶段完成(IA32_STAR、IA32_LSTAR、IA32_FMASK、IA32_SYSCALL_MASK),确保 syscall 指令能跳转到 amd64_syscall_stub。

🧵 SMP 多核初始化

src/arch/x86_64/smp.rs 中的 init() 函数负责唤醒所有 CPU 核心:

  1. 为每个 CPU 创建 Prcb:包含独立的 CpuGdt(含 TSS)、4 个内核栈(1 个常规 + 3 个 IST)、运行队列
  2. BSP(启动核心) 直接调用 processor_setup_bsp()
  3. AP(从属核心) 通过 Limine 的 cpu.bootstrap(processor_startup, prcb_ptr) 唤醒,执行 processor_startup
  4. 每个核心独立加载 GDT、IDT、配置 MSR、初始化本地 APIC
  5. BSP 自旋等待直到 PROCESSOR_COUNT == 总核心数

每个 Prcb 通过 MSR_GS_BASE 注册到 GS 段寄存器,使得 get_current_processor() 可以一条 mov rax, gs:[me] 指令获取当前 CPU 信息——这是内核中最高频的操作之一。

🏁 启动尾声:用户进程加载与中断开启

完成所有硬件初始化后,arch_entry() 最后两步:

sched::init();                    // 初始化调度器,入队 init_thread
unsafe { intr::enable_interrupts(); }  // sti — 打开中断
loop { asm::halt_forever(); }     // BSP 进入 halt 等待 IPI

init_thread(定义在 src/main.rs)是内核的第一个"用户态"任务:

  1. 从 Limine 模块列表中查找 user.elf
  2. 解析 ELF 头部,验证 e_type == ET_EXEC
  3. 创建用户进程地址空间,复制内核页表的 256~512 项(高半区映射)
  4. 逐个映射 PT_LOAD 段(代码段 + 数据段),处理 bss 零填充
  5. 在 0x7000_0000_0000 处建立 4KB 用户栈
  6. 以 ELF 入口点创建线程,入队调度

此后,系统就进入了正常的调度循环——定时器中断不断触发,sched::schedule() 在线程间切换,用户程序得以运行。

📂 关键文件速查

文件 说明
src/main.rs _start 入口、init_thread 用户进程加载
src/arch/x86_64/entry.rs Limine 请求声明、arch_entry() 初始化总调度
src/arch/x86_64/gdt.rs GDT 描述符、TSS、lgdt/ltr 加载
src/arch/x86_64/idt.rs IDT 256 项构建、lidt 加载
src/arch/x86_64/intr.rs 中断 stub、上下文保存/恢复、idt_handler
src/arch/x86_64/mminit.rs 物理内存管理、HHDM、页表映射
src/arch/x86_64/smp.rs Prcb、BSP/AP 启动、多核同步
src/arch/x86_64/syscall_entry.rs syscall/sysretq 快速路径
src/arch/x86_64/asm.rs cpuid、rdmsr/wrmsr、端口 I/O、hlt
src/arch/x86_64/crt.rs memcpy/memset/memcmp 等 C 运行时
src/arch/x86_64/mod.rs Context 结构体、页表标志位、常量
limine.conf 引导配置
Makefile 构建与 ISO 打包
Cargo.toml 依赖声明(limine、flanterm、elf 等)

🏗️ 构建与运行

# 编译内核 + 打包 ISO
make polaris.iso

# 仅编译内核
make kernel

# 编译用户态模块
make user

构建需要 Rust nightly 工具链(rust-toolchain.toml 指定)和自定义 target JSON toolchain/x86_64-kernel.json。ISO 生成后可直接在 QEMU 中运行:

qemu-system-x86_64 -cdrom polaris.iso -boot d

💡 调试提示:项目提供了 misc/gdbinit,可配合 GDB 附加到 QEMU 进行内核级调试。

🔑 总结

Polaris 的启动流程体现了一个现代 64 位内核的完整初始化链路:

Limine 引导 → 帧缓冲输出 → 内存管理(PMM+HHDM)
→ IDT 构建 → ACPI/HPET/APIC → 进程初始化
→ SMP 多核 → GDT/TSS 每核加载 → MSR 配置
→ 中断开启 → 调度循环 → 用户进程加载

整个初始化严格遵循"先内存后中断、先单核后多核、先内核后用户"的顺序,每一步都依赖前一步的基础设施。阅读源码时建议按此顺序逐文件推进,能最清晰地理解各模块之间的依赖关系。

登录后查看全文
Polaris