文件系统：3. io_uring-提交sqe

最新推荐文章于 2023-02-03 17:11:31 发布
最新推荐文章于 2023-02-03 17:11:31 发布
阅读量433 收藏 1
点赞数
分类专栏： Kernel 文章标签： linux kernel io_uring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jakelylll/article/details/128624202
版权

Kernel源码笔记目录

提交sqe

源码基于5.10

主流程

static int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr)
{
	struct io_submit_state state;
	struct io_kiocb *link = NULL;
	int i, submitted = 0;

	// 判断cq是否已经溢出
	if (test_bit(0, &ctx->sq_check_overflow)) {
		// 如果已经溢出，需要从溢出列表转移
		// 这个函数如果返回0,说明溢出列表没有转移完，cqe还是满的，所以就直接返回 忙
		if (!__io_cqring_overflow_flush(ctx, false, NULL, NULL))
			return -EBUSY;
	}

	// 可以提交的数量，io_sqring_entries是队列里剩余可提交的数量
	// 可提交数量是这3个的最小值
	nr = min3(nr, ctx->sq_entries, io_sqring_entries(ctx));

	// 增加nr个引用
	if (!percpu_ref_tryget_many(&ctx->refs, nr))
		return -EAGAIN;

	percpu_counter_add(&current->io_uring->inflight, nr);
	// 增加当前进程计数
	refcount_add(nr, &current->usage);

	// 开始提交，初始化state变量
	io_submit_state_start(&state, ctx, nr);

	for (i = 0; i < nr; i++) {
		const struct io_uring_sqe *sqe;
		struct io_kiocb *req;
		int err;

		// 从sq的头取出一个se
		sqe = io_get_sqe(ctx);
		if (unlikely(!sqe)) {
			// sqe为空，则直接增加cached_sq_head计数
			io_consume_sqe(ctx);
			break;
		}
		// 获取一个请求
		req = io_alloc_req(ctx, &state);
		if (unlikely(!req)) {
			// 如果一个都没提交，则需要重新请求
			if (!submitted)
				submitted = -EAGAIN;
			break;
		}
		// 递增 ctx->cached_sq_head，cached_sq_head是内核侧用来跟踪sq环的计数器
		io_consume_sqe(ctx);
		/* will complete beyond this point, count as submitted */
		submitted++;

		// 根据sqe信息初始化req
		err = io_init_req(ctx, req, sqe, &state);
		if (unlikely(err)) {
fail_req:
			io_put_req(req);
			io_req_complete(req, err);
			break;
		}

		trace_io_uring_submit_sqe(ctx, req->opcode, req->user_data,
						true, io_async_submit(ctx));
		// 提交se
		err = io_submit_sqe(req, sqe, &link, &state.comp);
		if (err)
			goto fail_req;
	}

	if (unlikely(submitted != nr)) {
		// 已提交的与预期的不相符
		int ref_used = (submitted == -EAGAIN) ? 0 : submitted;
		struct io_uring_task *tctx = current->io_uring;
		// 未用的引用数量
		int unused = nr - ref_used;

		// 把未用的引用数量从这些计数器里取掉
		percpu_ref_put_many(&ctx->refs, unused);
		percpu_counter_sub(&tctx->inflight, unused);
		put_task_struct_many(current, unused);
	}
	if (link)
		io_queue_link_head(link, &state.comp);
	io_submit_state_end(&state);

	// 同步sq头指针
	io_commit_sqring(ctx);

	return submitted;
}

提交的主流程：

  1. 检查溢出列表是否有完成的cqe
  2. 根据需要提交的最小数量，从sq里取出一个sqe,初始化req对象,进行提交
  3. 如果所提交的与期望提交的数量不相等，则修改相关引用计数
  4. 同步sq队列的头指针

state的初始化

state用来跟踪这次提交的状态.

