从内核到用户态：Rust 系统编程的安全边界与最佳实践

从内核到用户态：Rust 系统编程的安全边界与最佳实践

一、系统编程的信任链：内核接口与安全抽象

系统编程的核心是与操作系统内核交互：文件 IO、网络通信、进程管理、内存映射。这些操作通过系统调用（syscall）完成，而系统调用是用户态程序与内核态之间的唯一信任边界。每一次 syscall 都涉及上下文切换（保存/恢复寄存器、切换页表），开销约 200-1000 纳秒。频繁的 syscall 不仅影响性能，还增加了内核攻击面。

Rust 在系统编程中的独特价值在于：它可以在不引入运行时开销的前提下，将不安全的 syscall 接口封装为安全的 Rust API。std::fs 的所有函数底层都调用了 libc 的 open/read/write，但 Rust 的所有权系统保证了文件描述符不会泄漏（Drop 关闭 fd）、缓冲区不会越界（slice 边界检查）、并发访问不会产生数据竞争（Send/Sync 约束）。理解这些安全抽象的边界，是写出正确系统程序的前提。

二、系统调用的安全封装：从 fd 到 Rust 所有权

2.1 文件描述符的生命周期管理

文件描述符（fd）是内核维护的有限资源。每个进程默认限制 1024 个打开的 fd（可通过 ulimit -n 调整），泄漏的 fd 会导致 EMFILE 错误。Rust 的 std::fs::File 通过 Drop trait 在作用域结束时自动关闭 fd，但 RawFd（c_int）没有这个保证。

graph TB
    subgraph 文件描述符安全封装
        A[RawFd: c_int] -->|不安全| B[无 Drop 保证<br/>可能泄漏]
        C[OwnedFd] -->|安全| D[Drop 自动关闭<br/>所有权转移]
        E[AsFd trait] -->|多态| F[同时支持 OwnedFd<br/>和 BorrowedFd]
    end

    subgraph 系统调用封装模式
        G[unsafe syscall] -->|错误处理| H[io::Result 封装]
        G -->|资源管理| I[RAII Guard 封装]
        G -->|并发安全| J[Arc + Mutex 封装]
    end

    subgraph 内存映射安全
        K[mmap syscall] -->|映射区域| L[MappedRegion]
        L -->|Drop: munmap| M[自动解除映射]
        L -->|Deref to &[u8]| N[安全的只读访问]
        L -->|DerefMut to &mut [u8]| O[安全的读写访问]
    end

2.2 错误处理的零成本抽象

Linux 系统调用通过返回值指示错误：-1 表示失败，errno 存储具体错误码。Rust 的 io::Result 将这个模式封装为类型系统的一部分——编译器强制处理 Err 分支，且 Result 的内存布局与裸值相同（利用 niches 优化），没有额外的堆分配。

2.3 信号处理的复杂性

信号（Signal）是 Unix 系统中异步通知进程的机制。信号处理函数（Signal Handler）运行在特殊的上下文中：它可能中断任何代码点，包括正在持有锁的代码。在信号处理函数中调用非异步信号安全（Async-Signal-Safe）的函数是未定义行为。Rust 标准库的绝大多数函数都不是异步信号安全的，因此在信号处理函数中只能使用 write 系统调用写入管道来通知主循环。

三、生产级系统编程模式

3.1 安全的文件描述符封装

use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
use std::io;
use std::mem::ManuallyDrop;

/// 安全的文件描述符封装，保证 Drop 时关闭 fd
/// 替代裸 RawFd，防止资源泄漏
pub struct SafeFd {
    fd: RawFd,
}

impl SafeFd {
    /// 从原始 fd 创建安全封装
    /// 调用者必须确保 fd 是有效的且拥有所有权
    pub unsafe fn from_raw(fd: RawFd) -> io::Result<Self> {
        if fd < 0 {
            return Err(io::Error::from_raw_os_error(libc::EBADF));
        }
        Ok(Self { fd })
    }

    /// 打开文件并返回安全封装的 fd
    pub fn open(path: &std::path::Path, flags: libc::c_int, mode: libc::c_int) -> io::Result<Self> {
        let fd = unsafe {
            libc::open(
                path.to_str().ok_or_else(|| {
                    io::Error::new(io::ErrorKind::InvalidInput, "路径包含无效 UTF-8")
                })?.as_ptr() as *const libc::c_char,
                flags,
                mode,
            )
        };

        if fd < 0 {
            Err(io::Error::last_os_error())
        } else {
            Ok(Self { fd })
        }
    }

    /// 使用 pread 进行原子定位读取，避免 lseek 的竞态条件
    pub fn pread(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
        let n = unsafe {
            libc::pread(
                self.fd,
                buf.as_mut_ptr() as *mut libc::c_void,
                buf.len(),
                offset as libc::off_t,
            )
        };

        if n < 0 {
            Err(io::Error::last_os_error())
        } else {
            Ok(n as usize)
        }
    }

