]> git.hungrycats.org Git - linux/commitdiff
io_uring: defer foreign io-wq enqueues to task_work
authorKyle Zeng <kylebot@openai.com>
Wed, 4 Nov 2026 18:44:10 +0000 (11:44 -0700)
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Fri, 6 Nov 2026 17:06:12 +0000 (12:06 -0500)
Commit 3de16279b43dc285ed2222aba06cebdc82fdb28b upstream.

An IOPOLL ring without DEFER_TASKRUN can be reaped by a task other than
the one that submitted the I/O. If a polled request is marked
REQ_F_REISSUE, io_free_batch_list() calls io_queue_iowq() with the
original tctx. Ordinary task exit can tear down tctx->io_wq after
draining only the tracked requests. The live request pins the task, but
not its io-wq, so the foreign task can race io_wq_put_and_exit() and
enqueue through a freed or NULL queue.

Forward foreign userspace enqueues to the owning task before accessing
tctx->io_wq. Use a dedicated task_work callback so reissues still go
straight to io-wq, and fail them if task_work is running in cancellation
mode. Preserve the existing PF_KTHREAD cancellation path. This also
covers the other callers of io_queue_iowq() without changing the
worker-owned enqueue path.

Signed-off-by: Kyle Zeng <kylebot@openai.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
[axboe: 6.18 lacks 13b0742fd058, which removed io_req_queue_iowq(). Name
the new task_work callback io_queue_iowq_foreign_tw() so it doesn't
clash with the existing io_req_queue_iowq_tw()]
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
io_uring/io_uring.c

index ac097a9ac8c06849fe5c45e8b609cadc6dea2143..4a9f3a0fe50628f6bdbe2040a965f5f2e5b1bd56 100644 (file)
@@ -483,6 +483,19 @@ static __always_inline bool io_assign_file(struct io_kiocb *req,
        return !!req->file;
 }
 
+static void io_queue_iowq(struct io_kiocb *req);
+
+static void io_queue_iowq_foreign_tw(struct io_tw_req tw_req, io_tw_token_t tw)
+{
+       struct io_kiocb *req = tw_req.req;
+
+       io_tw_lock(req->ctx, tw);
+       if (unlikely(tw.cancel))
+               io_req_defer_failed(req, -ECANCELED);
+       else
+               io_queue_iowq(req);
+}
+
 static void io_queue_iowq(struct io_kiocb *req)
 {
        struct io_uring_task *tctx = req->tctx;
@@ -490,10 +503,17 @@ static void io_queue_iowq(struct io_kiocb *req)
        BUG_ON(!tctx);
        lockdep_assert_held(&req->ctx->uring_lock);
 
-       if ((current->flags & PF_KTHREAD) || !tctx->io_wq) {
-               io_req_task_queue_fail(req, -ECANCELED);
+       if (current->flags & PF_KTHREAD)
+               goto cancel;
+
+       /* Only the submitter can safely access its io-wq during task exit. */
+       if (unlikely(current != tctx->task)) {
+               req->io_task_work.func = io_queue_iowq_foreign_tw;
+               io_req_task_work_add(req);
                return;
        }
+       if (!tctx->io_wq)
+               goto cancel;
 
        /*
         * The file is looked up as late as possible, as it may be the result
@@ -522,6 +542,9 @@ static void io_queue_iowq(struct io_kiocb *req)
 
        trace_io_uring_queue_async_work(req, io_wq_is_hashed(&req->work));
        io_wq_enqueue(tctx->io_wq, &req->work);
+       return;
+cancel:
+       io_req_task_queue_fail(req, -ECANCELED);
 }
 
 static void io_req_queue_iowq_tw(struct io_tw_req tw_req, io_tw_token_t tw)