Re: [PATCH v1 09/30] io_uring: add io_uring_cmd_import_fixed_index()

[Caleb Sander Mateos <csander@purestorage.com>]

On Tue, Dec 2, 2025 at 4:36 PM Joanne Koong <joannelkoong@gmail.com> wrote:
>
> Add a new helper, io_uring_cmd_import_fixed_index(). This takes in a
> buffer index. This requires the buffer table to have been pinned
> beforehand. The caller is responsible for ensuring it does not use the
> returned iter after the buffer table has been unpinned.
>
> This is a preparatory patch needed for fuse-over-io-uring support, as
> the metadata for fuse requests will be stored at the last index, which
> will be different from the sqe's buffer index.
>
> Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
> ---
>  include/linux/io_uring/cmd.h | 10 ++++++++++
>  io_uring/rsrc.c              | 31 +++++++++++++++++++++++++++++++
>  io_uring/rsrc.h              |  2 ++
>  io_uring/uring_cmd.c         | 11 +++++++++++
>  4 files changed, 54 insertions(+)
>
> diff --git a/include/linux/io_uring/cmd.h b/include/linux/io_uring/cmd.h
> index 375fd048c4cb..a4b5eae2e5d1 100644
> --- a/include/linux/io_uring/cmd.h
> +++ b/include/linux/io_uring/cmd.h
> @@ -44,6 +44,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);
> +int io_uring_cmd_import_fixed_index(struct io_uring_cmd *ioucmd, u16 buf_index,
> +                                   int ddir, struct iov_iter *iter,
> +                                   unsigned int issue_flags);
>
>  /*
>   * Completes the request, i.e. posts an io_uring CQE and deallocates @ioucmd
> @@ -100,6 +103,13 @@ static inline int io_uring_cmd_import_fixed_vec(struct io_uring_cmd *ioucmd,
>  {
>         return -EOPNOTSUPP;
>  }
> +static inline int io_uring_cmd_import_fixed_index(struct io_uring_cmd *ioucmd,
> +                                                 u16 buf_index, int ddir,
> +                                                 struct iov_iter *iter,
> +                                                 unsigned int issue_flags)
> +{
> +       return -EOPNOTSUPP;
> +}
>  static inline void __io_uring_cmd_done(struct io_uring_cmd *cmd, s32 ret,
>                 u64 ret2, unsigned issue_flags, bool is_cqe32)
>  {
> diff --git a/io_uring/rsrc.c b/io_uring/rsrc.c
> index 67331cae0a5a..b6dd62118311 100644
> --- a/io_uring/rsrc.c
> +++ b/io_uring/rsrc.c
> @@ -1156,6 +1156,37 @@ int io_import_reg_buf(struct io_kiocb *req, struct iov_iter *iter,
>         return io_import_fixed(ddir, iter, node->buf, buf_addr, len);
>  }
>
> +int io_import_reg_buf_index(struct io_kiocb *req, struct iov_iter *iter,
> +                           u16 buf_index, int ddir, unsigned issue_flags)
> +{
> +       struct io_ring_ctx *ctx = req->ctx;
> +       struct io_rsrc_node *node;
> +       struct io_mapped_ubuf *imu;
> +
> +       io_ring_submit_lock(ctx, issue_flags);
> +
> +       if (buf_index >= req->ctx->buf_table.nr ||

This condition is already checked in io_rsrc_node_lookup() below.

> +           !(ctx->buf_table.flags & IO_RSRC_DATA_PINNED)) {
> +               io_ring_submit_unlock(ctx, issue_flags);
> +               return -EINVAL;
> +       }
> +
> +       /*
> +        * We don't have to grab the reference on the node because the buffer
> +        * table is pinned. The caller is responsible for ensuring the iter
> +        * isn't used after the buffer table has been unpinned.
> +        */
> +       node = io_rsrc_node_lookup(&ctx->buf_table, buf_index);
> +       io_ring_submit_unlock(ctx, issue_flags);
> +
> +       if (!node || !node->buf)
> +               return -EFAULT;
> +
> +       imu = node->buf;
> +
> +       return io_import_fixed(ddir, iter, imu, imu->ubuf, imu->len);
> +}
> +
>  /* 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)
>  {
> diff --git a/io_uring/rsrc.h b/io_uring/rsrc.h
> index d603f6a47f5e..658934f4d3ff 100644
> --- a/io_uring/rsrc.h
> +++ b/io_uring/rsrc.h
> @@ -64,6 +64,8 @@ struct io_rsrc_node *io_find_buf_node(struct io_kiocb *req,
>  int io_import_reg_buf(struct io_kiocb *req, struct iov_iter *iter,
>                         u64 buf_addr, size_t len, int ddir,
>                         unsigned issue_flags);
> +int io_import_reg_buf_index(struct io_kiocb *req, struct iov_iter *iter,
> +                           u16 buf_index, int ddir, unsigned issue_flags);
>  int io_import_reg_vec(int ddir, struct iov_iter *iter,
>                         struct io_kiocb *req, struct iou_vec *vec,
>                         unsigned nr_iovs, unsigned issue_flags);
> diff --git a/io_uring/uring_cmd.c b/io_uring/uring_cmd.c
> index 197474911f04..e077eba00efe 100644
> --- a/io_uring/uring_cmd.c
> +++ b/io_uring/uring_cmd.c
> @@ -314,6 +314,17 @@ int io_uring_cmd_import_fixed_vec(struct io_uring_cmd *ioucmd,
>  }
>  EXPORT_SYMBOL_GPL(io_uring_cmd_import_fixed_vec);
>
> +int io_uring_cmd_import_fixed_index(struct io_uring_cmd *ioucmd, u16 buf_index,
> +                                   int ddir, struct iov_iter *iter,
> +                                   unsigned int issue_flags)
> +{
> +       struct io_kiocb *req = cmd_to_io_kiocb(ioucmd);
> +
> +       return io_import_reg_buf_index(req, iter, buf_index, ddir,
> +                                      issue_flags);
> +}

Probably would make sense to make this an inline function, since it
immediately defers to io_import_reg_buf_index().

Best,
Caleb

> +EXPORT_SYMBOL_GPL(io_uring_cmd_import_fixed_index);
> +
>  void io_uring_cmd_issue_blocking(struct io_uring_cmd *ioucmd)
>  {
>         struct io_kiocb *req = cmd_to_io_kiocb(ioucmd);
> --
> 2.47.3
>