static void io_submit_state_start(struct io_submit_state *state,
				  struct io_ring_ctx *ctx, unsigned int max_ios)
{
	// 初始化进程的plug
	blk_start_plug(&state->plug);
	state->comp.nr = 0;
	INIT_LIST_HEAD(&state->comp.list);
	state->comp.ctx = ctx;
	state->free_reqs = 0;
	state->file = NULL;
	// max_ios就是要提交的数量
	state->ios_left = max_ios;
}

io_get_sqe

static const struct io_uring_sqe *io_get_sqe(struct io_ring_ctx *ctx)
{
	u32 *sq_array = ctx->sq_array;
	unsigned head;

	/*
	原文注释：
	 缓存的sq头（或cq尾）有两个目的：
		1）允许我们批量更新用户可见头部更新的成本。
		2）允许内核端自己跟踪头部，即使应用程序正在更新头部。
	 */
	// ctx->cached_sq_head是内核里用于跟踪sq头的指针，
	// 因为sq_array是一个环，所以要和mask相与
	head = READ_ONCE(sq_array[ctx->cached_sq_head & ctx->sq_mask]);

	// 这里表示还没到达环尾，一般情况都走这里，
	// 没到达环尾，就直接返回head对应的sqe
	if (likely(head < ctx->sq_entries))
		return &ctx->sq_sqes[head];

	// 走到这儿表示已经到达环尾
	// 丢弃无效的sq
	ctx->cached_sq_dropped++;
	WRITE_ONCE(ctx->rings->sq_dropped, ctx->cached_sq_dropped);
	return NULL;
}

sq队列和cq的存储不同，cq直接在cqe里存储，而sqe是通过间接的方式保存，先通过ctx->sq_array来获取sqe的下标，然后再去ctx->sq_sqes数组里找到真正的sqe。（todo: 为什么用这种方式存储，暂时还没看明白）

请求的分配和初始化

分配一个请求对象。

static struct io_kiocb *io_alloc_req(struct io_ring_ctx *ctx,
				     struct io_submit_state *state)
{
	// free_reqs是一个struct io_kiocb数组，里面存储的是空闲的请求
	if (!state->free_reqs) { // 第一次进入或者空闲数组用完，会走这个分支
		gfp_t gfp = GFP_KERNEL | __GFP_NOWARN;
		size_t sz;
		int ret;

		// ios_left是剩余要提交的数量，reqs数组的大小是8
		sz = min_t(size_t, state->ios_left, ARRAY_SIZE(state->reqs));

		// 批量分配
		ret = kmem_cache_alloc_bulk(req_cachep, gfp, sz, state->reqs);

		// 如果批量分配失败，则只尝试分配一个，
		if (unlikely(ret <= 0)) {
			state->reqs[0] = kmem_cache_alloc(req_cachep, gfp);
			if (!state->reqs[0])
				// 如果连一个都分配不下，那就尝试使用fallback_req，
				// 这个是在io_uring初始化的时候就分配的
				goto fallback;
			ret = 1;
		}
		state->free_reqs = ret;
	}

	// 分配成功，或者还有没用完的req，则直接从数组里获取一个请求返回
	state->free_reqs--;
	return state->reqs[state->free_reqs];
fallback:
	return io_get_fallback_req(ctx);
}

static struct io_kiocb *io_get_fallback_req(struct io_ring_ctx *ctx)
{
	struct io_kiocb *req;

	req = ctx->fallback_req;

	// 设置fallback_req为空，如果设置成功，说明没有人用它，如果设置失败说明已经有别人在用了
	if (!test_and_set_bit_lock(0, (unsigned long *) &ctx->fallback_req))
		return req;

	// 连fallback_req都申请不到那只能返回NULL
	return NULL;
}

第一次分配请求空间会尝试3次：1.批量分配; 2.只分配1个; 3.尝试使用fallbackreq。如果这3种方式都分配不下那就出错了。

static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req,
		       const struct io_uring_sqe *sqe,
		       struct io_submit_state *state)
{
	unsigned int sqe_flags;
	int id, ret;

	// 操作码
	req->opcode = READ_ONCE(sqe->opcode);
	// 用户数据
	req->user_data = READ_ONCE(sqe->user_data);
	// 异步数据
	req->async_data = NULL;
	req->file = NULL;
	// io_uring上下文
	req->ctx = ctx;
	req->flags = 0;

