Rust 编写 Linux 内核设备驱动实战：从字符设备到生产级内核模块

引言

2022 年，Linux 6.1 正式合并 Rust 支持，标志着内核开发进入多语言时代。三年过去，越来越多的开发者开始探索用 Rust 编写内核设备的可能性。本文将从零开始，展示如何用 Rust 编写一个完整的字符设备驱动程序，对比 C 版本分析 Rust 在内核态编程中的独特优势，并讨论在生产环境中使用 Rust 的真实挑战。

一、为什么在内核中使用 Rust？

Linux 内核中 97% 的代码是 C 语言。C 赋予开发者最大的灵活性，但代价是内存安全问题。根据微软和谷歌的统计，约 70% 的安全漏洞源于内存安全问题，内核场景尤为严重。

Rust 在以下方面具有显著优势：

• 内存安全：编译期消除 use-after-free、double-free、buffer overflow
• 并发安全：Send/Sync trait 在编译期阻止数据竞争
• 零成本抽象：高级语义不带来运行时开销
• 类型系统：利用 enum 和 pattern matching 强制处理所有分支

但内核态编程有其特殊性：不能使用标准库、需要与 C 的 VFS 子系统交互、处理物理直接映射等。这意味着 Rust 需要一套不同于用户态的编程范式。

二、构建开发环境

2.1 内核配置

确保内核版本 ≥ 6.1，并开启以下配置：

CONFIG_RUST=y
CONFIG_SAMPLES_RUST=y
CONFIG_RUST_PRINTK=y

2.2 最小可编译模块

创建 Kbuild 文件：

# Kbuild
obj-$(CONFIG_SAMPLE_RUST_MINIMAL)       += rust_minimal.o
obj-$(CONFIG_SAMPLE_RUST_NUMA)          += rust_numa.o
obj-$(CONFIG_SAMPLE_RUST_PLATFORM)      += rust_platform.o
obj-$(CONFIG_SAMPLE_RUST_PCI)           += rust_pci.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_SMOKE_TEST) += rust_driver_smoke_test.o

在内核源码树中运行的配置方式：

# 检查 Rust 是否启用
grep CONFIG_RUST /boot/config-$(uname -r)

三、字符设备驱动实战

我们将编写一个基于环形缓冲区的字符设备驱动，支持 read/write/poll/ioctl。这个场景足以展示内核 Rust 的核心模式。

3.1 模块骨架

// rust_chardev.rs
use kernel::prelude::*;
use kernel::file::{self, File};
use kernel::io_buffer::{IoBufferReader, IoBufferWriter};
use kernel::sync::{Mutex, CondVar};
use kernel::task::Task;
use kernel::delay::coarse_sleep_duration;
use kernel::bindings;

module! {
    type: CharDevModule,
    name: "rust_chardev",
    author: "ybb",
    description: "Rust character device driver with ring buffer",
    license: "GPL",
}

struct CharDevModule {
    dev: Pin<Box<Registration<CharDev>>>,
}

impl kernel::Module for CharDevModule {
    fn init(module: &'static ThisModule) -> Result<Self> {
        pr_info!("Rust char device driver loaded\n");

        let dev = Registration::new_pinned(
            fmt!("rust_chardev"),
            0,
            module,
        )?;

        Ok(Self { dev })
    }
}

impl Drop for CharDevModule {
    fn drop(&mut self) {
        pr_info!("Rust char device driver unloaded\n");
    }
}

3.2 环形缓冲区的实现

这是驱动的核心数据结构。我们使用 Rust 的类型系统确保并发安全：

use kernel::sync::{Mutex, CondVar, LockClassKey};

const BUF_SIZE: usize = 4096;

pub(crate) struct RingBuffer {
    inner: Mutex<RingBufferInner>,
    not_empty: CondVar,
    not_full: CondVar,
}

struct RingBufferInner {
    buffer: [u8; BUF_SIZE],
    head: usize,
    tail: usize,
    count: usize,
    closed: bool,
}

impl RingBuffer {
    pub(crate) fn new() -> Result<Self> {
        Ok(Self {
            inner: Mutex::new(RingBufferInner {
                buffer: [0u8; BUF_SIZE],
                head: 0,
                tail: 0,
                count: 0,
                closed: false,
            }, "RingBuffer::inner", LockClassKey::new()),
            not_empty: CondVar::new("RingBuffer::not_empty"),
            not_full: CondVar::new("RingBuffer::not_full"),
        })
    }

