random 5.12 bits
cover random 5.12 bits
1/4 is a fix.
Others may make slightly easier looking for ->io_uring usages.
Pavel Begunkov (4):
io_uring: choose right tctx->io_wq for try cancel
io_uring: inline io_req_clean_work()
io_uring: inline __io_queue_async_work()
io_uring: remove extra in_idle wake up
fs/io_uring.c | 44 +++++++++++++++----------------------------- 1 file changed, 15 insertions(+), 29 deletions(-)
Signature · 1 line
2.24.0
PATCH 1/4 io_uring: choose right tctx->io_wq for try cancel
When we cancel SQPOLL, @task in io_uring_try_cancel_requests() will differ from current. Use the right tctx from passed in @task, and don't forget that it can be NULL when the io_uring ctx exits.
--- fs/io_uring.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/io_uring.c +2 -1
@@ -8615,7 +8615,8 @@ static void io_uring_try_cancel_requests(struct io_ring_ctx *ctx, struct files_struct *files) {struct io_task_cancel cancel = { .task = task, .files = files, }; -struct io_uring_task *tctx = current->io_uring; +struct task_struct *tctx_task = task ?: current; +struct io_uring_task *tctx = tctx_task->io_uring;while (1 ) {enum io_wq_cancel cret;
Signature · 1 line
2.24.0
PATCH 2/4 io_uring: inline io_req_clean_work()
In reply to Pavel BegunkovInline io_req_clean_work(), less code and easier to analyse tctx dependencies and refs usage.
--- fs/io_uring.c | 30 +++++++++++++----------------- 1 file changed, 13 insertions(+), 17 deletions(-)
fs/io_uring.c +13 -17
@@ -1167,22 +1167,6 @@ static bool req_need_defer(struct io_kiocb *req, u32 seq)return false; } -static void io_req_clean_work (struct io_kiocb *req) -{ -if (req->flags &REQ_F_INFLIGHT ) { -struct io_ring_ctx *ctx = req->ctx; -struct io_uring_task *tctx = req->task->io_uring; -unsigned long flags; - -spin_lock_irqsave (&ctx->inflight_lock, flags); -list_del (&req->inflight_entry); -spin_unlock_irqrestore (&ctx->inflight_lock, flags); - req->flags &= ~REQ_F_INFLIGHT ; -if (atomic_read (&tctx->in_idle)) -wake_up (&tctx->wait); - } -} -static void io_req_track_inflight (struct io_kiocb *req) {struct io_ring_ctx *ctx = req->ctx;
@@ -1671,7 +1655,19 @@ static void io_dismantle_req(struct io_kiocb *req)io_put_file (req, req->file, (req->flags &REQ_F_FIXED_FILE ));if (req->fixed_rsrc_refs)percpu_ref_put (req->fixed_rsrc_refs); -io_req_clean_work (req); + +if (req->flags &REQ_F_INFLIGHT ) { +struct io_ring_ctx *ctx = req->ctx; +struct io_uring_task *tctx = req->task->io_uring; +unsigned long flags; + +spin_lock_irqsave (&ctx->inflight_lock, flags); +list_del (&req->inflight_entry); +spin_unlock_irqrestore (&ctx->inflight_lock, flags); + req->flags &= ~REQ_F_INFLIGHT ; +if (atomic_read (&tctx->in_idle)) +wake_up (&tctx->wait); + } }static inline void io_put_task (struct task_struct *task,int nr)
Signature · 1 line
2.24.0
PATCH 3/4 io_uring: inline __io_queue_async_work()
In reply to Pavel Begunkov__io_queue_async_work() is only called from io_queue_async_work(), inline it.
--- fs/io_uring.c | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-)
fs/io_uring.c +2 -11
@@ -1205,7 +1205,7 @@ static void io_prep_async_link(struct io_kiocb *req)io_prep_async_work (cur); } -static struct io_kiocb *__io_queue_async_work (struct io_kiocb *req) +static void io_queue_async_work (struct io_kiocb *req) {struct io_ring_ctx *ctx = req->ctx;struct io_kiocb *link =io_prep_linked_timeout (req);
@@ -1216,18 +1216,9 @@ static struct io_kiocb *__io_queue_async_work(struct io_kiocb *req)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); -return link; -} - -static void io_queue_async_work (struct io_kiocb *req) -{ -struct io_kiocb *link; -/* init ->work of the whole link before punting */ io_prep_async_link (req); - link =__io_queue_async_work (req); - +io_wq_enqueue (tctx->io_wq, &req->work);if (link)io_queue_linked_timeout (link); }
Signature · 1 line
2.24.0
PATCH 4/4 io_uring: remove extra in_idle wake up
In reply to Pavel Begunkovio_dismantle_req() is always followed by io_put_task(), which already do proper in_idle wake ups, so we can skip waking the owner task in io_dismantle_req(). The rules are simpler now, do io_put_task() shortly after ending a request, and it will be fine.
--- fs/io_uring.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
fs/io_uring.c +1 -3
@@ -1649,18 +1649,16 @@ static void io_dismantle_req(struct io_kiocb *req)if (req->flags &REQ_F_INFLIGHT ) {struct io_ring_ctx *ctx = req->ctx; -struct io_uring_task *tctx = req->task->io_uring;unsigned long flags;spin_lock_irqsave (&ctx->inflight_lock, flags);list_del (&req->inflight_entry);spin_unlock_irqrestore (&ctx->inflight_lock, flags); req->flags &= ~REQ_F_INFLIGHT ; -if (atomic_read (&tctx->in_idle)) -wake_up (&tctx->wait); } } +/* must to be called somewhat shortly after putting a request */ static inline void io_put_task (struct task_struct *task,int nr) {struct io_uring_task *tctx = task->io_uring;
Signature · 1 line
2.24.0
Jens Axboe
maintainerQuoted 11 lines · Pavel Begunkov
1/4 is a fix.
Others may make slightly easier looking for ->io_uring usages.Pavel Begunkov (4):
io_uring: choose righttctx->io_wqfor try cancel
io_uring: inlineio_req_clean_work()
io_uring: inline__io_queue_async_work()
io_uring: remove extrain_idlewake upfs/io_uring.c | 44 +++++++++++++++----------------------------- 1 file changed, 15 insertions(+), 29 deletions(-)
Looks good, applied.
Signature · 1 line
Jens Axboe