摘要:自 2022 年 Rust-for-Linux 项目正式合入 Linux 内核树以来,Rust 已经从实验性语言选项逐步走向生产级内核编程。本文深入分析 Rust 在内核中的核心架构设计(Pin、Unsafe 抽象、内存模型融合),梳理当前已合入/正在开发的子系统(DRM 驱动、NVMe、网络、文件系统),并展望 Rust 向内核核心调度器、内存管理等子系统渗透的工程路径与挑战。
一、为什么内核需要 Rust
1.1 内核 C 代码的安全困境
Linux 内核每年修复数百个 CVE,其中 60%-70% 与内存安全相关:缓冲区溢出、UAF (Use-After-Free)、Double-Free、越界读写、未初始化内存等。Mozilla 的统计数据显示,自 2015 年以来 Firefox 引擎中 73.9% 的高危 CVE 源于内存安全问题——而内核的代码复杂度远超浏览器。
// 典型的内核 C 漏洞模式:竞争条件导致的 UAF
struct device *dev = get_device_parent();
// ⚠️ 另一个线程可能在此期间释放了 dev
put_device(dev); // UAF
1.2 Rust 的核心承诺
Rust 在编译期通过 ownership 系统、borrow checker 和生命周期分析,可以 静态消除 整类内存安全问题:
- 数据竞争 通过
Send/Synctrait 在并发场景下被编译器拦截 - UAF / Double-Free 通过 RAII + 所有权模型天然消除
- 越界访问 通过
bounds check+ 迭代器模式消除 - 未初始化内存 通过
MaybeUnsafe/Opaque模式显式处理
这并非象牙塔里的学术理想——Google Android 团队自 2021 年起在新蓝牙驱动中使用 Rust,报告显示 内存安全漏洞从 2021 年的 17 个降至 2024 年的 0 个。
二、Rust 内核编程的核心架构设计
2.1 kernel crate 架构
Rust-for-Linux 项目在内核中构建了一个完整的 kernel crate,它提供了与 C 侧交互的 Rust 抽象层:
kernel/
├── sync/ # RwLock, Mutex, Arc, SpinLock
├── memory/ # __kernel, dma, mmio
├── types/ # Opaque, ForeignBorrowed, CStr
├── file/ # File, FileOperations
├── net/ # Socket, NetworkDevice
├── block/ # BlockDevice, BlockOps
├── block/
│ └── mq/ # MultiQueue调度
├── driver/ # Driver, PlatformDriver, PCI
├── rbtree/ # 红黑树
├── radix_tree/ # 基数树
├── xarray/ # XArray
├── linked_list/ # 侵入式链表
└── workqueue/ # WorkQueue
2.2 核心类型系统
kernel crate 中几个关键类型构成了安全抽象的基础:
/// 用于封装 C 分配的不透明类型——Rust 侧无法直接访问其字段
/// 所有访问必须通过 C 函数提供的安全封装
pub struct Opaque<T: ?Sized>(core::cell::UnsafeCell<T>);
/// 引用 C 侧拥有的内存——不拥有所有权,但保证生命周期有效
pub struct ForeignBorrowed<'a, T: ?Sized>(&'a T);
/// 内核字符串——保证有效 UTF-8 或显式长度
pub struct CStr<'a>(&'a [u8]);
2.3 Pin 自引用结构
内核中存在大量自引用结构(如链表节点、工作项、设备实例),C 中通过指针强制转换实现,Rust 则通过 Pin 保证:
// C 中的典型自引用:list_node 内嵌在 struct 中
// Rust 中通过 Pin 防止结构被移动,保证自引用有效
struct MyDriver {
list: ListHead, // 自引用:list 的 next 指向另一个 MyDriver 的 list
data: DeviceData,
}
impl PinInit<MyDriver> for MyDriver {
fn pin_init(this: PinInitSlot<'_, MyDriver>) -> impl PinInit<MyDriver> {
try_pin_init!(this as MyDriver {
list: ListHead::new(),
data: DeviceData::new(),
})
}
}
2.4 Unsafe 的规范化使用
Rust 内核并非零 unsafe——C 交互本质上是 unsafe 的。关键在于 将 unsafe 操作封装在安全的抽象层内:
// 不安全:直接调用 C 的 kmalloc
unsafe { bindings::kmalloc(size, flags) }
// 安全:封装在 Box::try_new 中
pub fn try_new(flags: GFP) -> Result<Box<T>, AllocError> {
// unsafe 块被封装在安全 API 内部
let ptr = unsafe { bindings::kmalloc(mem::size_of::<T>(), flags.0) };
if ptr.is_null() {
return Err(AllocError);
}
// 安全封装:返回的 Box 拥有该内存
Ok(unsafe { Box::from_raw(ptr as *mut T) })
}
三、子系统现状盘点:从驱动到核心层
3.1 已合入的子系统(截至 2026 年 10 月)
| 子系统 | 状态 | 代码规模 | 主要功能 |
|---|---|---|---|
rust: core |
已合入 6.1+ | ~15K LOC | 基础类型、同步原语、内存分配 |
drivers: nova |
已合合 Linux 6.12 | ~8K LOC | Nova GPU 实验性驱动骨架 |
net: ti_cpsw |
已合入 6.13 | ~3K LOC | TI CPSW 以太网驱动 |
drivers: nvme |
已合入 6.14 | ~5K LOC | NVMe 驱动 Rust 移植 |
fs: tarfs |
已合入 6.14 | ~2K LOC | Tar 文件系统只读实现 |
drivers: dwmac |
已合入 6.14 | ~2.5K LOC | DesignWare 以太网 MAC 驱动 |
drivers: raspberrypi |
合入中 | ~1.5K LOC | Raspberry Pi 固件接口 |
3.2 活跃的 WIP 子系统
// 正在开发中的关键模块(2026 年现状):
// 1. DRM 子系统完整 Rust 抽象层(drm_device, drm_file)
// 2. Block 层MultiQueue调度器 (block/mq/rust_blk.c)
// 3. Network 子系统中的 TC-eBPF-Rust 数据面
// 4. KVM irqfd/ioeventfd 的 Rust 宿主接口
// 5. Binder IPC 驱动 Rust 重写(Android 侧)
3.3 关键工程指标
根据 LWN 和 kernel.org 2026 年第三季度的数据:
- Rust 内核代码总量:约 50K LOC(含测试和文档)
- 活跃 Rust 内核开发者:约 120 人
- 每周合入 Rust 提交:约 15-20 个
- Rust 代码 CVE 密度:0 / KLOC(2024-2026 累计)
四、核心架构挑战与解决方案
4.1 与 C 代码的双向 FFI
Rust 内核中最复杂的不是 Rust 代码本身,而是 Rust 与 C 之间双向调用 的安全保证:
// C 侧调用 Rust 函数
extern int rust_block_device_init(struct block_device *bdev);
// Rust 侧调用 C 函数
unsafe extern "C" {
fn blk_mq_alloc_tag_set(set: *mut blk_mq_tag_set) -> c_int;
}
解决方案:kernel/build.rs + bindgen 自动生成 Rust FFI 绑定,并通过 c/helper.c 提供安全的 C 侧过渡层。
4.2 错误处理的跨语言统一
C 内核使用负数错误码(-ENOMEM、-EINVAL),Rust 使用 Result<T, E>。通过 kernel::error 模块统一:
pub type Result<T = ()> = core::result::Result<T, Error>;
impl Error {
/// 从 C 错误码转换
pub fn from_errno(errno: core::ffi::c_int) -> Error {
// -1..=-MAX_ERRNO → 有效错误码
// 其他 → EINVAL
}
}
4.3 内存分配与 SLUB/Buddy 的协同
Rust 内核使用内核标准的 GFP 分配器,通过 kernel::memory 模块封装:
pub fn alloc<T>(flags: GFP) -> Result<Box<T>, AllocError> {
// 调用 C 侧 kmalloc,由 SLUB/Buddy 分配器提供服务
}
pub fn free<T>(ptr: Box<T>) {
// Rust Drop 自动调用 kfree
}
关键设计决策:Rust 内核的 Box、Vec、Arc 直接使用 C 侧的页分配器,而非实现自己的内存池。这保证了内存碎片行为与 C 代码完全一致。
4.4 并发安全模型
内核 Rust 通过封装 C 的锁原语实现并发安全:
| Rust 抽象 | 底层 C 实现 | 保证 |
|---|---|---|
kernel::sync::SpinLock |
spinlock_t |
编译期禁止同时持有 |
kernel::sync::RwLock |
rw_semaphore |
读多写弱性编译检查 |
kernel::sync::Mutex |
struct mutex |
锁顺序防死锁 |
kernel::sync::Arc |
kref + 原子计数 |
引用计数编译检查 |
kernel::sync::Barrier |
smp_mb() |
内存屏障同步 |
五、未来演进路线图
5.1 近期(2026-2027):驱动层全面铺开
优先级排序:
1. GPU 驱动(NVIDIA Nova, AMD P-State Rust 接口)
2. NVMe-oF / 存储 RDMA 网络协议栈
3. 蓝牙 / WiFi 无线协议栈(已有 Android 基础)
4. eBPF verifier 子模块 Rust 重写
5.2 中期(2027-2029):子系统级渗透
这是最有野心也最困难的一步——将 Rust 引入内核核心子系统:
阶段一:模块化替换
├── io_uring 注册环/缓冲区管理(Rust 重写)
├── cgroup v2 控制器(Rust 实现新 controller)
├── Btrfs/ZFS FUSE 参考实现
└── Netfilter 匹配器模块
阶段二:核心层渗透
├── 调度器扩展(sched-ext BPF-Rust 调度器)
├── MMU notifier 接口 Rust 封装
├── Page Cache 预读逻辑
└── 网络协议栈 TCP Rust 实验实现
5.3 远期(2029+):架构重塑
核心调度器:CFS/EEVDF 部分子模块 Rust 化
├── 选择算法(pick_next_task)
├── 负载均衡统计
└── 调度域拓扑发现
内存管理:
├── Rmap 逆向映射
├── 文件系统 dentry 缓存 LRU
└── BIO 层抽象
安全增强:
├── LSM hook 策略引擎
├── IMA/EVM 数字签名验证
└── 密钥管理子系统
六、工程实践:如何编写高质量 Rust 内核代码
6.1 遵循的设计原则
// 原则一:最小 unsafe 暴露
// ❌ 不好:unsafe 暴露给调用者
pub unsafe fn register_device(dev: *mut bindings::device) { ... }
// ✅ 好:unsafe 封装在模块内部
pub fn register_device(dev: &Device) -> Result {
let ret = unsafe { bindings::device_register(dev.as_ptr()) };
// ...
}
// 原则二:善用类型状态模式 (Type State)
struct DeviceUninitialized;
struct DeviceOperational;
struct Device<State> {
regs:Registrars,
state: PhantomData<State>,
}
impl Device<DeviceUninitialized> {
fn init(self) -> Result<Device<DeviceOperational>> { ... }
}
impl Device<DeviceOperational> {
fn submit_io(&self, req: &IORequest) -> Result { ... }
}
// 编译期保证:未初始化的设备无法提交 I/O
6.2 调试与可观测性
# Rust 内核代码的调试配置
[features]
debug = ["kernel/debugfs", "kernel/tracepoints"]
// 使用内核的 tracepoint 设施
define_trace_rust!(my_driver_io_request, ctx, req);
// 在 Rust 代码中触发
trace_my_driver_io_request!(ctx, &req);
七、反对意见与客观评估
7.1 "性能开销"
微软 Azure 团队的实测数据显示:
| 子系统 | C 版本运行耗时 | Rust 版本运行耗时 | 差异 |
|---|---|---|---|
| NVMe 驱动 | 142.3 μs | 143.1 μs | +0.56% |
| 网络驱动 | 89.7 μs | 90.2 μs | +0.56% |
| 文件系统 | 210.4 μs | 211.5 μs | +0.52% |
结论:Rust 在 release 模式下与 C 的性能差异在 1% 以内,主要来自少量边界检查。通过 unsafe 和 unreachable_unchecked() 可进一步消除。
7.2 "编译时间"
Rust 的编译时间确实长于 C,但在增量编译(cargo +make COMPILE_RUST=1)下:
- 完整内核含 Rust:比纯 C 构建多 3-5 分钟(首次)
- 增量 Rust 修改:8-30 秒(取决于 crate 依赖规模)
解决方案:sccache + 分布式构建 + 模块预编译。
7.3 "人才储备"
Rust 内核开发者数量仍然有限,但增长迅速。Google、Microsoft、AWS、Red Hat 均已投入专职团队。kernel.org 数据表明每月新增贡献者增速 15%。
八、总结
Rust 进入 Linux 内核不是"要不要"的问题,而是"怎么走、走多快"的问题。在内存安全威胁日益严峻的背景下,Rust 已经从技术好奇心转变为内核安全的战略工具。
2022 ─── 2024 ─── 2026 ─── 2028 ─── 2030+
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
实验 驱动层 子系统 核心级 内核
阶段 铺设 渗透 重塑 原生
Rust 的融合是一场 渐进式的架构转型,而不是一夜之间的重写。正如 Linus Torvalds 在 2026 年 Linux 内核峰会上的公开表态:"I want to see Rust in the core scheduler within my lifetime"。
对于在 Linux 内核领域深耕的工程师而言,理解并掌握 Rust 已经不是加分项,而是未来十年的基本生存技能。
参考资料
- Rust-for-Linux 官方仓库:https://github.com/Rust-for-Linux/linux
- Linux 6.12-6.14 Rust 合入记录:https://lwn.net/Kernel/Index/#Rust
- Google Android Rust 迁移报告 (2024)
- Microsoft Azure Rust 内核性能评估 (2025)
- "Rust in the Linux Kernel" — LWN 系列文章(2022-2026)
- Linux 内核峰会 2026 — Rust 安全主题 Keynote
- kernel.org Rust 子系统治理文档

发表评论 取消回复