用 Rust 从零实现 mmap 与零拷贝 IO:sendfile 到底省了什么
"零拷贝"这个名字非常有误导性——数据当然还是会被拷贝,只是不再经过用户态。
一个静态文件服务器要把磁盘上的文件发给客户端,朴素写法是:
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 写结果应用只需要:
- 往 SQ 里写一条请求
- (可选)一次
io_uring_enter通知内核 - 轮询 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 把系统调用本身也批量化了。
三条实践原则:
- 不需要看数据就用 sendfile/splice,这是收益最大、风险最小的一步
- mmap 要小心 SIGBUS 和 msync 时机,它省的是拷贝不是持久化
std::io::copy已经内置了优化,先测量再手写 syscall
理解这些之后,你会明白 Nginx 配置里 sendfile on、tcp_nopush on、directio 这些开关到底在调什么——它们都在控制"数据经过几层"和"什么时候真正落盘"这两件事。