IO_uring

最新推荐文章于 2025-06-09 23:10:12 发布
最新推荐文章于 2025-06-09 23:10:12 发布
阅读量502 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： c/c++Linux服务器架构学习笔记 文章标签： c语言 c++ 开发语言
原文链接：https://blog.csdn.net/dillanzhou/article/details/109459544
本文详细介绍了io_uring接口的结构，包括SubmissionQueueEntry和CompletionQueueEvent，以及关键函数如io_uring_setup、io_uring_enter和io_uring_register。讲解了如何创建、操作和管理io环，以及liburing的简化使用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

io_uring 的接口

io_uring使用两个队列来传递IO请求和完成情况，这两个队列中的元素结构如下：

 // Submission Queue Entry
struct io_uring_sqe {
   __u8 opcode;        //请求类型，例如IORING_OP_READV
   __u8 flags;         //
   __u16 ioprio;       //优先级，和ioprio_set系统调用的作用类似
   __s32 fd;           //需要操作的文件fd
   __u64 off;          //文件偏移位置
   __u64 addr;         //读写数据地址，如果是readv/writev请求则是iovec数组地址
   __u32 len;          //读写数据长度，如果是readv/writev请求则是iovec数组长度
   union {
     __kernel_rwf_t rw_flags;    //请求相关的选项，其含义与对应的blocking syscall相同，例如preadv2
     __u32 fsync_flags;
     __u16 poll_events;
     __u32 sync_range_flags;
     __u32 msg_flags;   
   };
   __u64 user_data;    //使用者任意指定的字段，在复制到对应的cqe中，一般用于标识cqe与sqe的对应关系。
   union {
     __u16 buf_index;
     __u64 __pad2[3];
   };
};
 
// Completion Queue Event
struct io_uring_cqe {
   __u64 user_data;    //来自对应的sqe中的user_data字段
   __s32 res;          //请求处理结果，和普通IO操作的返回值差不多。一般成功时返回字节数，处理失败时返回-errno。
   __u32 flags;        //暂未使用
};

int io_uring_setup

int io_uring_setup(unsigned entries, struct io_uring_params *params);

这个函数返回一个io_uring的fd，后续通过这个fd来操作io_uring。entries是创建出的io_uring中包含的sqe（请求）数量，必须是1-4096间的2的幂级数。io_uring_params是一个与内核的交互参数，用户态调用者在其中指定需要的参数，内核也在其中反馈实际创建的情况，其定义和解释如下：


struct io_uring_params {
    __u32 sq_entries;                    /* IO请求sqe数量，内核输出 */
    __u32 cq_entries;                    /* IO完成事件cqe数量，内核输出 */
    __u32 flags;                         /* io_uring运行模式和配置，调用者输入 */
    __u32 sq_thread_cpu;
    __u32 sq_thread_idle;
    __u32 resv[5];                       /* 预留空间，用于对其cacheline，同时为将来扩展留下空间 */
    struct io_sqring_offsets sq_off;     /* sqe队列的偏移地址 */
    struct io_cqring_offsets cq_off;     /* cqe队列的偏移地址 */
};
 
struct io_sqring_offsets {
   __u32 head;            /* offset of ring head */
   __u32 tail;            /* offset of ring tail */
   __u32 ring_mask;       /* ring mask value */
   __u32 ring_entries;    /* entries in ring */
   __u32 flags;           /* ring flags */
   __u32 dropped;         /* number of sqes not submitted */
   __u32 array;           /* sqe index array */
   __u32 resv1;
   __u64 resv2;
};

这里需要关注的是io_sqring_offsets和io_cqring_offsets。这是内核分配的ring结构中需要用户态操作部分的相对偏移，用户态程序需要使用mmap将ring结构的内存映射到用户态来供后续交互：

struct app_sq_ring {
    unsigned *head;
    unsigned *tail;
    unsigned *ring_mask;
    unsigned *ring_entries;
    unsigned *flags;
    unsigned *dropped;
    unsigned *array;
};
 
struct app_sq_ring app_setup_sq_ring(int ring_fd, struct io_uring_params *p)
{
    struct app_sq_ring sqring;
    void *ptr;
    ptr = mmap(NULL, p→sq_off.array + p→sq_entries * sizeof(__u32),
    PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
    ring_fd, IORING_OFF_SQ_RING);
    sring→head = ptr + p→sq_off.head;
    sring→tail = ptr + p→sq_off.tail;
    sring→ring_mask = ptr + p→sq_off.ring_mask;
    sring→ring_entries = ptr + p→sq_off.ring_entries;
    sring→flags = ptr + p→sq_off.flags;
    sring→dropped = ptr + p→sq_off.dropped;
    sring→array = ptr + p→sq_off.array;
    return sring;
}

