implement timeout update
v2 cover implement timeout update
Timeout update is a IORING_OP_TIMEOUT_REMOVE request with timeout_flags containing a new IORING_TIMEOUT_UPDATE flag. Even though naming may be confusing, but update and remove are very similar both code and functionality wise, so doesn't seem necessary to add a new opcode.
Updates don't support offsets, but I don't see a need either. Can be implemented in the future by passing it in sqe->len.
v2: nits for [2/2] (Jens)
Pavel Begunkov (2):
io_uring: restructure io_timeout_cancel()
io_uring: add timeout update
fs/io_uring.c | 93 +++++++++++++++++++++++++++-------- include/uapi/linux/io_uring.h | 1 + 2 files changed, 73 insertions(+), 21 deletions(-)
Signature · 1 line
2.24.0
PATCH v2 1/2 io_uring: restructure io_timeout_cancel()
Add io_timeout_extract() helper, which searches and disarms timeouts, but doesn't complete them. No functional changes.
--- fs/io_uring.c | 42 +++++++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 19 deletions(-)
fs/io_uring.c +23 -19
@@ -5639,24 +5639,10 @@ static enum hrtimer_restart io_timeout_fn(struct hrtimer *timer)return HRTIMER_NORESTART ; } -static int __io_timeout_cancel (struct io_kiocb *req) -{ -struct io_timeout_data *io = req->async_data; -int ret; - - ret =hrtimer_try_to_cancel (&io->timer); -if (ret ==-1 ) -return -EALREADY ; -list_del_init (&req->timeout.list); - -req_set_fail_links (req); -io_cqring_fill_event (req, -ECANCELED ); -io_put_req_deferred (req,1 ); -return 0 ; -} - -static int io_timeout_cancel (struct io_ring_ctx *ctx,__u64 user_data) +static struct io_kiocb *io_timeout_extract (struct io_ring_ctx *ctx, +__u64 user_data) { +struct io_timeout_data *io;struct io_kiocb *req;int ret = -ENOENT ;
@@ -5668,9 +5654,27 @@ static int io_timeout_cancel(struct io_ring_ctx *ctx, __u64 user_data) }if (ret == -ENOENT ) -return ret; +return ERR_PTR (ret); + + io = req->async_data; + ret =hrtimer_try_to_cancel (&io->timer); +if (ret ==-1 ) +return ERR_PTR (-EALREADY ); +list_del_init (&req->timeout.list); +return req; +} -return __io_timeout_cancel (req); +static int io_timeout_cancel (struct io_ring_ctx *ctx,__u64 user_data) +{ +struct io_kiocb *req =io_timeout_extract (ctx, user_data); + +if (IS_ERR (req)) +return PTR_ERR (req); + +req_set_fail_links (req); +io_cqring_fill_event (req, -ECANCELED ); +io_put_req_deferred (req,1 ); +return 0 ; } static int io_timeout_remove_prep(struct io_kiocb *req,
Signature · 1 line
2.24.0
PATCH v2 2/2 io_uring: add timeout update
In reply to Pavel BegunkovSupport timeout updates through IORING_OP_TIMEOUT_REMOVE with passed in IORING_TIMEOUT_UPDATE. Updates doesn't support offset timeout mode. Oirignal timeout.off will be ignored as well.
--- fs/io_uring.c | 55 ++++++++++++++++++++++++++++++++--- include/uapi/linux/io_uring.h | 1 + 2 files changed, 52 insertions(+), 4 deletions(-)
fs/io_uring.c +51 -4
@@ -453,6 +453,10 @@ struct io_timeout {struct io_timeout_rem {struct file *file;u64 addr; + +/* timeout update */ +struct timespec64 ts; +u32 flags; };struct io_rw {
@@ -867,7 +871,10 @@ static const struct io_op_def io_op_defs[] = { .async_size = sizeof(struct io_timeout_data), .work_flags = IO_WQ_WORK_MM, }, - [IORING_OP_TIMEOUT_REMOVE] = {}, + [IORING_OP_TIMEOUT_REMOVE] = { +/* used by timeout updates' prep() */ + .work_flags = IO_WQ_WORK_MM, + }, [IORING_OP_ACCEPT] = { .needs_file = 1, .unbound_nonreg_file = 1,
@@ -5677,17 +5684,49 @@ static int io_timeout_cancel(struct io_ring_ctx *ctx, __u64 user_data)return 0 ; } +static int io_timeout_update (struct io_ring_ctx *ctx,__u64 user_data, +struct timespec64 *ts,enum hrtimer_mode mode) +{ +struct io_kiocb *req =io_timeout_extract (ctx, user_data); +struct io_timeout_data *data; + +if (IS_ERR (req)) +return PTR_ERR (req); + + req->timeout.off =0 ;/* noseq */ + data = req->async_data; +list_add_tail (&req->timeout.list, &ctx->timeout_list); +hrtimer_init (&data->timer,CLOCK_MONOTONIC , mode); + data->timer.function = io_timeout_fn; +hrtimer_start (&data->timer,timespec64_to_ktime (*ts), mode); +return 0 ; +} +static int io_timeout_remove_prep (struct io_kiocb *req,const struct io_uring_sqe *sqe) { +struct io_timeout_rem *tr = &req->timeout_rem; +int ret; +if (unlikely (req->ctx->flags &IORING_SETUP_IOPOLL ))return -EINVAL ;if (unlikely (req->flags & (REQ_F_FIXED_FILE |REQ_F_BUFFER_SELECT )))return -EINVAL ; -if (sqe->ioprio || sqe->buf_index || sqe->len || sqe->timeout_flags) +if (sqe->ioprio || sqe->buf_index || sqe->len)return -EINVAL ; - req->timeout_rem.addr =READ_ONCE (sqe->addr); + tr->addr =READ_ONCE (sqe->addr); + tr->flags =READ_ONCE (sqe->timeout_flags); +if (tr->flags &IORING_TIMEOUT_UPDATE ) { +if (tr->flags & ~(IORING_TIMEOUT_UPDATE |IORING_TIMEOUT_ABS )) +return -EINVAL ; +if (get_timespec64 (&tr->ts,u64_to_user_ptr (sqe->addr2))) +return -EFAULT ; + }else if (tr->flags) { +/* timeout removal doesn't support flags */ +return -EINVAL ; + } +return 0 ; }
@@ -5696,11 +5735,19 @@ static int io_timeout_remove_prep(struct io_kiocb *req,*/ static int io_timeout_remove (struct io_kiocb *req) { +struct io_timeout_rem *tr = &req->timeout_rem;struct io_ring_ctx *ctx = req->ctx;int ret;spin_lock_irq (&ctx->completion_lock); - ret =io_timeout_cancel (ctx, req->timeout_rem.addr); +if (req->timeout_rem.flags &IORING_TIMEOUT_UPDATE ) { +enum hrtimer_mode mode = (tr->flags &IORING_TIMEOUT_ABS ) + ?HRTIMER_MODE_ABS :HRTIMER_MODE_REL ; + + ret =io_timeout_update (ctx, tr->addr, &tr->ts, mode); + }else { + ret =io_timeout_cancel (ctx, tr->addr); + }io_cqring_fill_event (req, ret);io_commit_cqring (ctx);
include/uapi/linux/io_uring.h +1 -0
@@ -151,6 +151,7 @@ enum {* sqe->timeout_flags */ #define IORING_TIMEOUT_ABS (1U << 0) +#define IORING_TIMEOUT_UPDATE (1U << 1)/* * sqe->splice_flags
Signature · 1 line
2.24.0
Quoted 7 lines · Pavel Begunkov
Timeout update is a
IORING_OP_TIMEOUT_REMOVErequest withtimeout_flagscontaining a newIORING_TIMEOUT_UPDATEflag. Even though naming may be confusing, but update and remove are very similar both code and functionality wise, so doesn't seem necessary to add a new opcode.Updates don't support offsets, but I don't see a need either. Can be implemented in the future by passing it in
sqe->len.
Applied, thanks.
Signature · 1 line
Jens Axboe