返回文章列表

用 Rust 从零实现 mmap 与零拷贝 IO:sendfile 到底省了什么

476 字·4 分钟阅读
Rust从零造轮子IO

"零拷贝"这个名字非常有误导性——数据当然还是会被拷贝,只是不再经过用户态。

一个静态文件服务器要把磁盘上的文件发给客户端,朴素写法是:

let mut buf = vec![0u8; 64 * 1024];
loop {
    let n = file.read(&mut buf)?;
    if n == 0 { break; }
    socket.write_all(&buf[..n])?;
}

这段代码每一轮都要在用户态和内核态之间搬两次数据。要想明白为什么慢,得先把每一次拷贝数清楚。


把校验和替换掉:只要拷贝次数

一次 read + write 发 64KB,数据要经过:

1. 磁盘 -> 内核页缓存        (DMA 拷贝,不占 CPU)
2. 内核页缓存 -> 用户缓冲区   (CPU 拷贝 ①)
3. 用户缓冲区 -> socket 缓冲区 (CPU 拷贝 ②)
4. socket 缓冲区 -> 网卡      (DMA 拷贝,不占 CPU)

两次 CPU 拷贝,四次上下文切换(每对 read/write 各一次内核态往返)。

对于一个 10Gbps 的网卡、每秒传 1GB 数据,这就是每秒 2GB 的内存拷贝——纯粹在浪费 CPU 和内存带宽。

方案一:mmap

mmap 的思路是:把文件映射到进程的地址空间,读文件就变成读内存。

use std::os::unix::io::AsRawFd;
 
pub struct MappedFile {
    ptr: *mut u8,
    len: usize,
}
 
impl MappedFile {
    pub fn open(path: &str) -> std::io::Result<Self> {
        let file = std::fs::File::open(path)?;
        let len = file.metadata()?.len() as usize;
        let fd = file.as_raw_fd();
 
        let ptr = unsafe {
            libc::mmap(
                std::ptr::null_mut(),
                len,
                libc::PROT_READ,
                libc::MAP_PRIVATE,
                fd,
                0,
            )
        };
 
        if ptr == libc::MAP_FAILED {
            return Err(std::io::Error::last_os_error());
        }
 
        Ok(Self { ptr: ptr as *mut u8, len })
    }
 
    pub fn as_slice(&self) -> &[u8] {
        unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
    }
}
 
impl Drop for MappedFile {
    fn drop(&mut self) {
        unsafe {
            libc::munmap(self.ptr as *mut _, self.len);
        }
    }
}

用起来就像读一个 &[u8]:

let mapped = MappedFile::open("index.dat")?;
let header = &mapped.as_slice()[0..16];

mmap 省掉了哪次拷贝?

发送文件时(mmap + write):
1. 磁盘 -> 内核页缓存        (DMA)
2. ——— 没有用户态拷贝 ———    (mmap 让用户态直接看到页缓存)
3. 内核页缓存 -> socket 缓冲  (CPU 拷贝 ①)
4. socket 缓冲区 -> 网卡      (DMA)

从两次 CPU 拷贝降到一次。 而且"窗口"是页缓存,多个进程可以共享同一份物理页——这对读多写少的场景(比如多个进程读同一个索引文件)是巨大的内存节省。

mmap 的三个坑

1. 缺页异常(page fault)。 mmap 不是"把文件读进内存",它只是建立了映射。真正访问某个页时才触发缺页中断,从磁盘读进来。

这意味着:

首次遍历 mmap 区域 -> 每次缺页都是一次磁盘 IO

对于顺序扫描,mmap 的性能可能反而不如 read。 因为 read 可以预读(readahead),而缺页是一条条触发的。内核的 madvise(MADV_SEQUENTIAL) 可以缓解。

2. SIGBUS 而不是错误码。 如果映射的文件被另一个进程截断,访问越界的页会收到 SIGBUS 信号——进程直接崩,你没法 catch 成 Result。

这是 mmap 用于"共享文件"时最危险的特性。任何可能被外部修改的文件,用 mmap 都要非常谨慎。

3. 写入时机不可控。 MAP_SHARED 的写会由内核在某个时刻刷回磁盘(和前面 WAL 那篇讲的 fsync 问题一样):

// 想要"写立即可靠",必须显式同步
unsafe {
    libc::msync(ptr as *mut _, len, libc::MS_SYNC);
}

这就回到了那个核心问题:write 到 mmap 区域,和 write 到页缓存一样,都还没落盘。

mmap 省的是"用户态拷贝",不是"持久化时机"。 用 mmap 做存储时,msync 的调用点才是决定可靠性边界的地方。

方案二:sendfile

如果目标只是"把文件直接通过 socket 发出去",mmap 还是多了一次拷贝。sendfile 把这个场景做到了极致:

pub fn send_file(socket: &std::net::TcpStream, file: &std::fs::File) -> std::io::Result<u64> {
    use std::os::unix::io::AsRawFd;
 
    let in_fd = file.as_raw_fd();
    let out_fd = socket.as_raw_fd();
 
    let mut offset = 0i64;
    let remaining = file.metadata()?.len() as usize;
 
    let sent = unsafe {
        libc::sendfile(
            out_fd,
            in_fd,
            &mut offset,
            remaining,
        )
    };
 
    if sent < 0 {
        return Err(std::io::Error::last_os_error());
    }
    Ok(sent as u64)
}

sendfile 之后:

1. 磁盘 -> 内核页缓存        (DMA)
2. 内核页缓存 -> 网卡        (DMA,如果网卡支持 SG-DMA)