    pub(crate) fn read(&self, data: &mut impl IoBufferWriter) -> Result<usize> {
        let mut inner = self.inner.lock();

        // 等待数据可用或者设备关闭
        inner = self.not_empty.wait(inner, |inner| {
            inner.count > 0 || inner.closed
        })?;

        if inner.closed && inner.count == 0 {
            return Ok(0);
        }

        let mut copied = 0;
        let to_read = core::cmp::min(data.len(), inner.count);

        while copied < to_read {
            let chunk = core::cmp::min(
                to_read - copied,
                BUF_SIZE - inner.head,
            );
            data.write_slice(&inner.buffer[inner.head..inner.head + chunk])?;
            inner.head = (inner.head + chunk) % BUF_SIZE;
            copied += chunk;
        }

        inner.count -= copied;
        self.not_full.signal();

        Ok(copied)
    }

    pub(crate) fn write(&self, data: &mut impl IoBufferReader) -> Result<usize> {
        let mut inner = self.inner.lock();

        if inner.closed {
            return Err(ENODEV);
        }

        let mut copied = 0;
        let to_write = core::cmp::min(data.len(), BUF_SIZE - inner.count);

        while copied < to_write {
            let chunk = core::cmp::min(
                to_write - copied,
                BUF_SIZE - inner.tail,
            );
            data.read_slice(&mut inner.buffer[inner.tail..inner.tail + chunk])?;
            inner.tail = (inner.tail + chunk) % BUF_SIZE;
            copied += chunk;
        }

        inner.count += copied;
        self.not_empty.signal();

        Ok(copied)
    }

    pub(crate) fn close(&self) {
        let mut inner = self.inner.lock();
        inner.closed = true;
        self.not_empty.notify_all();
    }
}

3.3 文件操作实现

use kernel::file::Operations;

#[vtable]
impl Operations for CharDev {
    type Data = Arc<RingBuffer>;

    fn open(_context: &(), data: &Arc<RingBuffer>) -> Result<Self::Data> {
        pr_info!("rust_chardev: opened\n");
        Ok(data.clone())
    }

    fn read(
        data: <Self::Data as ForeignArcBorrow>::Borrowed<'_>,
        _file: &File,
        writer: &mut impl IoBufferWriter,
        offset: u64,
    ) -> Result<usize> {
        if offset != 0 {
            // 字符设备不支持 seek
            return Err(EINVAL);
        }
        data.read(writer)
    }

    fn write(
        data: <Self::Data as ForeignArcBorrow>::Borrowed<'_>,
        _file: &File,
        reader: &mut impl IoBufferReader,
        offset: u64,
    ) -> Result<usize> {
        if offset != 0 {
            return Err(EINVAL);
        }
        data.write(reader)
    }

    fn release(data: <Self::Data as ForeignArcBorrow>::Borrowed<'_>, _file: &File) {
        pr_info!("rust_chardev: released\n");
        data.close()
    }

    fn poll(
        data: <Self::Data as ForeignArcBorrow>::Borrowed<'_>,
        file: &File,
        table: &mut bindings::poll_table,
    ) -> Result<u32> {
        let mut inner = data.inner.lock();

        let mut flags = 0;
        if inner.count > 0 {
            flags |= bindings::POLLIN | bindings::POLLRDNORM;
        }
        if inner.count < BUF_SIZE {
            flags |= bindings::POLLOUT | bindings::POLLWRNORM;
        }

        Ok(flags)
    }
}

四、对比 C 版本的关键差异

4.1 错误处理

C 版本的典型模式：

// C 版本 - 容易遗忘的错误检查
static ssize_t char_read(struct file *filp, char __user *buf, 
                         size_t count, loff_t *ppos)
{
    int ret = mutex_lock_interruptible(&dev->lock);
    if (ret)
        return ret;

    while (dev->count == 0) {
        mutex_unlock(&dev->lock);
        if (filp->f_flags & O_NONBLOCK)
            return -EAGAIN;
        if (wait_event_interruptible(dev->wq, dev->count > 0))
            return -ERESTARTSYS;
        ret = mutex_lock_interruptible(&dev->lock);
        if (ret)
            return ret;
    }

    // 拷贝数据到用户空间 - 忘记检查会导致 oops
    ret = copy_to_user(buf, dev->buffer + dev->head, copied);
    ...
}

Rust 版本利用 ? 操作符和 Result 类型，强制开发者处理每一个可能的错误路径，遗漏错误检查在编译期就会触发警告或报错。

4.2 资源管理

C 需要手动 goto 清理：

// C 风格的错误处理链 - 容易泄漏资源
int driver_init(void)
{
    int err;

    err = alloc_chrdev_region(&dev_no, 0, 1, "mydev");
    if (err) goto out;

    dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    if (!dev) { err = -ENOMEM; goto out_unreg; }

    err = setup_interrupts(dev);
    if (err) goto out_free;

    err = register_filesystem(&fs);
    if (err) goto out_irq;

    return 0;

out_irq:
    free_irq(dev->irq, dev);
out_free:
    kfree(dev);
out_unreg:
    unregister_chrdev_region(dev_no, 1);
out:
    return err;
}

Rust 利用 RAII 和 Drop trait，资源在其 wrapper 离开作用域时自动释放。Pin<Box<T>> 确保内核对象不会被意外移动。

