前言

在 Rust 之后,系统编程领域迎来了另一位新选手:Zig。与 Rust 强调所有权和借用不同,Zig 走了一条更贴近 C 的路线 — 不提供 GC、没有隐式分配、没有运算符重载,全部控制在编译器可见范围内。这使得它在裸机(bare-metal)编程场景下拥有独特的表达力。

本文将以 RISC-V 64 位体系结构为靶板,用 Zig 从零搭建一个最小可运行的操作系统内核,完整覆盖:

  • RISC-V M-mode 启动流程与 OpenSBI 启动器交互
  • 从 M-mode 切换到 S-mode 的内核入口设置
  • 串口驱动(UART 16550a)实现早期输出能力
  • Sv39 三级页表的建立与内核空间映射
  • SBI( Supervisor Binary Interface)调用规范与定时器中断
  • 简单 Round-Robin 进程调度器

所有代码基于 Zig 0.13.x + QEMU virt 机器模型,可在本地复现。

一、为什么选 Zig 做内核开发

Zig 在裸机编程上的优势可以归结为三点:

1. comptime 完全替代 C 宏

C 内核中充斥着 #define 和复杂的预处理逻辑。Zig 的 comptime 机制允许类型安全的编译期计算,错误信息在编译阶段就足够清晰:

// 编译期计算页表索引
pub fn pageTableIndex(virt: u64, level: u32) u9 {
    const shift = 12 + @as(u6, level) * 9;
    return @truncate((virt >> shift) & 0x1FF);
}

2. 与 C 头文件的零成本互操作

RISC-V 特权架构有大量 CSR(Control and Status Registers)寄存器。Zig 可以 extern 声明 CSR 编号并直接嵌入 csrr 指令,无需写单独的汇编文件:

extern "csr" fn readSatp() u64 {
    var val: u64 = 0;
    asm volatile ("csrr %[ret], satp"
        : [ret] "=r" (val),
    );
    return val;
}

3. 显式的错误联合类型

C 内核中错误码与返回值混用是灾难源头。Zig 的 error 类型强制调用者处理失败路径:

pub const FrameError = error{OutOfMemory, InvalidAddress};

pub fn mapPage(pt: *PageTable, virt: u64, phys: u64, flags: u64) FrameError!void {
    // ... 缺页时返回 error.OutOfMemory
}

二、RISC-V 特权架构速览

RISC-V 定义了三个特权级:

模式 用途 我们用到
M-mode 机器模式,最高权限 由 OpenSBI 占用
S-mode 管理模式,操作系统内核 内核运行在此
U-mode 用户模式 用户进程运行

OpenSBI 固件在 M-mode 下运行,负责硬件初始化。内核通过 mret 指令从 M-mode 跳转到 S-mode。OpenSBI 提供 SBI 调用接口,让 S-mode 内核能请求 M-mode 完成特权操作(如设置定时器、IPI 核间中断)。

关键 CSR 寄存器速查:

  • mstatus / sstatus:状态寄存器,控制中断使能
  • mepc / sepc:异常程序计数器
  • mtvec / stvec:异常向量表基址
  • satp:页表根物理地址,启用虚拟内存
  • sie / sip:中断使能和挂起位

三、项目工程结构

zig-risc-v-kernel/
├── build.zig           # Zig 构建脚本(交叉编译配置)
├── src/
│   ├── main.zig        # 内核入口
│   ├── uart.zig        # UART 16550a 驱动
│   ├── paging.zig      # Sv39 页表管理
│   ├── trap.zig        # 中断/异常处理
│   ├── sched.zig       # 进程调度器
│   ├── sbi.zig         # SBI 调用封装
│   ├── start.zig       # 启动汇编入口
│   ├── kmalloc.zig     # 简单物理内存分配器
│   └── link.ld         # 链接脚本
└──...

链接脚本连接内核时入口函数命名为 _start,并指定入口地址。QEMU virt 平台中,内核加载到物理地址 0x80200000(OpenSBI 结束后跳转到此)。

OUTPUT_ARCH("riscv")
ENTRY(_start)

SECTIONS {
    . = 0x80200000;
    .text : { *(.text .text.*) }
    .rodata : { *(.rodata .rodata.*) }
    .data : { *(.data .data.*) }
    .bss : { *(.bss .bss.*) }
}

四、Boot 流程:从 M-mode 到 S-mode

启动阶段的核心任务是:设置早期页表、配置中断向量、跳转到 S-mode。

start.asm(启动汇编片段):