零次 CPU 拷贝,零次上下文切换。 这就是"零拷贝"这个名字的来源——数据完全没有进入用户态。

sendfile 是 Nginx 静态文件服务的核心优化。开启 sendfile on 之后,静态文件的吞吐能翻倍。

方案三:splice——管道连接两个 fd

sendfile 只能在"文件 → socket"这个方向用。splice 更通用:在两个 fd 之间搬数据,中间必须经过一个管道。

pub fn splice_stream(
    from: &std::net::TcpStream,
    to: &std::net::TcpStream,
) -> std::io::Result<u64> {
    use std::os::unix::io::{AsRawFd, FromRawFd};
 
    // 创建管道
    let mut pipe_fds = [0i32; 2];
    if unsafe { libc::pipe(pipe_fds.as_mut_ptr()) } < 0 {
        return Err(std::io::Error::last_os_error());
    }
 
    const BUF_SIZE: usize = 64 * 1024;
    let mut total = 0u64;
 
    loop {
        // socket -> pipe
        let n = unsafe {
            libc::splice(
                from.as_raw_fd(),
                std::ptr::null_mut(),
                pipe_fds[1],
                std::ptr::null_mut(),
                BUF_SIZE,
                libc::SPLICE_F_MOVE | libc::SPLICE_F_MORE,
            )
        };
 
        if n <= 0 {
            break;
        }
 
        // pipe -> socket
        let mut written = 0isize;
        while written < n {
            let w = unsafe {
                libc::splice(
                    pipe_fds[0],
                    std::ptr::null_mut(),
                    to.as_raw_fd(),
                    std::ptr::null_mut(),
                    (n - written) as usize,
                    libc::SPLICE_F_MOVE | libc::SPLICE_F_MORE,
                )
            };
            if w <= 0 {
                return Err(std::io::Error::last_os_error());
            }
            written += w;
        }
 
        total += n as u64;
    }
 
    unsafe {
        libc::close(pipe_fds[0]);
        libc::close(pipe_fds[1]);
    }
 
    Ok(total)
}

splice 的用途是"代理":它让一个反向代理可以在完全不碰数据内容的情况下转发流量。前面写过反向代理那篇,性能版本的转发就应该用 splice。

SPLICE_F_MOVE 这个标志很关键:它告诉内核"如果可以,直接移动页引用,不要拷贝内容"。没有它,splice 仍然是一次普通拷贝。

方案四:io_uring——把提交和完成也省掉

前面三种方案省的是"数据拷贝",但每次调用还是要一次系统调用。高 IOPS 场景下,系统调用本身成了瓶颈。

io_uring 的思路是把"提交请求"和"获取完成"都做成共享内存的环形队列:

应用                      内核
  │                        │
  ├── 提交队列 (SQ) ──────>│  应用往 SQ 写请求,不需要系统调用
  │                        │
  │<── 完成队列 (CQ) ──────┤  内核往 CQ 写结果

应用只需要:

  1. 往 SQ 里写一条请求
  2. (可选)一次 io_uring_enter 通知内核
  3. 轮询 CQ 看有没有完成

批量提交时一次系统调用能提交上千个请求。 这是 io_uring 相对 epoll 的根本优势:epoll 是"事件通知",io_uring 是"完整异步 IO 接口"。

在 Rust 生态里,tokio-uring 和 io-uring crate 提供了封装。但要注意:io_uring 依赖较新的内核(5.1+,稳定特性需要 5.6+),部署环境要确认。

把这些放回一个真实场景

一个文件下载服务,四种实现的对比:

实现 CPU 拷贝次数 系统调用/64KB 适用
read + write 2 2 简单、需要处理数据
mmap + write 1 2 需要读文件内容做处理
sendfile 0 1 纯转发,不碰内容
splice 0 2(管道两侧) 代理转发流

选择的核心问题是:"我需不需要看这份数据?"

  • 需要看(解析、过滤、加密)→ 只能用 read/write 或 mmap,数据必须进用户态
  • 不需要看(静态文件、代理转发)→ 用 sendfile / splice

"零拷贝"的前提是"你不碰数据"。 一旦需要处理内容,拷贝就不可避免——能做的只是减少次数(mmap)和优化时机(预读)。

Rust 里的实际 API

std 层面:

// 标准库的 copy 已经在内部用了 sendfile(Linux 上)
std::io::copy(&mut file, &mut socket)?;

这是个容易被忽略的点:std::io::copy 在 Linux 上会先尝试 copy_file_range / sendfile,失败才退回 read+write。所以很多时候你不需要自己调 sendfile,标准库已经做了。

需要显式控制时用 nix 或 libc:

// nix crate 的封装更友好
use nix::sys::sendfile::sendfile;
let sent = sendfile(out_fd, in_fd, Some(&mut offset), count)?;

结论

零拷贝的本质是把数据流转的每一段路都数清楚:

read + write 是 2 次 CPU 拷贝 + 4 次上下文切换;mmap 把它降到 1 次拷贝;sendfile 把纯转发场景降到 0 次拷贝 + 1 次系统调用;io_uring 把系统调用本身也批量化了。

三条实践原则:

  1. 不需要看数据就用 sendfile/splice,这是收益最大、风险最小的一步
  2. mmap 要小心 SIGBUS 和 msync 时机,它省的是拷贝不是持久化
  3. std::io::copy 已经内置了优化,先测量再手写 syscall

理解这些之后,你会明白 Nginx 配置里 sendfile on、tcp_nopush on、directio 这些开关到底在调什么——它们都在控制"数据经过几层"和"什么时候真正落盘"这两件事。