4.3 并发安全

C 没有类型系统帮助：

// C - 编译期无法发现竞态
struct device_state {
    int counter;
    struct list_head pending_list;
    // 是否有锁保护全靠函数命名约定
};

void increment_counter(struct device_state *s)
{
    s->counter++;  // 可能在另一个 CPU 上同时修改
}

Rust 利用类型系统：

// Rust - 编译器保证：持有 MutexGuard 才能访问数据
struct DeviceState {
    counter: usize,
    pending_list: VecDeque<Request>,
}

// 安全访问：必须通过 Mutex
fn increment_counter(state: &Arc<Mutex<DeviceState>>) {
    let mut guard = state.lock();
    guard.counter += 1;
} // 锁在这里自动释放

五、生产环境中的真实挑战

5.1 与 C 代码的 FFI 交互

内核大量子系统以 C 结构体和函数指针形式定义。调用它们需要 unsafe 块：

// 调用 C 内核函数必须使用 unsafe
unsafe fn deliver_signal(task: &Task, sig: i32) -> Result<()> {
    let result = bindings::send_sig(
        sig,
        task.as_ptr() as *mut bindings::task_struct,
        0,
    );
    if result < 0 {
        Err(Error::from_kernel_errno(result))
    } else {
        Ok(())
    }
}

最佳实践：将 unsafe 封装在安全抽象内部，上层业务代码完全不接触 unsafe。

5.2 内存分配限制

内核态不能使用标准库的 alloc::boxed::Box。所有堆分配必须通过内核的 alloc:: alloc::box::Box：

// 错误：使用标准库的 Box
// let buffer = Box::new([0u8; 4096]);  // 编译失败！

// 正确：使用内核提供的 Box
use kernel::alloc::Box;
let buffer: Box<[u8; 4096]> = Box::try_new_zeroed()?;

5.3 浮点运算的限制

内核上下文不允许使用浮点寄存器操作（因为保存/恢复 FPU 上下文代价极高）：

// 编译可能通过，但运行时会导致内核 panic
fn calculate_throughput(bytes: usize, ms: usize) -> f64 {
    (bytes as f64) / (ms as f64) * 1000.0  // 危险！
}

// 正确做法：使用定点运算或整数运算
fn calculate_throughput_bytes_per_sec(bytes: usize, ms: usize) -> usize {
    bytes / ms * 1000  // 整数运算
}

5.4 调试困难

内核态的 Rust 调试比用户态更具挑战性：

• pr_info! 宏输出到 dmesg，但不能像 println! 那样格式化复杂类型
• GDB 对 Rust 内核符号的支持有限
• KASAN 与 Rust 的结合仍在完善中

实际建议：

// 利用 Rust 的类型系统在编译期捕获错误
// 写单元测试验证核心数据结构（使用 #[test] 在用户态运行）

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_ring_buffer_basic() {
        let buf = RingBuffer::new().unwrap();
        // 测试读写逻辑...
    }
}

六、性能对比分析

在 Linux 6.6 内核上使用 C 和 Rust 编写的字符设备基准测试（读取 1GB 随机数据）：

分析：Rust 版本仅有轻微性能差距（约 2-7%），但在内存安全性上提供了编译期保证。代码行数减少得益于 Rust 强大的类型系统和错误处理方式。编译时间更长是 Rust 编译器的特性，但使用增量编译后差异可接受。

七、何时选择 Rust？适合场景总结

推荐使用 Rust 的场景

1. 新的驱动子系统：从零开始的项目没有历史包袱
2. 高安全要求组件：加密设备、网络数据包处理
3. 协议解析类代码：网络协议栈、文件系统元数据解析
4. 并发密集型模块：利用类型系统避免数据竞争

仍应使用 C 的场景

1. 维护已有稳定驱动：重写成本远超收益
2. 极致热路径优化：编译器优化已经高度调优
3. 平台相关汇编桥接：某些架构特定的原子操作
4. ABI 稳定性要求：需要与特定内核符号精确匹配

八、结语

Rust 进入 Linux 内核已经从实验性功能演进为生产可用技术。它的核心价值不在于性能提升，而在于用编译期保证消除整类内存安全漏洞。对于字符设备、PCI 驱动、网络设备等新编场景，Rust 已经展现出足够的成熟度。

随着 Linux 6.10+ 对 Rust 支持的不断改进，以及 Lina Asahi 团队的 GPU 驱动逐步用 Rust 重写，我们可以预见 Rust 将在内核生态中扮演越来越重要的角色。掌握 Rust 内核编程能力，将成为系统级开发者的重要竞争力。

参考资料：

• Rust for Linux 官方仓库
• Rust 内核文档：Rust 在内核中的使用
• The Linux Kernel Module Programming Guide
• Linux 6.1 Merge：Rust 支持合并