	// 引用先设成2，一个是提交队列引用，一个是完成队列
	refcount_set(&req->refs, 2);
	// 进程
	req->task = current;

	// 请求结果默认初始化成0
	req->result = 0;

	// 请求码错误
	if (unlikely(req->opcode >= IORING_OP_LAST))
		return -EINVAL;

	// 获取对应进程的mm失败
	if (unlikely(io_sq_thread_acquire_mm(ctx, req)))
		return -EFAULT;

	sqe_flags = READ_ONCE(sqe->flags);

	// 有非法标志
	if (unlikely(sqe_flags & ~SQE_VALID_FLAGS))
		return -EINVAL;

	// 检查上下文对io_uring是否有限制
	if (unlikely(!io_check_restriction(ctx, req, sqe_flags)))
		return -EACCES;

	// 判断当前操作是否支持buffer_select
	if ((sqe_flags & IOSQE_BUFFER_SELECT) &&
	    !io_op_defs[req->opcode].buffer_select)
		return -EOPNOTSUPP;

	id = READ_ONCE(sqe->personality);
	if (id) {
		struct io_identity *iod;

		// 从ctx里查找id对应的iod
		iod = xa_load(&ctx->personalities, id);
		if (unlikely(!iod))
			return -EINVAL;
		// 递增引用
		refcount_inc(&iod->count);

		// 初始化异步请求。todo: 有id的默认就是异步？
		__io_req_init_async(req);
		get_cred(iod->creds);
		req->work.identity = iod;
		req->work.flags |= IO_WQ_WORK_CREDS;
	}

	// 设置请求标志
	req->flags |= sqe_flags;

	// op请滶不需要文件
	if (!io_op_defs[req->opcode].needs_file)
		return 0;

	// 需要设置文件
	ret = io_req_set_file(state, req, READ_ONCE(sqe->fd));

	// 递减还要提交的请求数量
	state->ios_left--;
	return ret;
}

初始化的主要流程：

  1. 复制sqe里的opcode, user_data等数据
  2. 对opcode的正确性做校验
  3. 根据操作是否需要文件，来设置相关的文件

真正的提交动作

io_submit_sqe主要处理链接的情况。

static int io_submit_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
			 struct io_kiocb **link, struct io_comp_state *cs)
{
	struct io_ring_ctx *ctx = req->ctx;
	int ret;

	// link表示请求之间按顺序，第一次进来是空的
	if (*link) {
		struct io_kiocb *head = *link;

		/*
		 * Taking sequential execution of a link, draining both sides
		 * of the link also fullfils IOSQE_IO_DRAIN semantics for all
		 * requests in the link. So, it drains the head and the
		 * next after the link request. The last one is done via
		 * drain_next flag to persist the effect across calls.
		 */
		if (req->flags & REQ_F_IO_DRAIN) {
			head->flags |= REQ_F_IO_DRAIN;
			ctx->drain_next = 1;
		}
		ret = io_req_defer_prep(req, sqe);
		if (unlikely(ret)) {
			/* fail even hard links since we don't submit */
			head->flags |= REQ_F_FAIL_LINK;
			return ret;
		}
		trace_io_uring_link(ctx, req, head);
		list_add_tail(&req->link_list, &head->link_list);

		/* last request of a link, enqueue the link */
		if (!(req->flags & (REQ_F_LINK | REQ_F_HARDLINK))) {
			io_queue_link_head(head, cs);
			*link = NULL;
		}
	} else {
		// drain_next表示要跳过下一个请求，
		// 如果要跳过，则给这个请求设置相关标志.
		// 一般情况都不走这个分支
		if (unlikely(ctx->drain_next)) {
			req->flags |= REQ_F_IO_DRAIN;
			ctx->drain_next = 0;
		}

		if (req->flags & (REQ_F_LINK | REQ_F_HARDLINK)) {
			// todo: link后面再看
			req->flags |= REQ_F_LINK_HEAD;
			INIT_LIST_HEAD(&req->link_list);

			ret = io_req_defer_prep(req, sqe);
			if (unlikely(ret))
				req->flags |= REQ_F_FAIL_LINK;
			// 设置link的值
			*link = req;
		} else {
			// 一般的走这里
			io_queue_sqe(req, sqe, cs);
		}
	}