这里的一个疑问是为什么要让用户态程序再调用一次mmap，而不是在内核中就将地址映射好直接返回，这显然让接口的使用复杂度上升了很多。笔者认为这么做唯一的意义在于尽量保留了用户态程序对地址空间的控制力，可能在一些特殊场景下程序会需要特定的地址空间用于特殊用途，内核直接映射可能引入难以发现的问题。为了解决接口易用性的问题，liburing中封装了io_uring_queue_init接口，对于没有上述特殊需求的程序，直接使用这个接口即可。

io_uring_enter

int io_uring_enter(unsigned int fd, unsigned int to_submit, unsigned int min_complete, unsigned int flags, sigset_t sig);

在程序向sqring，即请求队列中插入了IO请求后，需要通知内核开始处理，这时就需要调用io_uring_enter。参数中的fd是io_uring的fd，to_submit是提交的IO请求数。

min_complete可以用来阻塞等待内核完成特定数量的请求，前提是flags中设置IORING_ENTER_GETEVENTS。这个功能可以单独调用来等待内核处理完成。需要注意的是由于采用共享内存队列的方式来同步请求完成情况，因此程序也可以不使用这个接口而是直接判断cqring的状态来获取IO完成情况并处理cqring中的完成事件。

io_uring_register

int io_uring_register(unsigned int fd, unsigned int opcode, void *arg, unsigned int nr_args);

IORING_REGISTER_FILES。内核异步处理sqe请求时，需要保证fd不会在处理过程中被关闭，因此需要在开始处理前增加fd引用计数，结束后再减少。而调用这个接口后就可以避免这种反复的引用计数操作。在调用后指定的文件fd的引用计数会增加，后续提交请求时只要在sqe的flags中指定IOSQE_FIXED_FILE就不会再修改引用计数。如果不再需要操作这个fd，可以用IORING_UNREGISTER_FILES这个opcode解除注册。
IORING_REGISTER_BUFFERS。在使用O_DIRECT模式时，内核需要先映射用户态的页面，处理完后再解除映射，这也是一种重复开销。使用这个opcode后，就可以把指定的buffer页面固定映射到内核中，处理请求时就不需要反复映射、解除映射

// io_uring, tcp server
// multhread, select/poll, epoll, coroutine, iouring
// reactor
// io 

#include <liburing.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#define ENTRIES_LENGTH		4096

enum {

	READ,
	WRITE,
	ACCEPT,

};

struct conninfo {
	int connfd;
	int type;
};

void set_read_event(struct io_uring *ring, int fd, void *buf, size_t len, int flags) {
	struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
	io_uring_prep_recv(sqe, fd, buf, len, flags);
	struct conninfo ci = {
		.connfd = fd,
		.type = READ
	};
	memcpy(&sqe->user_data, &ci, sizeof(struct conninfo));
}

void set_write_event(struct io_uring *ring, int fd, const void *buf, size_t len, int flags) {
	struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
	io_uring_prep_send(sqe, fd, buf, len, flags);
	struct conninfo ci = {
		.connfd = fd,
		.type = WRITE
	};
	memcpy(&sqe->user_data, &ci, sizeof(struct conninfo));
}

void set_accept_event(struct io_uring *ring, int fd,
	struct sockaddr *cliaddr, socklen_t *clilen, unsigned flags) {
	struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
	io_uring_prep_accept(sqe, fd, cliaddr, clilen, flags);
	struct conninfo ci = {
		.connfd = fd,
		.type = ACCEPT
	};
	memcpy(&sqe->user_data, &ci, sizeof(struct conninfo));

}

