社区编辑申请
注册/登录
从内核看IO_Uring的实现(一)
系统 Linux
最近研究了一下Linux的高性能异步IO框架io_uring,并尝试引入Node.js中应用起来。所以本文打算介绍一下io_uring在内核的实现,因为io_uring实现代码量大,逻辑复杂,所以只能慢慢分析。这一篇介绍io_uring初始化接口io_uring_setup的实现。

前言:最近研究了一下Linux的高性能异步IO框架io_uring,并尝试引入Node.js中应用起来。所以本文打算介绍一下io_uring在内核的实现,因为io_uring实现代码量大,逻辑复杂,所以只能慢慢分析。这一篇介绍io_uring初始化接口io_uring_setup的实现。

  1. static long io_uring_setup(u32 entries, struct io_uring_params __user *params){ 
  2.     struct io_uring_params p; 
  3.     int i; 
  4.  
  5.     if (copy_from_user(&p, params, sizeof(p))) 
  6.         return -EFAULT; 
  7.     // 支持的flag 
  8.     if (p.flags & ~(IORING_SETUP_IOPOLL | IORING_SETUP_SQPOLL | 
  9.             IORING_SETUP_SQ_AFF | IORING_SETUP_CQSIZE | 
  10.             IORING_SETUP_CLAMP | IORING_SETUP_ATTACH_WQ)) 
  11.         return -EINVAL; 
  12.  
  13.     return  io_uring_create(entries, &p, params); 

io_uring_setup是对io_uring_create的封装。第一个参数entries指定请求队列的长度,第二个参数params是用于调用方和内核通信的结构体。我们看一下定义。

  1. struct io_uring_params { 
  2.     // 定义请求队列长度(2的sq_entries次方),调用方定义 
  3.     __u32 sq_entries; 
  4.     // 完成队列长度,默认是2 * 请求队列长度 
  5.     __u32 cq_entries; 
  6.     // 控制内核行为的标记 
  7.     __u32 flags; 
  8.     // poll模式下开启的内核线程绑定的cpu 
  9.     __u32 sq_thread_cpu; 
  10.     // poll模式下开启的内核线程空闲时间,之后会挂起。 
  11.     __u32 sq_thread_idle; 
  12.     // 内核当前支持的能力,内核设置 
  13.     __u32 features; 
  14.     __u32 wq_fd; 
  15.     __u32 resv[3]; 
  16.     // 记录内核数据的结构体,调用方后续调用mmap需要用到。 
  17.     struct io_sqring_offsets sq_off; 
  18.     struct io_cqring_offsets cq_off; 
  19. }; 

我们接着看io_uring_create。

  1. static int io_uring_create(unsigned entries, struct io_uring_params *p, 
  2.                struct io_uring_params __user *params){ 
  3.     struct user_struct *user = NULL
  4.     struct io_ring_ctx *ctx; 
  5.     bool limit_mem; 
  6.     int ret; 
  7.  
  8.     p->sq_entries = roundup_pow_of_two(entries); 
  9.     // 自定义完成队列长度 
  10.     if (p->flags & IORING_SETUP_CQSIZE) { 
  11.         p->cq_entries = roundup_pow_of_two(p->cq_entries); 
  12.         // 完成队列不能小于请求队列 
  13.         if (p->cq_entries < p->sq_entries) 
  14.             return -EINVAL; 
  15.         // 超过阈值则需要设置IORING_SETUP_CLAMP标记 
  16.         if (p->cq_entries > IORING_MAX_CQ_ENTRIES) { 
  17.             if (!(p->flags & IORING_SETUP_CLAMP)) 
  18.                 return -EINVAL; 
  19.             p->cq_entries = IORING_MAX_CQ_ENTRIES; 
  20.         } 
  21.     } else { 
  22.         // 默认是两倍的请求队列长度 
  23.         p->cq_entries = 2 * p->sq_entries; 
  24.     } 
  25.     // 用户信息 
  26.     user = get_uid(current_user()); 
  27.     // 分配一个ctx记录上下文,因为调用方只能拿到fd,后续操作fd的时候会拿到关联的上下文 
  28.     ctx = io_ring_ctx_alloc(p); 
  29.     ctx->user = user
  30.     // 和poll模式相关的数据结构 
  31.     ctx->sqo_task = get_task_struct(current); 
  32.     // 分配一个io_rings 
  33.     ret = io_allocate_scq_urings(ctx, p); 
  34.     // 处理poll模式的逻辑 
  35.     ret = io_sq_offload_start(ctx, p); 
  36.     // 后面还有很多,一会分析 

io_uring_create代码比较多,我们分步分析。首先分配了一个io_ring_ctx结构体,这是核心的数据结构,用于记录io_uring实例的上下文,不过我们暂时不需要了解它具体的定义,因为实在太多,只关注本文相关的字段。

1 分配一个io_rings结构体

接着调用io_allocate_scq_urings分配一个io_rings结构体,这是非常核心的逻辑,我们看一下io_rings的定义。

  1. struct io_rings { 
  2.     struct io_uring     sq, cq; 
  3.     u32         sq_ring_mask, cq_ring_mask; 
  4.     u32         sq_ring_entries, cq_ring_entries; 
  5.     u32         sq_dropped; 
  6.     u32         sq_flags; 
  7.     u32         cq_flags; 
  8.     u32         cq_overflow; 
  9.     struct io_uring_cqe cqes[]; 
  10. }; 

io_rings主要用于记录请求和完成队列的信息。我们继续看io_allocate_scq_urings。

  1. static int io_allocate_scq_urings(struct io_ring_ctx *ctx, 
  2.                   struct io_uring_params *p){ 
  3.     struct io_rings *rings; 
  4.     size_t size, sq_array_offset; 
  5.     // 记录请求和完成队列大小到ctx 
  6.     ctx->sq_entries = p->sq_entries; 
  7.     ctx->cq_entries = p->cq_entries; 
  8.     /*  
  9.         计算结构体和额外数组的大小,sq_array_offset保存结构体大小, 
  10.         size保存结构体+额外数组+另一个额外数组的大小 
  11.     */ 
  12.     size = rings_size(p->sq_entries, p->cq_entries, &sq_array_offset); 
  13.     // 分配内存 
  14.     rings = io_mem_alloc(size); 
  15.     // ... 

io_allocate_scq_urings细节比较多,我们分开分析,我们看一下rings_size的逻辑。

  1. static unsigned long rings_size(unsigned sq_entries, unsigned cq_entries, 
  2.                 size_t *sq_offset){ 
  3.     struct io_rings *rings; 
  4.     size_t off, sq_array_size; 
  5.     // 计算结构体和格外数组的大小,见io_rings定义 
  6.     off = struct_size(rings, cqes, cq_entries); 
  7.     // sq_offset记录结构体大小 
  8.     if (sq_offset) 
  9.         *sq_offset = off
  10.     // 计算多个u32元素的数组的大小 
  11.     sq_array_size = array_size(sizeof(u32), sq_entries); 
  12.     // 计算结构体大小 + sq_array_size的大小保存到off 
  13.     if (check_add_overflow(off, sq_array_size, &off)) 
  14.         return SIZE_MAX; 
  15.     return off

struct_size是计算结构体和额外字段大小的宏,我们刚才看到io_rings结构体的定义中,最后一个字段是struct io_uring_cqe cqes[],看起来是个空数组,其实他的内存是紧跟着结构体后面分配的,结构如下。

下面我们看struct_size是如何计算的。

  1. #define struct_size(p, member, count)                   \ 
  2.     __ab_c_size(count,                      \ 
  3.             sizeof(*(p)->member) + __must_be_array((p)->member),\ 
  4.             sizeof(*(p))) 
  5.  
  6. static inline __must_check size_t __ab_c_size(size_t a, size_t b, size_t c){ 
  7.     size_t bytes; 
  8.     // 计算a * b保存到bytes 
  9.     if (check_mul_overflow(a, b, &bytes)) 
  10.         return SIZE_MAX; 
  11.     // 计算bytes + c保存搭配bytes 
  12.     if (check_add_overflow(bytes, c, &bytes)) 
  13.         return SIZE_MAX; 
  14.  
  15.     return bytes; 

我们看到计算方式就是数组元素大小*元素个数+结构体本身的大小。计算完结构体大小后又通过array_size计算了另一个数组的大小并加起来,所以io_rings的结构体如下所示。

分配了io_rings之后我们继续看接下来的逻辑。

  1. static int io_allocate_scq_urings(struct io_ring_ctx *ctx, 
  2.                   struct io_uring_params *p){ 
  3.     // ... 
  4.     // 记录到ctx中 
  5.     ctx->rings = rings; 
  6.     // sq_array记录rings结构体中,u32数组的首地址 
  7.     ctx->sq_array = (u32 *)((char *)rings + sq_array_offset); 
  8.     // 用于回环处理 
  9.     rings->sq_ring_mask = p->sq_entries - 1; 
  10.     rings->cq_ring_mask = p->cq_entries - 1; 
  11.     // 队列长度 
  12.     rings->sq_ring_entries = p->sq_entries; 
  13.     rings->cq_ring_entries = p->cq_entries; 
  14.     ctx->sq_mask = rings->sq_ring_mask; 
  15.     ctx->cq_mask = rings->cq_ring_mask; 
  16.     // 请求队列的数组大小 
  17.     size = array_size(sizeof(struct io_uring_sqe), p->sq_entries); 
  18.     // 分配内存并记录到sq_sqes 
  19.     ctx->sq_sqes = io_mem_alloc(size); 
  20.     return 0; 

进行了一系列设置后,架构如下。

创建完io_rings结构体后,我们继续回到io_uring_create中。

2 设置io_uring_params

内核申请完系列结构体后,需要通过io_uring_params结构体返回给调用方。

  1. static int io_uring_create(unsigned entries, struct io_uring_params *p, 
  2.                struct io_uring_params __user *params) { 
  3.  
  4.     ret = io_allocate_scq_urings(ctx, p); 
  5.     // 初始化poll模式相关逻辑,如果开启了的话 
  6.     ret = io_sq_offload_start(ctx, p); 
  7.     memset(&p->sq_off, 0, sizeof(p->sq_off)); 
  8.     // 记录字段在结构体的偏移 
  9.     p->sq_off.head = offsetof(struct io_rings, sq.head); 
  10.     p->sq_off.tail = offsetof(struct io_rings, sq.tail); 
  11.     p->sq_off.ring_mask = offsetof(struct io_rings, sq_ring_mask); 
  12.     p->sq_off.ring_entries = offsetof(struct io_rings, sq_ring_entries); 
  13.     p->sq_off.flags = offsetof(struct io_rings, sq_flags); 
  14.     p->sq_off.dropped = offsetof(struct io_rings, sq_dropped); 
  15.     p->sq_off.array = (char *)ctx->sq_array - (char *)ctx->rings; 
  16.  
  17.     memset(&p->cq_off, 0, sizeof(p->cq_off)); 
  18.     p->cq_off.head = offsetof(struct io_rings, cq.head); 
  19.     p->cq_off.tail = offsetof(struct io_rings, cq.tail); 
  20.     p->cq_off.ring_mask = offsetof(struct io_rings, cq_ring_mask); 
  21.     p->cq_off.ring_entries = offsetof(struct io_rings, cq_ring_entries); 
  22.     p->cq_off.overflow = offsetof(struct io_rings, cq_overflow); 
  23.     p->cq_off.cqes = offsetof(struct io_rings, cqes); 
  24.     p->cq_off.flags = offsetof(struct io_rings, cq_flags); 
  25.     // 内核支持的属性 
  26.     p->features = IORING_FEAT_SINGLE_MMAP | IORING_FEAT_NODROP | 
  27.             IORING_FEAT_SUBMIT_STABLE | IORING_FEAT_RW_CUR_POS | 
  28.             IORING_FEAT_CUR_PERSONALITY | IORING_FEAT_FAST_POLL | 
  29.             IORING_FEAT_POLL_32BITS; 
  30.  
  31.     copy_to_user(params, p, sizeof(*p)) 
  32.     // 获取fd 
  33.     ret = io_uring_get_fd(ctx); 
  34.     return ret; 

io_uring_create继续进行了一系列赋值,赋值完后架构如下。

3 获取文件描述符

内核通过io_uring_get_fd获取文件描述符返回给调用方。

  1. static int io_uring_get_fd(struct io_ring_ctx *ctx){ 
  2.     struct file *file; 
  3.     // 获取一个可用fd 
  4.     int ret = get_unused_fd_flags(O_RDWR | O_CLOEXEC); 
  5.     // 分配一个file结构体,设置函数集为io_uring_fops,并关联上下文ctx 
  6.     file = anon_inode_getfile("[io_uring]", &io_uring_fops, ctx, 
  7.                     O_RDWR | O_CLOEXEC); 
  8.  
  9.     // 关联fd和file结构体 
  10.     fd_install(ret, file); 
  11.     return ret; 

io_uring_get_fd申请了一个fd和file,这是遵循vfs的设计,最重要的是把io_uring的函数集挂在到file上,后续通过fd操作的io_uring实例的时候,经过vfs后就会执行对应的函数,另外还需要把ctx和file关联起来,因为后续通过fd操作io_uring时,需要拿到fd对应的io_uring上下文。至此。

io_uring_setup就分析完了,但是还不能使用。io_uring在设计中,为了减少系统调用和用户、内核数据通信的成本,实现了用户、内核共享数据结构的方式,这样用户和内核就可以操作同一份数据结构达到通信目的,而不用通过系统调用,更不需要设计来回复制。为了达到这个目的,用户拿到io_uring实例后,还需要调用mmap获取对应的内存映射。我们通过liburing库的逻辑来分析。

4 从liburing库看io_uring的使用

  1. int io_uring_queue_init_params(unsigned entries, struct io_uring *ring, 
  2.                    struct io_uring_params *p){ 
  3.     int fd, ret; 
  4.     // 调用io_uring_setup,拿到fd 
  5.     fd = __sys_io_uring_setup(entries, p); 
  6.     if (fd < 0) 
  7.         return -errno; 
  8.     // 内存映射 
  9.     ret = io_uring_queue_mmap(fd, p, ring); 
  10.     // 保存系统支持的属性 
  11.     ring->features = p->features; 
  12.     return 0; 

我们重点看一下io_uring_queue_mmap。

  1. int io_uring_queue_mmap(int fd, struct io_uring_params *p, struct io_uring *ring){ 
  2.     int ret; 
  3.  
  4.     memset(ring, 0, sizeof(*ring)); 
  5.     ret = io_uring_mmap(fd, p, &ring->sq, &ring->cq); 
  6.     // 记录flags和fd 
  7.     if (!ret) { 
  8.         ring->flags = p->flags; 
  9.         ring->ring_fd = fd; 
  10.     } 
  11.     return ret; 

继续看io_uring_mmap。

  1. static int io_uring_mmap(int fd, struct io_uring_params *p, 
  2.              struct io_uring_sq *sq, struct io_uring_cq *cq){ 
  3.     size_t size
  4.     int ret; 
  5.     // 请求队列需要映射的内存大小,即整个结构体struct io_rings结构体的大小 
  6.     sq->ring_sz = p->sq_off.array + p->sq_entries * sizeof(unsigned); 
  7.     // 请求队列和完成队列映射的内存大小一样,等于请求队列的 
  8.     cq->ring_sz = sq->ring_sz; 
  9.     // 映射并拿到虚拟地址,大小是sq->ring_sz 
  10.     sq->ring_ptr = mmap(0, sq->ring_sz, PROT_READ | PROT_WRITE, 
  11.             MAP_SHARED | MAP_POPULATE, fd, IORING_OFF_SQ_RING); 
  12.     cq->ring_ptr = sq->ring_ptr; 
  13.     // 通过首地址和偏移拿到对应字段的地址 
  14.     sq->khead = sq->ring_ptr + p->sq_off.head; 
  15.     sq->ktail = sq->ring_ptr + p->sq_off.tail; 
  16.     sq->kring_mask = sq->ring_ptr + p->sq_off.ring_mask; 
  17.     sq->kring_entries = sq->ring_ptr + p->sq_off.ring_entries; 
  18.     sq->kflags = sq->ring_ptr + p->sq_off.flags; 
  19.     sq->kdropped = sq->ring_ptr + p->sq_off.dropped; 
  20.     sq->array = sq->ring_ptr + p->sq_off.array; 
  21.     // 映射保存请求队列节点的内存 
  22.     size = p->sq_entries * sizeof(struct io_uring_sqe); 
  23.     sq->sqes = mmap(0, size, PROT_READ | PROT_WRITE, 
  24.                 MAP_SHARED | MAP_POPULATE, fd, 
  25.                 IORING_OFF_SQES); 
  26.     // 同上 
  27.     cq->khead = cq->ring_ptr + p->cq_off.head; 
  28.     cq->ktail = cq->ring_ptr + p->cq_off.tail; 
  29.     cq->kring_mask = cq->ring_ptr + p->cq_off.ring_mask; 
  30.     cq->kring_entries = cq->ring_ptr + p->cq_off.ring_entries; 
  31.     cq->koverflow = cq->ring_ptr + p->cq_off.overflow; 
  32.     cq->cqes = cq->ring_ptr + p->cq_off.cqes; 
  33.     if (p->cq_off.flags) 
  34.         cq->kflags = cq->ring_ptr + p->cq_off.flags; 
  35.     return 0; 

io_uring_mmap除了保存一些常用的字段信息外,最重要的是做了内存映射。我们看看mmap的最后一个参数分别是IORING_OFF_SQ_RING和IORING_OFF_SQES,接下来我们看看io_uring的mmap钩子的实现。

  1. static int io_uring_mmap(struct file *file, struct vm_area_struct *vma){ 
  2.     size_t sz = vma->vm_end - vma->vm_start; 
  3.     unsigned long pfn; 
  4.     void *ptr; 
  5.  
  6.     ptr = io_uring_validate_mmap_request(file, vma->vm_pgoff, sz); 
  7.  
  8.     pfn = virt_to_phys(ptr) >> PAGE_SHIFT; 
  9.     return remap_pfn_range(vma, vma->vm_start, pfn, sz, vma->vm_page_prot);}static void *io_uring_validate_mmap_request(struct file *file, 
  10.                         loff_t pgoff, size_t sz){ 
  11.     struct io_ring_ctx *ctx = file->private_data; 
  12.     loff_t offset = pgoff << PAGE_SHIFT; 
  13.     struct page *page; 
  14.     void *ptr; 
  15.  
  16.     switch (offset) { 
  17.     case IORING_OFF_SQ_RING: 
  18.     case IORING_OFF_CQ_RING: 
  19.         ptr = ctx->rings; 
  20.         break; 
  21.     case IORING_OFF_SQES: 
  22.         ptr = ctx->sq_sqes; 
  23.         break; 
  24.     default
  25.         return ERR_PTR(-EINVAL); 
  26.     } 
  27.  
  28.     page = virt_to_head_page(ptr); 
  29.     if (sz > page_size(page)) 
  30.         return ERR_PTR(-EINVAL); 
  31.  
  32.     return ptr; 

这里设计的内容涉及到了复杂的内存管理,从代码中我们大概知道,返回的地址分别是ctx->rings和ctx->sq_sqes。即我们操作mmap返回的虚拟地址时,映射到内核的数据结构是ctx的字段。这样就完成了数据共享。最后形成的架构图如下。

至此,分析就告一段落,io_uring的实现实在是复杂,需要反复阅读和思考,才能慢慢理解和了解它的原理。

后记:io_uring作为新一代IO框架,未来应该会在各大软件中使用,尤其是对性能有极高要求的服务器,所以是非常值得关注和学习的。

 

责任编辑:武晓燕 来源: 编程杂技
相关推荐

2021-07-03 08:04:10

2020-09-30 06:44:39

存储IO

2021-07-11 23:25:29

2021-09-07 09:30:38

2015-11-10 16:55:00

性能IO子系统Linux

2021-03-03 08:45:38

IO驱动式Linux

2010-05-05 13:13:55

Unix内核

2014-09-22 13:31:46

同话题下的热门内容

如何选择适合的公共 DNSLinux终端居然也可以做文件浏览器?Linux 怎么防止 ssh 被暴力破解Linux下如何配置普通用户的sudo命令权限?如何在基于 Ubuntu 的 Linux 发行版上安装最新的 Vim 9.0Linux内存管理(Golang实现)Linux Kernel 5.19 正式发布,支持龙芯 CPU架构为有经验用户量身定制的 Linux

编辑推荐

Linux系统下安装MySQL的步骤详解CentOS与Ubuntu有什么不同?Linux下如何使用minicom USB串口为什么你可能想要略过Ubuntu 17.04?Linux中7个判断文件系统类型的方法
我收藏的内容
点赞
收藏

51CTO技术栈公众号