	return 0;
}

static void io_queue_sqe(struct io_kiocb *req, const struct io_uring_sqe *sqe,
			 struct io_comp_state *cs)
{
	int ret;

	// 判断当前请求是否要被延迟处理
	ret = io_req_defer(req, sqe);
	if (ret) {
		// 如果ret不是-EIOCBQUEUED，那就是出现其它错误，
		// 直接让请求完成
		if (ret != -EIOCBQUEUED) {
fail_req:
			req_set_fail_links(req);
			io_put_req(req);
			io_req_complete(req, ret);
		}
	} else if (req->flags & REQ_F_FORCE_ASYNC) {
		// 异步请求
		if (!req->async_data) {
			// 准备异步数据
			ret = io_req_defer_prep(req, sqe);
			if (unlikely(ret))
				goto fail_req;
		}
		// 把请求入队列
		io_queue_async_work(req);
	} else {
		// 同步请求
		if (sqe) {
			// 调用相应的prep方法
			ret = io_req_prep(req, sqe);
			if (unlikely(ret))
				goto fail_req;
		}
		// 执行具体的请求
		__io_queue_sqe(req, cs);
	}
}


static int io_req_defer(struct io_kiocb *req, const struct io_uring_sqe *sqe)
{
	struct io_ring_ctx *ctx = req->ctx;
	struct io_defer_entry *de;
	int ret;
	u32 seq;

	// REQ_F_IO_DRAIN是要被排出的req
	// defer_list是被延迟请求的列表
	if (likely(list_empty_careful(&ctx->defer_list) &&
		!(req->flags & REQ_F_IO_DRAIN)))
		return 0;

	// 走到这儿，说明defer_list不为空，或者req有REQ_F_IO_DRAIN标志

	// 提交的序号，递增的
	seq = io_get_sequence(req);

	// 如果该请求不需要延迟，而且延迟列表为空
	if (!req_need_defer(req, seq) && list_empty_careful(&ctx->defer_list))
		// 走到这儿，说明req有REQ_F_IO_DRAIN标志
		return 0;

	// 走到这儿说明req需要延迟或者defer_list不为空

	// 走到这说明请求需要延迟

	// 如果没有异步数据，则分配之
	if (!req->async_data) {
		ret = io_req_defer_prep(req, sqe);
		if (ret)
			return ret;
	}
	// todo: 后面再看
	io_prep_async_link(req);

	de = kmalloc(sizeof(*de), GFP_KERNEL);
	if (!de)
		return -ENOMEM;

	spin_lock_irq(&ctx->completion_lock);
	if (!req_need_defer(req, seq) && list_empty(&ctx->defer_list)) {
		// todo: 走到这儿，说明不需要要延迟req，为什么和上面的处理不一样
		// 上面直接返回0, 而这里是加入到异步请求work
		spin_unlock_irq(&ctx->completion_lock);
		kfree(de);
		io_queue_async_work(req);
		return -EIOCBQUEUED;
	}

	trace_io_uring_defer(ctx, req, req->user_data);

	// 把请求和序号分配给de
	de->req = req;
	de->seq = seq;

	// 把de挂到延迟列表上
	list_add_tail(&de->list, &ctx->defer_list);
	spin_unlock_irq(&ctx->completion_lock);
	return -EIOCBQUEUED;
}


static u32 io_get_sequence(struct io_kiocb *req)
{
	struct io_kiocb *pos;
	struct io_ring_ctx *ctx = req->ctx;
	u32 total_submitted, nr_reqs = 1;

	// 如果当前请求是链表的头，则统计链内所有请求数
	if (req->flags & REQ_F_LINK_HEAD)
		list_for_each_entry(pos, &req->link_list, link_list)
			nr_reqs++;

	// cached_sq_head是内核消费sqe的位置
	// cached_sq_dropped是被放弃的sqe数量
	total_submitted = ctx->cached_sq_head - ctx->cached_sq_dropped;

	// 算出当前sqe的序号
	return total_submitted - nr_reqs;
}