    /// 使用 pwrite 进行原子定位写入
    pub fn pwrite(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
        let n = unsafe {
            libc::pwrite(
                self.fd,
                buf.as_ptr() as *const libc::c_void,
                buf.len(),
                offset as libc::off_t,
            )
        };

        if n < 0 {
            Err(io::Error::last_os_error())
        } else {
            Ok(n as usize)
        }
    }
}

impl Drop for SafeFd {
    fn drop(&mut self) {
        // 安全性：fd 由 SafeFd 独占拥有，关闭是安全的
        // 忽略 close 错误——重复关闭是编程错误，不应 panic
        unsafe {
            libc::close(self.fd);
        }
    }
}

// 禁止自动实现 Clone——fd 不能被两个所有者同时持有
// 如果需要共享，使用 Arc<SafeFd> 或 dup() 创建新的 fd

impl AsRawFd for SafeFd {
    fn as_raw_fd(&self) -> RawFd {
        self.fd
    }
}

3.2 内存映射的安全封装

use std::ptr;
use std::slice;

/// 安全的内存映射封装
/// Drop 时自动调用 munmap，防止内存泄漏
pub struct MappedRegion {
    ptr: *mut u8,
    len: usize,
    writable: bool,
}

impl MappedRegion {
    /// 创建只读内存映射
    pub fn map_readonly(fd: &SafeFd, offset: u64, len: usize) -> io::Result<Self> {
        let ptr = unsafe {
            libc::mmap(
                ptr::null_mut(),
                len,
                libc::PROT_READ,
                libc::MAP_PRIVATE,
                fd.as_raw_fd(),
                offset as libc::off_t,
            )
        };

        if ptr == libc::MAP_FAILED {
            Err(io::Error::last_os_error())
        } else {
            Ok(Self {
                ptr: ptr as *mut u8,
                len,
                writable: false,
            })
        }
    }

    /// 创建读写内存映射
    pub fn map_readwrite(fd: &SafeFd, offset: u64, len: usize) -> io::Result<Self> {
        let ptr = unsafe {
            libc::mmap(
                ptr::null_mut(),
                len,
                libc::PROT_READ | libc::PROT_WRITE,
                libc::MAP_SHARED,
                fd.as_raw_fd(),
                offset as libc::off_t,
            )
        };

        if ptr == libc::MAP_FAILED {
            Err(io::Error::last_os_error())
        } else {
            Ok(Self {
                ptr: ptr as *mut u8,
                len,
                writable: true,
            })
        }
    }

    /// 获取只读切片引用
    pub fn as_slice(&self) -> &[u8] {
        // 安全性：mmap 返回的内存区域在 munmap 前有效
        // 生命周期与 MappedRegion 绑定，不会悬垂
        unsafe { slice::from_raw_parts(self.ptr, self.len) }
    }

    /// 获取可变切片引用（仅限读写映射）
    pub fn as_mut_slice(&mut self) -> io::Result<&mut [u8]> {
        if !self.writable {
            return Err(io::Error::new(
                io::ErrorKind::PermissionDenied,
                "只读映射不允许写入",
            ));
        }
        // 安全性：writable 标志保证 PROT_WRITE，可变引用保证独占访问
        Ok(unsafe { slice::from_raw_parts_mut(self.ptr, self.len) })
    }

    /// 将修改刷新到磁盘
    pub fn sync(&self) -> io::Result<()> {
        let result = unsafe {
            libc::msync(
                self.ptr as *mut libc::c_void,
                self.len,
                libc::MS_SYNC,
            )
        };

        if result < 0 {
            Err(io::Error::last_os_error())
        } else {
            Ok(())
        }
    }
}

impl Drop for MappedRegion {
    fn drop(&mut self) {
        // 安全性：ptr 和 len 来自 mmap，munmap 参数一致
        // 忽略错误——进程退出时内核会自动解除所有映射
        unsafe {
            libc::munmap(self.ptr as *mut libc::c_void, self.len);
        }
    }
}

// MappedRegion 不是 Send/Sync 的——多线程访问需要外部同步
// 如果需要共享，使用 Arc<Mutex<MappedRegion>>

3.3 信号安全的事件通知

use std::io::{Read, Write};
use std::sync::atomic::{AtomicBool, Ordering};

/// 信号安全的通知机制
/// 信号处理函数中只写入管道，主循环通过 read 接收通知
pub struct SignalNotifier {
    pipe_read: SafeFd,
    pipe_write: SafeFd,
    triggered: AtomicBool,
}

impl SignalNotifier {
    pub fn new() -> io::Result<Self> {
        let mut fds: [libc::c_int; 2] = [-1, -1];
        // 创建管道，O_CLOEXEC 防止 fork 后 fd 泄漏
        let result = unsafe {
            libc::pipe2(fds.as_mut_ptr(), libc::O_CLOEXEC | libc::O_NONBLOCK)
        };

        if result < 0 {
            return Err(io::Error::last_os_error());
        }

        // 安全性：pipe2 成功返回后 fds 包含有效的 fd
        let pipe_read = unsafe { SafeFd::from_raw(fds[0])? };
        let pipe_write = unsafe { SafeFd::from_raw(fds[1])? };

        Ok(Self {
            pipe_read,
            pipe_write,
            triggered: AtomicBool::new(false),
        })
    }

