* [PATCH] rcu: Safe access to rcu_node structure's->exp_tasks
@ 2022-12-24 5:25 Zqiang
2023-01-06 3:10 ` Zhang, Qiang1
2023-01-06 3:41 ` Paul E. McKenney
0 siblings, 2 replies; 6+ messages in thread
From: Zqiang @ 2022-12-24 5:25 UTC (permalink / raw)
To: paulmck, frederic, quic_neeraju, joel; +Cc: rcu, linux-kernel
For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario
can result system oops.
CPU1 CPU2
rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall
if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL
raw_spin_lock_rcu_node
np = rcu_next_node_entry(t, rnp)
if (&t->rcu_node_entry == rnp->exp_tasks)
WRITE_ONCE(rnp->exp_tasks, np)
....
raw_spin_unlock_irqrestore_rcu_node
raw_spin_lock_irqsave_rcu_node
t = list_entry(rnp->exp_tasks->prev,
struct task_struct, rcu_node_entry)
(if rnp->exp_tasks is NULL
will trigger oops)
This problem is that CPU2 accesses rcu_node structure's->exp_tasks
without holding the rcu_node structure's ->lock and CPU2 did not
observe CPU1's change to rcu_node structure's->exp_tasks in time,
if rcu_node structure's->exp_tasks is set null pointer by CPU1, after
that CPU2 accesses members of rcu_node structure's->exp_tasks will
trigger oops.
This commit therefore allows rcu_node structure's->exp_tasks to be
accessed while holding rcu_node structure's ->lock.
Signed-off-by: Zqiang <qiang1.zhang@intel.com>
---
kernel/rcu/tree_exp.h | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/kernel/rcu/tree_exp.h b/kernel/rcu/tree_exp.h
index 7cc4856da081..902e7c8709c7 100644
--- a/kernel/rcu/tree_exp.h
+++ b/kernel/rcu/tree_exp.h
@@ -803,9 +803,11 @@ static int rcu_print_task_exp_stall(struct rcu_node *rnp)
int ndetected = 0;
struct task_struct *t;
- if (!READ_ONCE(rnp->exp_tasks))
- return 0;
raw_spin_lock_irqsave_rcu_node(rnp, flags);
+ if (!READ_ONCE(rnp->exp_tasks)) {
+ raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
+ return 0;
+ }
t = list_entry(rnp->exp_tasks->prev,
struct task_struct, rcu_node_entry);
list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) {
--
2.25.1
^ permalink raw reply related [flat|nested] 6+ messages in thread* RE: [PATCH] rcu: Safe access to rcu_node structure's->exp_tasks 2022-12-24 5:25 [PATCH] rcu: Safe access to rcu_node structure's->exp_tasks Zqiang @ 2023-01-06 3:10 ` Zhang, Qiang1 2023-01-06 3:41 ` Paul E. McKenney 1 sibling, 0 replies; 6+ messages in thread From: Zhang, Qiang1 @ 2023-01-06 3:10 UTC (permalink / raw) To: Zhang, Qiang1, paulmck, frederic, quic_neeraju, joel; +Cc: rcu, linux-kernel >For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario >can result system oops. > > CPU1 CPU2 >rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall > if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL > raw_spin_lock_rcu_node > np = rcu_next_node_entry(t, rnp) > if (&t->rcu_node_entry == rnp->exp_tasks) > WRITE_ONCE(rnp->exp_tasks, np) > .... > raw_spin_unlock_irqrestore_rcu_node > raw_spin_lock_irqsave_rcu_node > t = list_entry(rnp->exp_tasks->prev, > struct task_struct, rcu_node_entry) > (if rnp->exp_tasks is NULL > will trigger oops) > >This problem is that CPU2 accesses rcu_node structure's->exp_tasks >without holding the rcu_node structure's ->lock and CPU2 did not >observe CPU1's change to rcu_node structure's->exp_tasks in time, >if rcu_node structure's->exp_tasks is set null pointer by CPU1, after >that CPU2 accesses members of rcu_node structure's->exp_tasks will >trigger oops. > >This commit therefore allows rcu_node structure's->exp_tasks to be >accessed while holding rcu_node structure's ->lock. > >Signed-off-by: Zqiang <qiang1.zhang@intel.com> > Hi Paul, some suggestions for this modification? Thanks Zqiang >--- > kernel/rcu/tree_exp.h | 6 ++++-- > 1 file changed, 4 insertions(+), 2 deletions(-) > >diff --git a/kernel/rcu/tree_exp.h b/kernel/rcu/tree_exp.h >index 7cc4856da081..902e7c8709c7 100644 >--- a/kernel/rcu/tree_exp.h >+++ b/kernel/rcu/tree_exp.h >@@ -803,9 +803,11 @@ static int rcu_print_task_exp_stall(struct rcu_node *rnp) > int ndetected = 0; > struct task_struct *t; > >- if (!READ_ONCE(rnp->exp_tasks)) >- return 0; > raw_spin_lock_irqsave_rcu_node(rnp, flags); >+ if (!READ_ONCE(rnp->exp_tasks)) { >+ raw_spin_unlock_irqrestore_rcu_node(rnp, flags); >+ return 0; >+ } > t = list_entry(rnp->exp_tasks->prev, > struct task_struct, rcu_node_entry); > list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) { >-- >2.25.1 > ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH] rcu: Safe access to rcu_node structure's->exp_tasks 2022-12-24 5:25 [PATCH] rcu: Safe access to rcu_node structure's->exp_tasks Zqiang 2023-01-06 3:10 ` Zhang, Qiang1 @ 2023-01-06 3:41 ` Paul E. McKenney 2023-01-06 12:58 ` Zhang, Qiang1 2023-01-09 13:21 ` Frederic Weisbecker 1 sibling, 2 replies; 6+ messages in thread From: Paul E. McKenney @ 2023-01-06 3:41 UTC (permalink / raw) To: Zqiang; +Cc: frederic, quic_neeraju, joel, rcu, linux-kernel On Sat, Dec 24, 2022 at 01:25:53PM +0800, Zqiang wrote: > For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario > can result system oops. > > CPU1 CPU2 > rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall > if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL > raw_spin_lock_rcu_node > np = rcu_next_node_entry(t, rnp) > if (&t->rcu_node_entry == rnp->exp_tasks) > WRITE_ONCE(rnp->exp_tasks, np) > .... > raw_spin_unlock_irqrestore_rcu_node > raw_spin_lock_irqsave_rcu_node > t = list_entry(rnp->exp_tasks->prev, > struct task_struct, rcu_node_entry) > (if rnp->exp_tasks is NULL > will trigger oops) > > This problem is that CPU2 accesses rcu_node structure's->exp_tasks > without holding the rcu_node structure's ->lock and CPU2 did not > observe CPU1's change to rcu_node structure's->exp_tasks in time, > if rcu_node structure's->exp_tasks is set null pointer by CPU1, after > that CPU2 accesses members of rcu_node structure's->exp_tasks will > trigger oops. > > This commit therefore allows rcu_node structure's->exp_tasks to be > accessed while holding rcu_node structure's ->lock. > > Signed-off-by: Zqiang <qiang1.zhang@intel.com> Apologies for the delay and thank you for the reminder! Please check the wordsmithed version below, which I have queued. Thanx, Paul ------------------------------------------------------------------------ commit 389b0eafd72829fd63548f7ff4e8d6ac90fa1f98 Author: Zqiang <qiang1.zhang@intel.com> Date: Sat Dec 24 13:25:53 2022 +0800 rcu: Protect rcu_print_task_exp_stall() ->exp_tasks access For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario can result in a NULL-pointer dereference: CPU1 CPU2 rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL raw_spin_lock_rcu_node np = rcu_next_node_entry(t, rnp) if (&t->rcu_node_entry == rnp->exp_tasks) WRITE_ONCE(rnp->exp_tasks, np) .... raw_spin_unlock_irqrestore_rcu_node raw_spin_lock_irqsave_rcu_node t = list_entry(rnp->exp_tasks->prev, struct task_struct, rcu_node_entry) (if rnp->exp_tasks is NULL, this will dereference a NULL pointer) The problem is that CPU2 accesses the rcu_node structure's->exp_tasks field without holding the rcu_node structure's ->lock and CPU2 did not observe CPU1's change to rcu_node structure's ->exp_tasks in time. Therefore, if CPU1 sets rcu_node structure's->exp_tasks pointer to NULL, then CPU2 might dereference that NULL pointer. This commit therefore holds the rcu_node structure's ->lock while accessing that structure's->exp_tasks field. Signed-off-by: Zqiang <qiang1.zhang@intel.com> Signed-off-by: Paul E. McKenney <paulmck@kernel.org> diff --git a/kernel/rcu/tree_exp.h b/kernel/rcu/tree_exp.h index 7cc4856da0817..902e7c8709c7e 100644 --- a/kernel/rcu/tree_exp.h +++ b/kernel/rcu/tree_exp.h @@ -803,9 +803,11 @@ static int rcu_print_task_exp_stall(struct rcu_node *rnp) int ndetected = 0; struct task_struct *t; - if (!READ_ONCE(rnp->exp_tasks)) - return 0; raw_spin_lock_irqsave_rcu_node(rnp, flags); + if (!READ_ONCE(rnp->exp_tasks)) { + raw_spin_unlock_irqrestore_rcu_node(rnp, flags); + return 0; + } t = list_entry(rnp->exp_tasks->prev, struct task_struct, rcu_node_entry); list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) { ^ permalink raw reply related [flat|nested] 6+ messages in thread
* RE: [PATCH] rcu: Safe access to rcu_node structure's->exp_tasks 2023-01-06 3:41 ` Paul E. McKenney @ 2023-01-06 12:58 ` Zhang, Qiang1 2023-01-09 13:21 ` Frederic Weisbecker 1 sibling, 0 replies; 6+ messages in thread From: Zhang, Qiang1 @ 2023-01-06 12:58 UTC (permalink / raw) To: paulmck; +Cc: frederic, quic_neeraju, joel, rcu, linux-kernel > For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario > can result system oops. > > CPU1 CPU2 > rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall > if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL > raw_spin_lock_rcu_node > np = rcu_next_node_entry(t, rnp) > if (&t->rcu_node_entry == rnp->exp_tasks) > WRITE_ONCE(rnp->exp_tasks, np) > .... > raw_spin_unlock_irqrestore_rcu_node > raw_spin_lock_irqsave_rcu_node > t = list_entry(rnp->exp_tasks->prev, > struct task_struct, rcu_node_entry) > (if rnp->exp_tasks is NULL > will trigger oops) > > This problem is that CPU2 accesses rcu_node structure's->exp_tasks > without holding the rcu_node structure's ->lock and CPU2 did not > observe CPU1's change to rcu_node structure's->exp_tasks in time, > if rcu_node structure's->exp_tasks is set null pointer by CPU1, after > that CPU2 accesses members of rcu_node structure's->exp_tasks will > trigger oops. > > This commit therefore allows rcu_node structure's->exp_tasks to be > accessed while holding rcu_node structure's ->lock. > > Signed-off-by: Zqiang <qiang1.zhang@intel.com> > >Apologies for the delay and thank you for the reminder! > >Please check the wordsmithed version below, which I have queued. Thanks for wordsmithed, this description is more clear. Thanks Zqiang > > Thanx, Paul > >------------------------------------------------------------------------ > >commit 389b0eafd72829fd63548f7ff4e8d6ac90fa1f98 >Author: Zqiang <qiang1.zhang@intel.com> >Date: Sat Dec 24 13:25:53 2022 +0800 > > rcu: Protect rcu_print_task_exp_stall() ->exp_tasks access > > For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario can > result in a NULL-pointer dereference: > > CPU1 CPU2 > rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall > if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL > raw_spin_lock_rcu_node > np = rcu_next_node_entry(t, rnp) > if (&t->rcu_node_entry == rnp->exp_tasks) > WRITE_ONCE(rnp->exp_tasks, np) > .... > raw_spin_unlock_irqrestore_rcu_node > raw_spin_lock_irqsave_rcu_node > t = list_entry(rnp->exp_tasks->prev, > struct task_struct, rcu_node_entry) > (if rnp->exp_tasks is NULL, this > will dereference a NULL pointer) > > The problem is that CPU2 accesses the rcu_node structure's->exp_tasks > field without holding the rcu_node structure's ->lock and CPU2 did > not observe CPU1's change to rcu_node structure's ->exp_tasks in time. > Therefore, if CPU1 sets rcu_node structure's->exp_tasks pointer to NULL, > then CPU2 might dereference that NULL pointer. > > This commit therefore holds the rcu_node structure's ->lock while > accessing that structure's->exp_tasks field. > > Signed-off-by: Zqiang <qiang1.zhang@intel.com> > Signed-off-by: Paul E. McKenney <paulmck@kernel.org> > >diff --git a/kernel/rcu/tree_exp.h b/kernel/rcu/tree_exp.h >index 7cc4856da0817..902e7c8709c7e 100644 >--- a/kernel/rcu/tree_exp.h >+++ b/kernel/rcu/tree_exp.h >@@ -803,9 +803,11 @@ static int rcu_print_task_exp_stall(struct rcu_node *rnp) > int ndetected = 0; > struct task_struct *t; > >- if (!READ_ONCE(rnp->exp_tasks)) >- return 0; > raw_spin_lock_irqsave_rcu_node(rnp, flags); >+ if (!READ_ONCE(rnp->exp_tasks)) { >+ raw_spin_unlock_irqrestore_rcu_node(rnp, flags); >+ return 0; >+ } > t = list_entry(rnp->exp_tasks->prev, > struct task_struct, rcu_node_entry); > list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) { ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH] rcu: Safe access to rcu_node structure's->exp_tasks 2023-01-06 3:41 ` Paul E. McKenney 2023-01-06 12:58 ` Zhang, Qiang1 @ 2023-01-09 13:21 ` Frederic Weisbecker 2023-01-09 15:22 ` Paul E. McKenney 1 sibling, 1 reply; 6+ messages in thread From: Frederic Weisbecker @ 2023-01-09 13:21 UTC (permalink / raw) To: Paul E. McKenney; +Cc: Zqiang, quic_neeraju, joel, rcu, linux-kernel On Thu, Jan 05, 2023 at 07:41:46PM -0800, Paul E. McKenney wrote: > On Sat, Dec 24, 2022 at 01:25:53PM +0800, Zqiang wrote: > > For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario > > can result system oops. > > > > CPU1 CPU2 > > rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall > > if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL > > raw_spin_lock_rcu_node > > np = rcu_next_node_entry(t, rnp) > > if (&t->rcu_node_entry == rnp->exp_tasks) > > WRITE_ONCE(rnp->exp_tasks, np) > > .... > > raw_spin_unlock_irqrestore_rcu_node > > raw_spin_lock_irqsave_rcu_node > > t = list_entry(rnp->exp_tasks->prev, > > struct task_struct, rcu_node_entry) > > (if rnp->exp_tasks is NULL > > will trigger oops) > > > > This problem is that CPU2 accesses rcu_node structure's->exp_tasks > > without holding the rcu_node structure's ->lock and CPU2 did not > > observe CPU1's change to rcu_node structure's->exp_tasks in time, > > if rcu_node structure's->exp_tasks is set null pointer by CPU1, after > > that CPU2 accesses members of rcu_node structure's->exp_tasks will > > trigger oops. > > > > This commit therefore allows rcu_node structure's->exp_tasks to be > > accessed while holding rcu_node structure's ->lock. > > > > Signed-off-by: Zqiang <qiang1.zhang@intel.com> > > Apologies for the delay and thank you for the reminder! > > Please check the wordsmithed version below, which I have queued. > > Thanx, Paul > > ------------------------------------------------------------------------ > > commit 389b0eafd72829fd63548f7ff4e8d6ac90fa1f98 > Author: Zqiang <qiang1.zhang@intel.com> > Date: Sat Dec 24 13:25:53 2022 +0800 > > rcu: Protect rcu_print_task_exp_stall() ->exp_tasks access > > For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario can > result in a NULL-pointer dereference: > > CPU1 CPU2 > rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall > if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL > raw_spin_lock_rcu_node > np = rcu_next_node_entry(t, rnp) > if (&t->rcu_node_entry == rnp->exp_tasks) > WRITE_ONCE(rnp->exp_tasks, np) > .... > raw_spin_unlock_irqrestore_rcu_node > raw_spin_lock_irqsave_rcu_node > t = list_entry(rnp->exp_tasks->prev, > struct task_struct, rcu_node_entry) > (if rnp->exp_tasks is NULL, this > will dereference a NULL pointer) > > The problem is that CPU2 accesses the rcu_node structure's->exp_tasks > field without holding the rcu_node structure's ->lock and CPU2 did > not observe CPU1's change to rcu_node structure's ->exp_tasks in time. > Therefore, if CPU1 sets rcu_node structure's->exp_tasks pointer to NULL, > then CPU2 might dereference that NULL pointer. > > This commit therefore holds the rcu_node structure's ->lock while > accessing that structure's->exp_tasks field. > > Signed-off-by: Zqiang <qiang1.zhang@intel.com> > Signed-off-by: Paul E. McKenney <paulmck@kernel.org> > > diff --git a/kernel/rcu/tree_exp.h b/kernel/rcu/tree_exp.h > index 7cc4856da0817..902e7c8709c7e 100644 > --- a/kernel/rcu/tree_exp.h > +++ b/kernel/rcu/tree_exp.h > @@ -803,9 +803,11 @@ static int rcu_print_task_exp_stall(struct rcu_node *rnp) > int ndetected = 0; > struct task_struct *t; > > - if (!READ_ONCE(rnp->exp_tasks)) > - return 0; > raw_spin_lock_irqsave_rcu_node(rnp, flags); > + if (!READ_ONCE(rnp->exp_tasks)) { Does it have to be READ_ONCE then? Thanks. > + raw_spin_unlock_irqrestore_rcu_node(rnp, flags); > + return 0; > + } > t = list_entry(rnp->exp_tasks->prev, > struct task_struct, rcu_node_entry); > list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) { ^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH] rcu: Safe access to rcu_node structure's->exp_tasks 2023-01-09 13:21 ` Frederic Weisbecker @ 2023-01-09 15:22 ` Paul E. McKenney 0 siblings, 0 replies; 6+ messages in thread From: Paul E. McKenney @ 2023-01-09 15:22 UTC (permalink / raw) To: Frederic Weisbecker; +Cc: Zqiang, quic_neeraju, joel, rcu, linux-kernel On Mon, Jan 09, 2023 at 02:21:01PM +0100, Frederic Weisbecker wrote: > On Thu, Jan 05, 2023 at 07:41:46PM -0800, Paul E. McKenney wrote: > > On Sat, Dec 24, 2022 at 01:25:53PM +0800, Zqiang wrote: > > > For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario > > > can result system oops. > > > > > > CPU1 CPU2 > > > rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall > > > if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL > > > raw_spin_lock_rcu_node > > > np = rcu_next_node_entry(t, rnp) > > > if (&t->rcu_node_entry == rnp->exp_tasks) > > > WRITE_ONCE(rnp->exp_tasks, np) > > > .... > > > raw_spin_unlock_irqrestore_rcu_node > > > raw_spin_lock_irqsave_rcu_node > > > t = list_entry(rnp->exp_tasks->prev, > > > struct task_struct, rcu_node_entry) > > > (if rnp->exp_tasks is NULL > > > will trigger oops) > > > > > > This problem is that CPU2 accesses rcu_node structure's->exp_tasks > > > without holding the rcu_node structure's ->lock and CPU2 did not > > > observe CPU1's change to rcu_node structure's->exp_tasks in time, > > > if rcu_node structure's->exp_tasks is set null pointer by CPU1, after > > > that CPU2 accesses members of rcu_node structure's->exp_tasks will > > > trigger oops. > > > > > > This commit therefore allows rcu_node structure's->exp_tasks to be > > > accessed while holding rcu_node structure's ->lock. > > > > > > Signed-off-by: Zqiang <qiang1.zhang@intel.com> > > > > Apologies for the delay and thank you for the reminder! > > > > Please check the wordsmithed version below, which I have queued. > > > > Thanx, Paul > > > > ------------------------------------------------------------------------ > > > > commit 389b0eafd72829fd63548f7ff4e8d6ac90fa1f98 > > Author: Zqiang <qiang1.zhang@intel.com> > > Date: Sat Dec 24 13:25:53 2022 +0800 > > > > rcu: Protect rcu_print_task_exp_stall() ->exp_tasks access > > > > For kernels built with CONFIG_PREEMPT_RCU=y, the following scenario can > > result in a NULL-pointer dereference: > > > > CPU1 CPU2 > > rcu_preempt_deferred_qs_irqrestore rcu_print_task_exp_stall > > if (special.b.blocked) READ_ONCE(rnp->exp_tasks) != NULL > > raw_spin_lock_rcu_node > > np = rcu_next_node_entry(t, rnp) > > if (&t->rcu_node_entry == rnp->exp_tasks) > > WRITE_ONCE(rnp->exp_tasks, np) > > .... > > raw_spin_unlock_irqrestore_rcu_node > > raw_spin_lock_irqsave_rcu_node > > t = list_entry(rnp->exp_tasks->prev, > > struct task_struct, rcu_node_entry) > > (if rnp->exp_tasks is NULL, this > > will dereference a NULL pointer) > > > > The problem is that CPU2 accesses the rcu_node structure's->exp_tasks > > field without holding the rcu_node structure's ->lock and CPU2 did > > not observe CPU1's change to rcu_node structure's ->exp_tasks in time. > > Therefore, if CPU1 sets rcu_node structure's->exp_tasks pointer to NULL, > > then CPU2 might dereference that NULL pointer. > > > > This commit therefore holds the rcu_node structure's ->lock while > > accessing that structure's->exp_tasks field. > > > > Signed-off-by: Zqiang <qiang1.zhang@intel.com> > > Signed-off-by: Paul E. McKenney <paulmck@kernel.org> > > > > diff --git a/kernel/rcu/tree_exp.h b/kernel/rcu/tree_exp.h > > index 7cc4856da0817..902e7c8709c7e 100644 > > --- a/kernel/rcu/tree_exp.h > > +++ b/kernel/rcu/tree_exp.h > > @@ -803,9 +803,11 @@ static int rcu_print_task_exp_stall(struct rcu_node *rnp) > > int ndetected = 0; > > struct task_struct *t; > > > > - if (!READ_ONCE(rnp->exp_tasks)) > > - return 0; > > raw_spin_lock_irqsave_rcu_node(rnp, flags); > > + if (!READ_ONCE(rnp->exp_tasks)) { > > Does it have to be READ_ONCE then? Good point, that should not be necessary. I will drop the READ_ONCE on my next rebase. (Unless someone tells me there is something subtle that I am missing.) Thanx, Paul > Thanks. > > > + raw_spin_unlock_irqrestore_rcu_node(rnp, flags); > > + return 0; > > + } > > t = list_entry(rnp->exp_tasks->prev, > > struct task_struct, rcu_node_entry); > > list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) { ^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2023-01-09 15:23 UTC | newest] Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2022-12-24 5:25 [PATCH] rcu: Safe access to rcu_node structure's->exp_tasks Zqiang 2023-01-06 3:10 ` Zhang, Qiang1 2023-01-06 3:41 ` Paul E. McKenney 2023-01-06 12:58 ` Zhang, Qiang1 2023-01-09 13:21 ` Frederic Weisbecker 2023-01-09 15:22 ` Paul E. McKenney
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.