static bool req_need_defer(struct io_kiocb *req, u32 seq)
{
	// 如果当前请求要被排出
	if (unlikely(req->flags & REQ_F_IO_DRAIN)) {
		struct io_ring_ctx *ctx = req->ctx;
		
		// cq_tail+cq_overflow是cq列表上总共的cqe数量，
		// todo: 这个判断的逻辑？？
		return seq != ctx->cached_cq_tail
				+ READ_ONCE(ctx->cached_cq_overflow);
	}

	// 不需要排出，就不延迟
	return false;
}

io_queue_sqe主流程：

  1. 判断是否要延迟请求，如果要延迟则挂入defer_list。
  2. 根据是否有异步标志，来分别处理请求

异步提交

static int io_req_defer_prep(struct io_kiocb *req,
			     const struct io_uring_sqe *sqe)
{
	if (!sqe)
		return 0;
	// 分配异步数据
	if (io_alloc_async_data(req))
		return -EAGAIN;.
	// 调用对应操作的prep方法
	return io_req_prep(req, sqe);
}


static int io_alloc_async_data(struct io_kiocb *req)
{
	// 如果该操作不需要异步数据，则直接返回
	if (!io_op_defs[req->opcode].needs_async_data)
		return 0;

	return  __io_alloc_async_data(req);
}

static inline int __io_alloc_async_data(struct io_kiocb *req)
{
	// 如果异步数据大小为0，那为啥还要数据？
	WARN_ON_ONCE(!io_op_defs[req->opcode].async_size);
	// 分配操作对应异步数据内存
	req->async_data = kmalloc(io_op_defs[req->opcode].async_size, GFP_KERNEL);
	return req->async_data == NULL;
}

static void io_queue_async_work(struct io_kiocb *req)
{
	struct io_kiocb *link;

	// 加入队列
	link = __io_queue_async_work(req);

	// 如果link有值，则设置超时
	if (link)
		io_queue_linked_timeout(link);
}

static struct io_kiocb *__io_queue_async_work(struct io_kiocb *req)
{
	struct io_ring_ctx *ctx = req->ctx;
	// 如果链表的第一个元素的操作是IORING_OP_LINK_TIMEOUT，则这个link有值，反之没值
	// 这个link为什么要放在这个函数里，这个函数又没有用
	struct io_kiocb *link = io_prep_linked_timeout(req);

	trace_io_uring_queue_async_work(ctx, io_wq_is_hashed(&req->work), req,
					&req->work, req->flags);
	// 把work加入io_wq队列
	io_wq_enqueue(ctx->io_wq, &req->work);
	return link;
}

static struct io_kiocb *io_prep_linked_timeout(struct io_kiocb *req)
{
	struct io_kiocb *nxt;

	// 没有链接标志
	if (!(req->flags & REQ_F_LINK_HEAD))
		return NULL;
	// 有链接超时标志
	if (req->flags & REQ_F_LINK_TIMEOUT)
		return NULL;

	// 链表第一个元素
	nxt = list_first_entry_or_null(&req->link_list, struct io_kiocb,
					link_list);
	// 不是链接超时操作,直接返回
	if (!nxt || nxt->opcode != IORING_OP_LINK_TIMEOUT)
		return NULL;

	// 启用超时
	nxt->flags |= REQ_F_LTIMEOUT_ACTIVE;
	req->flags |= REQ_F_LINK_TIMEOUT;
	return nxt;
}

static void io_queue_linked_timeout(struct io_kiocb *req)
{
	struct io_ring_ctx *ctx = req->ctx;

	spin_lock_irq(&ctx->completion_lock);
	// 设置超时
	__io_queue_linked_timeout(req);
	spin_unlock_irq(&ctx->completion_lock);

	// 丢弃这个req，因为这个req只是用来做超时的
	io_put_req(req);
}