int main() {
	int listenfd = socket(AF_INET, SOCK_STREAM, 0);  // 
    if (listenfd == -1) return -1;
// listenfd
    struct sockaddr_in servaddr, clientaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(9999);
    if (-1 == bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
            return -2;
    }
	listen(listenfd, 10);
	struct io_uring_params params;
	memset(&params, 0, sizeof(params));
// epoll --> 
	struct io_uring ring;
	io_uring_queue_init_params(ENTRIES_LENGTH, &ring, &params);
	socklen_t clilen = sizeof(clientaddr);
	set_accept_event(&ring, listenfd, (struct sockaddr*)&clientaddr, &clilen, 0);
	char buffer[1024] = {0};
//
	while (1) {
		struct io_uring_cqe *cqe;
		io_uring_submit(&ring);
		int ret = io_uring_wait_cqe(&ring, &cqe);
		struct io_uring_cqe *cqes[10];
		int cqecount = io_uring_peek_batch_cqe(&ring, cqes, 10);
		int i = 0;
		unsigned count = 0;
		for (i = 0;i < cqecount;i ++) {
			cqe = cqes[i];
			count ++;
			struct conninfo ci;
			memcpy(&ci, &cqe->user_data, sizeof(ci));
			if (ci.type == ACCEPT) {
				int connfd = cqe->res;
				set_read_event(&ring, connfd, buffer, 1024, 0);
			} else if (ci.type == READ) {
				int bytes_read = cqe->res;
				if (bytes_read == 0) {
					close(ci.connfd);
				} else if (bytes_read < 0) {
				} else {
					printf("buffer : %s\n", buffer);
					set_write_event(&ring, ci.connfd, buffer, bytes_read, 0);
				}
			} else if (ci.type == WRITE) {
				set_read_event(&ring, ci.connfd, buffer, 1024, 0);
			}
		}
		io_uring_cq_advance(&ring, count);
	}
}

liburing

上文中提到，由于io_uring要实现强大的功能和最优的效率，因此其接口和使用方式会比较复杂。但对于大部分不需要极致IO性能的场景和开发者来说，只使用io_uring的基本功能就能获得大部分的性能收益。当只需要基本功能时，io_uring的复杂接口中很大一部分是不会使用的，同时一部分初始化操作也是基本不变的。因此，io_uring的作者又开发了liburing来简化一般场景下io_uring的使用。使用liburing后，io_uring初始化时的大部分参数都不再需要填写，也不需要自己再做内存映射，内存屏障和队列管理等复杂易错的逻辑也都封装在liburing提供的简单接口中，大幅降低了使用难度。
io_uring的创建与销毁

在liburing中封装了io_uring的创建与销毁操作接口，几乎不需要指定任何参数即可完成创建：

  1. struct io_uring ring;

  2. io_uring_queue_init(ENTRIES, &ring, 0);

  3. io_uring_queue_exit(&ring);

提交请求与处理完成事件

struct io_uring_sqe sqe;
struct io_uring_cqe cqe;
/* get an sqe and fill in a READV operation */
sqe = io_uring_get_sqe(&ring);
io_uring_prep_readv(sqe, fd, &iovec, 1, offset);
/* tell the kernel we have an sqe ready for consumption */
io_uring_submit(&ring);
/* wait for the sqe to complete */
io_uring_wait_cqe(&ring, &cqe);
/* read and process cqe event */
app_handle_cqe(cqe);
io_uring_cqe_seen(&ring, cqe);

上面这段代码是io_uring作者提供的样例，其中体现了几个关键操作接口：

io_uring_get_sqe(&ring)，从请求队列中获取一个空闲的请求结构。
io_uring_prep_readv(sqe, fd, &iovec, 1, offset)，构造一个readv读请求。
io_uring_submit(&ring)，将请求提交给内核。
io_uring_wait_cqe(&ring, &cqe)，等待请求完成。这是一个阻塞操作，还有一个非阻塞版本：io_uring_peek_cqe。
io_uring_cqe_seen(&ring, cqe)，通知内核已经完成对完成事件的处理。

通过这些接口，开发者已经能够很容易的写出异步IO的代码。

