From nobody Fri Oct 3 06:35:00 2025 Received: from mail-pj1-f99.google.com (mail-pj1-f99.google.com [209.85.216.99]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E23C23090DF for ; Thu, 4 Sep 2025 17:09:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.99 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1757005756; cv=none; b=DtZVxKHOtjpx4teY3v4mYqACVWlCd9HBnDwJNqcO970CrjcZwymg9ekrCC+EQQvNjKfciJSXsm2MyAkSRgk34O6Kk9qBtrcM9HsfjxffUMnGtYEjFD4avZ80sG7kRzqYyyhvjs8tjx9IAV+g+UZBfizKuKX9k616wUqvnPuFHlk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1757005756; c=relaxed/simple; bh=ue9oKPXcsKNyCP4UQy+Ff7QwGQCH0jHAlV7+JhRu6Js=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=PWM9w7JcSjcjMdzIhSqjWxg/6M6rPXsqhkSvWxaNtqYMn+WxXkXaGJpUSlKZmM4D/dHk5PLOE68eWax7rcaU6/BN3pjvpEpauCcBgQO7Lb7qFdGRPeyxjkY3+rgvA+0miMbeslpS1tuquRmSciD6yc11TJVWHxrtCy6ZB3FmlGE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com; spf=fail smtp.mailfrom=purestorage.com; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b=bR3xGZ6j; arc=none smtp.client-ip=209.85.216.99 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=purestorage.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=purestorage.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=purestorage.com header.i=@purestorage.com header.b="bR3xGZ6j" Received: by mail-pj1-f99.google.com with SMTP id 98e67ed59e1d1-3298dcfdf99so65478a91.3 for ; Thu, 04 Sep 2025 10:09:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=purestorage.com; s=google2022; t=1757005752; x=1757610552; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=23wu/Bc7dYajchioT9s8wTT9VXMmhq9bjzQDiK4wUhc=; b=bR3xGZ6j1y05Xr/VinJuUqvCPjr/Hz8g3X6hWMgj69Ch6ayhETp72/vjtBcERaMoAu tXowsRSzd0PKA9FafUkRQtQknN/3arQbS4fi51GpBLbDqaHbPYC+fYbr/eZ5UlgvUe1L NBe+nFtdVCX5O8wuxS6ZkGH/f0ssLsmZJGmKqh9MgENo2hPj8mURHqYaQ/o7KK0IzQ4e et1FB7N42HcaW1qmi01U0DU0/OofZTRmGdhjGatqHFWO0rv9Fhf8vFl1/t7CTdv2HZdP 0FmlBQJdggnfZADgrr5xV6xsxF4GSCcyhDa8yo03YiIeANn+8lTpuAo+djymqolCwvsn FJLA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1757005752; x=1757610552; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=23wu/Bc7dYajchioT9s8wTT9VXMmhq9bjzQDiK4wUhc=; b=iOPkT7QQHXIjEuKzqErjfJska0mkuL09Vx+y9rhuVzIEmi9D06ksMsYpm8Tr833rVZ UpO02Y0/RvTbK4Qr8BiPHjTCI01QUPbwTxX5dPA0xL7+DAzKzkGeUJVVQBxwM3BfEQpP LkGE/BQF4iItWd1ilbr4WGDcvI3VVdZr4VrRCb6cM1F84Jmf43c6Gx/mmEfSeJCDMvkx 3fAIclbyNiYTgxLR083ll9sLyPb85mVzv01KCoZt0lY4TsXwher5nXlKlhj7khlxk5+Y azk3KdlUTGvDjLD7eHPXjNHAiCUSNV+X0Lje0RKcajR0peexwy59e+Oj6YlE1HUQImEH u5gg== X-Forwarded-Encrypted: i=1; AJvYcCX99D4huN7sOd6z3e4MHDxWU/5fKSDKDNyCuKiyPUxOtLvxS3rfZ9dX7Wt0+x5kxrI6wjBWPwG+jIozQ8U=@vger.kernel.org X-Gm-Message-State: AOJu0YxNW1BmMoxQnejAbEzdhKtoXdViia1u1eM2R4H3Am88TalI5bEY ibj02KLzcUmw76N2Ut2euglfXGkAMPzQVDWxKxu+e0j9HTBsD0/51ta5TIW/Gm/skcoWv238+KK p+QaMaNCdeyHEdU+gKKw8HYOzZgfr6HZYS1rH X-Gm-Gg: ASbGncuxgXHBKkSobjMxufZaYSo5DXzYtDp+oPyRyY3WUpAF/AtRTdXxDdqZraje3CF 81ll9MGjqWKtiXGa20otaxQJe54+yJMlRzpHqm3sD0J/F3zq4dUeUcCk3uvboiuA9T72HTLdugl eM2sK1C2H73nShT6BkMqlaXPs9/OB+LODYjgtkuB/PX0U/f9Mnufwwh7MM7xvj7wIW5xvo7s9F3 u3QRk+mPj2Yb9gWvwijVpwDMWDGoRzqtLqiV8CVgi6C2niWJ4g9ipKAxhW8zawfvAdPnj+2MXnq EEdE5MoVgZC0qO2Xl8uY8vuAHn6ARwJDDajnaZId9J5tljcjdJg7ukIWgl/5jUPo0LUPNZn0 X-Google-Smtp-Source: AGHT+IHb/Ttk7opNgUgIaAxotnuf5QR5n78wzaVuzGrhrzbPBvVupirIi7yFUsslVf19tjV8av4rnExzOhe9 X-Received: by 2002:a17:90b:380b:b0:32b:96f2:e2c0 with SMTP id 98e67ed59e1d1-32b96f2e3ddmr2121936a91.5.1757005751963; Thu, 04 Sep 2025 10:09:11 -0700 (PDT) Received: from c7-smtp-2023.dev.purestorage.com ([208.88.159.129]) by smtp-relay.gmail.com with ESMTPS id 98e67ed59e1d1-327d8f579adsm1400702a91.0.2025.09.04.10.09.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Sep 2025 10:09:11 -0700 (PDT) X-Relaying-Domain: purestorage.com Received: from dev-csander.dev.purestorage.com (unknown [IPv6:2620:125:9007:640:ffff::1199]) by c7-smtp-2023.dev.purestorage.com (Postfix) with ESMTP id 5600A3409D7; Thu, 4 Sep 2025 11:09:11 -0600 (MDT) Received: by dev-csander.dev.purestorage.com (Postfix, from userid 1557716354) id 42FBBE41979; Thu, 4 Sep 2025 11:09:11 -0600 (MDT) From: Caleb Sander Mateos To: Jens Axboe Cc: io-uring@vger.kernel.org, linux-kernel@vger.kernel.org, Caleb Sander Mateos Subject: [PATCH v2 4/5] io_uring: factor out uring_lock helpers Date: Thu, 4 Sep 2025 11:09:01 -0600 Message-ID: <20250904170902.2624135-5-csander@purestorage.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20250904170902.2624135-1-csander@purestorage.com> References: <20250904170902.2624135-1-csander@purestorage.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" A subsequent commit will skip acquiring the io_ring_ctx uring_lock in io_uring_enter() and io_handle_tw_list() for IORING_SETUP_SINGLE_ISSUER. Prepare for this change by factoring out the uring_lock accesses under these functions into helper functions: - io_ring_ctx_lock() for mutex_lock(&ctx->uring_lock) - io_ring_ctx_unlock() for mutex_unlock(&ctx->uring_lock) - io_ring_ctx_assert_locked() for lockdep_assert_held(&ctx->uring_lock) For now, the helpers unconditionally call the mutex functions. But a subsequent commit will condition them on !IORING_SETUP_SINGLE_ISSUER. Signed-off-by: Caleb Sander Mateos --- io_uring/filetable.c | 3 ++- io_uring/io_uring.c | 51 ++++++++++++++++++++++++++------------------ io_uring/io_uring.h | 28 ++++++++++++++++++------ io_uring/kbuf.c | 6 +++--- io_uring/notif.c | 5 +++-- io_uring/notif.h | 3 ++- io_uring/poll.c | 2 +- io_uring/rsrc.c | 2 +- io_uring/rsrc.h | 3 ++- io_uring/rw.c | 2 +- io_uring/waitid.c | 2 +- 11 files changed, 67 insertions(+), 40 deletions(-) diff --git a/io_uring/filetable.c b/io_uring/filetable.c index a21660e3145a..aae283e77856 100644 --- a/io_uring/filetable.c +++ b/io_uring/filetable.c @@ -55,14 +55,15 @@ void io_free_file_tables(struct io_ring_ctx *ctx, struc= t io_file_table *table) table->bitmap =3D NULL; } =20 static int io_install_fixed_file(struct io_ring_ctx *ctx, struct file *fil= e, u32 slot_index) - __must_hold(&req->ctx->uring_lock) { struct io_rsrc_node *node; =20 + io_ring_ctx_assert_locked(ctx); + if (io_is_uring_fops(file)) return -EBADF; if (!ctx->file_table.data.nr) return -ENXIO; if (slot_index >=3D ctx->file_table.data.nr) diff --git a/io_uring/io_uring.c b/io_uring/io_uring.c index c7af9dc3d95a..69e1175256bb 100644 --- a/io_uring/io_uring.c +++ b/io_uring/io_uring.c @@ -554,11 +554,11 @@ static unsigned io_linked_nr(struct io_kiocb *req) =20 static __cold noinline void io_queue_deferred(struct io_ring_ctx *ctx) { bool drain_seen =3D false, first =3D true; =20 - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); __io_req_caches_free(ctx); =20 while (!list_empty(&ctx->defer_list)) { struct io_defer_entry *de =3D list_first_entry(&ctx->defer_list, struct io_defer_entry, list); @@ -925,11 +925,11 @@ bool io_post_aux_cqe(struct io_ring_ctx *ctx, u64 use= r_data, s32 res, u32 cflags * Must be called from inline task_work so we now a flush will happen late= r, * and obviously with ctx->uring_lock held (tw always has that). */ void io_add_aux_cqe(struct io_ring_ctx *ctx, u64 user_data, s32 res, u32 c= flags) { - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); lockdep_assert(ctx->lockless_cq); =20 if (!io_fill_cqe_aux(ctx, user_data, res, cflags)) { struct io_cqe cqe =3D io_init_cqe(user_data, res, cflags); =20 @@ -954,11 +954,11 @@ bool io_req_post_cqe(struct io_kiocb *req, s32 res, u= 32 cflags) */ if (!wq_list_empty(&ctx->submit_state.compl_reqs)) __io_submit_flush_completions(ctx); =20 lockdep_assert(!io_wq_current_is_worker()); - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); =20 if (!ctx->lockless_cq) { spin_lock(&ctx->completion_lock); posted =3D io_fill_cqe_aux(ctx, req->cqe.user_data, res, cflags); spin_unlock(&ctx->completion_lock); @@ -978,11 +978,11 @@ bool io_req_post_cqe32(struct io_kiocb *req, struct i= o_uring_cqe cqe[2]) { struct io_ring_ctx *ctx =3D req->ctx; bool posted; =20 lockdep_assert(!io_wq_current_is_worker()); - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); =20 cqe[0].user_data =3D req->cqe.user_data; if (!ctx->lockless_cq) { spin_lock(&ctx->completion_lock); posted =3D io_fill_cqe_aux32(ctx, cqe); @@ -1032,15 +1032,14 @@ static void io_req_complete_post(struct io_kiocb *r= eq, unsigned issue_flags) */ req_ref_put(req); } =20 void io_req_defer_failed(struct io_kiocb *req, s32 res) - __must_hold(&ctx->uring_lock) { const struct io_cold_def *def =3D &io_cold_defs[req->opcode]; =20 - lockdep_assert_held(&req->ctx->uring_lock); + io_ring_ctx_assert_locked(req->ctx); =20 req_set_fail(req); io_req_set_res(req, res, io_put_kbuf(req, res, NULL)); if (def->fail) def->fail(req); @@ -1052,16 +1051,17 @@ void io_req_defer_failed(struct io_kiocb *req, s32 = res) * handlers and io_issue_sqe() are done with it, e.g. inline completion pa= th. * Because of that, io_alloc_req() should be called only under ->uring_lock * and with extra caution to not get a request that is still worked on. */ __cold bool __io_alloc_req_refill(struct io_ring_ctx *ctx) - __must_hold(&ctx->uring_lock) { gfp_t gfp =3D GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO; void *reqs[IO_REQ_ALLOC_BATCH]; int ret; =20 + io_ring_ctx_assert_locked(ctx); + ret =3D kmem_cache_alloc_bulk(req_cachep, gfp, ARRAY_SIZE(reqs), reqs); =20 /* * Bulk alloc is all-or-nothing. If we fail to get a batch, * retry single alloc to be on the safe side. @@ -1126,11 +1126,11 @@ static void ctx_flush_and_put(struct io_ring_ctx *c= tx, io_tw_token_t tw) return; if (ctx->flags & IORING_SETUP_TASKRUN_FLAG) atomic_andnot(IORING_SQ_TASKRUN, &ctx->rings->sq_flags); =20 io_submit_flush_completions(ctx); - mutex_unlock(&ctx->uring_lock); + io_ring_ctx_unlock(ctx); percpu_ref_put(&ctx->refs); } =20 /* * Run queued task_work, returning the number of entries processed in *cou= nt. @@ -1150,11 +1150,11 @@ struct llist_node *io_handle_tw_list(struct llist_n= ode *node, io_task_work.node); =20 if (req->ctx !=3D ctx) { ctx_flush_and_put(ctx, ts); ctx =3D req->ctx; - mutex_lock(&ctx->uring_lock); + io_ring_ctx_lock(ctx); percpu_ref_get(&ctx->refs); } INDIRECT_CALL_2(req->io_task_work.func, io_poll_task_func, io_req_rw_complete, req, ts); @@ -1502,12 +1502,13 @@ static inline void io_req_put_rsrc_nodes(struct io_= kiocb *req) io_put_rsrc_node(req->ctx, req->buf_node); } =20 static void io_free_batch_list(struct io_ring_ctx *ctx, struct io_wq_work_node *node) - __must_hold(&ctx->uring_lock) { + io_ring_ctx_assert_locked(ctx); + do { struct io_kiocb *req =3D container_of(node, struct io_kiocb, comp_list); =20 if (unlikely(req->flags & IO_REQ_CLEAN_SLOW_FLAGS)) { @@ -1543,15 +1544,16 @@ static void io_free_batch_list(struct io_ring_ctx *= ctx, io_req_add_to_cache(req, ctx); } while (node); } =20 void __io_submit_flush_completions(struct io_ring_ctx *ctx) - __must_hold(&ctx->uring_lock) { struct io_submit_state *state =3D &ctx->submit_state; struct io_wq_work_node *node; =20 + io_ring_ctx_assert_locked(ctx); + __io_cq_lock(ctx); __wq_list_for_each(node, &state->compl_reqs) { struct io_kiocb *req =3D container_of(node, struct io_kiocb, comp_list); =20 @@ -1767,16 +1769,17 @@ io_req_flags_t io_file_get_flags(struct file *file) res |=3D REQ_F_SUPPORT_NOWAIT; return res; } =20 static __cold void io_drain_req(struct io_kiocb *req) - __must_hold(&ctx->uring_lock) { struct io_ring_ctx *ctx =3D req->ctx; bool drain =3D req->flags & IOSQE_IO_DRAIN; struct io_defer_entry *de; =20 + io_ring_ctx_assert_locked(ctx); + de =3D kmalloc(sizeof(*de), GFP_KERNEL_ACCOUNT); if (!de) { io_req_defer_failed(req, -ENOMEM); return; } @@ -2043,12 +2046,13 @@ static int io_req_sqe_copy(struct io_kiocb *req, un= signed int issue_flags) def->sqe_copy(req); return 0; } =20 static void io_queue_async(struct io_kiocb *req, unsigned int issue_flags,= int ret) - __must_hold(&req->ctx->uring_lock) { + io_ring_ctx_assert_locked(req->ctx); + if (ret !=3D -EAGAIN || (req->flags & REQ_F_NOWAIT)) { fail: io_req_defer_failed(req, ret); return; } @@ -2068,16 +2072,17 @@ static void io_queue_async(struct io_kiocb *req, un= signed int issue_flags, int r break; } } =20 static inline void io_queue_sqe(struct io_kiocb *req, unsigned int extra_f= lags) - __must_hold(&req->ctx->uring_lock) { unsigned int issue_flags =3D IO_URING_F_NONBLOCK | IO_URING_F_COMPLETE_DEFER | extra_flags; int ret; =20 + io_ring_ctx_assert_locked(req->ctx); + ret =3D io_issue_sqe(req, issue_flags); =20 /* * We async punt it if the file wasn't marked NOWAIT, or if the file * doesn't support non-blocking read/write attempts @@ -2085,12 +2090,13 @@ static inline void io_queue_sqe(struct io_kiocb *re= q, unsigned int extra_flags) if (unlikely(ret)) io_queue_async(req, issue_flags, ret); } =20 static void io_queue_sqe_fallback(struct io_kiocb *req) - __must_hold(&req->ctx->uring_lock) { + io_ring_ctx_assert_locked(req->ctx); + if (unlikely(req->flags & REQ_F_FAIL)) { /* * We don't submit, fail them all, for that replace hardlinks * with normal links. Extra REQ_F_LINK is tolerated. */ @@ -2155,17 +2161,18 @@ static __cold int io_init_fail_req(struct io_kiocb = *req, int err) return err; } =20 static int io_init_req(struct io_ring_ctx *ctx, struct io_kiocb *req, const struct io_uring_sqe *sqe) - __must_hold(&ctx->uring_lock) { const struct io_issue_def *def; unsigned int sqe_flags; int personality; u8 opcode; =20 + io_ring_ctx_assert_locked(ctx); + req->ctx =3D ctx; req->opcode =3D opcode =3D READ_ONCE(sqe->opcode); /* same numerical values with corresponding REQ_F_*, safe to copy */ sqe_flags =3D READ_ONCE(sqe->flags); req->flags =3D (__force io_req_flags_t) sqe_flags; @@ -2290,15 +2297,16 @@ static __cold int io_submit_fail_init(const struct = io_uring_sqe *sqe, return 0; } =20 static inline int io_submit_sqe(struct io_ring_ctx *ctx, struct io_kiocb *= req, const struct io_uring_sqe *sqe) - __must_hold(&ctx->uring_lock) { struct io_submit_link *link =3D &ctx->submit_state.link; int ret; =20 + io_ring_ctx_assert_locked(ctx); + ret =3D io_init_req(ctx, req, sqe); if (unlikely(ret)) return io_submit_fail_init(sqe, req, ret); =20 trace_io_uring_submit_req(req); @@ -2419,16 +2427,17 @@ static bool io_get_sqe(struct io_ring_ctx *ctx, con= st struct io_uring_sqe **sqe) *sqe =3D &ctx->sq_sqes[head]; return true; } =20 int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr) - __must_hold(&ctx->uring_lock) { unsigned int entries =3D io_sqring_entries(ctx); unsigned int left; int ret; =20 + io_ring_ctx_assert_locked(ctx); + if (unlikely(!entries)) return 0; /* make sure SQ entry isn't read before tail */ ret =3D left =3D min(nr, entries); io_get_task_refs(left); @@ -3518,14 +3527,14 @@ SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u= 32, to_submit, } else if (to_submit) { ret =3D io_uring_add_tctx_node(ctx); if (unlikely(ret)) goto out; =20 - mutex_lock(&ctx->uring_lock); + io_ring_ctx_lock(ctx); ret =3D io_submit_sqes(ctx, to_submit); if (ret !=3D to_submit) { - mutex_unlock(&ctx->uring_lock); + io_ring_ctx_unlock(ctx); goto out; } if (flags & IORING_ENTER_GETEVENTS) { if (ctx->syscall_iopoll) goto iopoll_locked; @@ -3534,11 +3543,11 @@ SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u= 32, to_submit, * it should handle ownership problems if any. */ if (ctx->flags & IORING_SETUP_DEFER_TASKRUN) (void)io_run_local_work_locked(ctx, min_complete); } - mutex_unlock(&ctx->uring_lock); + io_ring_ctx_unlock(ctx); } =20 if (flags & IORING_ENTER_GETEVENTS) { int ret2; =20 diff --git a/io_uring/io_uring.h b/io_uring/io_uring.h index d62b7d9fafed..a0580a1bf6b5 100644 --- a/io_uring/io_uring.h +++ b/io_uring/io_uring.h @@ -119,20 +119,35 @@ bool __io_alloc_req_refill(struct io_ring_ctx *ctx); bool io_match_task_safe(struct io_kiocb *head, struct io_uring_task *tctx, bool cancel_all); =20 void io_activate_pollwq(struct io_ring_ctx *ctx); =20 +static inline void io_ring_ctx_lock(struct io_ring_ctx *ctx) +{ + mutex_lock(&ctx->uring_lock); +} + +static inline void io_ring_ctx_unlock(struct io_ring_ctx *ctx) +{ + mutex_unlock(&ctx->uring_lock); +} + +static inline void io_ring_ctx_assert_locked(const struct io_ring_ctx *ctx) +{ + lockdep_assert_held(&ctx->uring_lock); +} + static inline void io_lockdep_assert_cq_locked(struct io_ring_ctx *ctx) { #if defined(CONFIG_PROVE_LOCKING) lockdep_assert(in_task()); =20 if (ctx->flags & IORING_SETUP_DEFER_TASKRUN) - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); =20 if (ctx->flags & IORING_SETUP_IOPOLL) { - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); } else if (!ctx->task_complete) { lockdep_assert_held(&ctx->completion_lock); } else if (ctx->submitter_task) { /* * ->submitter_task may be NULL and we can still post a CQE, @@ -300,11 +315,11 @@ static inline void io_put_file(struct io_kiocb *req) } =20 static inline void io_ring_submit_unlock(struct io_ring_ctx *ctx, unsigned issue_flags) { - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); if (unlikely(issue_flags & IO_URING_F_UNLOCKED)) mutex_unlock(&ctx->uring_lock); } =20 static inline void io_ring_submit_lock(struct io_ring_ctx *ctx, @@ -316,11 +331,11 @@ static inline void io_ring_submit_lock(struct io_ring= _ctx *ctx, * The only exception is when we've detached the request and issue it * from an async worker thread, grab the lock for that case. */ if (unlikely(issue_flags & IO_URING_F_UNLOCKED)) mutex_lock(&ctx->uring_lock); - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); } =20 static inline void io_commit_cqring(struct io_ring_ctx *ctx) { /* order cqe stores with ring update */ @@ -428,24 +443,23 @@ static inline bool io_task_work_pending(struct io_rin= g_ctx *ctx) return task_work_pending(current) || io_local_work_pending(ctx); } =20 static inline void io_tw_lock(struct io_ring_ctx *ctx, io_tw_token_t tw) { - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); } =20 /* * Don't complete immediately but use deferred completion infrastructure. * Protected by ->uring_lock and can only be used either with * IO_URING_F_COMPLETE_DEFER or inside a tw handler holding the mutex. */ static inline void io_req_complete_defer(struct io_kiocb *req) - __must_hold(&req->ctx->uring_lock) { struct io_submit_state *state =3D &req->ctx->submit_state; =20 - lockdep_assert_held(&req->ctx->uring_lock); + io_ring_ctx_assert_locked(req->ctx); =20 wq_list_add_tail(&req->comp_list, &state->compl_reqs); } =20 static inline void io_commit_cqring_flush(struct io_ring_ctx *ctx) diff --git a/io_uring/kbuf.c b/io_uring/kbuf.c index 3e9aab21af9d..ea6f3588d875 100644 --- a/io_uring/kbuf.c +++ b/io_uring/kbuf.c @@ -68,11 +68,11 @@ bool io_kbuf_commit(struct io_kiocb *req, } =20 static inline struct io_buffer_list *io_buffer_get_list(struct io_ring_ctx= *ctx, unsigned int bgid) { - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); =20 return xa_load(&ctx->io_bl_xa, bgid); } =20 static int io_buffer_add_list(struct io_ring_ctx *ctx, @@ -337,11 +337,11 @@ int io_buffers_peek(struct io_kiocb *req, struct buf_= sel_arg *arg, { struct io_ring_ctx *ctx =3D req->ctx; struct io_buffer_list *bl; int ret; =20 - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); =20 bl =3D io_buffer_get_list(ctx, arg->buf_group); if (unlikely(!bl)) return -ENOENT; =20 @@ -393,11 +393,11 @@ static int io_remove_buffers_legacy(struct io_ring_ct= x *ctx, { unsigned long i =3D 0; struct io_buffer *nxt; =20 /* protects io_buffers_cache */ - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); WARN_ON_ONCE(bl->flags & IOBL_BUF_RING); =20 for (i =3D 0; i < nbufs && !list_empty(&bl->buf_list); i++) { nxt =3D list_first_entry(&bl->buf_list, struct io_buffer, list); list_del(&nxt->list); diff --git a/io_uring/notif.c b/io_uring/notif.c index 8c92e9cde2c6..9dd248fcb213 100644 --- a/io_uring/notif.c +++ b/io_uring/notif.c @@ -14,11 +14,11 @@ static const struct ubuf_info_ops io_ubuf_ops; static void io_notif_tw_complete(struct io_kiocb *notif, io_tw_token_t tw) { struct io_notif_data *nd =3D io_notif_to_data(notif); struct io_ring_ctx *ctx =3D notif->ctx; =20 - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); =20 do { notif =3D cmd_to_io_kiocb(nd); =20 if (WARN_ON_ONCE(ctx !=3D notif->ctx)) @@ -108,15 +108,16 @@ static const struct ubuf_info_ops io_ubuf_ops =3D { .complete =3D io_tx_ubuf_complete, .link_skb =3D io_link_skb, }; =20 struct io_kiocb *io_alloc_notif(struct io_ring_ctx *ctx) - __must_hold(&ctx->uring_lock) { struct io_kiocb *notif; struct io_notif_data *nd; =20 + io_ring_ctx_assert_locked(ctx); + if (unlikely(!io_alloc_req(ctx, ¬if))) return NULL; notif->ctx =3D ctx; notif->opcode =3D IORING_OP_NOP; notif->flags =3D 0; diff --git a/io_uring/notif.h b/io_uring/notif.h index f3589cfef4a9..c33c9a1179c9 100644 --- a/io_uring/notif.h +++ b/io_uring/notif.h @@ -31,14 +31,15 @@ static inline struct io_notif_data *io_notif_to_data(st= ruct io_kiocb *notif) { return io_kiocb_to_cmd(notif, struct io_notif_data); } =20 static inline void io_notif_flush(struct io_kiocb *notif) - __must_hold(¬if->ctx->uring_lock) { struct io_notif_data *nd =3D io_notif_to_data(notif); =20 + io_ring_ctx_assert_locked(notif->ctx); + io_tx_ubuf_complete(NULL, &nd->uarg, true); } =20 static inline int io_notif_account_mem(struct io_kiocb *notif, unsigned le= n) { diff --git a/io_uring/poll.c b/io_uring/poll.c index ea75c5cd81a0..ba71403c8fd8 100644 --- a/io_uring/poll.c +++ b/io_uring/poll.c @@ -121,11 +121,11 @@ static struct io_poll *io_poll_get_single(struct io_k= iocb *req) static void io_poll_req_insert(struct io_kiocb *req) { struct io_hash_table *table =3D &req->ctx->cancel_table; u32 index =3D hash_long(req->cqe.user_data, table->hash_bits); =20 - lockdep_assert_held(&req->ctx->uring_lock); + io_ring_ctx_assert_locked(req->ctx); =20 hlist_add_head(&req->hash_node, &table->hbs[index].list); } =20 static void io_init_poll_iocb(struct io_poll *poll, __poll_t events) diff --git a/io_uring/rsrc.c b/io_uring/rsrc.c index 1e5b7833076a..1c1753de7340 100644 --- a/io_uring/rsrc.c +++ b/io_uring/rsrc.c @@ -347,11 +347,11 @@ static int __io_register_rsrc_update(struct io_ring_c= tx *ctx, unsigned type, struct io_uring_rsrc_update2 *up, unsigned nr_args) { __u32 tmp; =20 - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); =20 if (check_add_overflow(up->offset, nr_args, &tmp)) return -EOVERFLOW; =20 switch (type) { diff --git a/io_uring/rsrc.h b/io_uring/rsrc.h index a3ca6ba66596..d537a3b895d6 100644 --- a/io_uring/rsrc.h +++ b/io_uring/rsrc.h @@ -2,10 +2,11 @@ #ifndef IOU_RSRC_H #define IOU_RSRC_H =20 #include #include +#include "io_uring.h" =20 #define IO_VEC_CACHE_SOFT_CAP 256 =20 enum { IORING_RSRC_FILE =3D 0, @@ -97,11 +98,11 @@ static inline struct io_rsrc_node *io_rsrc_node_lookup(= struct io_rsrc_data *data return NULL; } =20 static inline void io_put_rsrc_node(struct io_ring_ctx *ctx, struct io_rsr= c_node *node) { - lockdep_assert_held(&ctx->uring_lock); + io_ring_ctx_assert_locked(ctx); if (!--node->refs) io_free_rsrc_node(ctx, node); } =20 static inline bool io_reset_rsrc_node(struct io_ring_ctx *ctx, diff --git a/io_uring/rw.c b/io_uring/rw.c index ab6b4afccec3..f00e02a02dc7 100644 --- a/io_uring/rw.c +++ b/io_uring/rw.c @@ -461,11 +461,11 @@ int io_read_mshot_prep(struct io_kiocb *req, const st= ruct io_uring_sqe *sqe) return 0; } =20 void io_readv_writev_cleanup(struct io_kiocb *req) { - lockdep_assert_held(&req->ctx->uring_lock); + io_ring_ctx_assert_locked(req->ctx); io_rw_recycle(req, 0); } =20 static inline loff_t *io_kiocb_update_pos(struct io_kiocb *req) { diff --git a/io_uring/waitid.c b/io_uring/waitid.c index 26c118f3918d..f7a5054d4d81 100644 --- a/io_uring/waitid.c +++ b/io_uring/waitid.c @@ -114,11 +114,11 @@ static void io_waitid_complete(struct io_kiocb *req, = int ret) struct io_waitid *iw =3D io_kiocb_to_cmd(req, struct io_waitid); =20 /* anyone completing better be holding a reference */ WARN_ON_ONCE(!(atomic_read(&iw->refs) & IO_WAITID_REF_MASK)); =20 - lockdep_assert_held(&req->ctx->uring_lock); + io_ring_ctx_assert_locked(req->ctx); =20 hlist_del_init(&req->hash_node); =20 ret =3D io_waitid_finish(req, ret); if (ret < 0) --=20 2.45.2