static void __io_queue_linked_timeout(struct io_kiocb *req)
{
	/*
	 * If the list is now empty, then our linked request finished before
	 * we got a chance to setup the timer
	 */
	if (!list_empty(&req->link_list)) {
		struct io_timeout_data *data = req->async_data;

		// 设置超时函数，
		data->timer.function = io_link_timeout_fn;

		// 启动计时器。
		hrtimer_start(&data->timer, timespec64_to_ktime(data->ts),
				data->mode);
	}
}

异步提交主要有4个流程：

  1. 分配异步数据
  2. 把req挂入io_wq的队列
  3. 如果需要设置超时，则设置之
  4. 调用对应操作的prep方法

同步提交

同步提交的第1步，也是调用各个操作的prep方法，然后再调用__io_queue_sqe，进行真正提交。异步任务到最后，也是调用__io_queue_sqe来执行真正的io操作。

static void __io_queue_sqe(struct io_kiocb *req, struct io_comp_state *cs)
{
	struct io_kiocb *linked_timeout;
	const struct cred *old_creds = NULL;
	int ret;

again:
	// 链式请求，第1个是超时req
	linked_timeout = io_prep_linked_timeout(req);

	// 切换请求的cred ?
	if ((req->flags & REQ_F_WORK_INITIALIZED) &&
	    (req->work.flags & IO_WQ_WORK_CREDS) &&
	    req->work.identity->creds != current_cred()) {
		if (old_creds)
			revert_creds(old_creds);
		if (old_creds == req->work.identity->creds)
			old_creds = NULL; /* restored original creds */
		else
			old_creds = override_creds(req->work.identity->creds);
	}

	// 调用具体操作对应的函数，执行对应操作
	ret = io_issue_sqe(req, true, cs);

	// 如果需要重试，但是请求不允许等待，则执行异步操作
	if (ret == -EAGAIN && !(req->flags & REQ_F_NOWAIT)) {
		// 先无法执行poll
		if (!io_arm_poll_handler(req)) {
			// 如果poll执行失败，则放到异步任务队列里
			io_queue_async_work(req);
		}

		// 设置超时，如果需要的话
		if (linked_timeout)
			io_queue_linked_timeout(linked_timeout);
	} else if (likely(!ret)) {
		// put当前请求，然后再找到链式请求的下一个请求，
		// 对于一般的请求req都为NULL
		req = io_put_req_find_next(req);

		// 重新设置超时
		if (linked_timeout)
			io_queue_linked_timeout(linked_timeout);

		if (req) {
			if (!(req->flags & REQ_F_FORCE_ASYNC))
				// 如果请求不需要异步，则继续处理
				goto again;
			// 不是异步请求，就放入队列
			io_queue_async_work(req);
		}
	} else {
		// 其它情况就是出错了，就直接设置出错标志，把请求结果放入cq就行了
		req->flags &= ~REQ_F_LINK_TIMEOUT;
		req_set_fail_links(req);
		io_put_req(req);
		io_req_complete(req, ret);
	}

	// 还原cred
	if (old_creds)
		revert_creds(old_creds);
}

同步提交流程：

  1. 切换cred
  2. 调用具体操作的io函数
  3. 执行操作失败，处理EAGAIN情况，这个情况会调用poll或者执行异步请求
  4. 执行操作成功，如果是链式调用，则处理下一个请求，根据请求是异步还是同步来进行处理
  5. 处理其它失败情况
  6. 还原cred