    /// 注册为 SIGTERM/SIGINT 的信号处理函数
    /// 注意：此方法必须在单线程环境中调用
    pub fn register_signals(&self) -> io::Result<()> {
        let write_fd = self.pipe_write.as_raw_fd();

        unsafe {
            let mut sa: libc::sigaction = std::mem::zeroed();
            sa.sa_sigaction = signal_handler as libc::sighandler_t;
            // SA_RESTART: 自动重启被中断的 syscall
            libc::sigemptyset(&mut sa.sa_mask);
            sa.sa_flags = libc::SA_RESTART;

            // 将 write_fd 存储为信号处理函数的上下文
            // 使用全局变量而非 sigaction 的 sa_data（后者不可靠）
            SIGNAL_PIPE_FD.store(write_fd, Ordering::Relaxed);

            if libc::sigaction(libc::SIGTERM, &sa, ptr::null_mut()) < 0 {
                return Err(io::Error::last_os_error());
            }
            if libc::sigaction(libc::SIGINT, &sa, ptr::null_mut()) < 0 {
                return Err(io::Error::last_os_error());
            }
        }

        Ok(())
    }

    /// 非阻塞检查是否收到信号
    pub fn check(&self) -> bool {
        self.triggered.load(Ordering::Acquire)
    }

    /// 阻塞等待信号
    pub fn wait(&self) -> io::Result<()> {
        let mut buf = [0u8; 1];
        // 阻塞读取管道，直到信号处理函数写入数据
        let mut read_fd = self.pipe_read;
        // 注意：这里简化了，实际应使用 poll/epoll
        loop {
            if self.triggered.load(Ordering::Acquire) {
                return Ok(());
            }
            std::thread::sleep(std::time::Duration::from_millis(100));
        }
    }
}

// 全局变量：信号处理函数使用的管道 fd
// 使用 AtomicI32 保证信号处理函数中的原子写入
use std::sync::atomic::AtomicI32;
static SIGNAL_PIPE_FD: AtomicI32 = AtomicI32::new(-1);

/// 信号处理函数：仅写入管道，不调用任何非异步信号安全的函数
extern "C" fn signal_handler(_sig: libc::c_int, _info: *mut libc::siginfo_t, _ctx: *mut libc::c_void) {
    let fd = SIGNAL_PIPE_FD.load(Ordering::Relaxed);
    if fd >= 0 {
        // write 是异步信号安全的
        unsafe {
            let byte: [u8; 1] = [1];
            libc::write(fd, byte.as_ptr() as *const libc::c_void, 1);
        }
    }
}

四、系统编程的安全边界：何时必须使用 unsafe

Rust 系统编程中，unsafe 不可避免——所有与内核的交互最终都通过 FFI 调用 C 函数完成。但 unsafe 的使用必须遵循严格的安全契约。

unsafe 块的最小化原则。每个 unsafe 块应尽可能小，只包含真正需要 unsafe 的操作。将安全逻辑移到 unsafe 块外部，使安全推理的范围最小化。每个 unsafe 块必须附带 SAFETY 注释，说明为什么这段代码是安全的。

FFI 边界的类型安全。C 函数的参数类型是 c_int、c_void* 等原始类型，Rust 端应提供类型安全的封装函数，将 Rust 的强类型参数转换为 C 的弱类型参数。封装函数内部是 unsafe 的，但公开的 API 是安全的。

信号处理函数的限制。信号处理函数中只能调用 POSIX 定义的异步信号安全函数（约 70 个），不能调用 malloc、printf、任何 Rust 标准库函数。违反这个规则可能导致死锁（如果信号中断了持有锁的代码）或内存损坏。

适用边界。Rust 系统编程最适合：需要直接与内核交互的高性能 IO（io_uring、mmap）、操作系统级别的工具开发（容器运行时、调试器）、嵌入式和裸机编程。不适合的场景包括：可以用 std::fs/tokio 完成的常规 IO 操作、不需要底层控制的业务逻辑代码。

五、总结

Rust 系统编程的核心挑战是在 unsafe 的内核接口上构建安全的 Rust API。本文展示了文件描述符的安全封装（SafeFd + Drop 保证）、内存映射的 RAII 管理（MappedRegion + sync）、信号安全的事件通知（管道 + 原子变量）三个生产级模式。落地路线建议：第一步，将项目中所有裸 RawFd 替换为 OwnedFd 或自定义的 SafeFd，利用 Drop 消除 fd 泄漏；第二步，对 mmap/munmap 操作统一封装为 MappedRegion，在 Drop 中保证解除映射；第三步，信号处理统一使用管道通知模式，禁止在信号处理函数中调用任何 Rust 标准库函数；第四步，所有 unsafe 块必须附带 SAFETY 注释，在 CI 中使用 cargo geiger 检查 unsafe 代码量是否增长。