从 epoll 到 io_uring:等待的成本,和一次语义错位
TL;DR
上一篇拆完 async fn 的状态机,留了两个坑:epoll 在高并发下到底卡在哪,io_uring 会不会把 reactor 干掉。
这篇一起补。答案分别是:
- epoll 不卡在
epoll_wait里,卡在它前后那两段路上; - reactor 不会被干掉,但 io_uring 会把它换个形状。
阻塞 read:一万条连接 = 一万个睡着的线程
→ select/poll:一次等一批,但每次都得把整个集合重报一遍
→ epoll:注册一次,内核记住,只报就绪的
→ 可它只说「现在读不会阻塞」,数据还得你自己搬
→ Linux AIO 想连搬也代劳,可惜只对 O_DIRECT 有效
→ io_uring:提交队列 + 完成队列,内核连搬带通知
→ reactor 没消失,只是从「通知就绪」改成「通知完成」
真正的麻烦藏在最后一步。io_uring 给的是完成(completion)语义,而 Rust 的 Future 是照着就绪(readiness)语义长的。这两个词差一个字,落到 API 上就是 &mut [u8] 和「缓冲区的所有权必须交出去」的区别。
等待只有三个变量
把「等」这个动作拆开,其实就三个问题:谁停下来、谁去叫醒、醒了之后谁搬东西。
| 接口 | 谁停 | 谁叫 | 谁搬 |
|---|---|---|---|
阻塞 read | 线程 | 内核(wake_up 唤醒队列) | 线程自己,在 read 里面 |
select/poll | 线程 | 内核 | 线程自己,再 read 一次 |
epoll | 线程(epoll_wait 里) | 内核回调 | 线程自己,再 read 一次 |
io_uring | 线程(可以不等) | 内核写 CQE | 内核 |
前三代有个共同点:内核只负责说「可以了」,read() 还是你自己发起的。
这不是偷懒。read(fd, buf, n) 的 buf 是用户态地址,内核只有在你调用的那一瞬间才知道它是谁。等你想让内核「顺手把数据也搬了」,就必须提前把地址告诉它。
io_uring 干的就是这件事,别的都是配套。
阻塞读:一个连接,一个睡着的线程
ssize_t n = read(fd, buf, len);
数据没到,内核大概这么走:
- 把线程挂到这个 fd 的
wait_queue_head_t上; - 状态改成
TASK_INTERRUPTIBLE,调schedule()让出 CPU; - 调度器挑下一个活干;
- 数据到了,网卡中断 → 软中断 → 协议栈 →
wake_up(),线程回到TASK_RUNNING; - 线程被重新调度,从
schedule()返回,复查条件,拷贝。
上一篇量过,两个线程 ping-pong 一次大概 1960ns。钱就花在这条路上:挂起一次内核陷进去,唤醒一次再陷进去,中间还过一遍调度器。
一万条连接就是一万份这个结构。所以真正的代价从来不是切换慢,是每一份等待都占着一个完整的调度实体和一块栈。为了等一个几百字节的包,先把 8MB 虚拟地址空间占了。
select 和 poll:能等一批,但每次都要重报
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
select(maxfd + 1, &rfds, NULL, NULL, NULL);
三个老毛病:
fd_set是位图,大小被FD_SETSIZE钉死在 1024。fd 号超了就没地方放。- 每次调用都得把整个位图拷进内核,回来再拷一遍。一万个 fd 是每次 1250 字节的来回,跟你实际有几个就绪毫无关系。
- 内核里没地方存「谁在等」,每次都从头扫。
poll 把位图换成数组,1024 的上限没了,另外两条原封不动。每次全量重传,每次内核全扫。
O(n) 里的 n 是注册总数,不是就绪数。一万个连接里三个活跃,照样扫一万次。
这背后的根子在于:select/poll 把「注册」和「等待」压进了同一个系统调用。只要这两件事捆在一起,就必然每次重报。想省掉,就得把注册拆出去,让内核常驻一份。
epoll:把等待搬进内核
int ep = epoll_create1(0);
struct epoll_event ev = { .events = EPOLLIN, .data.fd = fd };
epoll_ctl(ep, EPOLL_CTL_ADD, fd, &ev); // 注册一次,长期有效
struct epoll_event evs[64];
int n = epoll_wait(ep, evs, 64, -1); // 只返回就绪的
里面就两样东西
一棵红黑树,存所有注册过的 fd,epoll_ctl 增删改查 O(log n)。
一个就绪链表,存已经好了、还没被取走的。
注册的时候,内核顺手在这个 fd 的等待队列上挂一个 ep_poll_callback。fd 一旦就绪,回调被触发,把节点塞进就绪链表。于是 epoll_wait 只干两件事:链表非空就取一批,空了就自己睡。
复杂度 O(就绪数),跟总连接数脱钩。一万个连接三个活跃,它就只处理三个。
这一段经常被当成 epoll 的全部,然后得出「epoll 是 O(1)」的结论。不全对。
钱花在哪
上一篇那个问题,答案不在返回值里。
网卡中断(CPU 0)
→ 软中断 → 协议栈 → 数据进 socket 接收队列
→ ep_poll_callback():拿 ep->lock,把节点挂进 rdllist
→ wake_up() 叫醒 epoll 的等待者(可能得发 IPI 到另一个核)
worker(CPU 3)
→ 从 epoll_wait 出来,把就绪事件拷到用户态
→ 遍历事件:fd → runtime 里登记的对象 → 掏出 waker
→ waker.wake():把任务塞进某个 worker 的本地队列
→ 任务被调度,poll 一次,Ready,再 read() 把数据拷进来
中断在 CPU 0,处理在 CPU 3。中间至少两次缓存行改主:rdllist 的 head/tail 一次,任务的队列节点一次。这些一个都不在 epoll_wait 的返回值里,但都是真金白银。
还有一层更隐蔽的。rdllist 和 ep->lock 是每个 epoll 实例一份。多线程共用一个实例,所有 worker 抢同一把锁;每个 worker 各来一个,同一个 fd 又只能注册在其中一家,负载一偏就是一边饿死一边闲着。SO_REUSEPORT 在这几年这么流行,跟这个是同一个病根。
就绪不是完成
这个区别决定了上层所有 API 的形状,值得单独说一句。
epoll 报的是「你现在调
read不会阻塞」,不是「数据已经在你手里了」。
边界情况会露馅。「就绪」到你真正调 read,中间隔着一整个用户态,另一个线程完全可能先把数据叼走了。所以在 epoll 上做异步,read 必须能处理 EAGAIN。
epoll 默认水平触发,条件还在就会反复报,漏一次还有下一次,日子好过些。但语义上它始终是「就绪」,不是「完成」。这一点等到 io_uring 出场会变得很要命。
还剩两件事
epoll 把「通知」做到了极致,但有两样它管不着:
- 数据还得你自己搬。一次唤醒,后面跟一次
read系统调用,再加一次内存拷贝。三件事一件都省不掉。 - 每次操作还得一次系统调用。一万个就绪,就是一万次
read。
io_uring:连「做」也交出去
它先干掉的是 Linux AIO
很多人以为 io_uring 是来替 epoll 的。其实它第一个动手的对象是 Linux AIO(io_submit / io_getevents)。
那东西有两个硬伤:
- 只有
O_DIRECT的块设备是真异步。走页缓存的文件,提交的时候直接同步阻塞,等于没异步。这也是上一篇说「tokio 的文件 IO 其实是阻塞线程池」的原因:io_uring 之前,Linux 上压根没有通用的异步文件 IO。 - 提交一次系统调用,取完成又一次,批量能力约等于没有。
而且它跟 epoll 一样,是就绪思路的延长线,没碰「谁搬数据」。
两个环
io_uring 对外只有三个系统调用。核心想法土得掉渣:拿一块共享内存当队列,用户态和内核态互相传纸条,系统调用就省了。
用户态 内核态
┌──────────────┐ ┌──────────────┐
│ SQ: tail ───┼─── 写入 SQE ─→│ │
│ SQ: head ←──┼────────────┼── 消费 │
├──────────────┤ ├──────────────┤
│ CQ: tail ←──┼────────────┼── 写入 CQE │
│ CQ: head ───┼─── 读取 CQE ─→│ │
└──────────────┘ └──────────────┘
(两个环在同一段 mmap 里,SINGLE_MMAP)
- SQ:你往里填「要做什么」。一条 SQE 64 字节。
- CQ:内核往里写「做完了,结果这样」。一条 CQE 16 字节。
- 两边各自维护 head/tail,靠内存序同步,不上锁(单生产者单消费者)。
关键是:填 SQE 不是系统调用,只是往共享内存写 64 字节。
进内核的时机只有一个:把 tail 推出去、告诉内核有活干。这一次 io_uring_enter 能一口气干三件事:
- 提交一批(
to_submit); - 顺带等一批完成(
min_complete加IORING_ENTER_GETEVENTS); - 或者纯提交,不等。
开了 IORING_SETUP_SQPOLL 更省,内核起个线程盯着 tail,连这一下 enter 都免了。代价是常驻一个核。
手搓一遍
不碰 liburing,直接对着 linux/io_uring.h 写,才知道那层封装到底在遮什么。
系统调用入口就两行:
#include <linux/io_uring.h>
#include <sys/syscall.h>
#include <sys/mman.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
static int io_uring_setup(unsigned entries, struct io_uring_params *p) {
return syscall(__NR_io_uring_setup, entries, p);
}
static int io_uring_enter(int fd, unsigned submit, unsigned wait, unsigned flags) {
return syscall(__NR_io_uring_enter, fd, submit, wait, flags, NULL, 0);
}
初始化最多三次 mmap,换回八个指针:
struct ring {
unsigned *sq_head, *sq_tail, *sq_mask, *sq_array;
unsigned sq_entries;
unsigned pending; /* 已填写、尚未通知内核的 SQE 数 */
struct io_uring_sqe *sqes;
unsigned *cq_head, *cq_tail, *cq_mask;
struct io_uring_cqe *cqes;
int fd;
};
static void ring_init(struct ring *r, unsigned entries) {
struct io_uring_params p;
memset(&p, 0, sizeof(p));
r->fd = io_uring_setup(entries, &p);
if (r->fd < 0) { perror("io_uring_setup"); exit(1); }
r->sq_entries = p.sq_entries;
r->pending = 0;
/* 环里承载 SQE / CQE 的区域,外加 array 映射表 */
size_t sq_sz = p.sq_off.array + p.sq_entries * sizeof(unsigned);
size_t cq_sz = p.cq_off.cqes + p.cq_entries * sizeof(struct io_uring_cqe);
/* SINGLE_MMAP:SQ 环和 CQ 环在同一块物理页,映射一次就够 */
size_t sz = sq_sz > cq_sz ? sq_sz : cq_sz;
char *sq = mmap(NULL, sz, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_POPULATE, r->fd, IORING_OFF_SQ_RING);
char *cq = (p.features & IORING_FEAT_SINGLE_MMAP)
? sq
: mmap(NULL, cq_sz, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_POPULATE, r->fd, IORING_OFF_CQ_RING);
/* SQE 是定长 64 字节的连续数组,单独映射 */
r->sqes = mmap(NULL, p.sq_entries * sizeof(struct io_uring_sqe),
PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
r->fd, IORING_OFF_SQES);
/* 偏移量由内核给,写死会随版本炸 */
r->sq_head = (unsigned *)(sq + p.sq_off.head);
r->sq_tail = (unsigned *)(sq + p.sq_off.tail);
r->sq_mask = (unsigned *)(sq + p.sq_off.ring_mask);
r->sq_array = (unsigned *)(sq + p.sq_off.array);
r->cq_head = (unsigned *)(cq + p.cq_off.head);
r->cq_tail = (unsigned *)(cq + p.cq_off.tail);
r->cq_mask = (unsigned *)(cq + p.cq_off.ring_mask);
r->cqes = (struct io_uring_cqe *)(cq + p.cq_off.cqes);
}
ring_mask 的来历是个小约定:环大小向上取整到 2 的幂,于是 tail & mask 就是下标,不用取模。两个环宁可浪费一点空间,也要保住这个性质。
然后是填 SQE 和提交。这段我第一次写错了,值得展开。
static struct io_uring_sqe *get_sqe(struct ring *r) {
unsigned tail = *r->sq_tail + r->pending; /* 用户态自己记账 */
if (tail - *r->sq_head >= r->sq_entries) return NULL; /* 环满了 */
unsigned idx = tail & *r->sq_mask;
r->sq_array[idx] = idx; /* array 决定内核按什么顺序取 */
r->pending++;
return &r->sqes[idx];
}
static void submit_and_wait(struct ring *r, unsigned wait) {
/* 全部填完,才把 tail 写回共享内存 */
__atomic_store_n(r->sq_tail, *r->sq_tail + r->pending, __ATOMIC_RELEASE);
io_uring_enter(r->fd, r->pending, wait, IORING_ENTER_GETEVENTS);
r->pending = 0;
}
主流程:
int main(void) {
struct ring r;
ring_init(&r, 8);
int fd = open("/etc/hostname", O_RDONLY);
static char buf[256];
/* 第一条:NOP,先把环跑通 */
struct io_uring_sqe *sqe = get_sqe(&r);
memset(sqe, 0, sizeof(*sqe));
sqe->opcode = IORING_OP_NOP;
sqe->user_data = 1;
/* 第二条:READ,buf 的地址直接交给内核 */
sqe = get_sqe(&r);
memset(sqe, 0, sizeof(*sqe));
sqe->opcode = IORING_OP_READ;
sqe->fd = fd;
sqe->addr = (unsigned long)buf;
sqe->len = sizeof(buf);
sqe->off = 0;
sqe->user_data = 2;
submit_and_wait(&r, 1); /* 两条都交,但只等一条回来 */
/* 收 CQE。完成顺序不保证跟提交顺序一致,靠 user_data 认领 */
for (int got = 0; got < 2; got++) {
while (*r.cq_head == *r.cq_tail) { /* 完整实现还得处理等待 */
io_uring_enter(r.fd, 0, 1, IORING_ENTER_GETEVENTS);
}
struct io_uring_cqe *cqe = &r.cqes[*r.cq_head & *r.cq_mask];
printf("user_data=%llu res=%d\n",
(unsigned long long)cqe->user_data, cqe->res);
(*r.cq_head)++; /* 告诉内核:这条我取走了 */
}
return 0;
}
第一次跑,两条 READ
第一版里 get_sqe 是这么写的:直接读 *r->sq_tail 当下标,提交的时候才推进它。
跑出来是这样:
user_data=2 res=5
user_data=2 res=5
NOP 没了,两条 READ。盯着看一会儿就明白了:两次 get_sqe 之间 *r->sq_tail 一动没动,所以两次都返回 sqes[0]。第二条 memset 把第一条 NOP 整个盖掉,sq_array[0] 和 sq_array[1] 指向同一块内存。于是提交上去的是两条一模一样的 READ。
修法是加个 pending 计数,在用户态记账,提交时才把 tail 推出去。
这个坑不是笔误。sq_tail 一旦写进共享内存,就等于宣告「这一段归你了,拿去吧」。SQPOLL 模式下内核线程一直盯着它,你推早了,它就会去读一块还没填完的内存。liburing 在用户态缓存 head/tail,也是同一个理由。
几个绕不开的细节
user_data是唯一身份证。64 位整数,内核原样带回来。Rust 那边通常塞 slab 下标或者Arc<Task>的裸指针,CQE 一到就靠它找到 waker。相当于 epoll 的epoll_event.data。- 完成是乱序的。提交顺序 NOP、READ,回来不一定是这个顺序。所以
user_data不是图方便,是必需品。 res就是返回值,负数等于-errno。这里没有errno这回事。- 共用一块 mmap 说明 SQ 和 CQ 生死一致。这个信号挺明显:提交和完成是一体两面,不像 epoll 的注册表和就绪链表那样可以拆开看。
内存账
512 项的环:
SQE : 512 × 64B = 32 KB
array: 512 × 4B = 2 KB
CQE : 1024 × 16B = 16 KB (CQ 默认是 SQ 的两倍,防完成丢失)
─────────
50 KB ≈ 每条在途请求 100 字节
上一篇把「每个并发单元」的成本从 8MB 压到几百字节。这里换个算法:每条在途 IO 大概 100 字节,里面没有栈,没有调度实体,也没有一个睡着的线程。
CQ 取两倍不是大方,是因为完成可能比提交跑得还快。CQ 满了还有 CQE 要写,内核只能置 overflow 标志先攒着,等你腾地方再补。这是一条必须处理的错误路径,别当它不存在。
link 和 multishot
后面讲 Rust 要用到,先记住两个。
link:给 SQE 打上 IOSQE_IO_LINK,内核串行执行,前一个失败后面全取消。read → write 这种「把 A 搬到 B」不用再回用户态两趟。
multishot:一条 IORING_OP_ACCEPT_MULTISHOT 或 RECV_MULTISHOT 能产生多条 CQE,直到你取消。
第二个有意思。它把就绪语义又塞回了完成接口里。 一次提交、反复完成,这不就是 epoll_ctl 注册一次、反复上报的路子,只不过现在连搬运都在内核里做完了。
回到 Rust
poll 的语义就是 readiness
Future::poll 只问一件事:现在好了没有。返回 Pending 的时候带一条契约:将来一定得有人调 waker。
「还没好」=「条件没满足」=「有资格了再来问我」。这就是 readiness,一个字都不差。
所以这也不是谁抄谁。Future 的抽象边界正好卡在「通知」这一步,压根没管数据谁搬——因为它出生在 epoll 的世界里。
三种后端摆在一起,接口形状差得很明显:
| 后端 | poll 说 Ready 是什么意思 | 借用检查器看到什么 |
|---|---|---|
epoll | 现在 read 不会阻塞 | 借用只在 poll 内部,可以 &mut [u8] |
| 阻塞线程池 | 真读完了 | 同上,阻塞在别的线程 |
io_uring | 内核已经读完了 | buffer 在内核手里,碰不得 |
第三行就是所有麻烦的源头。
reactor 只换了事件源
epoll 后端:
任务 poll → 撞上 EAGAIN → 把 waker 登记到 fd 的槽位 → 返回 Pending
epoll_wait 回来 → fd 就绪 → 取出 waker → wake() → 任务回到队列
任务 poll → 这次 read 成功 → 返回 Ready
io_uring 后端:
任务 poll → 填一条 SQE(user_data = 任务 id)→ 返回 Pending
CQE 回来 → 按 user_data 找到 waker → wake()
任务 poll → 直接读 cqe->res → 返回 Ready
结构一模一样,只是事件源从「fd 就绪」换成了「CQE 到了」。
那最省事的接法就很明显:把 io_uring 的 fd 塞进现有的 epoll reactor。它的 fd 本身可 poll,CQ 里有货就变可读。
代价也很明显:省下来的那次 read,被一次 epoll_wait 换回去了。 绕一圈,还是在用 epoll 通知自己「有 CQE 了」。所以 tokio-uring 不这么干,它自己起一个线程阻塞在 io_uring_enter 上。
buffer 借不出去
真正的分水岭在两个签名上:
// tokio(readiness):借用
async fn read(&mut self, buf: &mut [u8]) -> io::Result<usize>;
// tokio-uring(completion):交出所有权
async fn read<T: IoBufMut>(&mut self, buf: T) -> BufResult<usize, T>;
tokio 敢借,因为它是就绪模型:poll 返回 Ready 的那一刻,数据早就被 read() 拷进 buffer 了,借用从来没跨过暂停点。
tokio-uring 必须拿走,因为 poll 返回 Pending 的时候,buf.as_mut_ptr() 已经在内核手上了。内核可以在你返回之后的任意时刻往那个地址写。 用户态这时候还能拿到 &mut [u8],就是 data race——还是内核参与的那种,编译器根本管不着。
Pin 在这里也跟着变了味道:
在
async fn的状态机里,buffer 是结构体的一个字段,地址等于 future 地址加一个固定偏移。所以Pin住 future,等于把交给内核的那个指针也钉死了。
epoll 时代,Pin 主要防「自引用状态机被搬走」;到了 io_uring,它还多了一重职责:保证内核手里那根裸指针不会失效。同一个类型,干两份活。
取消更麻烦。就绪模型下,取消就是不再 poll,干净利落。完成模型下,你得发一条 IORING_OP_ASYNC_CANCEL,然后等它的结果——因为在取消发出去之前,那个操作可能已经做完了。CQE 没回来就释放 buffer,内核就往已释放的内存里写。
所以 Rust 里所有 io_uring 封装都有这几个特征:Drop 里带 grace period,返回 BufResult,死活不给 &mut [u8]。不是他们代码写得丑,是完成语义逼的。
内核吃掉了一部分 executor
把前面两个特性拎出来看:
- link 把「两个 await」压成「一条 SQE 链」,状态机少一个变体,少一次唤醒;
- multishot 把「
epoll_ctl注册 + 反复wake」这一套整个搬进内核。
内核确实在抢 reactor 和 executor 的活。Future 也没被架空,只是理由换了。
有,但理由变了。内核交付的粒度是「一批操作做完了」,Future 表达的是一个任务活了一辈子:
- 组合:
select!、join!、timeout都在类型层面拼,内核压根不知道哪个 future 属于哪个任务; - 取消:
drop即取消,这套语义只有用户态定得了,内核只认 SQE; - 调度:任务之间的公平性、队列、偷取,内核一概不管;
- 抽象:同一份代码要能跑在 epoll 和 io_uring 上,中间就得有一层把「完成」糊成「就绪」的东西,那就是 reactor。
内核优化的是单次系统调用的往返,Future 优化的是逻辑任务的表达。层级都不一样,谈不上替代。
现实问题
写到这,io_uring 看着像个纯升级。但它有个绕不过去的坎:攻击面。
一个能在内核里长期攥着用户指针、文件引用,还允许你注册任意内存当 buffer 的接口,等于在内核里开了一整套新的生命周期管理。这些年出事的方向基本集中在几处:注册 buffer 和文件表的管理、SQE 链失败时的回滚、各个 opcode 的参数校验。
后果是三方面的:
- 能不能用先打个问号。Google 在 Android 上对第三方 App 禁了 io_uring,ChromeOS 和自家生产环境也关着,理由说得很直白:提权漏洞里出现频率太高,收益盖不住风险。不少容器运行时和发行版在 seccomp 里直接把
io_uring_setup拦了,云厂商也可能在宿主机上关掉。你写好的代码,到别人机器上可能直接EPERM。 - 出问题不好查。
strace只能看见一次io_uring_enter,具体提交了啥全在共享内存里,不进内核就看不见。既没有read那样的调用栈,也没有 epoll 那样干净的 fd 语义。 - 性能不是白给的。小 IO 场景,填 SQE 加收 CQE 未必比一次
read便宜。SQPOLL要占一个核,IOPOLL只对块设备有意义。网络路径上的大头通常是协议栈和内存拷贝,不是系统调用次数,批处理红利得在高 IOPS 下才吃得到。
所以它的位置很清楚:不是通用替代品,是给特定负载准备的刀。
怎么选
| 场景 | 选什么 | 为什么 |
|---|---|---|
| 普通网络服务,连接数万级 | epoll(tokio) | 生态熟、能观测、不赌内核配置 |
| 极高 IOPS,大量小请求 | io_uring | 批量提交,能省掉逐次系统调用 |
| 真正的异步文件 IO | io_uring | Linux 上没别的路,其他都是线程池假扮的 |
| 要发给任意客户端 | epoll | 对面可能根本没有 io_uring 权限 |
| 延迟敏感,想自己管调度 | io_uring + 自研 executor | SQPOLL 加绑核 |
几个常见坑:
- 以为 epoll 说可读就一定有数据。
EAGAIN必须处理,多线程共享 fd 时尤其如此。 - 用了边缘触发却不排空。ET 只在状态跳变时报一次,你不读到
EAGAIN,它永远不会再吭声。 - 以为 io_uring 的完成按提交顺序来。
user_data不是可选项。 - 取消完立刻释放 buffer。取消是异步的,CQE 可能在你释放之后才到。
- 给完成模型设计
&mut [u8]接口。编译器会拦你,别硬绕。
最后
上一篇留的两个问题,现在能答了。
epoll 的瓶颈确实不在 epoll_wait 里。它在中断上下文那次 ep_poll_callback,在跨核的 rdllist 争用,在返回之后「fd → waker → 队列 → 调度」那一串分发。扫早就不成问题了,问题是你把一万个等待合进内核,回头还得一个一个拆出来。
io_uring 也不会让 reactor 变得多余,它只是把 reactor 换了个形状。epoll 的 reactor 把「就绪」翻译成唤醒,io_uring 的把「完成」翻译成唤醒。翻译层一直在,变的只是源头:从「可以了」变成「做完了」。
真正被改写的是 Rust 这边。borrow checker、Pin、Drop,这三个东西的含义都跟着「谁攥着 buffer」一起变了。接口从就绪换到完成,看着是内核的事,其实把 Rust 内存安全模型的边界重新画了一遍。
下一步想看看 IORING_REGISTER_PBUF_RING(预注册 buffer 环)和 zero-copy 收发。那条路才是真的把拷贝也省掉,但 buffer 生命周期的复杂度得上一个台阶。
参考资料
- io_uring(7) —— 信息密度极高,配着
linux/io_uring.h一起啃 - epoll(7) —— 边缘触发那段逐字读
- Efficient IO with io_uring —— Jens Axboe 的原始设计文档,两个环和内存序讲得最清楚
- Lord of the io_uring —— 不依赖 liburing 的写法,这篇的代码大致沿这条线
- tokio-uring 源码 —— 看
BufResult和 slab 怎么把完成事件对回 future - The C10K problem —— 一切从这一万个连接开始