.section .text.entry
.globl _start
_start:
    # OpenSBI 通过 a0 传入 hartid,a1 传入 DTB 地址
    csrw mscratch, a0      # 暂存 hartid
    csrw mscratch+8, a1    # 暂存 DTB

    # 加载 C 栈地址(由链接脚本定义)
    la sp, _stack_top
    call kmain

只有主核(hart 0)执行完整初始化流程。其他核在执行时等待主核唤醒。

main.zig 启动逻辑:

const std = @import("std");

export fn kmain(hartid: usize) !void {
    // 初始化 UART,从此刻起可以输出日志
    uart.init(0x10000000);

    std.debug.print("\x1b[32m[boot]\x1b[0m hart {} kernel start\n", .{hartid});

    // 初始化物理内存分配器
    kmallocator.init();

    // 构建 Sv39 三级页表,建立内核空间映射
    const root = try paging.setupKernelMap();

    // 写 satp 寄存器启用虚拟内存
    paging.enablePaging(root);

    // 初始化中断系统
    trap.init();

    // 进入调度器
    sched.run();
}

五、UART 16550a 驱动

早期内核没有格式化 I/O,串口是唯一的调试通道。QEMU virt 平台默认使用 16550a 兼容串口,寄存器基址 0x10000000。

pub const Uart = struct {
    base: *volatile [5]u8,

    pub fn init(base_addr: usize) void {
        const uart = Uart{ .base = @ptrFromInt(base_addr) };

        // 禁用中断
        uart.base[1] = 0x00;
        // 使能 DLAB
        uart.base[3] = 0x80;
        // 设置波特率 38400(除数低/高字节)
        uart.base[0] = 0x03;
        uart.base[1] = 0x00;
        // 8N1,关闭 DLAB
        uart.base[3] = 0x03;
        // 使能 FIFO,清缓冲区
        uart.base[2] = 0xC7;

        _ = uart;
    }

    pub fn putc(c: u8) void {
        const base = @as(*volatile [5]u8, @ptrFromInt(0x10000000));
        // 等待 TX FIFO 有空位
        while ((base[5] & 0x20) == 0) {}
        base[0] = c;
    }

    pub fn print(comptime fmt: []const u8, args: anytype) void {
        // 基于 putc 实现格式化输出
        // ...
    }
};

有了 putc 后,我们可以实现 std.debug.print 的 writer 接口,让所有 Zig 的日志和调试输出都通过串口。

六、Sv39 三级页表

RISC-V Sv39 将 39 位虚拟地址空间划分为三级页表,每级 9 位索引 × 512 条目/级,页大小 4KB。地址结构如下:

  VPN[2]   VPN[1]   VPN[0]   页内偏移
[38:30]  [29:21]  [20:12]   [11:0]
 9 bits   9 bits   9 bits   12 bits

每个页表项(PTE)为 64 位:

[63:54] 保留  [53:10] PPN   [9:8] RSW  [7:0] 标志位
                物理页号           D A G U X W R V

其中标志位含义:

  • V:有效位
  • R/W/X:读/写/执行
  • U:用户态可访问
  • A:Accessed(硬件置位)
  • D:Dirty(硬件置位)

我们的页表管理代码:

pub const PTE = packed struct {
    flags: u8,       // V | R | W | X | U | G | A | D
    rsw: u8,
    ppn_low: u16,
    ppn_high: u32,

    pub fn isValid(self: PTE) bool { return (self.flags & 0x01) != 0; }
    pub fn isLeaf(self: PTE) bool { return (self.flags & 0x0E) != 0; }
    pub fn getPhys(self: PTE) u64 {
        return (@as(u64, self.ppn_high) << 20) | (@as(u64, self.ppn_low) << 2);
    }
};

/// 虚拟地址 -> 物理地址映射
pub fn mapPage(pt: *PageTable, virt: u64, phys: u64, flags: u8) FrameError!void {
    const vpn = [_]u9{
        @truncate((virt >> 12) & 0x1FF),
        @truncate((virt >> 21) & 0x1FF),
        @truncate((virt >> 30) & 0x1FF),
    };

    var table: *PageTable = pt;
    var level: u32 = 2;
    while (level > 0) : (level -= 1) {
        const entry = &table.entries[vpn[level]];
        if (!entry.isValid()) {
            // 分配新页表页,清零
            const newPage = try kmallocator.allocPage();
            @memset(@as([*]u8, @ptrFromInt(newPage))[0..4096], 0);
            entry.* = .{
                .flags = 0x01,  // V=1
                .ppn_low = @truncate(vpn[0]),
                .ppn_high = @truncate((newPage >> 12) >> 10),
                .rsw = 0,
            };
        }
        table = @ptrFromInt(entry.getPhys());
    }

    // 设置叶子 PTE
    table.entries[vpn[0]] = .{
        .flags = flags | 0x01,  // V=1 + 用户标志
        .ppn_low = @truncate(phys & 0x3FF_FFFF),
        .ppn_high = @truncate((phys >> 22)),
        .rsw = 0,
    };
}

