From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A9A352D9780; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161524; cv=none; b=IjpTE9trP9hdRbAHQ20nXYQzSO8epC7RTtVXhZrwnw/9Ech10NHZ+TGsEaIo9HjQYx3QSGsubI8L0JIykpQFR92kKpMf9fcYiPTHwEYV1TbfChT3dEMZ5K8ZsBAIbwPGvdHHZ68bOT7dxKZD5DQRVNsu57nbnmL5PNaR6v2E7cs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161524; c=relaxed/simple; bh=6Xs3jwDoSFtHtLmZe767+cTvDIZN3KlwcFjw/arZtkM=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=UgI3ztjG0IjHssxOtrZo3jdfIlwun+IJrv7AmIdSCtPFwRdVwWJYb/lesSIXbcOcF4JEFB83axQ81pN3DeQ9nrscTJtyft2IbHT6Sgc5Rgp93xb0bKdoFmTabqnJ/3k50JatTGG7GV9etzQjZIINQFLSL8+EQ3uifIY4ltOQpTQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=FiWC7J5y; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="FiWC7J5y" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8EF5C1F000E9; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161522; bh=n+oAf3hk5jmN4VFVeAO70gcuYbRCnvfHxBQClN5hEMo=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=FiWC7J5yGOVkSiwmfgYSQ3LIyPWzejhnZ8xxp/DdC8Zvu/w3wXU2t8n1R3FmYHiiO AgRmMXuAt4CZP7J0WIm2ChJBt5fikqaEVNj2ay5VMEnYOIBjZDGfFMGurvHzJrRQ/v HMBR4HUHxAmdC/pM/vMetpbKUNOtugCHX/oM7oJaPaYIbg+nD77jo1RaHfulztUjLt Bu9Imrk4uS+a5z9vv8U7s7zhXv1tAcpogJgVpCmEUfk1PE6JTE+fP0GDAp9xKLI02t ydHhNSvcZmPU2toOlcUL4sG81r98+gskSx4tCpU2lWn+bqT1Lacyu0yl+1yWZmG13L 6skIh4SlrOFRQ== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 6D52BCE0569; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" Subject: [PATCH 01/11] rcutorture: Abstract reader-segment dump into rcu_torture_dump_read_segs() Date: Wed, 15 Jul 2026 17:25:10 -0700 Message-Id: <20260716002520.11895-1-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" This commit abstracts the open-coded dumping of reader segments in the rcu_torture_cleanup() function into a new rcu_torture_dump_read_segs() function. This abstraction will allow reader segments to be dumped for other purposes. Signed-off-by: Paul E. McKenney --- kernel/rcu/rcutorture.c | 148 +++++++++++++++++++++------------------- 1 file changed, 76 insertions(+), 72 deletions(-) diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index 882a158ada7bbd..ffeca1b7e17016 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -2401,6 +2401,80 @@ struct rcu_torture_one_read_state { unsigned long long ts; }; =20 +static void rcu_torture_dump_read_segs(struct rt_read_seg *rrsp, int nsegs) +{ + bool firsttime; + int i; + int j; + + firsttime =3D 1; + for (i =3D 0; i < nsegs; i++) { + if (IS_ENABLED(CONFIG_RCU_TORTURE_TEST_LOG_GP)) + pr_alert("\t%lluus ", div64_u64(rrsp[i].rt_ts, 1000ULL)); + else + pr_alert("\t"); + pr_cont("%d: %#4x", i, rrsp[i].rt_readstate); + if (rrsp[i].rt_delay_jiffies !=3D 0) { + pr_cont("%s%ldjiffies", firsttime ? "" : "+", + rrsp[i].rt_delay_jiffies); + firsttime =3D 0; + } + if (IS_ENABLED(CONFIG_RCU_TORTURE_TEST_LOG_CPU)) { + pr_cont(" CPU %2d", rrsp[i].rt_cpu); + if (rrsp[i].rt_cpu !=3D rrsp[i].rt_end_cpu) + pr_cont("->%-2d", rrsp[i].rt_end_cpu); + else + pr_cont(" ..."); + } + if (IS_ENABLED(CONFIG_RCU_TORTURE_TEST_LOG_GP) && + cur_ops->gather_gp_seqs && cur_ops->format_gp_seqs) { + char buf1[20+1]; + char buf2[20+1]; + char sepchar =3D '-'; + + cur_ops->format_gp_seqs(rrsp[i].rt_gp_seq, buf1, ARRAY_SIZE(buf1)); + cur_ops->format_gp_seqs(rrsp[i].rt_gp_seq_end, buf2, ARRAY_SIZE(buf2)); + if (rrsp[i].rt_gp_seq =3D=3D rrsp[i].rt_gp_seq_end) { + if (buf2[0]) { + for (j =3D 0; buf2[j]; j++) + buf2[j] =3D '.'; + if (j) + buf2[j - 1] =3D ' '; + } + sepchar =3D ' '; + } + pr_cont(" %s%c%s", buf1, sepchar, buf2); + } + if (rrsp[i].rt_delay_ms !=3D 0) { + pr_cont(" %s%ldms", firsttime ? "" : "+", rrsp[i].rt_delay_ms); + firsttime =3D 0; + } + if (rrsp[i].rt_delay_us !=3D 0) { + pr_cont(" %s%ldus", firsttime ? "" : "+", rrsp[i].rt_delay_us); + firsttime =3D 0; + } + pr_cont("%s", rrsp[i].rt_preempted ? " preempted" : ""); + if (rrsp[i].rt_readstate & RCUTORTURE_RDR_BH) + pr_cont(" BH"); + if (rrsp[i].rt_readstate & RCUTORTURE_RDR_IRQ) + pr_cont(" IRQ"); + if (rrsp[i].rt_readstate & RCUTORTURE_RDR_PREEMPT) + pr_cont(" PREEMPT"); + if (rrsp[i].rt_readstate & RCUTORTURE_RDR_RBH) + pr_cont(" RBH"); + if (rrsp[i].rt_readstate & RCUTORTURE_RDR_SCHED) + pr_cont(" SCHED"); + if (rrsp[i].rt_readstate & RCUTORTURE_RDR_RCU_1) + pr_cont(" RCU_1"); + if (rrsp[i].rt_readstate & RCUTORTURE_RDR_RCU_2) + pr_cont(" RCU_2"); + pr_cont("\n"); + + } + if (rt_read_preempted) + pr_alert("\tReader was preempted.\n"); +} + static void init_rcu_torture_one_read_state(struct rcu_torture_one_read_st= ate *rtorsp, struct torture_random_state *trsp) { @@ -4094,11 +4168,9 @@ static void rcu_gpwrap_lag_cleanup(void) static void rcu_torture_cleanup(void) { - int firsttime; int flags =3D 0; unsigned long gp_seq =3D 0; int i; - int j; =20 if (torture_cleanup_begin()) { if (cur_ops->cb_barrier !=3D NULL) { @@ -4183,76 +4255,8 @@ rcu_torture_cleanup(void) pr_alert("Failure/close-call rcutorture reader segments:\n"); if (rt_read_nsegs =3D=3D 0) pr_alert("\t: No segments recorded!!!\n"); - firsttime =3D 1; - for (i =3D 0; i < rt_read_nsegs; i++) { - if (IS_ENABLED(CONFIG_RCU_TORTURE_TEST_LOG_GP)) - pr_alert("\t%lluus ", div64_u64(err_segs[i].rt_ts, 1000ULL)); - else - pr_alert("\t"); - pr_cont("%d: %#4x", i, err_segs[i].rt_readstate); - if (err_segs[i].rt_delay_jiffies !=3D 0) { - pr_cont("%s%ldjiffies", firsttime ? "" : "+", - err_segs[i].rt_delay_jiffies); - firsttime =3D 0; - } - if (IS_ENABLED(CONFIG_RCU_TORTURE_TEST_LOG_CPU)) { - pr_cont(" CPU %2d", err_segs[i].rt_cpu); - if (err_segs[i].rt_cpu !=3D err_segs[i].rt_end_cpu) - pr_cont("->%-2d", err_segs[i].rt_end_cpu); - else - pr_cont(" ..."); - } - if (IS_ENABLED(CONFIG_RCU_TORTURE_TEST_LOG_GP) && - cur_ops->gather_gp_seqs && cur_ops->format_gp_seqs) { - char buf1[20+1]; - char buf2[20+1]; - char sepchar =3D '-'; - - cur_ops->format_gp_seqs(err_segs[i].rt_gp_seq, - buf1, ARRAY_SIZE(buf1)); - cur_ops->format_gp_seqs(err_segs[i].rt_gp_seq_end, - buf2, ARRAY_SIZE(buf2)); - if (err_segs[i].rt_gp_seq =3D=3D err_segs[i].rt_gp_seq_end) { - if (buf2[0]) { - for (j =3D 0; buf2[j]; j++) - buf2[j] =3D '.'; - if (j) - buf2[j - 1] =3D ' '; - } - sepchar =3D ' '; - } - pr_cont(" %s%c%s", buf1, sepchar, buf2); - } - if (err_segs[i].rt_delay_ms !=3D 0) { - pr_cont(" %s%ldms", firsttime ? "" : "+", - err_segs[i].rt_delay_ms); - firsttime =3D 0; - } - if (err_segs[i].rt_delay_us !=3D 0) { - pr_cont(" %s%ldus", firsttime ? "" : "+", - err_segs[i].rt_delay_us); - firsttime =3D 0; - } - pr_cont("%s", err_segs[i].rt_preempted ? " preempted" : ""); - if (err_segs[i].rt_readstate & RCUTORTURE_RDR_BH) - pr_cont(" BH"); - if (err_segs[i].rt_readstate & RCUTORTURE_RDR_IRQ) - pr_cont(" IRQ"); - if (err_segs[i].rt_readstate & RCUTORTURE_RDR_PREEMPT) - pr_cont(" PREEMPT"); - if (err_segs[i].rt_readstate & RCUTORTURE_RDR_RBH) - pr_cont(" RBH"); - if (err_segs[i].rt_readstate & RCUTORTURE_RDR_SCHED) - pr_cont(" SCHED"); - if (err_segs[i].rt_readstate & RCUTORTURE_RDR_RCU_1) - pr_cont(" RCU_1"); - if (err_segs[i].rt_readstate & RCUTORTURE_RDR_RCU_2) - pr_cont(" RCU_2"); - pr_cont("\n"); - - } - if (rt_read_preempted) - pr_alert("\tReader was preempted.\n"); + else + rcu_torture_dump_read_segs(err_segs, rt_read_nsegs); } if (atomic_read(&n_rcu_torture_error) || n_rcu_torture_barrier_error) rcu_torture_print_module_parms(cur_ops, "End of test: FAILURE"); --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 75A9329D264; Thu, 16 Jul 2026 00:25:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161528; cv=none; b=EXjTV1Fmr0Zo7ou2Sc1g9PnGwwO9OSrrspvV3/jeK6wHwtPtONkLZIOH5Ga5OXCxEgcRK30dtSlfLk479I5whPmxgVR4NbPr6KnBwFLjilPiJp+5VywtrAHRJTj8giIgFBgFMTdbuJdKEZX4ErXl2a4pVowwbGKgSu950URNYTM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161528; c=relaxed/simple; bh=dtiD5MWRpv5f2vxTXp0PQ0Ig54T7aIr3nnw87lKjGUk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=miNs7q8DUUj9ZI2Qkx5K5El0OHhsbpTg7LK+XSethLm3WWXfsbfhgFTGDp0pPQN7bgBi2Rxu7TArLcEuLMwESrEeli4VH35DDIr4mC+QszZkppsKjychLzkMJPvJhEcTSHDDgEIacZ5Rz0f1t3xB/2HDVAb03t+V/Lon1cRuS9o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=QbomRkO6; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="QbomRkO6" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9D0CA1F00A3A; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161522; bh=dxZleyWjSHr+J8NWJtni/nMu+YZ1Zz0bHgcl35cOdjA=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=QbomRkO6AAzneAmU0EavI5M/8gSwyds+vKVZhoJzeK3Cdw3s0yudZ40RdAlRpejR8 X8nw4RwLc5b2EfPdxfkvEHTs+Cf91wIgsESdIj2dns5fdaa6FZ1VUCkimH4Gs7XnNT ELKSbSG6P7w6z14ryBD0bOY5BRlVtAldeulfXSqeh+zK0OTqxe6fVY5SP8WsVh7g7r ykbQCJr1FgX3Q28rT7rm03MhZLKhzHk7Q2u0GeX5ZeVCaviTIqsZ0DYjGaan00pBlk dmB5KQDHG2ZM4IJuxHqfWe386oBCmeepoe8jb6Tesst8XoMpt0Pp1h37/T9NFjY30Z 8J06Facg0MQwA== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 71F18CE0B87; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" Subject: [PATCH 02/11] rcutorture: Check for immediate deboosting at reader end Date: Wed, 15 Jul 2026 17:25:11 -0700 Message-Id: <20260716002520.11895-2-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" This commit adds a check for failure to have fully deboosted a multi-segmented RCU reader at the end of the full read-side critical section. This check only happens for fully task-level readers, because a a handler might have interrupted an already-boosted task-level RCU reader, and a reader in that handler could then cause false positives. The first failed check (due to an RCU reader that was not immediately deboosted) causes a splat, but only when the disabled-by-default deboost_timeliness_check module parameter is enabled. Regardless of the value of this parameter, it produces a list of the segments making up that RCU reader following a "Slow-deboost rcutorture reader segments" heading. Subsequent failures fail silently, all in the name of keeping console output down to a dull roar. Although most uses of RCU priority boosting serve as debugging aids, this might change, and in fact might already have changed. And allowing (for example) RCU priority boosting to persist until the next scheduler tick could cause an aggressively real-time system to miss sub-millisecond deadlines. So we do need to find this sort of problem during testing, and preferably not in the field. The name and type of the newly added rcu_torture_ops function pointer (named "->is_task_rcu_boosted()") may need to change should other end-of-reader checks be needed. But let's start simple. Oh, and Claude figured out that rcu_is_task_rcu_boosted() could be lockless. Perhaps there is hope for AI yet! ;-) Signed-off-by: Paul E. McKenney --- kernel/rcu/rcu.h | 7 +++++++ kernel/rcu/rcutorture.c | 24 ++++++++++++++++++++++++ kernel/rcu/tree_plugin.h | 32 +++++++++++++++++++++++++++++++- 3 files changed, 62 insertions(+), 1 deletion(-) diff --git a/kernel/rcu/rcu.h b/kernel/rcu/rcu.h index fa6d30ce73d1fd..14faa11ef23cd0 100644 --- a/kernel/rcu/rcu.h +++ b/kernel/rcu/rcu.h @@ -695,4 +695,11 @@ static inline int rcu_stall_notifier_call_chain(unsign= ed long val, void *v) { re void synchronize_rcu_trivial_preempt(void); #endif // #ifdef CONFIG_TRIVIAL_PREEMPT_RCU =20 +#if defined(CONFIG_RCU_TORTURE_TEST) && defined(CONFIG_RCU_BOOST) +bool rcu_is_task_rcu_boosted(void); +#else // #if defined(CONFIG_RCU_TORTURE_TEST) && defined(CONFIG_RCU_BOOST) +static inline bool rcu_is_task_rcu_boosted(void) { return false; } +#endif // #else // #if defined(CONFIG_RCU_TORTURE_TEST) && defined(CONFIG_= RCU_BOOST) + + #endif /* __LINUX_RCU_H */ diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index ffeca1b7e17016..1a033ae1f1eb6a 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -80,6 +80,7 @@ MODULE_AUTHOR("Paul E. McKenney a= nd Josh Triplett is_task_rcu_boosted && cur_ops->is_task_rcu_boosted() && + !in_serving_softirq() && !in_hardirq() && !in_nmi() && + READ_ONCE(firsttime) && xchg(&firsttime, 0)) { + WARN_ON_ONCE(deboost_timeliness_check); + nsegs =3D rtors.rtrsp - rtors.rtseg; + nsegs =3D clamp_val(nsegs, 0, RCUTORTURE_RDR_MAX_SEGS); + pr_alert("Slow-deboost rcutorture reader segments:\n"); + rcu_torture_dump_read_segs(rtors.rtseg, nsegs); + } return true; } =20 diff --git a/kernel/rcu/tree_plugin.h b/kernel/rcu/tree_plugin.h index 95ad967adcf3cb..c5dbdf8d7990cb 100644 --- a/kernel/rcu/tree_plugin.h +++ b/kernel/rcu/tree_plugin.h @@ -923,7 +923,7 @@ void rcu_read_unlock_strict(void) * * The in_atomic_preempt_off() check ensures that we come here holding * the last preempt_count (which will get dropped once we return to - * __rcu_read_unlock(). + * __rcu_read_unlock()). */ rdp =3D this_cpu_ptr(&rcu_data); rdp->cpu_no_qs.b.norm =3D false; @@ -1320,6 +1320,36 @@ static void rcu_spawn_one_boost_kthread(struct rcu_n= ode *rnp) wake_up_process(t); /* get to TASK_INTERRUPTIBLE quickly. */ } =20 +#ifdef CONFIG_RCU_TORTURE_TEST + +/* + * Is the current task RCU priority boosted? This is used by + * rcutorture to check that tasks are always deboosted once then exit + * an RCU read-side critical section, no matter how many overlapping + * segments of rcu_read_lock(), preempt_disable(), local_bh_disable(), + * or local_irq_disable() made up that reader. + * + * The lockless accesses in rt_mutex_owner(&rnp->boost_mtx.rtmutex) + * are safe because tasks release ->boost_mtx when they own it, they + * cannot be boosted unless current->rcu_blocked_node is non-NULL, + * current->rcu_blocked_node is modified only by the current task, + * rt_mutex_owner() uses READ_ONCE() on the ->owner field, and the owner + * switching among other tasks cannot force an equality comparison. + */ +bool rcu_is_task_rcu_boosted(void) +{ + struct rcu_node *rnp; + struct task_struct *t =3D current; + + rnp =3D t->rcu_blocked_node; + if (!rnp) + return false; + return rt_mutex_owner(&rnp->boost_mtx.rtmutex) =3D=3D t; +} +EXPORT_SYMBOL_GPL(rcu_is_task_rcu_boosted); + +#endif // #ifdef CONFIG_RCU_TORTURE_TEST + #else /* #ifdef CONFIG_RCU_BOOST */ =20 static void rcu_initiate_boost(struct rcu_node *rnp, unsigned long flags) --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 84CB72D876B; Thu, 16 Jul 2026 00:25:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161526; cv=none; b=B6HsTfK2+yAiSnEz3edyhUE8/LBd+mwfNKKKygyweMzs6MeCzXpkhGorHYgB6eOVm8M8sul6UOj/DpX23zzE1E5/uTRwVzehMr4ZRJID/QSxsgI7gohtOL+1q3ci4eX9c2XYbAXv93P0+yrMSa5ATDDkhfEIixfeVoNe8hT8vE4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161526; c=relaxed/simple; bh=soARazhdETV/IcIoEarjnfAFvY4T4vxaTG3G8RT4xDU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=nznfKMnhjGOkfeU+NGEzlUnSl5p4kzNMVfYjReab8R0Laga2mloVgf64VLNdG3CAKURwjQTCpASOxFcEvP8fYIlpJaTGfC4dFLkkJMUi16/oJpbjsSbjDYD9OjJvUipkVvdBoDXqDsaX95qZqFNtGIO/8nxK5uV8wJv2Prj3qcw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=hDvfXFSC; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="hDvfXFSC" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A51F51F00A3D; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161522; bh=RxhdemyKTyff1v8+uLGbIuPcBR7mfVc135xZvhUs8gA=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=hDvfXFSCE9SIQGaUAsJ9qk99VxPqCrT+/TQZAj7FxCBs4FaLrRaBRWtvnS1pP4/WJ c2aLaLw58iH86DIXcA/4C2ESieu/aEZ8u5OfMNKuGtT1+/ji0CKXTQKuSgJkZxZX3f J6FbIy4VDzSKXKDhrUPUAjjTneVlNB4EszLSj/E8GVDu6ommQ0YO9lSDSTRbzUiyFa aX9eiNRXdU8fHjH/0282iCLW4g/mqlTT/CgWGU4NqeS6U7Q93IS/oNZtrB9s4LBhU5 JXBgvG7xQPYkngR//APWdOk2xT0F5t3RKTd3G/GEZGJsU59Z1C9D+zHISdsgQtZrB+ Kz1Q+qzL+bDBw== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 74C4ECE0B8B; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" Subject: [PATCH 03/11] rcutorture: Make srcu_read_delay() check for disabled interrupts Date: Wed, 15 Jul 2026 17:25:12 -0700 Message-Id: <20260716002520.11895-3-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" Once rcutorture starts invoking rcu_torture_one_read() from hardware interrupt handlers, srcu_read_delay() will need to avoid invoking schedule_timeout_interruptible() from such handlers. Note that in_hardirq() does not suffice because some architectures invoke what would otherwise be hardware interrupt handlers directly from the idle loop. Therefore, a simple irqs_disabled() is pressed into service. Signed-off-by: Paul E. McKenney --- kernel/rcu/rcutorture.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index 1a033ae1f1eb6a..0e0ad4cccc3644 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -767,7 +767,7 @@ srcu_read_delay(struct torture_random_state *rrsp, stru= ct rt_read_seg *rtrsp) =20 delay =3D torture_random(rrsp) % (nrealreaders * 2 * longdelay * uspertick); - if (!delay && in_task()) { + if (!delay && in_task() && !irqs_disabled()) { schedule_timeout_interruptible(longdelay); rtrsp->rt_delay_jiffies =3D longdelay; } else { --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2F3DA283FDC; Thu, 16 Jul 2026 00:25:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161526; cv=none; b=jYYLbDboCtEipqstdLZvVIvpFA89Zxxw8fmgOAt2aU+Jt3nl2ehU3U0xNKDRUIKjtYOZ5Jg0KSfIZUU2dGjdePc0PrC3ToSbwHUWGPG+Bmw5zUD/J1m8D+nRJqQLrVZZvOVfNViwlzWXF8fUXjZPS67aOdlpmcS3GdnIMeJQJWo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161526; c=relaxed/simple; bh=Fp1S4CRvW8WyKvOKMb6g8l3GzM4Ar49CmxkWRADPVLg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Zt2eb2A5HtDIBnTxuwljVCzPUNg9VQrLu/5q+WKS/RZ4WqcefL6TbfidA8BH30eHoelcB+kTvIpLA3LnecBMEjPEGutL3SzjelNxvlfhB9gOVGkSDCI1R7bzXodlgiqR9Q76a0ZzDsbLNhr7pmTIQOOSuk10H576Vlz7uL0R3lo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=GRhYE/kP; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="GRhYE/kP" Received: by smtp.kernel.org (Postfix) with ESMTPSA id AF6931F00A3F; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161522; bh=y9F4AsnS2gHcnajM+AAYGEb3rcNhUl/Z3dMPF7FxKYw=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=GRhYE/kPr7vDbfdmMQvKQYjeAdFRtR0JgC4wcqYbiX/CdmUnDvhBSo7qKPisZTa8L nwezdSJy/jqzrKyUdJGzYeiy8fc7tDyeqe24DWk2wJePoLky4P2GnainQ1hH7XN3Le iw6BsBTrMI2onLeyGRCMHmGLyGR0ZHarGydFKVrErjfE5ZBTtHak1PvPzPYlUX1/Xf 04LeIOOQsg7toX+LMCtnBGIN7MHIQ231ZVRU/RAH+Mn7+V2PI8MfWYH8eGIj+Ia971 s5TcwYq8hsjSnHq8c5It5zz115TdvwywJQ1vwSO5EK7UMSM7cAObb+Vg/EGDsmmT1F jPrucxnd1c0Pg== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 775A3CE0C44; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" Subject: [PATCH 04/11] rcutorture: Test RCU readers from hardware interrupt handlers Date: Wed, 15 Jul 2026 17:25:13 -0700 Message-Id: <20260716002520.11895-4-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" Although rcutorture has long had the irqreader module parameter, this parameter results only in RCU readers in softirq handlers, specifically, timers. This commit therefore uses smp_call_function_single() to test RCU readers in real hardware interrupt handlers, thus providing the full effect from the irqreader module parameter. However, consistency/debug checks must account for the possibility that the smp_call_function_single() handler function is directly invoked from the idle loop, in which case, for example, in_hardirq() will return false. This commit uses a per-CPU variable to record being in the rcu_torture_irq() smp_call_function_single() handler function. Signed-off-by: Paul E. McKenney --- kernel/rcu/rcutorture.c | 77 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 71 insertions(+), 6 deletions(-) diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index 0e0ad4cccc3644..2f510743722fce 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -213,6 +213,7 @@ static long n_rcu_torture_boost_ktrerror; static long n_rcu_torture_boost_failure; static long n_rcu_torture_boosts; static atomic_long_t n_rcu_torture_timers; +static atomic_long_t n_rcu_torture_irqs; static long n_barrier_attempts; static long n_barrier_successes; /* did rcu_barrier test succeed? */ static unsigned long n_read_exits; @@ -2127,6 +2128,8 @@ static void rcu_torture_reader_do_mbchk(long myid, st= ruct rcu_torture *rtp, smp_store_release(&rtrcp_assigner->rtc_chkrdr, -1); // Assigner can again= assign. } =20 +static DEFINE_PER_CPU(bool, torture_in_scf_handler); + // Verify the specified RCUTORTURE_RDR* state. #define ROEC_ARGS "%s %s: Current %#x To add %#x To remove %#x preempt_= count() %#x\n", __func__, s, curstate, new, old, preempt_count() static void rcutorture_one_extend_check(char *s, int curstate, int new, in= t old) @@ -2136,7 +2139,7 @@ static void rcutorture_one_extend_check(char *s, int = curstate, int new, int old) if (!IS_ENABLED(CONFIG_RCU_TORTURE_TEST_CHK_RDR_STATE) || in_nmi()) return; =20 - WARN_ONCE(!(curstate & RCUTORTURE_RDR_IRQ) && irqs_disabled() && !in_hard= irq(), ROEC_ARGS); + WARN_ONCE(!(curstate & RCUTORTURE_RDR_IRQ) && irqs_disabled() && !in_hard= irq() && !this_cpu_read(torture_in_scf_handler), ROEC_ARGS); WARN_ONCE((curstate & RCUTORTURE_RDR_IRQ) && !irqs_disabled(), ROEC_ARGS); =20 // If CONFIG_PREEMPT_COUNT=3Dn, further checks are unreliable. @@ -2153,7 +2156,7 @@ static void rcutorture_one_extend_check(char *s, int = curstate, int new, int old) =20 // Interrupt handlers have all sorts of stuff disabled, so ignore // unintended disabling. - if (in_serving_softirq() || in_hardirq()) + if (in_serving_softirq() || in_hardirq() || this_cpu_read(torture_in_scf_= handler)) return; =20 WARN_ONCE(cur_ops->extendables && @@ -2345,12 +2348,19 @@ rcutorture_extend_mask(int oldmask, struct torture_= random_state *trsp) mask |=3D RCUTORTURE_RDR_RCU_1; } =20 + /* + * Don't mess with interrupt masking in interrupt handlers. + */ + if (in_hardirq() || this_cpu_read(torture_in_scf_handler)) + mask &=3D ~(preempts_irq | bhs); + /* * Can't enable bh w/irq disabled. */ if (mask & RCUTORTURE_RDR_IRQ) mask |=3D oldmask & bhs; =20 + /* * Ideally these sequences would be detected in debug builds * (regardless of RT), but until then don't stop testing @@ -2605,6 +2615,7 @@ static bool rcu_torture_one_read(struct torture_rando= m_state *trsp, long myid) return false; rtors.rtrsp =3D rcutorture_loop_extend(&rtors.readstate, trsp, rtors.rtrs= p); rcu_torture_one_read_end(&rtors, trsp); + // This splat will happen on systems built with CONFIG_IRQ_WORK=3Dn // and on systems where arch_irq_work_has_interrupt() returns false. // It might also happen on systems using a short-duration clock @@ -2643,7 +2654,7 @@ static void rcu_torture_timer(struct timer_list *unus= ed) atomic_long_inc(&n_rcu_torture_timers); (void)rcu_torture_one_read(this_cpu_ptr(&rcu_torture_timer_rand), -1); =20 - /* Test call_rcu() invocation from interrupt handler. */ + /* Test call_rcu() invocation from softirq handler. */ if (cur_ops->call) { struct rcu_head *rhp =3D kmalloc_obj(*rhp, GFP_NOWAIT); =20 @@ -2652,6 +2663,41 @@ static void rcu_torture_timer(struct timer_list *unu= sed) } } =20 +static DEFINE_TORTURE_RANDOM_PERCPU(rcu_torture_irq_rand); + +/* + * RCU torture reader from timer handler. Dereferences rcu_torture_curren= t, + * incrementing the corresponding element of the pipeline array. The + * counter in the element should never be greater than 1, otherwise, the + * RCU implementation is broken. + * + * Note that on some systems, "interrupts" from idle are direct calls + * rather than interrupts. The torture_in_scf_handler per-CPU variable + * accounts for this case. + */ +static void rcu_torture_irq(void *unused) +{ + WARN_ON_ONCE(in_nmi()); + lockdep_assert_irqs_disabled(); + atomic_long_inc(&n_rcu_torture_irqs); + this_cpu_write(torture_in_scf_handler, true); + (void)rcu_torture_one_read(this_cpu_ptr(&rcu_torture_irq_rand), -1); + this_cpu_write(torture_in_scf_handler, false); + + // Test call_rcu() invocation from interrupt handler. Interrupts + // will always be disabled here, even in CONFIG_PREEMPT_RT=3Dy kernels. + // The "right" thing to do would be to create a special-purpose + // lockless or raw-spinlock-protected allocator, but in the meantime, + // skip testing call_rcu() from interrupt handlers in kernels built + // with either CONFIG_PREEMPT_RT=3Dy or CONFIG_PROVE_LOCKING=3Dy. + if (cur_ops->call && !IS_ENABLED(CONFIG_PROVE_LOCKING) && !IS_ENABLED(CON= FIG_PREEMPT_RT)) { + struct rcu_head *rhp =3D kmalloc_obj(*rhp, GFP_NOWAIT); + + if (rhp) + cur_ops->call(rhp, rcu_torture_timer_cb); + } +} + /* * RCU torture reader kthread. Repeatedly dereferences rcu_torture_curren= t, * incrementing the corresponding element of the pipeline array. The @@ -2661,6 +2707,7 @@ static void rcu_torture_timer(struct timer_list *unus= ed) static int rcu_torture_reader(void *arg) { + unsigned long lastscf =3D jiffies; unsigned long lastsleep =3D jiffies; long myid =3D (long)arg; int mynumonline =3D myid; @@ -2674,8 +2721,25 @@ rcu_torture_reader(void *arg) tick_dep_set_task(current, TICK_DEP_BIT_RCU); // CPU bound, so need tick. do { if (irqreader && cur_ops->irq_capable) { - if (!timer_pending(&t)) + if (!timer_pending(&t)) { + int cpu; + mod_timer(&t, jiffies + 1); + preempt_disable(); + cpu =3D torture_random(&rand) % nr_cpu_ids; + if (!cpu_online(cpu)) { + cpu =3D cpumask_next(cpu, cpu_online_mask); + if (cpu >=3D nr_cpu_ids) + cpu =3D cpumask_next(-1, cpu_online_mask); + } + // An smp_call_function_single() to self is not an interrupt! + if (cpu !=3D smp_processor_id() && + time_after(jiffies, lastscf + HZ * nrealreaders / 50)) { + smp_call_function_single(cpu, rcu_torture_irq, NULL, 0); + lastscf =3D jiffies; + } + preempt_enable(); + } } if (!rcu_torture_one_read(&rand, myid) && !torture_must_stop()) schedule_timeout_interruptible(HZ); @@ -2951,10 +3015,11 @@ rcu_torture_stats_print(void) atomic_read(&n_rcu_torture_mbchk_fail), atomic_read(&n_rcu_torture_mbchk= _tries), n_rcu_torture_barrier_error, n_rcu_torture_boost_ktrerror); - pr_cont("rtbf: %ld rtb: %ld nt: %ld ", + pr_cont("rtbf: %ld rtb: %ld nt: %ld ni: %ld ", n_rcu_torture_boost_failure, n_rcu_torture_boosts, - atomic_long_read(&n_rcu_torture_timers)); + atomic_long_read(&n_rcu_torture_timers), + atomic_long_read(&n_rcu_torture_irqs)); if (updownreaders) pr_cont("ndowns: %lu nups: %lu nhrt: %lu nmigrates: %lu ", ndowns, nups,= nunexpired, nmigrates); torture_onoff_stats(); --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 528DA26B95B; Thu, 16 Jul 2026 00:25:23 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161526; cv=none; b=sgt+7TA0fQRY8vjOkQ946VXDhhD9TGDZPqfNrWFbB0p30uSL2lGwvlMHp7ykZpX6ZWIb/cbScp2EKU//Z0VMrnGJAkFelijZfkY0+sevnItndXjy+P5r7gi9K/yihRcPbCbYYeXLZdruSY0Cm5qFoPUihJmIbOoV0drd6xOG5Ek= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161526; c=relaxed/simple; bh=jKYmTWVVL10o+NufIsoR8Is111BlNfKDFScrak8F2FU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=FNSLNXXmL4Jp/b/c29GL4+8Q24GEMLMJJNx7GP0wKtJydomr/D4W0RlD8b4ZOSZsPzz8WQmUJJVo72ctcQ+gsSxSqGcvAtAPHrPyNm8xFflsyL+OaTegB1YPekEwy04zLFg2IdaaMXROcaKWJgXAgCSo1saGSUsbtZU7vnuvNXE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=i2Jgv79Q; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="i2Jgv79Q" Received: by smtp.kernel.org (Postfix) with ESMTPSA id BAA0E1F00ACA; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161522; bh=+PPBNj++Jf4jIxy0AW9k3sg9cYh/s+9GRNT/n/1Y7Ck=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=i2Jgv79Qs6f38tk5XvGyhZy9Z9XK4MxyzpXrhJbHIXf1VyxDrDC0667AvtIbrbRhJ UTZ4ea2UxpIZ7LxFWXetH31gMeoSifVESIaOq3VhNXO0jGUj5w2XDbnYot0nlocACc wxRJTg+NPtYqlG05YBDGfQXAqz3F/qXzLknkhYYYKNl6wCINqRkKlvx6WrDmbziNAX 36if7p8FOJfFAJmcTs+G7new8XK1WUUMbBOfbF5T/evaMchc1pV5BZuyzHz5rLoCMi hsY4j9ekjtmgK8+kLnRBMTV80UQvFxpa2Dsdqk82b0wtSKQ+2wB7+hBfwl+rUXMyat WFWQNsq1OAL3Q== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 79B6DCE0C57; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" Subject: [PATCH 05/11] rcutorture: Use cpumask_next_wrap() in rcu_torture_preempt() Date: Wed, 15 Jul 2026 17:25:14 -0700 Message-Id: <20260716002520.11895-5-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" The rcu_torture_preempt() function uses cpumask_next(), and if that returns an out-of-bounds result, re-invokes cpumask_next() on -1. Which is exactly what cpumask_next_wrap() does. This commit therefore saves a couple of lines by instead using cpumask_next_wrap(). This was reported by metacode when asked to look for opportunities to use cpumask_next_wrap() in kernel/rcu. Signed-off-by: Paul E. McKenney --- kernel/rcu/rcutorture.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index 2f510743722fce..64b56ec823c1af 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -4183,9 +4183,7 @@ static int rcu_torture_preempt(void *unused) // Wait for preempt_interval ms with up to 100us fuzz. torture_hrtimeout_ms(preempt_interval, 100, &rand); // Select online CPU. - cpu =3D cpumask_next(cpu, cpu_online_mask); - if (cpu >=3D nr_cpu_ids) - cpu =3D cpumask_next(-1, cpu_online_mask); + cpu =3D cpumask_next_wrap(cpu, cpu_online_mask); WARN_ON_ONCE(cpu >=3D nr_cpu_ids); // Move to that CPU, if can't do so, retry later. if (torture_sched_setaffinity(current->pid, cpumask_of(cpu), false)) --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 934E42D1907; Thu, 16 Jul 2026 00:25:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161527; cv=none; b=Fz/l7wzzFgtRG2+2YseQ38ZGMQLw5IePijuLQxO7gI22CmU7so3dL22KoYH5G04HiyqLhWEzfPAr2Oxfw52tURapiKdyDgRvocfIat7I6wm1k+garXYCLR892im51Z8lG0fT1Z4I/mWthzkE1nr+Ui7ABOwyh0RA5rs+0D1mpcU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161527; c=relaxed/simple; bh=MiSicBxAP8pbF4HSksNimmbE3PEse7VM+Hsu1u7Uxsg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=bfsdglihf6ISSOOXV7MtN1fMyeP/ed3Vc3e8dLKzSZlVcR2Ks+jJv/+Ii729klr/gx6cdmg0HMapWlHA9lkL3q1Go4p45UYPkw1RmWryeen3oQnGMlyX0FGeCJiyaDc6a/ODcYSSVPwgdbQTf3EiA9pF5iOTJ3gDUC89HtjGBeY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=BrFWvxGX; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="BrFWvxGX" Received: by smtp.kernel.org (Postfix) with ESMTPSA id CB84D1F00ADB; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161522; bh=Z5KXD0bvc6C+lKUybNSUiAX92DHyWBYmG9YhYb8bd0w=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=BrFWvxGXFtQDlC1iF4PQpWf93qD4MOZHQMxo9rb1z4B/gVCHEPBYNyMfjXysevKpE jD71TDxQgsAOK5qWDOJnNh3AgzjKWjWQryIy3Xg7Faxdy0lGO3s7Vmf0Ts7j9stQ/l 0YIStF55b71U0kKZVaPMFgbnH9BE+xSSQyBlIoEIRrygAEkZOwVRkUiAdvKIxmwGrp 8St68unVOEuCOzC+fdN/MpO1JsYDZPpf4ZDbxMJxfASNG9Ocd9hVpgl9cHMSSd17/U WVGMLfK82jhFpmbzFQJK1Kaq9NKoyc8WD7+13VkTYzN2n/70o2o7ymYPw3ojyRf+2S UD9YAePXtzpUA== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 7C83ECE0D3B; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, Kunwu Chan , Zqiang , Wang Lian , "Paul E . McKenney" Subject: [PATCH 06/11] rcutorture: Use task_state_to_char() for task-state reporting Date: Wed, 15 Jul 2026 17:25:15 -0700 Message-Id: <20260716002520.11895-6-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" From: Kunwu Chan Use the kernel's standard symbolic task-state representation instead of printing raw hexadecimal task-state values. Suggested-by: Zqiang Co-developed-by: Wang Lian Signed-off-by: Wang Lian Signed-off-by: Kunwu Chan Signed-off-by: Paul E. McKenney --- kernel/rcu/rcutorture.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index 64b56ec823c1af..05ef7bb65f710e 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -3076,10 +3076,10 @@ rcu_torture_stats_print(void) if (cur_ops->get_gp_data) cur_ops->get_gp_data(&flags, &gp_seq); wtp =3D READ_ONCE(writer_task); - pr_alert("??? Writer stall state %s(%d) g%lu f%#x ->state %#x cpu %d\n", + pr_alert("??? Writer stall state %s(%d) g%lu f%#x ->state %c cpu %d\n", rcu_torture_writer_state_getname(), rcu_torture_writer_state, gp_seq, flags, - wtp =3D=3D NULL ? ~0U : wtp->__state, + wtp =3D=3D NULL ? '?' : task_state_to_char(wtp), wtp =3D=3D NULL ? -1 : (int)task_cpu(wtp)); if (!splatted && wtp) { sched_show_task(wtp); --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 936952D8399; Thu, 16 Jul 2026 00:25:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161528; cv=none; b=PAOrcxmOwHZOYUFgk4x4j6ZJODQOAMrU+BSktFgWiO+vTBVyJP6v2KlXqvh7eV0/JibTABTAh4pK/b+jQQGeDpaObpprmRKxE63xLZfg1mJOYIEZUbtEJVS11DrJhbtladUVNMPnPtWGq6pWVgj0F0PhUve/mFnlOl89UXU623c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161528; c=relaxed/simple; bh=aCTJ8iBFcRGQD3b/DWJ3keWmzQPZGG0Mc5oLdXyY4Ew=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=qoLp1jxqPj4OzMYV2cGbAN42iACWlNkGLuYS66/gHhciqc1dBaozOny2mhM7ewq0tvVeW8pLigE8jeQZhyPVtc9LCjBKKDaoUj+EnZxFn68jHNK60Q88ELULpGqrt82LVMHBiOo6FTVMxhxQlVbRdmXMnm+zlcdfM9FOJ3cV1V4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=DMPoebig; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="DMPoebig" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D82B31F00ADF; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161522; bh=JH5EDmWuDn+RBKTBXQ04GfMfNJ2NrkdwVZ5DmZSS+bA=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=DMPoebigerv2Zcx/myqvuYOEjRT2Gps3NRjuDrzZGkIZ4A5C52DMZia2FuZHmgjBY rFMPZhv6eA389QZeXitzuAinCau+H9FQP73qzkZP+sa8/hBGWA7AJQbgH6qDNt30em BrIgUo4w9TzJ3SquKG+tnZDHiIG8I0S88hLYIIopmUYEGlXrGpcodXzVcRCp9Grg4d vKGTLAQktrHEFkFevfSAr9hnAf0zjRosfj1kP1UtemAq9i6il2gFi2i5HeXV75FZKX VORf/QHlG9FdIpFyFINbo3w8C/nsvsq1ogINUCAqgbRNpQvsK7Z70hpk3K1VXis4TZ QkGynk7Oa0B0A== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 7F049CE0E0B; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" , Breno Leitao , Puranjay Mohan , Usama Arif Subject: [PATCH 07/11] rcutorture: Add nwriters module parameter Date: Wed, 15 Jul 2026 17:25:16 -0700 Message-Id: <20260716002520.11895-7-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" Believe it or not, there are people who would like to run rcutorture without actually torturing RCU. For example, some people would like to induce various types of stall warnings without placing any unnecessary additional overhead on their systems running in production. And rcutorture provides the stall_cpu, stall_cpu_holdoff, stall_no_softlockup, stall_cpu_irqsoff, stall_cpu_block, and stall_cpu_repeat module parameters in order to allow the user to force numerous types of stalls. In addition, rcutorture provides a great number of other module parameters to allow the user to reduce other overhead. But unfortunately, there is no way to turn of the rcu_torture_writer() portion of this torture test, which on my x86 laptop consumes somewhere between 40% and 45% of a CPU. Although this is quite lightweight for a torture test, it is not welcome on systems running production workloads. This commit therefore adds an nwriters module parameter that defaults to 1 but can be set to 0 in order to disable the rcu_torture_writer() portion of the torture test, but that cannot be set to any other value (that is what the fakewriters module parameter is for!). This reduces the overhead to well under 1% of a CPU, which is much more likely to be compatible with production workloads. Reported-by: Breno Leitao Reported-by: Puranjay Mohan Reported-by: Usama Arif Signed-off-by: Paul E. McKenney --- Documentation/admin-guide/kernel-parameters.txt | 5 +++++ kernel/rcu/rcutorture.c | 14 ++++++++------ 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentatio= n/admin-guide/kernel-parameters.txt index b5493a7f8f2281..b942149720c9bf 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -6117,6 +6117,11 @@ Kernel parameters the number of CPUs. For example, -2 selects N (the number of CPUs), -3 selects N+1, and so on. =20 + rcutorture.nwriters=3D [KNL] + Set number of RCU writers, which must be either + zero or one. For additional writers, use instead + the rcutorture.nfakewriters parameter. + rcutorture.object_debug=3D [KNL] Enable debug-object double-call_rcu() testing. =20 diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index 05ef7bb65f710e..a6a8b9ba342d02 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -116,6 +116,7 @@ torture_param(int, n_barrier_cbs, 0, "# of callbacks/kt= hreads for barrier testin torture_param(int, n_up_down, 32, "# of concurrent up/down hrtimer-based R= CU readers"); torture_param(int, nfakewriters, 4, "Number of RCU fake writer threads"); torture_param(int, nreaders, -1, "Number of RCU reader threads"); +torture_param(bool, nwriters, 1, "Number of RCU writer threads (0 or 1)"); torture_param(int, object_debug, 0, "Enable debug-object double call_rcu()= testing"); torture_param(int, onoff_holdoff, 0, "Time after boot before CPU hotplugs = (s)"); torture_param(int, onoff_interval, 0, "Time between CPU hotplugs (jiffies)= , 0=3Ddisable"); @@ -3163,7 +3164,7 @@ static void rcu_torture_print_module_parms(struct rcu_torture_ops *cur_ops, const char= *tag) { pr_alert("%s" TORTURE_FLAG - "--- %s: nreaders=3D%d nfakewriters=3D%d " + "--- %s: nreaders=3D%d nwriters=3D%d nfakewriters=3D%d " "stat_interval=3D%d verbose=3D%d test_no_idle_hz=3D%d " "shuffle_interval=3D%d stutter=3D%d irqreader=3D%d " "fqs_duration=3D%d fqs_holdoff=3D%d fqs_stutter=3D%d " @@ -3178,7 +3179,7 @@ rcu_torture_print_module_parms(struct rcu_torture_ops= *cur_ops, const char *tag) "nocbs_nthreads=3D%d nocbs_toggle=3D%d " "test_nmis=3D%d " "preempt_duration=3D%d preempt_interval=3D%d n_up_down=3D%d\n", - torture_type, tag, nrealreaders, nrealfakewriters, + torture_type, tag, nrealreaders, nwriters, nrealfakewriters, stat_interval, verbose, test_no_idle_hz, shuffle_interval, stutter, irqreader, fqs_duration, fqs_holdoff, fqs_stutter, test_boost, cur_ops->can_boost, @@ -4754,10 +4755,11 @@ rcu_torture_init(void) goto unwind; } =20 - firsterr =3D torture_create_kthread(rcu_torture_writer, NULL, - writer_task); - if (torture_init_error(firsterr)) - goto unwind; + if (nwriters) { + firsterr =3D torture_create_kthread(rcu_torture_writer, NULL, writer_tas= k); + if (torture_init_error(firsterr)) + goto unwind; + } =20 firsterr =3D rcu_torture_updown_init(); if (torture_init_error(firsterr)) --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 85B682DF134; Thu, 16 Jul 2026 00:25:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161531; cv=none; b=SHQwCsmxv4tenD7gdLuBcFK+v2ZhA0H53YRCbGqVRccMm+vwnBOPDeoCf4JAMXeFJZ6V3bwjDkP9Q+FK1vXuk9YBkMOJwQULr+/wHS4EbyAsWp7azDyuuujWvU/GUVRxom3tohOKtHMcsRbBsW4R3oiK/1RlrCwxcTga+aQ9daE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161531; c=relaxed/simple; bh=Jjl3SE2rLdpUtNPn4o7XuSq/LnB/VF011jsxpNIOszA=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Z5FHCV5HXpipt1lKRWD0ik94qs7/mF3McTRN5NQdpPUwk0LA4J4ZOAAAPjpYdCiNObIwHtetFk7sThUZMkyUWA9u9L1G6M0aXa+JWK+QOOB+3bg3g7xrMo5gRLFDSQZYwNJs3w10elIBKIjAWdxkig+l8NgTDP+/OP6qtUmKvCM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=QhNqibui; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="QhNqibui" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D9F8A1F01558; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161522; bh=pdF7AJpaq+Dg2l9UISLXY1kgDLD+XAKQk0wFurP0uhk=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=QhNqibuiKEw0UpJmfMltIaiuIYAk14JWMmYsmAMR+1P9vbW2OfHyFLUDHgJ5T50Jo 2Gt2MOnAbUU2CWvI4vpOB4An9dslvD8F8Hd15OqeqOEjVRIWb3FosryoEwH6GQVWpV 07x8hwLkiEyl9IvgIK/0ZTDCFLhVDGKjncSYiQXi8w5XIxw8tPmEkVfA0hmSwdrLh2 6r/cie2ThX5DFsYwmSx7uS8vssll7c+vwgF8zWnqbZvjpDTAJORA1YbDs/8JUFyRw6 zBOtpeBEtXvki05nwhD23Db3qGWQ7x3LvHgHWl6VOfm1pJ5/ZuGzax5I1UaZM3YnnJ tGJcNYS1OaJsQ== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 81B41CE0E2A; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" Subject: [PATCH 08/11] rcutorture: Add a stall_only module parameter Date: Wed, 15 Jul 2026 17:25:17 -0700 Message-Id: <20260716002520.11895-8-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" This commit adds a stall_only module parameter that shuts off all rcutorture kthreads other than the RCU CPU stall-warning test kthreads. The purpose of this is to test production applictions' reactions to CPU stalls, and with minimal additional overhead. Or you can omit the stall-warning tests as well and get a heavy no-op, your choice! Signed-off-by: Paul E. McKenney --- .../admin-guide/kernel-parameters.txt | 9 +++++++++ kernel/rcu/rcutorture.c | 18 ++++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentatio= n/admin-guide/kernel-parameters.txt index b942149720c9bf..40d2831add4a21 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -6211,6 +6211,15 @@ Kernel parameters and stall_gp_kthread are specified, the kthread is starved first, then the CPU. =20 + rcutorture.stall_only=3D [KNL] + Shut off all rcutorture kthreads other than the + RCU CPU stall-warning test kthreads. The purpose + of this is to test production applictions' + reactions to CPU stalls, and with minimal + additional overhead. Or you can omit the + stall-warning tests as well and get a heavy + no-op, your choice! + rcutorture.stat_interval=3D [KNL] Time (s) between statistics printk()s. =20 diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index a6a8b9ba342d02..a0d27756141846 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -140,6 +140,7 @@ torture_param(int, stall_cpu_irqsoff, 0, "Disable inter= rupts while stalling."); torture_param(int, stall_cpu_block, 0, "Sleep while stalling."); torture_param(int, stall_cpu_repeat, 0, "Number of additional stalls after= the first one."); torture_param(int, stall_gp_kthread, 0, "Grace-period kthread stall durati= on (s)."); +torture_param(bool, stall_only, 0, "Suppress all non-CPU-stall kthreads."); torture_param(int, stat_interval, 60, "Number of seconds between stats pri= ntk()s"); torture_param(int, stutter, 5, "Number of seconds to run/halt test"); torture_param(int, test_boost, 1, "Test RCU prio boost: 0=3Dno, 1=3Dmaybe,= 2=3Dyes."); @@ -4649,6 +4650,23 @@ rcu_torture_init(void) cur_ops =3D NULL; goto unwind; } + if (stall_only) { + pr_alert("rcu-torture: stall_only specified, suppressing all else.\n"); + fqs_stutter =3D 0; + fwd_progress =3D 0; + n_barrier_cbs =3D 0; + nfakewriters =3D 0; + nocbs_nthreads =3D 0; + nreaders =3D 0; + n_up_down =3D 0; + nwriters =3D 0; + onoff_interval =3D 0; + preempt_duration =3D 0; + read_exit_burst =3D 0; + shuffle_interval =3D 0; + stutter =3D 0; + test_boost =3D 0; + } if (cur_ops->fqs =3D=3D NULL && fqs_duration !=3D 0) { pr_alert("rcu-torture: ->fqs NULL and non-zero fqs_duration, fqs disable= d.\n"); fqs_duration =3D 0; --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 843632DF132; Thu, 16 Jul 2026 00:25:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161529; cv=none; b=gl23ZYRDBaqdyBAvw0Q3tnSSsvKBQx4aVrgUhjd7wUAj+Kgvmw5T+6lUffuShaGAdlZdvZm+UG4zdEaDgkd2A0oT2czwY0YT0UgdJiWF7l/VDBWjLqFqMPIDHSB0S8uEktvwbUfZunOfYMxCEissB/uWV5AfY0AVfFdCgi4hB8s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161529; c=relaxed/simple; bh=sJ1SVhaxvni9Qc07RTKJ5sYtAbxY3Aea5ZR37XYDRFE=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=Wn60vyFdtu8HZ9M3pO+ZUjbO/yyAo5kDMEr+Rh4hNJ4mNMa0/54J8YAdqD9wHm2uxUTAveTb3DEPHbb9OojilPaiCf9Wg1o9orx+7fAE0MQM1CHiXq3n5yY1cfRULJbIw5L/II77QEAwYZsY35KcmonsTwtbBe+xFc2p/p6S3fw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=YNjCBeBJ; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="YNjCBeBJ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E30D51F00ADE; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161522; bh=kYqIhYGIkpcAhqxrRXz1I/HJj9abQVlfXFliDeZQqpM=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=YNjCBeBJrzmKBPL8C3q5j9b+/rGhRprL+YIM79RHYWIjv/kk9cZZCx5giq9DxbEFi rHT4TouManOQm5lU8KHYvVxAArxIm6a/ajYAJxB8alWJMDbN0VOai6ftY3QxpI72hS VHxn9GHcuSc4Yqci0FsEvPxkJzki5zbcP9WTMD/b3q4DeaKjOJOZnEdDt2oIHhyfyj 5nGQ7OH8sT9tBxP5gGNaR4/AA/2L2tuMUrvCuDbK/c4tw73/HC8PGoqW4GIA4MT2zy 0Z4cpPMcnKJL7V4vl6W27DqqXJJmeH7UjDqohLr2+Y13GRQa34oh8JdkidCmC+rP0r pA3Y1fnBj5cXA== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 8410ECE0E5D; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" Subject: [PATCH 09/11] rcutorture: Test RCU Tasks Trace GP implying RCU GP Date: Wed, 15 Jul 2026 17:25:18 -0700 Message-Id: <20260716002520.11895-9-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" An RCU Tasks Trace grace period is supposed to imply an RCU grace period, and this implication is relied on by BPF. But this is not currently tested. This commit therefore makes tasks_tracing_torture_read_lock() sometimes use rcu_read_lock() instead of rcu_read_lock_trace(), thus testing the required implication. Signed-off-by: Paul E. McKenney --- kernel/rcu/rcutorture.c | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index a0d27756141846..c8118c38812aee 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -766,11 +766,12 @@ srcu_read_delay(struct torture_random_state *rrsp, st= ruct rt_read_seg *rtrsp) const long uspertick =3D 1000000 / HZ; const long longdelay =3D 10; =20 - /* We want there to be long-running readers, but not all the time. */ + // We want there to be long-running readers, but not all the time. + // The !rcu_preempt_depth() is for RCU Tasks Trace. =20 delay =3D torture_random(rrsp) % (nrealreaders * 2 * longdelay * uspertick); - if (!delay && in_task() && !irqs_disabled()) { + if (!delay && !in_atomic() && !rcu_preempt_depth() && !irqs_disabled()) { schedule_timeout_interruptible(longdelay); rtrsp->rt_delay_jiffies =3D longdelay; } else { @@ -1219,15 +1220,24 @@ static struct rcu_torture_ops tasks_rude_ops =3D { * Definitions for tracing RCU-tasks torture testing. */ =20 +// Note that an RCU Tasks Trace GP must imply an RCU GP. static int tasks_tracing_torture_read_lock(void) { - rcu_read_lock_trace(); - return 0; + int use_rcu =3D !(jiffies & 0xff); + + if (use_rcu) + rcu_read_lock(); + else + rcu_read_lock_trace(); + return use_rcu; } =20 -static void tasks_tracing_torture_read_unlock(int idx) +static void tasks_tracing_torture_read_unlock(int use_rcu) { - rcu_read_unlock_trace(); + if (use_rcu) + rcu_read_unlock(); + else + rcu_read_unlock_trace(); } =20 static void rcu_tasks_tracing_torture_deferred_free(struct rcu_torture *p) --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 806502D7DE7; Thu, 16 Jul 2026 00:25:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161532; cv=none; b=Wty8dXFs1n59AA5cTrT1Wv7FOi6B9s0ZPnil3ZM1v+4qSqOJbYWy1D6NP2ft/rg8np4Y5UMtYcRCGnZECWuUEnuo9Wd+k0FVyjct5SCYNslfey3t+rNasUdfp+ZcbqpSvYijCbtKH64OXFTKhCbWNNeCSWCFeoUczWAGHQpZT9A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161532; c=relaxed/simple; bh=OOSdQVrYwmh+RTss2fts75ttboe3Qa8Pwyl4rm5cL2A=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=RfAaEI10z/xtA5UeMSUM+RkEvxMPnLvkvSuY3sQ1CB4g2/orsaVYGzP1bU4sEIHr50t/iJg/OYLdlDBO61LSYTBvkRUcl1ibxlZLjtoayFyaNoZKgiNehHt1b6n8Oym8D9LBo+02DZsd4XuftisKWjgGryRkjiMhDH62aOpYxIc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=AST3j8zB; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="AST3j8zB" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E85BA1F0155A; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161523; bh=naLwP4ocZHefeFlWoSOcGsJA9i8DDPgQKHV4njTu0s0=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=AST3j8zBSDnM4FSjLVEsmolw0UkmYrf8Kdb244HtyD1AaygesW6KfRCMJ/PSWNQmd /YuG6iZCtZZEPm38uXhMmnrj5DVIn3bKrQFlbO00p92EV7EbIVFMY+MoXSxUWTvGMG PBeM7KbE22JlGZWkaJJ35rIyzOH9j2XVjzIyVLFo31h1gLQ2SHQ2d6BndcAhZTKvr4 R9qOv79BDnc7m6UsSvLZq8BD4ERclmyt3uTsfURM9oN/PQN6wb5M9eI52cw4D/CCuX 2eAKvsxx+2NMwjbr2QLHc72bwWL0uNzGNnvDrau0B/2URtpH2Pazjf9G0ctLfBcHMw +xm4b6nAAEhTQ== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 865F8CE0E86; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" Subject: [PATCH 10/11] rcutorture: Make RCU Tasks Trace track Reader Batches Date: Wed, 15 Jul 2026 17:25:19 -0700 Message-Id: <20260716002520.11895-10-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" This commit adds the ->get_sp_seq and ->gp_diff fields to the tasks_tracing_ops structure so that RCU Tasks Trace rcutorture runs will track Reader Batch. Signed-off-by: Paul E. McKenney --- include/linux/rcupdate_trace.h | 3 +++ kernel/rcu/rcutorture.c | 3 ++- kernel/rcu/tasks.h | 6 ++++++ 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/include/linux/rcupdate_trace.h b/include/linux/rcupdate_trace.h index cee89e51e45cbb..f2c4173bf14fde 100644 --- a/include/linux/rcupdate_trace.h +++ b/include/linux/rcupdate_trace.h @@ -198,10 +198,13 @@ static inline void rcu_tasks_trace_expedite_current(v= oid) srcu_expedite_current(&rcu_tasks_trace_srcu_struct); } =20 +unsigned long rcu_tasks_trace_batches_completed(void); + // Placeholders to enable stepwise transition. void __init rcu_tasks_trace_suppress_unused(void); =20 #else +static inline unsigned long rcu_tasks_trace_batches_completed(void) { retu= rn 0; } /* * The BPF JIT forms these addresses even when it doesn't call these * functions, so provide definitions that result in runtime errors. diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index c8118c38812aee..8514fef3ec10b6 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -1252,7 +1252,8 @@ static struct rcu_torture_ops tasks_tracing_ops =3D { .read_delay =3D srcu_read_delay, /* just reuse srcu's version. */ .readunlock =3D tasks_tracing_torture_read_unlock, .readlock_held =3D rcu_read_lock_trace_held, - .get_gp_seq =3D rcu_no_completed, + .get_gp_seq =3D rcu_tasks_trace_batches_completed, + .gp_diff =3D rcu_seq_diff, .deferred_free =3D rcu_tasks_tracing_torture_deferred_free, .sync =3D synchronize_rcu_tasks_trace, .exp_sync =3D synchronize_rcu_tasks_trace, diff --git a/kernel/rcu/tasks.h b/kernel/rcu/tasks.h index f4da5fad70f516..496acac8796fa7 100644 --- a/kernel/rcu/tasks.h +++ b/kernel/rcu/tasks.h @@ -1606,4 +1606,10 @@ static inline void rcu_tasks_bootup_oddness(void) {} DEFINE_SRCU_FAST(rcu_tasks_trace_srcu_struct); EXPORT_SYMBOL_GPL(rcu_tasks_trace_srcu_struct); =20 +unsigned long rcu_tasks_trace_batches_completed(void) +{ + return srcu_batches_completed(&rcu_tasks_trace_srcu_struct); +} +EXPORT_SYMBOL_GPL(rcu_tasks_trace_batches_completed); + #endif /* #else #ifdef CONFIG_TASKS_TRACE_RCU */ --=20 2.40.1 From nobody Sat Jul 25 16:53:28 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D8E3A2C028F; Thu, 16 Jul 2026 00:25:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161531; cv=none; b=ftbDuBw7YoCt21/5+jhEtUPQq20nEk4Os5Lq9aVeWTSvfv6g+lM3het6ZIIpqXdpWTBiwvgL+jhqBf+9bRkVnxkd9ACod10Nsxlut3qr9LuJ+UE9A2Z5XyqFUTPUNVYGOxXVQyx/xP/XI/XrHFE2y3DHijNXMyj3pyLi17AOgOQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784161531; c=relaxed/simple; bh=5TRH08HpnQpKefliFHBcZse/jV9F6sm8wkK7QGwdEwI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=arLvxTXGFg8bl6RU79OG65owj+Ggw7aamZvRwfTdN5cR3gUuU3A7gVdiMc5RXVtvGmD8SdwL4vopLXVu33LySzdjIL3tNRBJnjr1+3pkjOGGONsF4csWph253AB/JIdCpS9CzD7DCAuVYNN2v917N55nsmQwta2KUcfize8ZJjA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=hmP4Wtj8; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="hmP4Wtj8" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EF1011F01559; Thu, 16 Jul 2026 00:25:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784161523; bh=e8XPOoUXngqgBuzXy/XFx1AR3lM5r9CAVwZr40LUuY4=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=hmP4Wtj8ai4zKr7Mky+15dV+y0X7AtLz0BT2nUgJtAx5YCyBUoz5IHlkCwfr3n19h ON8Fud1G347Jcy3SEvUS0r19v7OpnMU9rk7fjVuqztYmT8Hn5wCnGHYxXGi+PExPVR h4eJEsRSwEHBWkpRNN3Dz/FjBDezSh7KsPXlC+GFVY3qWq0W7wmdvJnbT0hhGZbzvp suMq9UjO6AAwsDXk7bRnv6fyAG0YZRdmsaurRtnjMmlnvaL74IdrmVTZx+Qln0eIYt cAzYhdCuR8tIZiyV05n0ZswriWmVI+e6o9uVEHyXHTGm1sWf9PRoJRXWC1pIzzopyS sGv0lSM7usRIg== Received: by paulmck-ThinkPad-P17-Gen-1.home (Postfix, from userid 1000) id 88B48CE0E8B; Wed, 15 Jul 2026 17:25:22 -0700 (PDT) From: "Paul E. McKenney" To: rcu@vger.kernel.org Cc: linux-kernel@vger.kernel.org, kernel-team@meta.com, rostedt@goodmis.org, "Paul E. McKenney" Subject: [PATCH 11/11] rcutorture: Use this_cpu_inc() for rcu_torture_count[] and rcu_torture_batch[] Date: Wed, 15 Jul 2026 17:25:20 -0700 Message-Id: <20260716002520.11895-11-paulmck@kernel.org> X-Mailer: git-send-email 2.40.1 In-Reply-To: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> References: <3f56c779-b900-40f9-9a24-6136fb28ddfb@paulmck-laptop> 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" Currently __this_cpu_inc() is used to increment elements of both the rcu_torture_count[] and rcu_torture_batch[] arrays. However, this can fail when the increments can happen in interrupt handlers, as recently became possible. This commit therefore upgrades the uses of __this_cpu_inc() to the interrupt-safe this_cpu_inc(). KCSAN located this issue. Signed-off-by: Paul E. McKenney --- kernel/rcu/rcutorture.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/kernel/rcu/rcutorture.c b/kernel/rcu/rcutorture.c index 8514fef3ec10b6..9180016d87c0ce 100644 --- a/kernel/rcu/rcutorture.c +++ b/kernel/rcu/rcutorture.c @@ -2565,13 +2565,13 @@ static void rcu_torture_one_read_end(struct rcu_tor= ture_one_read_state *rtorsp, rtorsp->ts, rtorsp->started, completed); rcu_ftrace_dump(DUMP_ALL); } - __this_cpu_inc(rcu_torture_count[pipe_count]); + this_cpu_inc(rcu_torture_count[pipe_count]); completed =3D rcutorture_seq_diff(completed, rtorsp->started); if (completed > RCU_TORTURE_PIPE_LEN) { /* Should not happen, but... */ completed =3D RCU_TORTURE_PIPE_LEN; } - __this_cpu_inc(rcu_torture_batch[completed]); + this_cpu_inc(rcu_torture_batch[completed]); preempt_enable(); if (rtorsp->checkpolling) { if (cur_ops->get_gp_state && cur_ops->poll_gp_state) --=20 2.40.1