cancellation fixes
cover cancellation fixes
1-3 timeout cancellation fixes
4/4 prevents a regression cancelling more than needed
Pavel Begunkov (4):
io_uring: fix timeout cancel return code
io_uring: do post-completion chore on t-out cancel
io_uring: don't cancel-track common timeouts
io_uring: don't cancel extra on files match
fs/io_uring.c | 53 ++++++++++++++++++++++++++------------------------- 1 file changed, 27 insertions(+), 26 deletions(-)
Signature · 1 line
2.24.0
PATCH 1/4 io_uring: fix timeout cancel return code
When we cancel a timeout we should emit a sensible return code, like -ECANCELED but not 0, otherwise it may trick users.
--- fs/io_uring.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
fs/io_uring.c +4 -4
@@ -1248,7 +1248,7 @@ static void io_queue_async_work(struct io_kiocb *req)io_queue_linked_timeout (link); } -static void io_kill_timeout (struct io_kiocb *req) +static void io_kill_timeout (struct io_kiocb *req,int status) {struct io_timeout_data *io = req->async_data;int ret;
@@ -1258,7 +1258,7 @@ static void io_kill_timeout(struct io_kiocb *req)atomic_set (&req->ctx->cq_timeouts,atomic_read (&req->ctx->cq_timeouts) +1 );list_del_init (&req->timeout.list); -io_cqring_fill_event (req,0 ); +io_cqring_fill_event (req, status);io_put_req_deferred (req,1 ); } }
@@ -1275,7 +1275,7 @@ static bool io_kill_timeouts(struct io_ring_ctx *ctx, struct task_struct *tsk,spin_lock_irq (&ctx->completion_lock);list_for_each_entry_safe (req, tmp, &ctx->timeout_list, timeout.list) {if (io_match_task (req, tsk, files)) { -io_kill_timeout (req); +io_kill_timeout (req, -ECANCELED ); canceled++; } }
@@ -1327,7 +1327,7 @@ static void io_flush_timeouts(struct io_ring_ctx *ctx)break ;list_del_init (&req->timeout.list); -io_kill_timeout (req); +io_kill_timeout (req,0 ); }while (!list_empty (&ctx->timeout_list)); ctx->cq_last_tm_flush = seq;
Signature · 1 line
2.24.0
PATCH 2/4 io_uring: do post-completion chore on t-out cancel
In reply to Pavel BegunkovDon't forget about io_commit_cqring() + io_cqring_ev_posted() after exit/exec cancelling timeouts. Both functions declared only after io_kill_timeouts(), so to avoid tons of forward declarations move it down.
--- fs/io_uring.c | 42 ++++++++++++++++++++++-------------------- 1 file changed, 22 insertions(+), 20 deletions(-)
fs/io_uring.c +22 -20
@@ -1263,26 +1263,6 @@ static void io_kill_timeout(struct io_kiocb *req, int status) } } -/* -* Returns true if we found and killed one or more timeouts -*/ -static bool io_kill_timeouts (struct io_ring_ctx *ctx,struct task_struct *tsk, -struct files_struct *files) -{ -struct io_kiocb *req, *tmp; -int canceled =0 ; - -spin_lock_irq (&ctx->completion_lock); -list_for_each_entry_safe (req, tmp, &ctx->timeout_list, timeout.list) { -if (io_match_task (req, tsk, files)) { -io_kill_timeout (req, -ECANCELED ); - canceled++; - } - } -spin_unlock_irq (&ctx->completion_lock); -return canceled !=0 ; -} -static void __io_queue_deferred (struct io_ring_ctx *ctx) { do {
@@ -8608,6 +8588,28 @@ static void io_ring_exit_work(struct work_struct *work)io_ring_ctx_free (ctx); } +/* Returns true if we found and killed one or more timeouts */ +static bool io_kill_timeouts (struct io_ring_ctx *ctx,struct task_struct *tsk, +struct files_struct *files) +{ +struct io_kiocb *req, *tmp; +int canceled =0 ; + +spin_lock_irq (&ctx->completion_lock); +list_for_each_entry_safe (req, tmp, &ctx->timeout_list, timeout.list) { +if (io_match_task (req, tsk, files)) { +io_kill_timeout (req, -ECANCELED ); + canceled++; + } + } +io_commit_cqring (ctx); +spin_unlock_irq (&ctx->completion_lock); + +if (canceled !=0 ) +io_cqring_ev_posted (ctx); +return canceled !=0 ; +} +static void io_ring_ctx_wait_and_kill (struct io_ring_ctx *ctx) {unsigned long index;
Signature · 1 line
2.24.0
PATCH 3/4 io_uring: don't cancel-track common timeouts
In reply to Pavel BegunkovDon't account usual timeouts (i.e. not linked) as REQ_F_INFLIGHT but keep behaviour prior to dd59a3d595cc1 ("io_uring: reliably cancel linked timeouts").
--- fs/io_uring.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/io_uring.c +2 -1
@@ -5564,7 +5564,8 @@ static int io_timeout_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe, data->mode =io_translate_timeout_mode (flags);hrtimer_init (&data->timer,CLOCK_MONOTONIC , data->mode); -io_req_track_inflight (req); +if (is_timeout_link) +io_req_track_inflight (req);return 0 ; }
Signature · 1 line
2.24.0
PATCH 4/4 io_uring: don't cancel extra on files match
In reply to Pavel BegunkovAs tasks always wait and kill their io-wq on exec/exit, files are of no more concern to us, so we don't need to specifically cancel them by hand in those cases. Moreover we should not, because io_match_task() looks at req->task->files now, which is always true and so leads to extra cancellations, that wasn't a case before per-task io-wq.
--- fs/io_uring.c | 2 -- 1 file changed, 2 deletions(-)
fs/io_uring.c +0 -2
@@ -1095,8 +1095,6 @@ static bool io_match_task(struct io_kiocb *head,io_for_each_link (req, head) {if (req->flags &REQ_F_INFLIGHT )return true; -if (req->task->files == files) -return true; }return false; }
Signature · 1 line
2.24.0
Quoted 11 lines · Pavel Begunkov
1-3 timeout cancellation fixes
4/4 prevents a regression cancelling more than neededPavel Begunkov (4):
io_uring: fix timeout cancel return code
io_uring: do post-completion chore on t-out cancel
io_uring: don't cancel-track common timeouts
io_uring: don't cancel extra on files matchfs/io_uring.c | 53 ++++++++++++++++++++++++++------------------------- 1 file changed, 27 insertions(+), 26 deletions(-)
Thanks, applied.
Signature · 1 line
Jens Axboe