七、Trap 处理与中断委托

RISC-V 的 Exception、Interrupt、Trap 统一通过 stvec 寄存器指向的处理函数响应。

我们的 trap handler 需要区分三种场景:

  1. Exception:页故障、非法指令、系统调用(ecall from U/S-mode)
  2. Interrupt:软件中断、定时器中断、外部中断
  3. Environment Call:用户态发起的 SBI 调用
const TrapFrame = packed struct {
    regs: [32]u64,  // x0-x31
    sepc: u64,
    scause: u64,
    stval: u64,
    sstatus: u64,
};

export fn trapHandler(tf: *TrapFrame) void {
    const cause = tf.scause;
    const isInt = (cause >> 63) != 0;
    const code = cause & 0x7FFF_FFFF;

    if (isInt) {
        // 中断
        switch (code) {
            5 => timerInterrupt(tf),  // S-mode 定时器中断
            9 => externalInterrupt(tf), // 外部中断(PLIC)
            else => debugPanic("unexpected interrupt: {}", code),
        }
    } else {
        // 异常
        switch (code) {
            8, 9 => handleSyscall(tf),   // ecall from U/S-mode
            12, 13, 15 => handlePageFault(tf), // 指令/读/写页故障
            2 => illegalInstruction(tf),
            else => debugPanic("unexpected exception: {}, sepc=0x{x}", .{code, tf.sepc}),
        }
    }
}

中断委托(Delegation):

默认情况下,所有中断和异常都落在 M-mode 处理。通过设置 medeleg 和 mideleg 寄存器,我们可以将 S-mode 的 trap 委托回 S-mode 处理,避免频繁的 M↔S 模式切换:

fn delegateTraps() void {
    // 委托 S-mode 同步异常到 S-mode(medeleg 位 8,9,12,13,15 等)
    const MEDLEG_SYNC = (1 << 8) | (1 << 9) | (1 << 12) | (1 << 13) | (1 << 15);
    asm volatile ("csrw medecl, %[val]"
        : 
        : [val] "r" (MEDLEG_SYNC),
    );

    // 委托 S-mode 中断到 S-mode(mideleg 位 5 定时器, 9 外部)
    const MIDELEG_ALL = (1 << 5) | (1 << 9);
    asm volatile ("csrw mideleg, %[val]"
        :
        : [val] "r" (MIDELEG_ALL),
    );
}

八、SBI 调用与定时器

Supervisor Binary Interface 是 OpenSBI 为 S-mode 内核提供的接口。每个 SBI 扩展通过 a7 传扩展 ID,a6 传函数 ID。

pub const SBI_EID_BASE: u64 = 0x10;
pub const SBI_EID_TIMER: u64 = 0x54494D45; // "TIME"

/// 设置下一次定时器中断的绝对时间
pub fn setTimer(stime_value: u64) callconv(.C) SbiRet {
    return sbiCall(1, stime_value, 0, 0, SBI_EID_TIMER, 0);
}

const SbiRet = extern struct {
    error: i64,
    value: i64,
};

fn sbiCall(
    arg0: u64, arg1: u64, arg2: u64, arg3: u64,
    fid: u64, extid: u64,
) SbiRet {
    var err: i64 = 0;
    var val: i64 = 0;
    asm volatile ("ecall"
        : [err] "={x10}" (err), [val] "={x11}" (val),
        : [a0] "{x10}" (arg0), [a1] "{x11}" (arg1),
          [a2] "{x12}" (arg2), [a3] "{x13}" (arg3),
          [a6] "{x16}" (fid), [a7] "{x17}" (extid),
        : "memory",
    );
    return .{ .error = err, .value = val };
}

注意 asm volatile 中的 "memory" clobber — Zig 的 inline asm 遵循 GCC 语义,需要显式告诉编译器 ecall 有内存副作用。

九、进程调度器

我们实现一个简单的 Round-Robin 调度器。每个进程维护一个 TaskControlBlock(TCB),包含独立的内核栈、用户栈和保存的上下文。