苟浩
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
io-uring:Rust的io_uring库
05-01
要使用io-uring板条箱，请首先将其添加到Cargo.toml ： [ dependencies ] io-uring = " 0.5 " 接下来，我们可以开始使用io-uring板条箱。 以下是使用“ Read文件”的快速介绍。 use io_uring :: {opcode, types, ...
新一代异步IO框架 io_uring ｜ 得物技术
SmartCodeTech的博客
04-13 977
得益于精妙的设计，io_uring的性能基本超越linux 内核以往任何软件层面的IO解决方案，达到了与硬件级解决方案媲美的性能。io_uring 需要较高版本的内核支持，目前还没有大面积普及，但可以预料他是 linux 内核 IO未来的核心发展方向。
Linux操作系统之基础IO
qq_61039408的博客
02-03 1288
当我们的程序运行起来变成进程之后，OS会默认的帮我们打开3个标准输入输出。分别是标准输入(用于键盘写入)，标准输出(用于显示器显示)，表示错误(也是用于显示器显示)。因为我们基本的输入，比如输入命令行指令，还有看到我们的命令行，以及我们出现的一些错误我们是必须看到的，所以任何一个进程在创建的时候都必须开启这3个标准输入输出。而Linux下一切皆文件！！！这3个标准输入输出也对应的有struct file。我们进程一创建就已经指向了这个struct file了。因此0，1，2已经被占用，数组从3开始继续进行存
【io_uring】简介和使用
乐园
10-23 2493
io_uring 文章目录io_uring简介使用系统调用liburing样例代码流程实现系统调用`io_uring_setup``io_uring_enter``io_uring_register`参考资料 简介 io_uring 是 Linux 在 5.1 版本引入的一套新的异步 IO 实现。相比 Linux 在 2.6 版本引入的 AIO，io_uring 性能强很多，接近 SPDK[1]，同时支持 buffer IO io_uring 的作者 Jens Axboe 是 Linux 内核块层和其他块设
一文详细讲解 io_uring
youzhangjing_的博客
11-11 1290
Linux内核5.1支持了新的异步IO框架iouring，由Block IO大神也即Fio作者Jens Axboe开发，意在提供一套公用的网络和磁盘异步IO，不过io_uring目前在磁盘方面要比网络方面更加成熟。熟悉Linux系统编程的同学都清楚，Linux并没有提供完善的异步IO(网络IO、磁盘IO)机制。
【kernel exploit】CVE-2021-41073 内核类型混淆漏洞利用分析
panhewu9919的博客
07-10 1016
CVE-2021-41073
io_uring-by-example:io_uring by Example文章系列的配套存储库
05-13
它具有一组示例程序，这些示例程序作为示例来说明Linux io_uring子系统的用法。 这些示例一个接一个地构建，变得越来越复杂。 以下是示例的作用： 01_regular_cat ：这是等效的“ cat”程序示例，它使用常规的同步I...
rio：纯锈io_uring库，基于libc构建，对线程和异步友好，抗滥用
02-03
rio：纯锈io_uring库，基于libc构建，对线程和异步友好，抗滥用
io_uring_server:使用io_uring socket实现的一个传输文件服务器
03-20
io_uring主指南中的示例程序。源代码，例如。制作说明cmake用于构建这些示例。请确保它已安装在您的系统上。签出此仓库并更改其目录后，请运行以下命令： $ mkdir build$ cd build$ cmake ..$ cmake --build .这会将...
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 用法分析 II ：io_uring 原理和系统调用初步介绍
锐龙处理器
11-18 3013
这个为了方便，之后还要总结一下这个全部的用法摘要，方便查阅。所以分为 3 篇内容（其实前面还有一篇讲异步 IO 的也算吧），第一个是 io_uring 的简单原理分析和 raw interfaces，第二篇是讲 liburing 以及高性能 polling 机制，第三篇是接口以及各选项的总结摘要（这之前先参考 manual 和 liburing 的头文件吧，liburing 也自带了 system call 的 manual）。 主要的 io_uring 的资料有这些：io_uring.pdf ...
Linux中的内存分配和释放之kmem_cache_alloc()函数分析
热门推荐
satanwxd的专栏
03-17 2万+
  记得上篇文章中我们提到了这个函数，在kmem_cache_create()函数调用它的语句是cachep = (kmem_cache_t *) kmem_cache_alloc(&cache_cache, SLAB_KERNEL);这里的cachep是我们要申请的高速缓存内存的描述结构体(kmem_cache_t)，但是我们也需要高速缓存内存来存放这个结构体。就是cache_cache所描
io_uring简单了解
iUcool的博客
08-15 2379
当我们进行一个系统调用，用户层的应用程序调用内核，它在内核空间中复制数据。在内核完成执行之后，它将结果复制回用户空间缓冲区。然后它返回。在这段时间内，系统调用仍然被阻塞那么如何解决多次复制和同步问题呢由此便引出了io_uringio_uring是2019年Linux5.1内核首次引入的高性能异步IO框架，能显著带来加速IO密集型应用的性能但相比正确使用的AIO可能最多只有5%的提升io_uring来自于Jens Axboe的观察——随着设备越来越快，中断驱动效率已经低于轮训模式。............
linux内核-内存管理
csdn546229768的博客
01-29 1052
*分配一块给某个数据结构使用的缓存描述符name:对象的名字 size:对象的实际大小 align:对齐要求，通常填0，创建是自动选择。flags:可选标志位 ctor: 构造函数 */ struct kmem_cache * kmem_cache_create(const char * name , size_t size , size_t align , unsigned long flags， void(* ctor)(void *));
Linux网络设计之异步IO机制与io_uring
Lion_Long的博客
09-06 784
io_uring主要由三部分构成：内核提供的三个系统调用接口（io_uring_setup、io_uring_register、io_uring_enter），内核实现的系统调用，应用层提供的liburing库。io_uring_submite会在底层协议栈执行accept、recv、send等功能。从fio测试磁盘IO的测试结果来看，io_uring的IOPS与libaio相同，是psync的两倍。io_uring的异步操作在内核下完成，用户态调用api是感觉不到异步操作的。
硬盘由于io设备错误无法运行此项请求_使用Go进行io_uring的动手实践
weixin_39981185的博客
11-22 563
作者:秃头大哥出处:https://studygolang.com/articles/31360在Linux中，系统调用(syscalls)是一切的核心。 它们是应用程序与内核交互的主要接口。 因此，至关重要的是它们要快。 尤其在后Spectre / Meltdown后世界中，这一点尤为重要。如果觉得看完文章有所收获的话，可以关注我一下哦知乎： 秃顶之路:https://www.zhihu.com...
Linux网络设计之实现io_uring用户态接口
Lion_Long的博客
09-07 381
io_uring比epoll好的点是io_uring使用共享内存，不仅仅共享了IO事件，需要的变量也通过共享内存共享到用户空间，像SQ和CQ队列。io_uring不仅可以处理网络IO，也可以处理磁盘IO。
io_uring技术的分析与思考
dillanzhou的博客
12-03 9042
io_uring是Linux 5.1中引入的一套新的syscall接口，用于支持异步IO。近来这套机制颇受关注，很多人认为它代表了与内核实现高性能交互的一种模式。本文将对io_uring的原理和实现进行分析，了解其相对于原有IO机制的优势，并尝试预测其应用场景和发展趋势。 异步IO机制 在介绍io_uring之前，需要先了解一下其实现的异步IO机制，以及io_uring之前的异步IO是如何实现的。 在linux下，目前绝大部分程序中的IO操作都是同步的，最后通过read/write系列的系统调用实现对
linux异步IO：io_uring
Mr0cheng的专栏
03-18 1253
为了改善posix aio目前存在的问题，新的异步IO驱动：io_uring如何解决了posix aio的问题。围绕这个问题，本文首先介绍了异步IO的概念，然后介绍了posix aio存在的问题，最后根据io_uring的源码分析io_uring为什么比posix aio优异。 同步IO和异步IO posix定义如下： 同步IO：导致请求进程阻塞，知道IO操作完成。 异步IO：不导致请求进程阻塞。...
mac rust io-uring
最新发布
09-06
Mac Rust io-uring是一种在Mac操作系统上使用Rust语言进行开发的io-uring库。 io-uring是Linux内核中的一个新特性，它为应用程序提供了一种高性能、高效率的异步I/O操作方式。它通过使用事件驱动和无锁技术，实现了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值