Linux高性能异步I/O接口io_uring
lingshengxiyou的博客
03-24 440
io_uring这样原生的异步接口直接就能够采用proactor这样的主动通知模式，减少了轮询的开销，同时还能够设置内核线程自动提交SQE中的任务，理论上io_uring的IO性能一定是超过epoll接口和reactor模式的。通过上面的介绍，我们其实可以发现，如果普通应用程序运行的用户态需要访问硬件设备，或者访问网络，读取磁盘文件时，那就必须通过调用Linux提供的系统API，将命令参数压入用户态的应用栈中，系统调用将应用栈中命令参数取到内核执行栈中，在内核态中执行指令。这就是内核和用户态的上下文切换。
uring:用于io_uring框架的Golang库（无CGO）
05-23
用于io_uring框架的Golang库（无CGO） io_uring是异步IO的新内核接口。 最好的介绍是。 请注意，该库主要在5.8。*内核上进行了测试。 虽然该库的核心未使用任何新功能，但将通过io_uring在内核上工作，该io_uring...
io_uring
平面到立体
07-16 290
io_uring 原始文档的学习及发掘应用场景
liburing的接口分类
最新发布
m0_51149023的博客
06-09 485
liburing的接口分类
异步IO -- io_uring
A152419的博客
04-11 1145
io_uring是一种高效的 Linux 输入/输出（I/O）子系统，用于提高异步I/O的性能和灵活性。它提供了一种比传统的 POSIX 异步 I/O 接口更高效和可扩展的方法来执行文件操作、网络通信等任务。
io_uring简单了解
iUcool的博客
08-15 3090
当我们进行一个系统调用，用户层的应用程序调用内核，它在内核空间中复制数据。在内核完成执行之后，它将结果复制回用户空间缓冲区。然后它返回。在这段时间内，系统调用仍然被阻塞那么如何解决多次复制和同步问题呢由此便引出了io_uringio_uring是2019年Linux5.1内核首次引入的高性能异步IO框架，能显著带来加速IO密集型应用的性能但相比正确使用的AIO可能最多只有5%的提升io_uring来自于Jens Axboe的观察——随着设备越来越快，中断驱动效率已经低于轮训模式。............
io_uring、liburing
GHL284271090的博客
10-30 1828
io_uring是linux内核中高效的异步I/O框架，Linux内核5.1引入，用于提高I/O的性能。liburing是基于io_uring封装的库，提供更简洁的api。
xe:结合使用io_uring和C ++ 20协程支持，实现超快速IO事件循环
03-28
结合使用io_uring和C ++ 20协程支持，实现超快速I / O事件循环 建筑 先决条件 cmake sudo apt install cmake 具有协程支持的g ++ / clang ++ 建造 1. mkdir build ; cd build 2. cmake -DCMAKE_BUILD_TYPE= " ...
io-uring:Rust的io_uring库
05-01
要使用io-uring板条箱，请首先将其添加到Cargo.toml ： [ dependencies ] io-uring = " 0.5 " 接下来，我们可以开始使用io-uring板条箱。 以下是使用“ Read文件”的快速介绍。 use io_uring :: {opcode, types, ...
Efficient IO with io_uring
09-23
《高效IO：深入理解io_uring》 在Linux操作系统中，进行文件I/O操作有多种方式。最初的且最基础的是read(2)和write(2)系统调用，随后增加了带有偏移量参数的pread(2)和pwrite(2)，接着又有了基于向量的preadv(2)和...
zestginx:Zest Projects的NGINX分支通过将功能从HTTP3支持添加到AIO的io_uring后端来扩展Web服务器。目前，它是由Chaotic-AUR为Arch Linux构建的，可通过以下网址在AUR上找到：
03-18
IO_Uring作为AIO后端。 OCSP对BoringSSL的支持。 SNI不匹配的安静握手拒绝。 除上述内容外，Zestginx的预构建还进行了其他一些更改，例如： Brotli对NGINX的压缩支持。 Cloudflare的Zlib，可实现更快的GZip。 ...
iouring-go:io_uring对go的支持
03-21
io_uring去 正在进行的工作该库添加了对 for Go的支持。这个库类似于 。如果您想贡献自己的力量来发送PR或电子邮件，则有很多事情需要清理。另外，也请查看的库，以获取类似的方法。理想情况下，将这些方法添加到Go运行时以实现最佳效率，因此这些库更像是POC，请参见。 与提交/完成队列进行交互 设计 设计该库的目的是，如果您想使用自己的实现来处理提交/完成，则所有内容都可以使用。另外， Ring结构上也有一些辅助方法，这些方法也可以与标准库接口交互。还有一个用于创建net.Listener的接口，但是它仍在进行中。 提交队列 提交和完成队列都被映射为切片，然后问题就变成了如何设计一个高效的API，该API也能够与许多标准库接口进行交互。一种选择是运行后台goroutine，该goroutine管理队列中的所有操作并使用通道对请求进行排队。这种方法的缺点是通道设计中的可能使其对于高吞吐
Linux IO模式之io_uring
大隐隐于野
12-18 1798
作为科普性质的文章，在介绍 io_uring 之前，我们可以先整体看一下 linux 的 IO 模型大体有哪些类型。图 1.1从图 1.1 中可以看出，linux 的 IO 主要可以分为两个大类，而我们今天要介绍的 io_uring 就属于其中的 kernel IO 模型中的 async IO 模式的一种。
Vagrant-io_uring
Fawkess的博客
04-14 245
一个基于io_uring的服务器，可供学习。 https://github.com/fawkesLi-lhh/Vagrant-io_uring/ （ps：这大概是全网第一个demo吧，哈哈哈哈哈哈）
【译】高性能异步 IO —— io_uring (Effecient IO with io_uring)
IceberGu的博客
10-23 2452
本文的目的是介绍最新的 Linux 异步 IO 接口 io_uring ，并将其与现有产品进行比较。 我们将探讨其存在的原因，它的内部工作原理以及开放给用户的接口。 本文不会讨论特定命令之类的细节，这些都可以查看相关 man 文档或者 lord of the io_uring，我们会介绍 io_uring 及其工作原理，希望读者可以更深刻的理解。 本文和 man 之间会有一些重叠，如果不提供这些细节就无法提供对 io_uring 的描述 介绍 Linux 中有很多方法可以执行基于文件的 IO，最古老和基本的
io_uring概要
weixin_40915836的博客
09-05 959
在 liburing 库和 Linux 的 io_uring 接口中，io_uring_sq（提交队列，Submission Queue）、io_uring_cq（完成队列，Completion Queue）和 io_uring 结构体各自扮演着关键的角色，它们共同构成了 io_uring 异步 I/O 框架的基础。用户空间程序通过设置SQE的不同字段来指定要执行的I/O操作。Linux社区开发的一种新型异步I/O框架，通过提供高度可扩展和高性能的异步I/O接口，有效解决了传统异步I/O框架中的性能瓶颈。
io_uring 新异步 IO 机制，性能提升超 150%，堪比 SPDK
云布道师
08-05 2434
凌云时刻 · 技术导读：Alibaba Cloud Linux 2 是阿里云操作系统团队基于开源 Linux 4.19 LTS 版本打造的一款针对云应用场景的下一代 Linux OS 发...
网络编程 io_uring
xiaofeilongyu的博客
03-01 1424
io_uring高性能网络I/O处理
io_uring c++
12-29
### 如何在C++中使用io_uring进行异步IO操作 #### 创建和初始化io_uring实例 为了利用`io_uring`执行异步I/O，在程序启动之初需先建立一个`io_uring`对象。此过程涉及指定参数，如入口数量等配置项[^3]。 ```cpp #include <liburing.h> struct io_uring ring; int ret; ret = io_uring_queue_init(32, &ring, 0); if (ret < 0) { perror("queue init failed"); } ``` 这段代码展示了如何导入必要的头文件并尝试创建具有默认选项的`io_uring`队列，其中包含了最多32个待处理的操作请求。 #### 提交读写请求到SQ（提交队列） 一旦有了可用的`io_uring`结构体，就可以准备向其提交具体的I/O指令了。对于简单的文件读取来说： ```cpp struct iovec iov; iov.iov_base = buf; // 假设buf是一个预分配好的缓冲区地址 iov.iov_len = sizeof(buf); struct io_uring_sqe *sqe = io_uring_get_sqe(&ring); io_uring_prep_read(sqe, fd, &iov, 1, offset); // 文件描述符fd，偏移量offset由外部提供 ``` 这里定义了一个`iovec`类型的变量用来表示数据传输的目标位置，并通过`io_uring_prep_read()`函数设置好相应的读取命令给定至特定文件的位置上。 #### 获取已完成的任务结果 当应用程序准备好检查是否有任何已结束的任务时，则可以从CQ（完成队列）里提取信息出来： ```cpp struct io_uring_cqes cqe; unsigned head; while ((head = io_uring_peek_batch_cqe(&ring, &cqe, 1)) != UINT_MAX) { struct io_uring_cqe *cqeptr = &cqe[0]; if (cqeptr->res >= 0) { /* 成功 */ } else { /* 失败 */ } io_uring_cq_advance(&ring, 1); } // 完成所有事件处理后记得同步队列状态 io_uring_submit_and_wait(&ring, 1); ``` 上述片段说明了怎样循环遍历当前存在的完成条目列表，并依据返回的状态码判断每次操作的成功与否。最后一步确保即使没有新的任务加入也能让CPU知道我们已经完成了现有工作的确认工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值