const Task = struct {
    pid: usize,
    state: enum { Ready, Running, Zombie },
    ctx: Context,         // 保存的寄存器上下文
    kernel_stack: u64,    // 内核栈顶物理地址
    user_stack: u64,      // 用户栈顶虚拟地址
};

const Context = packed struct {
    ra: u64, sp: u64,
    s: [12]u64,  // s0-s11(被调用者保存)
    sepc: u64,   // 陷阱返回地址
    sstatus: u64,
};

var current_task: ?*Task = null;
var task_list: [16]Task = undefined;
var task_count: usize = 0;
var next_pid: usize = 1;

/// 创建新任务:分配栈空间,设置初始上下文
pub fn taskCreate(entry: u64) !*Task {
    const t = &task_list[task_count];
    t.pid = next_pid;
    next_pid += 1;
    t.state = .Ready;

    // 分配 2 页的内核栈
    t.kernel_stack = try kmallocator.allocPage();
    const sp = t.kernel_stack + (2 * 4096);

    // 分配用户栈(1 页)
    t.user_stack = try kmallocator.allocPage() + 4096;

    // 初始化上下文
    t.ctx = .{
        .ra = @intFromPtr(&userEntry),  // 返回地址
        .sp = sp - 64,                   // trap frame 占 32 × 8 = 256 字节
        .s = [_]u64{0} ** 12,
        .sepc = entry,                   // 用户入口
        .sstatus = 0x00000000_00040000,  // SPP=0 (U-mode), SPIE=1
    };

    task_count += 1;
    return t;
}

/// 上下文切换(汇编实现,保存 s0-s11, ra, sp, sepc, sstatus)
extern fn switchContext(old: *Context, new: *Context) void;

/// 定时器中断到期后触发调度
fn timerInterrupt(tf: *TrapFrame) void {
    const DEFAULT_SLICE: u64 = 1_000_000;  // ~1ms at 1GHz
    _ = sbi.setTimer(@as(u64, @intCast(sbi.timeBase)) + DEFAULT_SLICE);

    if (task_count <= 1) return;

    const idx = for (0..task_count) |i| {
        if (&task_list[i] == current_task.?) break i;
    } else task_count;

    // Round-Robin:选择下一个 Ready 任务
    var next_idx = (idx + 1) % task_count;
    while (task_list[next_idx].state != .Ready) {
        next_idx = (next_idx + 1) % task_count;
    }

    const old_task = current_task.?;
    current_task = &task_list[next_idx];
    current_task.?.state = .Running;

    switchContext(&old_task.ctx, &current_task.?.ctx);
}

进程首次从 S-mode 进入 U-mode 通过修改 sepc 为用户入口地址、设置 sstatus.SPP=0 后在 sret 指令中完成切换。switchContext 的汇编实现保存旧任务的 callee-saved 寄存器,恢复新任务的寄存器,最后执行 sret。

十、验证与运行

使用以下命令启动 QEMU 并运行内核:

# 构建(示例使用 zig 0.13.x)
zig build -Drelease-safe=false

# 在 QEMU 上运行(需要安装 qemu-system-riscv64)
qemu-system-riscv64 \
    -machine virt \
    -cpu rv64 \
    -m 128M \
    -bios opensbi-riscv64-generic-fw_dynamic.bin \
    -kernel zig-out/bin/kernel \
    -nographic

串口输出示例:

[boot] hart 0 kernel start
[mm] Sv39 page table enabled, virtual memory on
[trap] delegating S-mode traps
[sched] created task 1 (entry=0x3ffffff000)
[sched] created task 2 (entry=0x3ffffff000)
[sched] timer interrupt, switching task 1 -> 2
[sched] timer interrupt, switching task 2 -> 1
...

可以看到两个用户任务在定时器驱动下交替运行。

十一、下一步与工程展望

上面的代码实现了 RISC-V 内核的最小可运行骨架,但离生产可用还差很多:

  1. 文件系统:移植 LittleFS 或至少一个只读 ramfs
  2. 系统调用接口:实现 read/write/exbrk/sbrk 等 POSIX 化接口
  3. 多核调度:通过 SBI 的 HSM 扩展唤醒 secondary harts
  4. PLIC 外部中断:配置 Platform Level Interrupt Controller 接收外设中断
  5. 用户 ELF 加载:解析 ELF 文件并将段映射到用户地址空间

Zig 的 comptime 特性还可以在 trait 层面实现类似 Rust 的 typestate 模式 — 利用类型和状态标志在编译期强制 API 的正确调用顺序(例如,未启用页表时不能分配用户地址)。这是后续可以深入挖掘的方向。


参考资源

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部