2022-05-25 19:59:19 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/io_uring.h>
|
2022-07-16 03:16:22 +08:00
|
|
|
#include <linux/security.h>
|
2022-09-30 14:27:39 +08:00
|
|
|
#include <linux/nospec.h>
|
2022-05-25 19:59:19 +08:00
|
|
|
|
|
|
|
#include <uapi/linux/io_uring.h>
|
|
|
|
|
|
|
|
#include "io_uring.h"
|
2022-09-30 14:27:38 +08:00
|
|
|
#include "rsrc.h"
|
2022-05-25 19:59:19 +08:00
|
|
|
#include "uring_cmd.h"
|
|
|
|
|
2023-03-27 23:38:15 +08:00
|
|
|
static void io_uring_cmd_work(struct io_kiocb *req, struct io_tw_state *ts)
|
2022-05-25 19:59:19 +08:00
|
|
|
{
|
2022-08-11 15:11:15 +08:00
|
|
|
struct io_uring_cmd *ioucmd = io_kiocb_to_cmd(req, struct io_uring_cmd);
|
2023-03-27 23:38:15 +08:00
|
|
|
unsigned issue_flags = ts->locked ? 0 : IO_URING_F_UNLOCKED;
|
2022-05-25 19:59:19 +08:00
|
|
|
|
2023-03-21 10:01:25 +08:00
|
|
|
ioucmd->task_work_cb(ioucmd, issue_flags);
|
2022-05-25 19:59:19 +08:00
|
|
|
}
|
|
|
|
|
2023-05-15 20:54:42 +08:00
|
|
|
void __io_uring_cmd_do_in_task(struct io_uring_cmd *ioucmd,
|
|
|
|
void (*task_work_cb)(struct io_uring_cmd *, unsigned),
|
|
|
|
unsigned flags)
|
2022-05-25 19:59:19 +08:00
|
|
|
{
|
|
|
|
struct io_kiocb *req = cmd_to_io_kiocb(ioucmd);
|
|
|
|
|
|
|
|
ioucmd->task_work_cb = task_work_cb;
|
|
|
|
req->io_task_work.func = io_uring_cmd_work;
|
2023-05-15 20:54:42 +08:00
|
|
|
__io_req_task_work_add(req, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__io_uring_cmd_do_in_task);
|
|
|
|
|
|
|
|
void io_uring_cmd_do_in_task_lazy(struct io_uring_cmd *ioucmd,
|
|
|
|
void (*task_work_cb)(struct io_uring_cmd *, unsigned))
|
|
|
|
{
|
|
|
|
__io_uring_cmd_do_in_task(ioucmd, task_work_cb, IOU_F_TWQ_LAZY_WAKE);
|
2022-05-25 19:59:19 +08:00
|
|
|
}
|
2023-05-15 20:54:42 +08:00
|
|
|
EXPORT_SYMBOL_GPL(io_uring_cmd_do_in_task_lazy);
|
2022-05-25 19:59:19 +08:00
|
|
|
|
|
|
|
static inline void io_req_set_cqe32_extra(struct io_kiocb *req,
|
|
|
|
u64 extra1, u64 extra2)
|
|
|
|
{
|
|
|
|
req->extra1 = extra1;
|
|
|
|
req->extra2 = extra2;
|
|
|
|
req->flags |= REQ_F_CQE32_INIT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called by consumers of io_uring_cmd, if they originally returned
|
|
|
|
* -EIOCBQUEUED upon receiving the command.
|
|
|
|
*/
|
2023-03-21 10:01:25 +08:00
|
|
|
void io_uring_cmd_done(struct io_uring_cmd *ioucmd, ssize_t ret, ssize_t res2,
|
|
|
|
unsigned issue_flags)
|
2022-05-25 19:59:19 +08:00
|
|
|
{
|
|
|
|
struct io_kiocb *req = cmd_to_io_kiocb(ioucmd);
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
req_set_fail(req);
|
|
|
|
|
2022-08-03 20:07:57 +08:00
|
|
|
io_req_set_res(req, ret, 0);
|
2022-05-25 19:59:19 +08:00
|
|
|
if (req->ctx->flags & IORING_SETUP_CQE32)
|
|
|
|
io_req_set_cqe32_extra(req, res2, 0);
|
2023-04-13 02:07:36 +08:00
|
|
|
if (req->ctx->flags & IORING_SETUP_IOPOLL) {
|
2022-08-24 00:14:41 +08:00
|
|
|
/* order with io_iopoll_req_issued() checking ->iopoll_complete */
|
|
|
|
smp_store_release(&req->iopoll_completed, 1);
|
2023-04-13 02:07:36 +08:00
|
|
|
} else {
|
|
|
|
struct io_tw_state ts = {
|
|
|
|
.locked = !(issue_flags & IO_URING_F_UNLOCKED),
|
|
|
|
};
|
|
|
|
io_req_task_complete(req, &ts);
|
|
|
|
}
|
2022-05-25 19:59:19 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(io_uring_cmd_done);
|
|
|
|
|
|
|
|
int io_uring_cmd_prep_async(struct io_kiocb *req)
|
|
|
|
{
|
2022-08-11 15:11:15 +08:00
|
|
|
struct io_uring_cmd *ioucmd = io_kiocb_to_cmd(req, struct io_uring_cmd);
|
2022-05-25 19:59:19 +08:00
|
|
|
|
io_uring: Pass whole sqe to commands
Currently uring CMD operation relies on having large SQEs, but future
operations might want to use normal SQE.
The io_uring_cmd currently only saves the payload (cmd) part of the SQE,
but, for commands that use normal SQE size, it might be necessary to
access the initial SQE fields outside of the payload/cmd block. So,
saves the whole SQE other than just the pdu.
This changes slightly how the io_uring_cmd works, since the cmd
structures and callbacks are not opaque to io_uring anymore. I.e, the
callbacks can look at the SQE entries, not only, in the cmd structure.
The main advantage is that we don't need to create custom structures for
simple commands.
Creates io_uring_sqe_cmd() that returns the cmd private data as a null
pointer and avoids casting in the callee side.
Also, make most of ublk_drv's sqe->cmd priv structure into const, and use
io_uring_sqe_cmd() to get the private structure, removing the unwanted
cast. (There is one case where the cast is still needed since the
header->{len,addr} is updated in the private structure)
Suggested-by: Pavel Begunkov <asml.silence@gmail.com>
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Keith Busch <kbusch@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Pavel Begunkov <asml.silence@gmail.com>
Link: https://lore.kernel.org/r/20230504121856.904491-3-leitao@debian.org
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2023-05-04 20:18:55 +08:00
|
|
|
memcpy(req->async_data, ioucmd->sqe, uring_sqe_size(req->ctx));
|
|
|
|
ioucmd->sqe = req->async_data;
|
2022-05-25 19:59:19 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int io_uring_cmd_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
|
|
|
|
{
|
2022-08-11 15:11:15 +08:00
|
|
|
struct io_uring_cmd *ioucmd = io_kiocb_to_cmd(req, struct io_uring_cmd);
|
2022-05-25 19:59:19 +08:00
|
|
|
|
2022-09-30 14:27:39 +08:00
|
|
|
if (sqe->__pad1)
|
2022-05-25 19:59:19 +08:00
|
|
|
return -EINVAL;
|
2022-09-30 14:27:39 +08:00
|
|
|
|
|
|
|
ioucmd->flags = READ_ONCE(sqe->uring_cmd_flags);
|
|
|
|
if (ioucmd->flags & ~IORING_URING_CMD_FIXED)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (ioucmd->flags & IORING_URING_CMD_FIXED) {
|
|
|
|
struct io_ring_ctx *ctx = req->ctx;
|
|
|
|
u16 index;
|
|
|
|
|
|
|
|
req->buf_index = READ_ONCE(sqe->buf_index);
|
|
|
|
if (unlikely(req->buf_index >= ctx->nr_user_bufs))
|
|
|
|
return -EFAULT;
|
|
|
|
index = array_index_nospec(req->buf_index, ctx->nr_user_bufs);
|
|
|
|
req->imu = ctx->user_bufs[index];
|
|
|
|
io_req_set_rsrc_node(req, ctx, 0);
|
|
|
|
}
|
io_uring: Pass whole sqe to commands
Currently uring CMD operation relies on having large SQEs, but future
operations might want to use normal SQE.
The io_uring_cmd currently only saves the payload (cmd) part of the SQE,
but, for commands that use normal SQE size, it might be necessary to
access the initial SQE fields outside of the payload/cmd block. So,
saves the whole SQE other than just the pdu.
This changes slightly how the io_uring_cmd works, since the cmd
structures and callbacks are not opaque to io_uring anymore. I.e, the
callbacks can look at the SQE entries, not only, in the cmd structure.
The main advantage is that we don't need to create custom structures for
simple commands.
Creates io_uring_sqe_cmd() that returns the cmd private data as a null
pointer and avoids casting in the callee side.
Also, make most of ublk_drv's sqe->cmd priv structure into const, and use
io_uring_sqe_cmd() to get the private structure, removing the unwanted
cast. (There is one case where the cast is still needed since the
header->{len,addr} is updated in the private structure)
Suggested-by: Pavel Begunkov <asml.silence@gmail.com>
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Keith Busch <kbusch@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Pavel Begunkov <asml.silence@gmail.com>
Link: https://lore.kernel.org/r/20230504121856.904491-3-leitao@debian.org
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2023-05-04 20:18:55 +08:00
|
|
|
ioucmd->sqe = sqe;
|
2022-05-25 19:59:19 +08:00
|
|
|
ioucmd->cmd_op = READ_ONCE(sqe->cmd_op);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int io_uring_cmd(struct io_kiocb *req, unsigned int issue_flags)
|
|
|
|
{
|
2022-08-11 15:11:15 +08:00
|
|
|
struct io_uring_cmd *ioucmd = io_kiocb_to_cmd(req, struct io_uring_cmd);
|
2022-05-25 19:59:19 +08:00
|
|
|
struct io_ring_ctx *ctx = req->ctx;
|
|
|
|
struct file *file = req->file;
|
|
|
|
int ret;
|
|
|
|
|
2023-03-09 00:26:13 +08:00
|
|
|
if (!file->f_op->uring_cmd)
|
2022-05-25 19:59:19 +08:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2022-07-16 03:16:22 +08:00
|
|
|
ret = security_uring_cmd(ioucmd);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2022-05-25 19:59:19 +08:00
|
|
|
if (ctx->flags & IORING_SETUP_SQE128)
|
|
|
|
issue_flags |= IO_URING_F_SQE128;
|
|
|
|
if (ctx->flags & IORING_SETUP_CQE32)
|
|
|
|
issue_flags |= IO_URING_F_CQE32;
|
2022-08-24 00:14:41 +08:00
|
|
|
if (ctx->flags & IORING_SETUP_IOPOLL) {
|
2023-03-09 00:26:13 +08:00
|
|
|
if (!file->f_op->uring_cmd_iopoll)
|
|
|
|
return -EOPNOTSUPP;
|
2022-05-25 19:59:19 +08:00
|
|
|
issue_flags |= IO_URING_F_IOPOLL;
|
2022-08-24 00:14:41 +08:00
|
|
|
req->iopoll_completed = 0;
|
|
|
|
WRITE_ONCE(ioucmd->cookie, NULL);
|
|
|
|
}
|
2022-05-25 19:59:19 +08:00
|
|
|
|
|
|
|
ret = file->f_op->uring_cmd(ioucmd, issue_flags);
|
|
|
|
if (ret == -EAGAIN) {
|
|
|
|
if (!req_has_async_data(req)) {
|
|
|
|
if (io_alloc_async_data(req))
|
|
|
|
return -ENOMEM;
|
|
|
|
io_uring_cmd_prep_async(req);
|
|
|
|
}
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != -EIOCBQUEUED) {
|
2022-08-11 17:14:59 +08:00
|
|
|
if (ret < 0)
|
|
|
|
req_set_fail(req);
|
|
|
|
io_req_set_res(req, ret, 0);
|
2022-08-23 23:10:22 +08:00
|
|
|
return ret;
|
2022-05-25 19:59:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return IOU_ISSUE_SKIP_COMPLETE;
|
|
|
|
}
|
2022-09-30 14:27:38 +08:00
|
|
|
|
|
|
|
int io_uring_cmd_import_fixed(u64 ubuf, unsigned long len, int rw,
|
|
|
|
struct iov_iter *iter, void *ioucmd)
|
|
|
|
{
|
|
|
|
struct io_kiocb *req = cmd_to_io_kiocb(ioucmd);
|
|
|
|
|
|
|
|
return io_import_fixed(rw, iter, req->imu, ubuf, len);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(io_uring_cmd_import_fixed);
|