io_uring: extend bvec registration and add mem region lookup
Subsystems (4)
cover io_uring: extend bvec registration and add mem region lookup
This series refactors and extends the io_uring registered buffers infrastructure to allow external subsystems to register pre-existing bvec arrays directly and obtain references to registered memory regions.
The motivation for the patches in this series is to make fuse zero-copy possible.
These patches are split out from a previous larger fuse-over-io_uring series [1]. The remaining fuse patches will be submitted separately and linked to.
Thanks,
Joanne
[1] https://lore.kernel.org/linux-fsdevel/[email protected]/
Joanne Koong (5):
io_uring/rsrc: rename
io_buffer_register_bvec()/io_buffer_unregister_bvec()
io_uring/rsrc: split io_buffer_register_request() logic io_uring/rsrc: allow buffer release callback to be optional io_uring/rsrc: add io_buffer_register_bvec() io_uring/rsrc: add io_uring_registered_mem_region_get()
Documentation/block/ublk.rst | 14 ++-- drivers/block/ublk_drv.c | 22 +++--- include/linux/io_uring/cmd.h | 47 ++++++++++-- io_uring/rsrc.c | 143 ++++++++++++++++++++++++++--------- 4 files changed, 165 insertions(+), 61 deletions(-)
Signature · 1 line
2.52.0
PATCH 1/5 io_uring/rsrc: rename io_buffer_register_bvec()/io_buffer_unregister_bvec()
Currently, io_buffer_register_bvec() takes in a request. In preparation for supporting kernel-populated buffers in fuse io-uring (which will need to register bvecs directly, not through a struct request), rename this to io_buffer_register_request().
A subsequent patch will commandeer the "io_buffer_register_bvec()" function name to support registering bvecs directly.
Rename io_buffer_unregister_bvec() to a more generic name, io_buffer_unregister(), as both io_buffer_register_request() and io_buffer_register_bvec() callers will use it for unregistration.
--- Documentation/block/ublk.rst | 14 +++++++------- drivers/block/ublk_drv.c | 22 +++++++++++----------- include/linux/io_uring/cmd.h | 26 ++++++++++++++++++++------ io_uring/rsrc.c | 14 +++++++------- 4 files changed, 45 insertions(+), 31 deletions(-)
Documentation/block/ublk.rst +7 -7
@@ -382,17 +382,17 @@ Zero copy --------- ublk zero copy relies on io_uring's fixed kernel buffer, which provides -two APIs: `io_buffer_register_bvec()` and `io_buffer_unregister_bvec`. +two APIs: `io_buffer_register_request()` and `io_buffer_unregister`. ublk adds IO command of `UBLK_IO_REGISTER_IO_BUF` to call -`io_buffer_register_bvec()` for ublk server to register client request +`io_buffer_register_request()` for ublk server to register client request buffer into io_uring buffer table, then ublk server can submit io_uring IOs with the registered buffer index. IO command of `UBLK_IO_UNREGISTER_IO_BUF` -calls `io_buffer_unregister_bvec()` to unregister the buffer, which is -guaranteed to be live between calling `io_buffer_register_bvec()` and -`io_buffer_unregister_bvec()`. Any io_uring operation which supports this -kind of kernel buffer will grab one reference of the buffer until the -operation is completed. +calls `io_buffer_unregister()` to unregister the buffer, which is guaranteed +to be live between calling `io_buffer_register_request()` and +`io_buffer_unregister()`. Any io_uring operation which supports this kind of +kernel buffer will grab one reference of the buffer until the operation is +completed. ublk server implementing zero copy or user copy has to be CAP_SYS_ADMIN and be trusted, because it is ublk server's responsibility to make sure IO buffer
drivers/block/ublk_drv.c +11 -11
@@ -1627,8 +1627,8 @@ ublk_auto_buf_register(const struct ublk_queue *ubq, struct request *req, {int ret; - ret =io_buffer_register_bvec (cmd, req, ublk_io_release, - io->buf.auto_reg.index, issue_flags); + ret =io_buffer_register_request (cmd, req, ublk_io_release, + io->buf.auto_reg.index, issue_flags);if (ret) {if (io->buf.auto_reg.flags &UBLK_AUTO_BUF_REG_FALLBACK ) {ublk_auto_buf_reg_fallback (ubq, req->tag);
@@ -1868,7 +1868,7 @@ static int __ublk_batch_dispatch(struct ublk_queue *ubq,ublk_io_unlock (io);if (index !=-1 ) -io_buffer_unregister_bvec (data->cmd, index, +io_buffer_unregister (data->cmd, index, data->issue_flags); }
@@ -3091,8 +3091,8 @@ static int ublk_register_io_buf(struct io_uring_cmd *cmd,if (!req)return -EINVAL ; - ret =io_buffer_register_bvec (cmd, req, ublk_io_release, index, - issue_flags); + ret =io_buffer_register_request (cmd, req, ublk_io_release, index, + issue_flags);if (ret) {ublk_put_req_ref (io, req);return ret;
@@ -3123,8 +3123,8 @@ ublk_daemon_register_io_buf(struct io_uring_cmd *cmd,if (!ublk_dev_support_zero_copy (ub) || !ublk_rq_has_data (req))return -EINVAL ; - ret =io_buffer_register_bvec (cmd, req, ublk_io_release, index, - issue_flags); + ret =io_buffer_register_request (cmd, req, ublk_io_release, index, + issue_flags);if (ret)return ret;
@@ -3139,7 +3139,7 @@ static int ublk_unregister_io_buf(struct io_uring_cmd *cmd,if (!(ub->dev_info.flags &UBLK_F_SUPPORT_ZERO_COPY ))return -EINVAL ; -return io_buffer_unregister_bvec (cmd, index, issue_flags); +return io_buffer_unregister (cmd, index, issue_flags); }static int ublk_check_fetch_buf (const struct ublk_device *ub,__u64 buf_addr)
@@ -3280,7 +3280,7 @@ static int ublk_ch_uring_cmd_local(struct io_uring_cmd *cmd, goto out;/* -* io_buffer_unregister_bvec() doesn't access the ubq or io, +* io_buffer_unregister() doesn't access the ubq or io, * so no need to validate the q_id, tag, or task */ if (_IOC_NR (cmd_op) ==UBLK_IO_UNREGISTER_IO_BUF )
@@ -3347,7 +3347,7 @@ static int ublk_ch_uring_cmd_local(struct io_uring_cmd *cmd, req =ublk_fill_io_cmd (io, cmd); ret =ublk_config_io_buf (ub, io, cmd, addr, &buf_idx);if (buf_idx !=UBLK_INVALID_BUF_IDX ) -io_buffer_unregister_bvec (cmd, buf_idx, issue_flags); +io_buffer_unregister (cmd, buf_idx, issue_flags); compl =ublk_need_complete_req (ub, io);if (req_op (req) ==REQ_OP_ZONE_APPEND )
@@ -3682,7 +3682,7 @@ static int ublk_batch_commit_io(struct ublk_queue *ubq, }if (buf_idx !=UBLK_INVALID_BUF_IDX ) -io_buffer_unregister_bvec (data->cmd, buf_idx, data->issue_flags); +io_buffer_unregister (data->cmd, buf_idx, data->issue_flags);if (req_op (req) ==REQ_OP_ZONE_APPEND ) req->__sector =ublk_batch_zone_lba (uc, elem);if (compl)
include/linux/io_uring/cmd.h +20 -6
@@ -106,6 +106,12 @@ bool io_uring_is_kmbuf_ring(struct io_uring_cmd *cmd, unsigned int buf_group,struct io_br_sel io_ring_buffer_select (struct io_kiocb *req,size_t *len,struct io_buffer_list *bl,unsigned int issue_flags); + +int io_buffer_register_request (struct io_uring_cmd *cmd,struct request *rq, +void (*release)(void *),unsigned int index, +unsigned int issue_flags); +int io_buffer_unregister (struct io_uring_cmd *cmd,unsigned int index, +unsigned int issue_flags);#else static inline int io_uring_cmd_import_fixed(u64 ubuf, unsigned long len, int rw,
@@ -184,6 +190,20 @@ static inline struct io_br_sel io_ring_buffer_select(struct io_kiocb *req, };return sel; } +static inline int io_buffer_register_request (struct io_uring_cmd *cmd, +struct request *rq, +void (*release)(void *), +unsigned int index, +unsigned int issue_flags) +{ +return -EOPNOTSUPP ; +} +static inline int io_buffer_unregister (struct io_uring_cmd *cmd, +unsigned int index, +unsigned int issue_flags) +{ +return -EOPNOTSUPP ; +}#endif static inline struct io_uring_cmd *io_uring_cmd_from_tw (struct io_tw_req tw_req)
@@ -233,10 +253,4 @@ static inline void io_uring_cmd_done32(struct io_uring_cmd *ioucmd, s32 ret, return __io_uring_cmd_done(ioucmd, ret, res2, issue_flags, true); } -int io_buffer_register_bvec (struct io_uring_cmd *cmd,struct request *rq, -void (*release)(void *),unsigned int index, -unsigned int issue_flags); -int io_buffer_unregister_bvec (struct io_uring_cmd *cmd,unsigned int index, -unsigned int issue_flags); -#endif /* _LINUX_IO_URING_CMD_H */
io_uring/rsrc.c +7 -7
@@ -924,9 +924,9 @@ int io_sqe_buffers_register(struct io_ring_ctx *ctx, void __user *arg,return ret; } -int io_buffer_register_bvec (struct io_uring_cmd *cmd,struct request *rq, -void (*release)(void *),unsigned int index, -unsigned int issue_flags) +int io_buffer_register_request (struct io_uring_cmd *cmd,struct request *rq, +void (*release)(void *),unsigned int index, +unsigned int issue_flags) {struct io_ring_ctx *ctx =cmd_to_io_kiocb (cmd)->ctx;struct io_rsrc_data *data = &ctx->buf_table;
@@ -986,10 +986,10 @@ int io_buffer_register_bvec(struct io_uring_cmd *cmd, struct request *rq,io_ring_submit_unlock (ctx, issue_flags);return ret; } -EXPORT_SYMBOL_GPL (io_buffer_register_bvec); +EXPORT_SYMBOL_GPL (io_buffer_register_request); -int io_buffer_unregister_bvec (struct io_uring_cmd *cmd,unsigned int index, -unsigned int issue_flags) +int io_buffer_unregister (struct io_uring_cmd *cmd,unsigned int index, +unsigned int issue_flags) {struct io_ring_ctx *ctx =cmd_to_io_kiocb (cmd)->ctx;struct io_rsrc_data *data = &ctx->buf_table;
@@ -1019,7 +1019,7 @@ int io_buffer_unregister_bvec(struct io_uring_cmd *cmd, unsigned int index,io_ring_submit_unlock (ctx, issue_flags);return ret; } -EXPORT_SYMBOL_GPL (io_buffer_unregister_bvec); +EXPORT_SYMBOL_GPL (io_buffer_unregister);static int validate_fixed_range (u64 buf_addr,size_t len,const struct io_mapped_ubuf *imu)
Signature · 1 line
2.52.0
PATCH 2/5 io_uring/rsrc: split io_buffer_register_request() logic
In reply to Joanne KoongSplit the main initialization logic in io_buffer_register_request() into a helper function.
This is a preparatory patch for supporting kernel-populated buffers in fuse io-uring, which will be reusing this logic.
--- io_uring/rsrc.c | 84 ++++++++++++++++++++++++++++++------------------- 1 file changed, 51 insertions(+), 33 deletions(-)
io_uring/rsrc.c +51 -33
@@ -924,64 +924,82 @@ int io_sqe_buffers_register(struct io_ring_ctx *ctx, void __user *arg,return ret; } -int io_buffer_register_request (struct io_uring_cmd *cmd,struct request *rq, -void (*release)(void *),unsigned int index, -unsigned int issue_flags) +static struct io_mapped_ubuf *io_kernel_buffer_init (struct io_ring_ctx *ctx, +unsigned int nr_bvecs, +unsigned int total_bytes, +u8 dir, +void (*release)(void *), +void *priv, +unsigned int index) { -struct io_ring_ctx *ctx =cmd_to_io_kiocb (cmd)->ctx;struct io_rsrc_data *data = &ctx->buf_table; -struct req_iterator rq_iter;struct io_mapped_ubuf *imu;struct io_rsrc_node *node; -struct bio_vec bv; -unsigned int nr_bvecs =0 ; -int ret =0 ; -io_ring_submit_lock (ctx, issue_flags); -if (index >= data->nr) { - ret = -EINVAL ; - goto unlock; - } +if (index >= data->nr) +return ERR_PTR (-EINVAL ); index =array_index_nospec (index, data->nr); -if (data->nodes[index]) { - ret = -EBUSY ; - goto unlock; - } +if (data->nodes[index]) +return ERR_PTR (-EBUSY ); node =io_rsrc_node_alloc (ctx,IORING_RSRC_BUFFER ); -if (!node) { - ret = -ENOMEM ; - goto unlock; - } +if (!node) +return ERR_PTR (-ENOMEM ); -/* -* blk_rq_nr_phys_segments() may overestimate the number of bvecs -* but avoids needing to iterate over the bvecs -*/ - imu =io_alloc_imu (ctx,blk_rq_nr_phys_segments (rq)); + imu =io_alloc_imu (ctx, nr_bvecs);if (!imu) {kfree (node); - ret = -ENOMEM ; - goto unlock; +return ERR_PTR (-ENOMEM ); } imu->ubuf =0 ; - imu->len =blk_rq_bytes (rq); + imu->len = total_bytes; imu->acct_pages =0 ; imu->folio_shift =PAGE_SHIFT ; + imu->nr_bvecs = nr_bvecs;refcount_set (&imu->refs,1 ); imu->release = release; - imu->priv = rq; + imu->priv = priv; + imu->dir =1 << dir; imu->flags =IO_REGBUF_F_KBUF ; - imu->dir =1 <<rq_data_dir (rq); + node->buf = imu; + data->nodes[index] = node; + +return imu; +} + +int io_buffer_register_request (struct io_uring_cmd *cmd,struct request *rq, +void (*release)(void *),unsigned int index, +unsigned int issue_flags) +{ +struct io_ring_ctx *ctx =cmd_to_io_kiocb (cmd)->ctx; +struct req_iterator rq_iter; +struct io_mapped_ubuf *imu; +struct bio_vec bv; +/* +* blk_rq_nr_phys_segments() may overestimate the number of bvecs +* but avoids needing to iterate over the bvecs +*/ +unsigned int nr_bvecs =blk_rq_nr_phys_segments (rq); +unsigned int total_bytes =blk_rq_bytes (rq); +int ret =0 ; + +io_ring_submit_lock (ctx, issue_flags); + + imu =io_kernel_buffer_init (ctx, nr_bvecs, total_bytes,rq_data_dir (rq), + release, rq, index); +if (IS_ERR (imu)) { + ret =PTR_ERR (imu); + goto unlock; + } + + nr_bvecs =0 ;rq_for_each_bvec (bv, rq, rq_iter) imu->bvec[nr_bvecs++] = bv; imu->nr_bvecs = nr_bvecs; - node->buf = imu; - data->nodes[index] = node; unlock:io_ring_submit_unlock (ctx, issue_flags);return ret;
Signature · 1 line
2.52.0
Re: [PATCH v1 2/5] io_uring/rsrc: split io_buffer_register_request() logic
Quoted 79 lines · Joanne Koong
Split the main initialization logic in
io_buffer_register_request()into a helper function.This is a preparatory patch for supporting kernel-populated buffers in fuse io-uring, which will be reusing this logic.
Signed-off-by Joanne Koong <[email protected]>Reviewed-by Caleb Sander Mateos <[email protected]>--- io_uring/rsrc.c | 84 ++++++++++++++++++++++++++++++------------------- 1 file changed, 51 insertions(+), 33 deletions(-)io_uring/rsrc.c +15
-28@@ -924,64 +924,82 @@ int io_sqe_buffers_register(struct io_ring_ctx *ctx, void __user *arg,return ret; } -int io_buffer_register_request (struct io_uring_cmd *cmd,struct request *rq, -void (*release)(void *),unsigned int index, -unsigned int issue_flags) +static struct io_mapped_ubuf *io_kernel_buffer_init (struct io_ring_ctx *ctx, +unsigned int nr_bvecs, +unsigned int total_bytes, +u8 dir, +void (*release)(void *), +void *priv, +unsigned int index) { -struct io_ring_ctx *ctx =cmd_to_io_kiocb (cmd)->ctx;struct io_rsrc_data *data = &ctx->buf_table; -struct req_iterator rq_iter;struct io_mapped_ubuf *imu;struct io_rsrc_node *node; -struct bio_vec bv; -unsigned int nr_bvecs =0 ; -int ret =0 ; -io_ring_submit_lock (ctx, issue_flags); -if (index >= data->nr) { - ret = -EINVAL ; - goto unlock; - } +if (index >= data->nr) +return ERR_PTR (-EINVAL ); index =array_index_nospec (index, data->nr); -if (data->nodes[index]) { - ret = -EBUSY ; - goto unlock; - } +if (data->nodes[index]) +return ERR_PTR (-EBUSY ); node =io_rsrc_node_alloc (ctx,IORING_RSRC_BUFFER ); -if (!node) { - ret = -ENOMEM ; - goto unlock; - } +if (!node) +return ERR_PTR (-ENOMEM ); -/* -* blk_rq_nr_phys_segments() may overestimate the number of bvecs -* but avoids needing to iterate over the bvecs -*/ - imu =io_alloc_imu (ctx,blk_rq_nr_phys_segments (rq)); + imu =io_alloc_imu (ctx, nr_bvecs);if (!imu) {kfree (node); - ret = -ENOMEM ; - goto unlock; +return ERR_PTR (-ENOMEM ); } imu->ubuf =0 ;
io_uring/rsrc.c int io_sqe_buffers_register(struct io_ring_ctx *ctx, void __user *arg, · line 964
Quoted 10 lines
io_uring/rsrc.c +4
-2- imu->len =blk_rq_bytes (rq); + imu->len = total_bytes; imu->acct_pages =0 ; imu->folio_shift =PAGE_SHIFT ; + imu->nr_bvecs = nr_bvecs;refcount_set (&imu->refs,1 ); imu->release = release; - imu->priv = rq; + imu->priv = priv; + imu->dir =1 << dir;
I'm going to update this line to take a bitmasked dir directly so that callers can set both dest and source if needed. I'll send out v2 with this change.
Thanks,
Joanne
Quoted 9 lines
io_uring/rsrc.c +6
-1imu->flags =IO_REGBUF_F_KBUF ; - imu->dir =1 <<rq_data_dir (rq); + node->buf = imu; + data->nodes[index] = node; + +return imu; +} +
PATCH 3/5 io_uring/rsrc: allow buffer release callback to be optional
In reply to Joanne KoongThis is a preparatory patch for supporting kernel-populated buffers in fuse io-uring, which does not need a release callback.
--- io_uring/rsrc.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
io_uring/rsrc.c +2 -1
@@ -133,7 +133,8 @@ static void io_buffer_unmap(struct io_ring_ctx *ctx, struct io_mapped_ubuf *imu)if (imu->acct_pages)io_unaccount_mem (ctx->user, ctx->mm_account, imu->acct_pages); - imu->release (imu->priv); +if (imu->release) + imu->release (imu->priv);io_free_imu (ctx, imu); }
Signature · 1 line
2.52.0
PATCH 4/5 io_uring/rsrc: add io_buffer_register_bvec()
In reply to Joanne KoongAdd io_buffer_register_bvec() for registering a bvec array.
This is a preparatory patch for fuse-over-io-uring zero-copy.
--- include/linux/io_uring/cmd.h | 12 ++++++++++++ io_uring/rsrc.c | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+)
include/linux/io_uring/cmd.h +12 -0
@@ -110,6 +110,9 @@ struct io_br_sel io_ring_buffer_select(struct io_kiocb *req, size_t *len,int io_buffer_register_request (struct io_uring_cmd *cmd,struct request *rq,void (*release)(void *),unsigned int index,unsigned int issue_flags); +int io_buffer_register_bvec (struct io_uring_cmd *cmd,const struct bio_vec *bvs, +unsigned int nr_bvecs,unsigned int total_bytes, +u8 dir,unsigned int index,unsigned int issue_flags);int io_buffer_unregister (struct io_uring_cmd *cmd,unsigned int index,unsigned int issue_flags);#else
@@ -198,6 +201,15 @@ static inline int io_buffer_register_request(struct io_uring_cmd *cmd, {return -EOPNOTSUPP ; } +static inline int io_buffer_register_bvec (struct io_uring_cmd *cmd, +const struct bio_vec *bvs, +unsigned int nr_bvecs, +unsigned int total_bytes,u8 dir, +unsigned int index, +unsigned int issue_flags) +{ +return -EOPNOTSUPP ; +}static inline int io_buffer_unregister (struct io_uring_cmd *cmd,unsigned int index,unsigned int issue_flags)
io_uring/rsrc.c +32 -0
@@ -1007,6 +1007,38 @@ int io_buffer_register_request(struct io_uring_cmd *cmd, struct request *rq, }EXPORT_SYMBOL_GPL (io_buffer_register_request); +/* +* bvs is copied internally. caller may free it on return. +*/ +int io_buffer_register_bvec (struct io_uring_cmd *cmd,const struct bio_vec *bvs, +unsigned int nr_bvecs,unsigned int total_bytes, +u8 dir,unsigned int index, +unsigned int issue_flags) +{ +struct io_ring_ctx *ctx =cmd_to_io_kiocb (cmd)->ctx; +struct io_mapped_ubuf *imu; +struct bio_vec *bvec; +unsigned int i; +int ret =0 ; + +io_ring_submit_lock (ctx, issue_flags); + imu =io_kernel_buffer_init (ctx, nr_bvecs, total_bytes, dir,NULL , +NULL , index); +if (IS_ERR (imu)) { + ret =PTR_ERR (imu); + goto unlock; + } + + bvec = imu->bvec; +for (i =0 ; i < nr_bvecs; i++) + bvec[i] = bvs[i]; + +unlock: +io_ring_submit_unlock (ctx, issue_flags); +return ret; +} +EXPORT_SYMBOL_GPL (io_buffer_register_bvec); +int io_buffer_unregister (struct io_uring_cmd *cmd,unsigned int index,unsigned int issue_flags) {
Signature · 1 line
2.52.0
PATCH 5/5 io_uring/rsrc: add io_uring_registered_mem_region_get()
In reply to Joanne KoongAdd io_uring_registered_mem_region_get() helper to allow io_uring command handlers to retrieve the vmapped pointer to the ring's registered memory region's pages as well as the size of the region. This provides a way for uring cmd implementations to directly access pre-registered memory for passing data.
This will be used by fuse for reading/writing header data between the kernel and the server.
--- include/linux/io_uring/cmd.h | 9 +++++++++ io_uring/rsrc.c | 18 ++++++++++++++++++ 2 files changed, 27 insertions(+)
include/linux/io_uring/cmd.h +9 -0
@@ -51,6 +51,9 @@ int io_uring_cmd_import_fixed_vec(struct io_uring_cmd *ioucmd,size_t uvec_segs, int ddir, struct iov_iter *iter, unsigned issue_flags); +void *io_uring_registered_mem_region_get (struct io_uring_cmd *cmd, +unsigned *nr_pages, +unsigned issue_flags);/* * Completes the request, i.e. posts an io_uring CQE and deallocates @ioucmd
@@ -131,6 +134,12 @@ static inline int io_uring_cmd_import_fixed_vec(struct io_uring_cmd *ioucmd, {return -EOPNOTSUPP ; } +static inline void *io_uring_registered_mem_region_get (struct io_uring_cmd *cmd, +unsigned *nr_pages, +unsigned issue_flags) +{ +return NULL ; +}static inline void __io_uring_cmd_done (struct io_uring_cmd *cmd,s32 ret,u64 ret2,unsigned issue_flags,bool is_cqe32) {
io_uring/rsrc.c +18 -0
@@ -1180,6 +1180,24 @@ int io_import_reg_buf(struct io_kiocb *req, struct iov_iter *iter,return io_import_fixed (ddir, iter, node->buf, buf_addr, len); } +void *io_uring_registered_mem_region_get (struct io_uring_cmd *cmd, +unsigned *nr_pages, +unsigned issue_flags) +{ +struct io_ring_ctx *ctx =cmd_to_io_kiocb (cmd)->ctx; +void *ptr; + +io_ring_submit_lock (ctx, issue_flags); + + ptr = ctx->param_region.ptr; + *nr_pages = ctx->param_region.nr_pages; + +io_ring_submit_unlock (ctx, issue_flags); + +return ptr; +} +EXPORT_SYMBOL_GPL (io_uring_registered_mem_region_get); +/* Lock two rings at once. The rings must be different! */ static void lock_two_rings (struct io_ring_ctx *ctx1,struct io_ring_ctx *ctx2) {
Signature · 1 line
2.52.0