Harden async submit checks
Jens Axboe
maintainercover Harden async submit checks
Hi,
Patch 1 ensures that we don't resubmit from release, which doesn't make sense for the reasons outlined in that patch. Patch 2 just adds a proactive safety check in case we do add a bug that can cause that to happen, as it might be problematic for those future cases if they can happen for request types that won't naturally fail.
Signature · 1 line
Jens Axboe
Jens Axboe
maintainerPATCH 1/2 io_uring: never attempt iopoll reissue from release path
There are two reasons why this shouldn't be done:
1) Ring is exiting, and we're canceling requests anyway. Any request should be canceled anyway. In theory, this could iterate for a number of times if someone else is also driving the target block queue into request starvation, however the likelihood of this happening is miniscule.
2) If the original task decided to pass the ring to another task, then we don't want to be reissuing from this context as it may be an unrelated task. This can only happen for pure read/write, and we'll get -EFAULT on them anyway.
--- fs/io_uring.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
fs/io_uring.c +7 -7
@@ -2205,7 +2205,7 @@ static inline bool io_run_task_work(void)* Find and free completed poll iocbs */ static void io_iopoll_complete (struct io_ring_ctx *ctx,unsigned int *nr_events, -struct list_head *done) +struct list_head *done,bool resubmit) {struct req_batch rb;struct io_kiocb *req;
@@ -2220,7 +2220,7 @@ static void io_iopoll_complete(struct io_ring_ctx *ctx, unsigned int *nr_events, req = list_first_entry(done, struct io_kiocb, inflight_entry);list_del (&req->inflight_entry); -if (READ_ONCE (req->result) == -EAGAIN && +if (READ_ONCE (req->result) == -EAGAIN && resubmit && !(req->flags &REQ_F_DONT_REISSUE )) { req->iopoll_completed =0 ;req_ref_get (req);
@@ -2244,7 +2244,7 @@ static void io_iopoll_complete(struct io_ring_ctx *ctx, unsigned int *nr_events, }static int io_do_iopoll (struct io_ring_ctx *ctx,unsigned int *nr_events, -long min) +long min,bool resubmit) {struct io_kiocb *req, *tmp;LIST_HEAD (done);
@@ -2287,7 +2287,7 @@ static int io_do_iopoll(struct io_ring_ctx *ctx, unsigned int *nr_events, }if (!list_empty (&done)) -io_iopoll_complete (ctx, nr_events, &done); +io_iopoll_complete (ctx, nr_events, &done, resubmit);return ret; }
@@ -2305,7 +2305,7 @@ static void io_iopoll_try_reap_events(struct io_ring_ctx *ctx)while (!list_empty (&ctx->iopoll_list)) {unsigned int nr_events =0 ; -io_do_iopoll (ctx, &nr_events,0 ); +io_do_iopoll (ctx, &nr_events,0 , false);/* let it sleep and repeat later if can't complete a request */ if (nr_events ==0 )
@@ -2367,7 +2367,7 @@ static int io_iopoll_check(struct io_ring_ctx *ctx, long min) list_empty(&ctx->iopoll_list))break ; } - ret =io_do_iopoll (ctx, &nr_events, min); + ret =io_do_iopoll (ctx, &nr_events, min, true); }while (!ret && nr_events < min && !need_resched ()); out:mutex_unlock (&ctx->uring_lock);
@@ -6798,7 +6798,7 @@ static int __io_sq_thread(struct io_ring_ctx *ctx, bool cap_entries)mutex_lock (&ctx->uring_lock);if (!list_empty (&ctx->iopoll_list)) -io_do_iopoll (ctx, &nr_events,0 ); +io_do_iopoll (ctx, &nr_events,0 , true);/* * Don't submit if refs are dying, good for io_uring_register(),
Signature · 1 line
2.32.0
Jens Axboe
maintainerPATCH 2/2 io_uring: explicitly catch any illegal async queue attempt
In reply to Jens AxboeCatch an illegal case to queue async from an unrelated task that got the ring fd passed to it. This should not be possible to hit, but better be proactive and catch it explicitly. io-wq is extended to check for early IO_WQ_WORK_CANCEL being set on a work item as well, so it can run the request through the normal cancelation path.
--- fs/io-wq.c | 7 ++++++- fs/io_uring.c | 11 +++++++++++ 2 files changed, 17 insertions(+), 1 deletion(-)
fs/io-wq.c +6 -1
@@ -731,7 +731,12 @@ static void io_wqe_enqueue(struct io_wqe *wqe, struct io_wq_work *work)int work_flags;unsigned long flags; -if (test_bit (IO_WQ_BIT_EXIT , &wqe->wq->state)) { +/* +* If io-wq is exiting for this task, or if the request has explicitly +* been marked as one that should not get executed, cancel it here. +*/ +if (test_bit (IO_WQ_BIT_EXIT , &wqe->wq->state) || + (work->flags &IO_WQ_WORK_CANCEL )) {io_run_cancel (work, wqe);return ; }
fs/io_uring.c +11 -0
@@ -1294,6 +1294,17 @@ static void io_queue_async_work(struct io_kiocb *req)/* init ->work of the whole link before punting */ io_prep_async_link (req); + +/* +* Not expected to happen, but if we do have a bug where this _can_ +* happen, catch it here and ensure the request is marked as +* canceled. That will make io-wq go through the usual work cancel +* procedure rather than attempt to run this request (or create a new +* worker for it). +*/ +if (WARN_ON_ONCE (!same_thread_group (req->task, current))) + req->work.flags |IO_WQ_WORK_CANCEL ; +trace_io_uring_queue_async_work (ctx,io_wq_is_hashed (&req->work), req, &req->work, req->flags);io_wq_enqueue (tctx->io_wq, &req->work);
Signature · 1 line
2.32.0