Skip to contentSkip to conversation

RCU fixes

PATCH Superseded Scott Wood 5 participants 43 messages Aug 21, 2019 – Aug 28, 2019

Subsystems (2)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Scott Wood

author
#0 lore raw

v2 cover RCU fixes

This is a respin of the "Address rcutorture issues" patchset, minus the actual rcutorture changes.

I still plan to implement detection of bad nesting scenarios, but it's complicated by the need to distinguish (on a non-RT kernel) between irq/preempt disabling that would and would not happen on an RT kernel (which would also have the benefit of being able to detect nesting regular spinlocks inside raw spinlocks on a non-RT debug kernel). In the meantime I could send the rcutorture changes as a PREEMPT_RT only patch, though the extent of the changes depends on whether my migrate disable patchset is applied since it removes a restriction.

Scott Wood (3):
rcu: Acquire RCU lock when disabling BHs
sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep
rcu: Disable use_softirq on PREEMPT_RT

 include/linux/rcupdate.h |  4 ++++
 include/linux/sched.h    |  4 ++--
 kernel/rcu/tree.c        |  9 ++++++++-
 kernel/rcu/tree_plugin.h |  2 +-
 kernel/rcu/update.c      |  4 ++++
 kernel/sched/core.c      |  8 ++++++++
 kernel/softirq.c         | 12 +++++++++---
 7 files changed, 36 insertions(+), 7 deletions(-)
Signature · 1 line
1.8.3.1
author
#1 lore raw

PATCH v2 1/3 rcu: Acquire RCU lock when disabling BHs

A plain local_bh_disable() is documented as creating an RCU critical section, and (at least) rcutorture expects this to be the case. However, in_softirq() doesn't block a grace period on PREEMPT_RT, since RCU checks preempt_count() directly. Even if RCU were changed to check in_softirq(), that wouldn't allow blocked BH disablers to be boosted.

Fix this by calling rcu_read_lock() from local_bh_disable(), and update rcu_read_lock_bh_held() accordingly.

---
Another question is whether non-raw spinlocks are intended to create an RCU read-side critical section due to implicit preempt disable. If they are, then we'd need to add rcu_read_lock() there as well since RT doesn't disable preemption (and rcutorture should explicitly test with a spinlock). If not, the documentation should make that clear.

 include/linux/rcupdate.h |  4 ++++
 kernel/rcu/update.c      |  4 ++++
 kernel/softirq.c         | 12 +++++++++---
 3 files changed, 17 insertions(+), 3 deletions(-)
include/linux/rcupdate.h +4 -0
index 388ace315f32..d6e357378732 100644
@@ -615,10 +615,12 @@ static inline void rcu_read_unlock(void)
 static inline void rcu_read_lock_bh(void)
 {
 	local_bh_disable();
+#ifndef CONFIG_PREEMPT_RT_FULL
 	__acquire(RCU_BH);
 	rcu_lock_acquire(&rcu_bh_lock_map);
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_lock_bh() used illegally while idle");
+#endif
 }
 
 /*
@@ -628,10 +630,12 @@ static inline void rcu_read_lock_bh(void)
  */
 static inline void rcu_read_unlock_bh(void)
 {
+#ifndef CONFIG_PREEMPT_RT_FULL
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_unlock_bh() used illegally while idle");
 	rcu_lock_release(&rcu_bh_lock_map);
 	__release(RCU_BH);
+#endif
 	local_bh_enable();
 }
 
kernel/rcu/update.c +4 -0
index 016c66a98292..a9cdf3d562bc 100644
@@ -296,7 +296,11 @@ int rcu_read_lock_bh_held(void)
 		return 0;
 	if (!rcu_lockdep_current_cpu_online())
 		return 0;
+#ifdef CONFIG_PREEMPT_RT_FULL
+	return lock_is_held(&rcu_lock_map) || irqs_disabled();
+#else
 	return in_softirq() || irqs_disabled();
+#endif
 }
 EXPORT_SYMBOL_GPL(rcu_read_lock_bh_held);
 
kernel/softirq.c +9 -3
index d16d080a74f7..6080c9328df1 100644
@@ -115,8 +115,10 @@ void __local_bh_disable_ip(unsigned long ip, unsigned int cnt)
 	long soft_cnt;
 
 	WARN_ON_ONCE(in_irq());
-	if (!in_atomic())
+	if (!in_atomic()) {
 		local_lock(bh_lock);
+		rcu_read_lock();
+	}
 	soft_cnt = this_cpu_inc_return(softirq_counter);
 	WARN_ON_ONCE(soft_cnt == 0);
 	current->softirq_count += SOFTIRQ_DISABLE_OFFSET;
@@ -151,8 +153,10 @@ void _local_bh_enable(void)
 #endif
 
 	current->softirq_count -= SOFTIRQ_DISABLE_OFFSET;
-	if (!in_atomic())
+	if (!in_atomic()) {
+		rcu_read_unlock();
 		local_unlock(bh_lock);
+	}
 }
 
 void _local_bh_enable_rt(void)
@@ -185,8 +189,10 @@ void __local_bh_enable_ip(unsigned long ip, unsigned int cnt)
 	WARN_ON_ONCE(count < 0);
 	local_irq_enable();
 
-	if (!in_atomic())
+	if (!in_atomic()) {
+		rcu_read_unlock();
 		local_unlock(bh_lock);
+	}
 
 	current->softirq_count -= SOFTIRQ_DISABLE_OFFSET;
 	preempt_check_resched();
Signature · 1 line
1.8.3.1
#2 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 8 lines · Scott Wood

A plain local_bh_disable() is documented as creating an RCU critical section, and (at least) rcutorture expects this to be the case. However, in_softirq() doesn't block a grace period on PREEMPT_RT, since RCU checks preempt_count() directly. Even if RCU were changed to check in_softirq(), that wouldn't allow blocked BH disablers to be boosted.

Fix this by calling rcu_read_lock() from local_bh_disable(), and update rcu_read_lock_bh_held() accordingly.

Cool! Some questions and comments below.

Thanx, Paul

Quoted 4 lines

---
Another question is whether non-raw spinlocks are intended to create an RCU read-side critical section due to implicit preempt disable.

Hmmm... Did non-raw spinlocks act like rcu_read_lock_sched() and rcu_read_unlock_sched() pairs in -rt prior to the RCU flavor consolidation? If not, I don't see why they should do so after that consolidation in -rt.

Quoted 4 lines

If they
are, then we'd need to add rcu_read_lock() there as well since RT doesn't disable preemption (and rcutorture should explicitly test with a spinlock). If not, the documentation should make that clear.

True enough!

Quoted 10 lines
 include/linux/rcupdate.h |  4 ++++
 kernel/rcu/update.c      |  4 ++++
 kernel/softirq.c         | 12 +++++++++---
 3 files changed, 17 insertions(+), 3 deletions(-)
include/linux/rcupdate.h +0 -0
index 388ace315f32..d6e357378732 100644

include/linux/rcupdate.h static inline void rcu_read_unlock(void) · line 623

Quoted 9 lines
include/linux/rcupdate.h +2 -0
@@ -615,10 +615,12 @@ static inline void rcu_read_unlock(void)
 static inline void rcu_read_lock_bh(void)
 {
 	local_bh_disable();
+#ifndef CONFIG_PREEMPT_RT_FULL
 	__acquire(RCU_BH);
 	rcu_lock_acquire(&rcu_bh_lock_map);
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_lock_bh() used illegally while idle");
+#endif

Any chance of this using "if (!IS_ENABLED(CONFIG_PREEMPT_RT_FULL))"? We should be OK providing a do-nothing __maybe_unused rcu_bh_lock_map for lockdep-enabled -rt kernels, right?

include/linux/rcupdate.h static inline void rcu_read_lock_bh(void) · line 638

Quoted 13 lines
include/linux/rcupdate.h +2 -0
 }
 
 /*
@@ -628,10 +630,12 @@ static inline void rcu_read_lock_bh(void)
  */
 static inline void rcu_read_unlock_bh(void)
 {
+#ifndef CONFIG_PREEMPT_RT_FULL
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_unlock_bh() used illegally while idle");
 	rcu_lock_release(&rcu_bh_lock_map);
 	__release(RCU_BH);
+#endif

Ditto.

Quoted 8 lines
include/linux/rcupdate.h +0 -0
 	local_bh_enable();
 }
 
kernel/rcu/update.c +0 -0
index 016c66a98292..a9cdf3d562bc 100644

kernel/rcu/update.c int rcu_read_lock_bh_held(void) · line 303

Quoted 8 lines
kernel/rcu/update.c +4 -0
@@ -296,7 +296,11 @@ int rcu_read_lock_bh_held(void)
 		return 0;
 	if (!rcu_lockdep_current_cpu_online())
 		return 0;
+#ifdef CONFIG_PREEMPT_RT_FULL
+	return lock_is_held(&rcu_lock_map) || irqs_disabled();
+#else
 	return in_softirq() || irqs_disabled();
+#endif

And globally.

Quoted 32 lines
kernel/rcu/update.c +0 -0
 }
 EXPORT_SYMBOL_GPL(rcu_read_lock_bh_held);
 
kernel/softirq.c +6 -2
index d16d080a74f7..6080c9328df1 100644
@@ -115,8 +115,10 @@ void __local_bh_disable_ip(unsigned long ip, unsigned int cnt)
 	long soft_cnt;
 
 	WARN_ON_ONCE(in_irq());
-	if (!in_atomic())
+	if (!in_atomic()) {
 		local_lock(bh_lock);
+		rcu_read_lock();
+	}
 	soft_cnt = this_cpu_inc_return(softirq_counter);
 	WARN_ON_ONCE(soft_cnt == 0);
 	current->softirq_count += SOFTIRQ_DISABLE_OFFSET;
@@ -151,8 +153,10 @@ void _local_bh_enable(void)
 #endif
 
 	current->softirq_count -= SOFTIRQ_DISABLE_OFFSET;
-	if (!in_atomic())
+	if (!in_atomic()) {
+		rcu_read_unlock();
 		local_unlock(bh_lock);
+	}
 }
 
 void _local_bh_enable_rt(void)

kernel/softirq.c void __local_bh_enable_ip(unsigned long ip, unsigned int cnt) · line 195

Quoted 8 lines
kernel/softirq.c +3 -1
@@ -185,8 +189,10 @@ void __local_bh_enable_ip(unsigned long ip, unsigned int cnt)
 	WARN_ON_ONCE(count < 0);
 	local_irq_enable();
 
-	if (!in_atomic())
+	if (!in_atomic()) {
+		rcu_read_unlock();
 		local_unlock(bh_lock);
+	}

The return from in_atomic() is guaranteed to be the same at local_bh_enable() time as was at the call to the corresponding local_bh_disable()?

I could have sworn that I ran afoul of this last year. Might these added rcu_read_lock() and rcu_read_unlock() calls need to check for CONFIG_PREEMPT_RT_FULL?

Quoted 5 lines
kernel/softirq.c +0 -0
 	current->softirq_count -= SOFTIRQ_DISABLE_OFFSET;
 	preempt_check_resched();
Signature · 1 line
1.8.3.1
#3 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 19 lines · Paul E. McKenney
Quoted 8 lines · Scott Wood

A plain local_bh_disable() is documented as creating an RCU critical section, and (at least) rcutorture expects this to be the case. However, in_softirq() doesn't block a grace period on PREEMPT_RT, since RCU checks preempt_count() directly. Even if RCU were changed to check in_softirq(), that wouldn't allow blocked BH disablers to be boosted.

Fix this by calling rcu_read_lock() from local_bh_disable(), and update rcu_read_lock_bh_held() accordingly.

Cool! Some questions and comments below.

Thanx, Paul

Quoted 4 lines

---
Another question is whether non-raw spinlocks are intended to create an RCU read-side critical section due to implicit preempt disable.

Quoted 4 lines

Hmmm... Did non-raw spinlocks act like rcu_read_lock_sched() and rcu_read_unlock_sched() pairs in -rt prior to the RCU flavor consolidation? If not, I don't see why they should do so after that consolidation in -rt.

May be I am missing something, but I didn't see the connection between consolidation and this patch. AFAICS, this patch is so that rcu_read_lock_bh_held() works at all on -rt. Did I badly miss something?

Quoted 22 lines
Quoted 4 lines

If they
are, then we'd need to add rcu_read_lock() there as well since RT doesn't disable preemption (and rcutorture should explicitly test with a spinlock). If not, the documentation should make that clear.

True enough!

Quoted 15 lines
 include/linux/rcupdate.h |  4 ++++
 kernel/rcu/update.c      |  4 ++++
 kernel/softirq.c         | 12 +++++++++---
 3 files changed, 17 insertions(+), 3 deletions(-)
include/linux/rcupdate.h +1 -0
index 388ace315f32..d6e357378732 100644
@@ -615,10 +615,12 @@ static inline void rcu_read_unlock(void)
 static inline void rcu_read_lock_bh(void)
 {
 	local_bh_disable();
+#ifndef CONFIG_PREEMPT_RT_FULL
 	__acquire(RCU_BH);
Quoted 8 lines

include/linux/rcupdate.h static inline void rcu_read_unlock(void) · line 623

Quoted 4 lines
include/linux/rcupdate.h +1 -0
 	rcu_lock_acquire(&rcu_bh_lock_map);
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_lock_bh() used illegally while idle");
+#endif

Any chance of this using "if (!IS_ENABLED(CONFIG_PREEMPT_RT_FULL))"? We should be OK providing a do-nothing __maybe_unused rcu_bh_lock_map for lockdep-enabled -rt kernels, right?

Since this function is small, I prefer if -rt defines their own rcu_read_lock_bh() which just does the local_bh_disable(). That would be way cleaner IMO. IIRC, -rt does similar things for spinlocks, but it has been sometime since I look at the -rt patchset.

Quoted 19 lines

include/linux/rcupdate.h static inline void rcu_read_lock_bh(void) · line 638

Quoted 13 lines
include/linux/rcupdate.h +2 -0
 }
 
 /*
@@ -628,10 +630,12 @@ static inline void rcu_read_lock_bh(void)
  */
 static inline void rcu_read_unlock_bh(void)
 {
+#ifndef CONFIG_PREEMPT_RT_FULL
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_unlock_bh() used illegally while idle");
 	rcu_lock_release(&rcu_bh_lock_map);
 	__release(RCU_BH);
+#endif

Ditto.

Quoted 3 lines
include/linux/rcupdate.h +0 -0
 	local_bh_enable();
 }
 
Quoted 15 lines

kernel/rcu/update.c int rcu_read_lock_bh_held(void) · line 303

Quoted 13 lines
kernel/rcu/update.c +4 -0
index 016c66a98292..a9cdf3d562bc 100644
@@ -296,7 +296,11 @@ int rcu_read_lock_bh_held(void)
 		return 0;
 	if (!rcu_lockdep_current_cpu_online())
 		return 0;
+#ifdef CONFIG_PREEMPT_RT_FULL
+	return lock_is_held(&rcu_lock_map) || irqs_disabled();
+#else
 	return in_softirq() || irqs_disabled();
+#endif

And globally.

And could be untangled a bit as well:

if (irqs_disabled())

	return 1;

if (IS_ENABLED(CONFIG_PREEMPT_RT_FULL))

	return lock_is_held(&rcu_lock_map);

return in_softirq();

Quoted 45 lines
Quoted 32 lines
kernel/rcu/update.c +0 -0
 }
 EXPORT_SYMBOL_GPL(rcu_read_lock_bh_held);
 
kernel/softirq.c +6 -2
index d16d080a74f7..6080c9328df1 100644
@@ -115,8 +115,10 @@ void __local_bh_disable_ip(unsigned long ip, unsigned int cnt)
 	long soft_cnt;
 
 	WARN_ON_ONCE(in_irq());
-	if (!in_atomic())
+	if (!in_atomic()) {
 		local_lock(bh_lock);
+		rcu_read_lock();
+	}
 	soft_cnt = this_cpu_inc_return(softirq_counter);
 	WARN_ON_ONCE(soft_cnt == 0);
 	current->softirq_count += SOFTIRQ_DISABLE_OFFSET;
@@ -151,8 +153,10 @@ void _local_bh_enable(void)
 #endif
 
 	current->softirq_count -= SOFTIRQ_DISABLE_OFFSET;
-	if (!in_atomic())
+	if (!in_atomic()) {
+		rcu_read_unlock();
 		local_unlock(bh_lock);
+	}
 }
 
 void _local_bh_enable_rt(void)

kernel/softirq.c void __local_bh_enable_ip(unsigned long ip, unsigned int cnt) · line 195

Quoted 8 lines
kernel/softirq.c +3 -1
@@ -185,8 +189,10 @@ void __local_bh_enable_ip(unsigned long ip, unsigned int cnt)
 	WARN_ON_ONCE(count < 0);
 	local_irq_enable();
 
-	if (!in_atomic())
+	if (!in_atomic()) {
+		rcu_read_unlock();
 		local_unlock(bh_lock);
+	}

The return from in_atomic() is guaranteed to be the same at local_bh_enable() time as was at the call to the corresponding local_bh_disable()?

Quoted 3 lines

I could have sworn that I ran afoul of this last year. Might these added rcu_read_lock() and rcu_read_unlock() calls need to check for CONFIG_PREEMPT_RT_FULL?

Great point! I think they should be guarded but will let Scott answer that one.

thanks,

- Joel

#4 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 20 lines · Joel Fernandes
Quoted 19 lines · Paul E. McKenney
Quoted 8 lines · Scott Wood

A plain local_bh_disable() is documented as creating an RCU critical section, and (at least) rcutorture expects this to be the case. However, in_softirq() doesn't block a grace period on PREEMPT_RT, since RCU checks preempt_count() directly. Even if RCU were changed to check in_softirq(), that wouldn't allow blocked BH disablers to be boosted.

Fix this by calling rcu_read_lock() from local_bh_disable(), and update rcu_read_lock_bh_held() accordingly.

Cool! Some questions and comments below.

Thanx, Paul

Quoted 4 lines

---
Another question is whether non-raw spinlocks are intended to create an RCU read-side critical section due to implicit preempt disable.

Quoted 8 lines
Quoted 4 lines

Hmmm... Did non-raw spinlocks act like rcu_read_lock_sched() and rcu_read_unlock_sched() pairs in -rt prior to the RCU flavor consolidation? If not, I don't see why they should do so after that consolidation in -rt.

May be I am missing something, but I didn't see the connection between consolidation and this patch. AFAICS, this patch is so that rcu_read_lock_bh_held() works at all on -rt. Did I badly miss something?

I was interpreting Scott's question (which would be excluded from the git commit log) as relating to a possible follow-on patch.

The question is "how special can non-raw spinlocks be in -rt?". From what I can see, they have been treated as sleeplocks from an RCU viewpoint, so maybe that should continue to be the case. It does deserve some thought because in mainline a non-raw spinlock really would block a post-consolidation RCU grace period, even in PREEMPT kernels.

But then again, you cannot preempt a non-raw spinlock in mainline but you can in -rt, so extending that exception to RCU is not unreasonable.

Either way, we do need to make a definite decision and document it. If I were forced to make a decision right now, I would follow the old behavior, so that only raw spinlocks were guaranteed to block RCU grace periods. But I am not being forced, so let's actually discuss and make a conscious decision. ;-)

Thanx, Paul

#5 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 39 lines · Paul E. McKenney
Quoted 20 lines · Joel Fernandes
Quoted 19 lines · Paul E. McKenney
Quoted 8 lines · Scott Wood

A plain local_bh_disable() is documented as creating an RCU critical section, and (at least) rcutorture expects this to be the case. However, in_softirq() doesn't block a grace period on PREEMPT_RT, since RCU checks preempt_count() directly. Even if RCU were changed to check in_softirq(), that wouldn't allow blocked BH disablers to be boosted.

Fix this by calling rcu_read_lock() from local_bh_disable(), and update rcu_read_lock_bh_held() accordingly.

Cool! Some questions and comments below.

Thanx, Paul

Quoted 4 lines

---
Another question is whether non-raw spinlocks are intended to create an RCU read-side critical section due to implicit preempt disable.

Quoted 8 lines
Quoted 4 lines

Hmmm... Did non-raw spinlocks act like rcu_read_lock_sched() and rcu_read_unlock_sched() pairs in -rt prior to the RCU flavor consolidation? If not, I don't see why they should do so after that consolidation in -rt.

May be I am missing something, but I didn't see the connection between consolidation and this patch. AFAICS, this patch is so that rcu_read_lock_bh_held() works at all on -rt. Did I badly miss something?

I was interpreting Scott's question (which would be excluded from the git commit log) as relating to a possible follow-on patch.

The question is "how special can non-raw spinlocks be in -rt?". From what I can see, they have been treated as sleeplocks from an RCU viewpoint, so maybe that should continue to be the case. It does deserve some thought because in mainline a non-raw spinlock really would block a post-consolidation RCU grace period, even in PREEMPT kernels.

Quoted 8 lines

But then again, you cannot preempt a non-raw spinlock in mainline but you can in -rt, so extending that exception to RCU is not unreasonable.

Either way, we do need to make a definite decision and document it. If I were forced to make a decision right now, I would follow the old behavior, so that only raw spinlocks were guaranteed to block RCU grace periods. But I am not being forced, so let's actually discuss and make a conscious decision. ;-)

I think non-raw spinlocks on -rt should at least do rcu_read_lock() so that any driver or kernel code that depends on this behavior and works on non-rt also works on -rt. It also removes the chance a kernel developer may miss documentation and accidentally forget that their code may break on -rt. I am curious to see how much this design pattern appears in the kernel (spin_lock'ed section "intended" as an RCU-reader by code sequences).

Logically speaking, to me anything that disables preemption on non-RT should do rcu_read_lock() on -rt so that from RCU's perspective, things are working. But I wonder where we would draw the line and if the bar is to need actual examples of usage patterns to make a decision..

Any thoughts?

thanks,

- Joel

#6 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 56 lines · Joel Fernandes
Quoted 39 lines · Paul E. McKenney
Quoted 20 lines · Joel Fernandes
Quoted 19 lines · Paul E. McKenney
Quoted 8 lines · Scott Wood

A plain local_bh_disable() is documented as creating an RCU critical section, and (at least) rcutorture expects this to be the case. However, in_softirq() doesn't block a grace period on PREEMPT_RT, since RCU checks preempt_count() directly. Even if RCU were changed to check in_softirq(), that wouldn't allow blocked BH disablers to be boosted.

Fix this by calling rcu_read_lock() from local_bh_disable(), and update rcu_read_lock_bh_held() accordingly.

Cool! Some questions and comments below.

Thanx, Paul

Quoted 4 lines

---
Another question is whether non-raw spinlocks are intended to create an RCU read-side critical section due to implicit preempt disable.

Quoted 8 lines
Quoted 4 lines

Hmmm... Did non-raw spinlocks act like rcu_read_lock_sched() and rcu_read_unlock_sched() pairs in -rt prior to the RCU flavor consolidation? If not, I don't see why they should do so after that consolidation in -rt.

May be I am missing something, but I didn't see the connection between consolidation and this patch. AFAICS, this patch is so that rcu_read_lock_bh_held() works at all on -rt. Did I badly miss something?

I was interpreting Scott's question (which would be excluded from the git commit log) as relating to a possible follow-on patch.

The question is "how special can non-raw spinlocks be in -rt?". From what I can see, they have been treated as sleeplocks from an RCU viewpoint, so maybe that should continue to be the case. It does deserve some thought because in mainline a non-raw spinlock really would block a post-consolidation RCU grace period, even in PREEMPT kernels.

Quoted 8 lines

But then again, you cannot preempt a non-raw spinlock in mainline but you can in -rt, so extending that exception to RCU is not unreasonable.

Either way, we do need to make a definite decision and document it. If I were forced to make a decision right now, I would follow the old behavior, so that only raw spinlocks were guaranteed to block RCU grace periods. But I am not being forced, so let's actually discuss and make a conscious decision. ;-)

I think non-raw spinlocks on -rt should at least do rcu_read_lock() so that any driver or kernel code that depends on this behavior and works on non-rt also works on -rt. It also removes the chance a kernel developer may miss documentation and accidentally forget that their code may break on -rt. I am curious to see how much this design pattern appears in the kernel (spin_lock'ed section "intended" as an RCU-reader by code sequences).

Quoted 6 lines

Logically speaking, to me anything that disables preemption on non-RT should do rcu_read_lock() on -rt so that from RCU's perspective, things are working. But I wonder where we would draw the line and if the bar is to need actual examples of usage patterns to make a decision..

Any thoughts?

Yes. Let's listen to what the -rt guys have to say. After all, they are the ones who would be dealing with any differences in semantics.

Thanx, Paul

author
#7 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

In reply to Joel Fernandes
Quoted 8 lines · Joel Fernandes
Quoted 7 lines · Paul E. McKenney
Quoted 5 lines · Scott Wood

---
Another question is whether non-raw spinlocks are intended to create an
RCU read-side critical section due to implicit preempt disable.

Quoted 8 lines
Quoted 4 lines

Hmmm... Did non-raw spinlocks act like rcu_read_lock_sched() and rcu_read_unlock_sched() pairs in -rt prior to the RCU flavor consolidation? If not, I don't see why they should do so after that consolidation in -rt.

May be I am missing something, but I didn't see the connection between consolidation and this patch. AFAICS, this patch is so that rcu_read_lock_bh_held() works at all on -rt. Did I badly miss something?

Before consolidation, RT mapped rcu_read_lock_bh_held() to rcu_read_lock_bh() and called rcu_read_lock() from rcu_read_lock_bh(). This somehow got lost when rebasing on top of 5.0.

Quoted 24 lines
Quoted 15 lines
Quoted 15 lines
 include/linux/rcupdate.h |  4 ++++
 kernel/rcu/update.c      |  4 ++++
 kernel/softirq.c         | 12 +++++++++---
 3 files changed, 17 insertions(+), 3 deletions(-)
include/linux/rcupdate.h +1 -0
index 388ace315f32..d6e357378732 100644
@@ -615,10 +615,12 @@ static inline void rcu_read_unlock(void)
 static inline void rcu_read_lock_bh(void)
 {
 	local_bh_disable();
+#ifndef CONFIG_PREEMPT_RT_FULL
 	__acquire(RCU_BH);
Quoted 8 lines

include/linux/rcupdate.h static inline void rcu_read_unlock(void) · line 623

Quoted 4 lines
include/linux/rcupdate.h +1 -0
 	rcu_lock_acquire(&rcu_bh_lock_map);
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_lock_bh() used illegally while idle");
+#endif

Any chance of this using "if (!IS_ENABLED(CONFIG_PREEMPT_RT_FULL))"? We should be OK providing a do-nothing __maybe_unused rcu_bh_lock_map for lockdep-enabled -rt kernels, right?

Quoted 5 lines

Since this function is small, I prefer if -rt defines their own rcu_read_lock_bh() which just does the local_bh_disable(). That would be way
cleaner IMO. IIRC, -rt does similar things for spinlocks, but it has been sometime since I look at the -rt patchset.

I'll do it whichever way you all decide, though I'm not sure I agree about it being cleaner (especially while RT is still out-of-tree and a change to the non-RT version that fails to trigger a merge conflict is a concern).

What about moving everything but the local_bh_disable into a separate function called from rcu_read_lock_bh, and making that a no-op on RT?

Quoted 19 lines
Quoted 16 lines
Quoted 6 lines
kernel/rcu/update.c +0 -0
index 016c66a98292..a9cdf3d562bc 100644

kernel/rcu/update.c int rcu_read_lock_bh_held(void) · line 303

Quoted 8 lines
kernel/rcu/update.c +4 -0
@@ -296,7 +296,11 @@ int rcu_read_lock_bh_held(void)
 		return 0;
 	if (!rcu_lockdep_current_cpu_online())
 		return 0;
+#ifdef CONFIG_PREEMPT_RT_FULL
+	return lock_is_held(&rcu_lock_map) || irqs_disabled();
+#else
 	return in_softirq() || irqs_disabled();
+#endif

And globally.

And could be untangled a bit as well:

Quoted 7 lines

if (irqs_disabled())

	return 1;

if (IS_ENABLED(CONFIG_PREEMPT_RT_FULL))

	return lock_is_held(&rcu_lock_map);

return in_softirq();

OK.

-Scott

#8 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 14 lines · Scott Wood
Quoted 13 lines · Joel Fernandes
Quoted 11 lines · Paul E. McKenney
Quoted 5 lines · Scott Wood

---
Another question is whether non-raw spinlocks are intended to create an
RCU read-side critical section due to implicit preempt disable.

Hmmm... Did non-raw spinlocks act like rcu_read_lock_sched() and rcu_read_unlock_sched() pairs in -rt prior to the RCU flavor consolidation? If not, I don't see why they should do so after that consolidation in -rt.

Quoted 7 lines
Quoted 3 lines

May be I am missing something, but I didn't see the connection between consolidation and this patch. AFAICS, this patch is so that rcu_read_lock_bh_held() works at all on -rt. Did I badly miss something?

Before consolidation, RT mapped rcu_read_lock_bh_held() to rcu_read_lock_bh() and called rcu_read_lock() from rcu_read_lock_bh(). This somehow got lost when rebasing on top of 5.0.

so now rcu_read_lock_bh_held() is untouched and in_softirq() reports 1. So the problem is that we never hold RCU but report 1 like we do?

Sebastian

author
#9 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 21 lines · Sebastian Andrzej Siewior
Quoted 20 lines · Scott Wood
Quoted 18 lines · Joel Fernandes
Quoted 8 lines · Paul E. McKenney
Quoted 6 lines · Scott Wood

---
Another question is whether non-raw spinlocks are intended to create
an
RCU read-side critical section due to implicit preempt disable.

Quoted 4 lines

Hmmm... Did non-raw spinlocks act like rcu_read_lock_sched() and rcu_read_unlock_sched() pairs in -rt prior to the RCU flavor consolidation? If not, I don't see why they should do so after that consolidation in -rt.

May be I am missing something, but I didn't see the connection between consolidation and this patch. AFAICS, this patch is so that rcu_read_lock_bh_held() works at all on -rt. Did I badly miss something?

Quoted 7 lines
Quoted 4 lines

Before consolidation, RT mapped rcu_read_lock_bh_held() to rcu_read_lock_bh() and called rcu_read_lock() from rcu_read_lock_bh(). This
somehow got lost when rebasing on top of 5.0.

so now rcu_read_lock_bh_held() is untouched and in_softirq() reports 1. So the problem is that we never hold RCU but report 1 like we do?

Yes.

-Scott

#10 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 9 lines · Scott Wood
Quoted 7 lines
Quoted 4 lines

Before consolidation, RT mapped rcu_read_lock_bh_held() to rcu_read_lock_bh() and called rcu_read_lock() from rcu_read_lock_bh(). This
somehow got lost when rebasing on top of 5.0.

so now rcu_read_lock_bh_held() is untouched and in_softirq() reports 1. So the problem is that we never hold RCU but report 1 like we do?

Yes.

I understand the part where "rcu_read_lock() becomes part of local_bh_disable()". But why do you modify rcu_read_lock_bh_held() and rcu_read_lock_bh()? Couldn't they remain as-is?

Quoted 1 line

-Scott

Sebastian

author
#11 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 10 lines · Sebastian Andrzej Siewior
Quoted 9 lines · Scott Wood
Quoted 8 lines
Quoted 4 lines

Before consolidation, RT mapped rcu_read_lock_bh_held() to rcu_read_lock_bh() and called rcu_read_lock() from rcu_read_lock_bh(). This
somehow got lost when rebasing on top of 5.0.

so now rcu_read_lock_bh_held() is untouched and in_softirq() reports 1.
So the problem is that we never hold RCU but report 1 like we do?

Quoted 5 lines
Quoted 1 line

Yes.

I understand the part where "rcu_read_lock() becomes part of local_bh_disable()". But why do you modify rcu_read_lock_bh_held() and rcu_read_lock_bh()? Couldn't they remain as-is?

Yes, it looks like they can. I recall having problems with rcu_read_lock_bh_held() in an earlier version which is what prompted the change, but looking back I don't see what the problem was.

-Scott

#12 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

In reply to Scott Wood
Quoted 3 lines · Scott Wood
Quoted 2 lines · Joel Fernandes
Quoted 1 line · Paul E. McKenney

On Wed, Aug 21, 2019 at 06:19:04PM -0500, Scott Wood wrote:

[ . . . ]

Quoted 30 lines
Quoted 24 lines
Quoted 15 lines
Quoted 15 lines
 include/linux/rcupdate.h |  4 ++++
 kernel/rcu/update.c      |  4 ++++
 kernel/softirq.c         | 12 +++++++++---
 3 files changed, 17 insertions(+), 3 deletions(-)
include/linux/rcupdate.h +1 -0
index 388ace315f32..d6e357378732 100644
@@ -615,10 +615,12 @@ static inline void rcu_read_unlock(void)
 static inline void rcu_read_lock_bh(void)
 {
 	local_bh_disable();
+#ifndef CONFIG_PREEMPT_RT_FULL
 	__acquire(RCU_BH);
Quoted 8 lines

include/linux/rcupdate.h static inline void rcu_read_unlock(void) · line 623

Quoted 4 lines
include/linux/rcupdate.h +1 -0
 	rcu_lock_acquire(&rcu_bh_lock_map);
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_lock_bh() used illegally while idle");
+#endif

Any chance of this using "if (!IS_ENABLED(CONFIG_PREEMPT_RT_FULL))"? We should be OK providing a do-nothing __maybe_unused rcu_bh_lock_map for lockdep-enabled -rt kernels, right?

Quoted 5 lines

Since this function is small, I prefer if -rt defines their own rcu_read_lock_bh() which just does the local_bh_disable(). That would be way
cleaner IMO. IIRC, -rt does similar things for spinlocks, but it has been sometime since I look at the -rt patchset.

Quoted 6 lines

I'll do it whichever way you all decide, though I'm not sure I agree about it being cleaner (especially while RT is still out-of-tree and a change to the non-RT version that fails to trigger a merge conflict is a concern).

What about moving everything but the local_bh_disable into a separate function called from rcu_read_lock_bh, and making that a no-op on RT?

That makes a lot of sense to me!

Thanx, Paul

author
#13 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

In reply to Paul E. McKenney
Quoted 11 lines · Paul E. McKenney
Quoted 10 lines · Scott Wood
include/linux/rcupdate.h +1 -0
index 388ace315f32..d6e357378732 100644
@@ -615,10 +615,12 @@ static inline void rcu_read_unlock(void)
 static inline void rcu_read_lock_bh(void)
 {
 	local_bh_disable();
+#ifndef CONFIG_PREEMPT_RT_FULL
 	__acquire(RCU_BH);
Quoted 8 lines

include/linux/rcupdate.h static inline void rcu_read_unlock(void) · line 623

Quoted 4 lines
include/linux/rcupdate.h +1 -0
 	rcu_lock_acquire(&rcu_bh_lock_map);
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_lock_bh() used illegally while idle");
+#endif

Any chance of this using "if (!IS_ENABLED(CONFIG_PREEMPT_RT_FULL))"? We should be OK providing a do-nothing __maybe_unused rcu_bh_lock_map for lockdep-enabled -rt kernels, right?

OK.

Quoted 5 lines
Quoted 5 lines
include/linux/rcupdate.h +0 -0
@@ -185,8 +189,10 @@ void __local_bh_enable_ip(unsigned long ip,
 > > unsigned int cnt)
 	WARN_ON_ONCE(count < 0);
 	local_irq_enable();
 
Quoted 9 lines

include/linux/rcupdate.h void __local_bh_enable_ip(unsigned long ip, · line 196

Quoted 5 lines
include/linux/rcupdate.h +3 -1
-	if (!in_atomic())
+	if (!in_atomic()) {
+		rcu_read_unlock();
 		local_unlock(bh_lock);
+	}

The return from in_atomic() is guaranteed to be the same at local_bh_enable() time as was at the call to the corresponding local_bh_disable()?

That's an existing requirement on RT (which rcutorture currently violates) due to bh_lock.

Quoted 3 lines

I could have sworn that I ran afoul of this last year. Might these added rcu_read_lock() and rcu_read_unlock() calls need to check for CONFIG_PREEMPT_RT_FULL?

This code is already under a PREEMPT_RT_FULL ifdef.

-Scott

#14 lore raw

Re: [PATCH RT v2 1/3] rcu: Acquire RCU lock when disabling BHs

Quoted 38 lines · Scott Wood
Quoted 11 lines · Paul E. McKenney
Quoted 10 lines · Scott Wood
include/linux/rcupdate.h +1 -0
index 388ace315f32..d6e357378732 100644
@@ -615,10 +615,12 @@ static inline void rcu_read_unlock(void)
 static inline void rcu_read_lock_bh(void)
 {
 	local_bh_disable();
+#ifndef CONFIG_PREEMPT_RT_FULL
 	__acquire(RCU_BH);
Quoted 8 lines

include/linux/rcupdate.h static inline void rcu_read_unlock(void) · line 623

Quoted 4 lines
include/linux/rcupdate.h +1 -0
 	rcu_lock_acquire(&rcu_bh_lock_map);
 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
 			 "rcu_read_lock_bh() used illegally while idle");
+#endif

Any chance of this using "if (!IS_ENABLED(CONFIG_PREEMPT_RT_FULL))"? We should be OK providing a do-nothing __maybe_unused rcu_bh_lock_map for lockdep-enabled -rt kernels, right?

OK.

Quoted 5 lines
Quoted 5 lines
include/linux/rcupdate.h +0 -0
@@ -185,8 +189,10 @@ void __local_bh_enable_ip(unsigned long ip,
 > > unsigned int cnt)
 	WARN_ON_ONCE(count < 0);
 	local_irq_enable();
 
Quoted 9 lines

include/linux/rcupdate.h void __local_bh_enable_ip(unsigned long ip, · line 196

Quoted 5 lines
include/linux/rcupdate.h +3 -1
-	if (!in_atomic())
+	if (!in_atomic()) {
+		rcu_read_unlock();
 		local_unlock(bh_lock);
+	}

The return from in_atomic() is guaranteed to be the same at local_bh_enable() time as was at the call to the corresponding local_bh_disable()?

Quoted 8 lines

That's an existing requirement on RT (which rcutorture currently violates) due to bh_lock.

Quoted 3 lines

I could have sworn that I ran afoul of this last year. Might these added rcu_read_lock() and rcu_read_unlock() calls need to check for CONFIG_PREEMPT_RT_FULL?

This code is already under a PREEMPT_RT_FULL ifdef.

Good enough, then!

Thanx, Paul

author
#15 lore raw

PATCH v2 2/3 sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

In reply to Scott Wood

Without this, rcu_note_context_switch() will complain if an RCU read lock is held when migrate_enable() calls stop_one_cpu().

---
v2: Added comment.

If my migrate disable changes aren't taken, then pin_current_cpu() will also need to use sleeping_lock_inc() because calling __read_rt_lock() bypasses the usual place it's done.

 include/linux/sched.h    | 4 ++--
 kernel/rcu/tree_plugin.h | 2 +-
 kernel/sched/core.c      | 8 ++++++++
 3 files changed, 11 insertions(+), 3 deletions(-)
include/linux/sched.h +2 -2
index 7e892e727f12..1ebc97f28009 100644
@@ -673,7 +673,7 @@ struct task_struct {
 	int				migrate_disable_atomic;
 # endif
 #endif
-#ifdef CONFIG_PREEMPT_RT_FULL
+#ifdef CONFIG_PREEMPT_RT_BASE
 	int				sleeping_lock;
 #endif
 
@@ -1881,7 +1881,7 @@ static __always_inline bool need_resched(void)
 	return unlikely(tif_need_resched());
 }
 
-#ifdef CONFIG_PREEMPT_RT_FULL
+#ifdef CONFIG_PREEMPT_RT_BASE
 static inline void sleeping_lock_inc(void)
 {
 	current->sleeping_lock++;
kernel/rcu/tree_plugin.h +1 -1
index 23a54e4b649c..7a3aa085ce2c 100644
@@ -292,7 +292,7 @@ void rcu_note_context_switch(bool preempt)
 	barrier(); /* Avoid RCU read-side critical sections leaking down. */
 	trace_rcu_utilization(TPS("Start context switch"));
 	lockdep_assert_irqs_disabled();
-#if defined(CONFIG_PREEMPT_RT_FULL)
+#if defined(CONFIG_PREEMPT_RT_BASE)
 	sleeping_l = t->sleeping_lock;
 #endif
 	WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0 && !sleeping_l);
kernel/sched/core.c +8 -0
index e1bdd7f9be05..0758ee85634e 100644
@@ -7405,7 +7405,15 @@ void migrate_enable(void)
 			unpin_current_cpu();
 			preempt_lazy_enable();
 			preempt_enable();
+
+			/*
+			 * sleeping_lock_inc suppresses a debug check for
+			 * sleeping inside an RCU read side critical section
+			 */
+			sleeping_lock_inc();
 			stop_one_cpu(task_cpu(p), migration_cpu_stop, &arg);
+			sleeping_lock_dec();
+
 			return;
 		}
 	}
Signature · 1 line
1.8.3.1
#16 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 4 lines · Scott Wood

Without this, rcu_note_context_switch() will complain if an RCU read lock is held when migrate_enable() calls stop_one_cpu().

I have to ask... Both sleeping_lock_inc() and sleeping_lock_dec() are no-ops if not CONFIG_PREEMPT_RT_BASE?

Thanx, Paul

Quoted 70 lines

---
v2: Added comment.

If my migrate disable changes aren't taken, then pin_current_cpu() will also need to use sleeping_lock_inc() because calling __read_rt_lock() bypasses the usual place it's done.

 include/linux/sched.h    | 4 ++--
 kernel/rcu/tree_plugin.h | 2 +-
 kernel/sched/core.c      | 8 ++++++++
 3 files changed, 11 insertions(+), 3 deletions(-)
include/linux/sched.h +2 -2
index 7e892e727f12..1ebc97f28009 100644
@@ -673,7 +673,7 @@ struct task_struct {
 	int				migrate_disable_atomic;
 # endif
 #endif
-#ifdef CONFIG_PREEMPT_RT_FULL
+#ifdef CONFIG_PREEMPT_RT_BASE
 	int				sleeping_lock;
 #endif
 
@@ -1881,7 +1881,7 @@ static __always_inline bool need_resched(void)
 	return unlikely(tif_need_resched());
 }
 
-#ifdef CONFIG_PREEMPT_RT_FULL
+#ifdef CONFIG_PREEMPT_RT_BASE
 static inline void sleeping_lock_inc(void)
 {
 	current->sleeping_lock++;
kernel/rcu/tree_plugin.h +1 -1
index 23a54e4b649c..7a3aa085ce2c 100644
@@ -292,7 +292,7 @@ void rcu_note_context_switch(bool preempt)
 	barrier(); /* Avoid RCU read-side critical sections leaking down. */
 	trace_rcu_utilization(TPS("Start context switch"));
 	lockdep_assert_irqs_disabled();
-#if defined(CONFIG_PREEMPT_RT_FULL)
+#if defined(CONFIG_PREEMPT_RT_BASE)
 	sleeping_l = t->sleeping_lock;
 #endif
 	WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0 && !sleeping_l);
kernel/sched/core.c +8 -0
index e1bdd7f9be05..0758ee85634e 100644
@@ -7405,7 +7405,15 @@ void migrate_enable(void)
 			unpin_current_cpu();
 			preempt_lazy_enable();
 			preempt_enable();
+
+			/*
+			 * sleeping_lock_inc suppresses a debug check for
+			 * sleeping inside an RCU read side critical section
+			 */
+			sleeping_lock_inc();
 			stop_one_cpu(task_cpu(p), migration_cpu_stop, &arg);
+			sleeping_lock_dec();
+
 			return;
 		}
 	}
Signature · 1 line
1.8.3.1
author
#17 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 8 lines · Paul E. McKenney
Quoted 4 lines · Scott Wood

Without this, rcu_note_context_switch() will complain if an RCU read lock is held when migrate_enable() calls stop_one_cpu().

I have to ask... Both sleeping_lock_inc() and sleeping_lock_dec() are no-ops if not CONFIG_PREEMPT_RT_BASE?

Yes.

-Scott

#18 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

In reply to Scott Wood
Quoted 20 lines · Scott Wood

Without this, rcu_note_context_switch() will complain if an RCU read lock is held when migrate_enable() calls stop_one_cpu().

---
v2: Added comment.

If my migrate disable changes aren't taken, then pin_current_cpu() will also need to use sleeping_lock_inc() because calling __read_rt_lock() bypasses the usual place it's done.

 include/linux/sched.h    | 4 ++--
 kernel/rcu/tree_plugin.h | 2 +-
 kernel/sched/core.c      | 8 ++++++++
 3 files changed, 11 insertions(+), 3 deletions(-)
kernel/sched/core.c +0 -0
@@ -7405,7 +7405,15 @@ void migrate_enable(void)
 			unpin_current_cpu();

kernel/sched/core.c void migrate_enable(void) · line 7415

Quoted 10 lines
kernel/sched/core.c +7 -0
 			preempt_lazy_enable();
 			preempt_enable();
+
+			/*
+			 * sleeping_lock_inc suppresses a debug check for
+			 * sleeping inside an RCU read side critical section
+			 */
+			sleeping_lock_inc();
 			stop_one_cpu(task_cpu(p), migration_cpu_stop, &arg);
+			sleeping_lock_dec();

this looks like an ugly hack. This sleeping_lock_inc() is used where we actually hold a sleeping lock and schedule() which is okay. But this would mean we hold a RCU lock and schedule() anyway. Is that okay?

kernel/sched/core.c void migrate_enable(void) · line 7419

Quoted 4 lines
kernel/sched/core.c +1 -0
+
 			return;
 		}
 	}

Sebastian

author
#19 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 27 lines · Sebastian Andrzej Siewior
Quoted 26 lines · Scott Wood

Without this, rcu_note_context_switch() will complain if an RCU read lock is held when migrate_enable() calls stop_one_cpu().

---
v2: Added comment.

If my migrate disable changes aren't taken, then pin_current_cpu() will also need to use sleeping_lock_inc() because calling __read_rt_lock() bypasses the usual place it's done.

 include/linux/sched.h    | 4 ++--
 kernel/rcu/tree_plugin.h | 2 +-
 kernel/sched/core.c      | 8 ++++++++
 3 files changed, 11 insertions(+), 3 deletions(-)
kernel/sched/core.c +4 -0
@@ -7405,7 +7405,15 @@ void migrate_enable(void)
 			unpin_current_cpu();
 			preempt_lazy_enable();
 			preempt_enable();
+
+			/*
+			 * sleeping_lock_inc suppresses a debug check for
+			 * sleeping inside an RCU read side critical section
Quoted 8 lines

kernel/sched/core.c void migrate_enable(void) · line 7415

Quoted 4 lines
kernel/sched/core.c +3 -0
+			 */
+			sleeping_lock_inc();
 			stop_one_cpu(task_cpu(p), migration_cpu_stop, &arg);
+			sleeping_lock_dec();

this looks like an ugly hack. This sleeping_lock_inc() is used where we actually hold a sleeping lock and schedule() which is okay. But this would mean we hold a RCU lock and schedule() anyway. Is that okay?

Perhaps the name should be changed, but the concept is the same -- RT- specific sleeping which should be considered involuntary for the purpose of debug checks. Voluntary sleeping is not allowed in an RCU critical section because it will break the critical section on certain flavors of RCU, but that doesn't apply to the flavor used on RT. Sleeping for a long time in an RCU critical section would also be a bad thing, but that also doesn't apply here.

-Scott

#20 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 37 lines · Scott Wood
Quoted 27 lines · Sebastian Andrzej Siewior
Quoted 26 lines · Scott Wood

Without this, rcu_note_context_switch() will complain if an RCU read lock is held when migrate_enable() calls stop_one_cpu().

---
v2: Added comment.

If my migrate disable changes aren't taken, then pin_current_cpu() will also need to use sleeping_lock_inc() because calling __read_rt_lock() bypasses the usual place it's done.

 include/linux/sched.h    | 4 ++--
 kernel/rcu/tree_plugin.h | 2 +-
 kernel/sched/core.c      | 8 ++++++++
 3 files changed, 11 insertions(+), 3 deletions(-)
kernel/sched/core.c +4 -0
@@ -7405,7 +7405,15 @@ void migrate_enable(void)
 			unpin_current_cpu();
 			preempt_lazy_enable();
 			preempt_enable();
+
+			/*
+			 * sleeping_lock_inc suppresses a debug check for
+			 * sleeping inside an RCU read side critical section
Quoted 8 lines

kernel/sched/core.c void migrate_enable(void) · line 7415

Quoted 4 lines
kernel/sched/core.c +3 -0
+			 */
+			sleeping_lock_inc();
 			stop_one_cpu(task_cpu(p), migration_cpu_stop, &arg);
+			sleeping_lock_dec();

this looks like an ugly hack. This sleeping_lock_inc() is used where we actually hold a sleeping lock and schedule() which is okay. But this would mean we hold a RCU lock and schedule() anyway. Is that okay?

Quoted 7 lines

Perhaps the name should be changed, but the concept is the same -- RT- specific sleeping which should be considered involuntary for the purpose of debug checks. Voluntary sleeping is not allowed in an RCU critical section because it will break the critical section on certain flavors of RCU, but that doesn't apply to the flavor used on RT. Sleeping for a long time in an RCU critical section would also be a bad thing, but that also doesn't apply here.

I think the name should definitely be changed. At best, it is super confusing to call it "sleeping_lock" for this scenario. In fact here, you are not even blocking on a lock.

Maybe "sleeping_allowed" or some such.

thanks,

- Joel

#21 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 15 lines · Joel Fernandes
Quoted 6 lines · Scott Wood
Quoted 4 lines · Sebastian Andrzej Siewior

this looks like an ugly hack. This sleeping_lock_inc() is used where we actually hold a sleeping lock and schedule() which is okay. But this would mean we hold a RCU lock and schedule() anyway. Is that okay?

Quoted 7 lines

Perhaps the name should be changed, but the concept is the same -- RT- specific sleeping which should be considered involuntary for the purpose of debug checks. Voluntary sleeping is not allowed in an RCU critical section because it will break the critical section on certain flavors of RCU, but that doesn't apply to the flavor used on RT. Sleeping for a long time in an RCU critical section would also be a bad thing, but that also doesn't apply here.

Quoted 5 lines

I think the name should definitely be changed. At best, it is super confusing to call it "sleeping_lock" for this scenario. In fact here, you are not even blocking on a lock.

Maybe "sleeping_allowed" or some such.

The mechanism that is used here may change in future. I just wanted to make sure that from RCU's side it is okay to schedule here.

Quoted 3 lines

thanks,

- Joel

Sebastian

#22 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 16 lines · Sebastian Andrzej Siewior
Quoted 15 lines · Joel Fernandes
Quoted 13 lines · Scott Wood
Quoted 4 lines · Sebastian Andrzej Siewior

this looks like an ugly hack. This sleeping_lock_inc() is used where we actually hold a sleeping lock and schedule() which is okay. But this would mean we hold a RCU lock and schedule() anyway. Is that okay?

Perhaps the name should be changed, but the concept is the same -- RT- specific sleeping which should be considered involuntary for the purpose of debug checks. Voluntary sleeping is not allowed in an RCU critical section because it will break the critical section on certain flavors of RCU, but that doesn't apply to the flavor used on RT. Sleeping for a long time in an RCU critical section would also be a bad thing, but that also doesn't apply here.

Quoted 8 lines
Quoted 5 lines

I think the name should definitely be changed. At best, it is super confusing to call it "sleeping_lock" for this scenario. In fact here, you are not even blocking on a lock.

Maybe "sleeping_allowed" or some such.

The mechanism that is used here may change in future. I just wanted to make sure that from RCU's side it is okay to schedule here.

Good point.

The effect from RCU's viewpoint will be to split any non-rcu_read_lock() RCU read-side critical section at this point. This alrady happens in a few places, for example, rcu_note_context_switch() constitutes an RCU quiescent state despite being invoked with interrupts disabled (as is required!). The __schedule() function just needs to understand (and does understand) that the RCU read-side critical section that would otherwise span that call to rcu_node_context_switch() is split in two by that call.

However, if this was instead an rcu_read_lock() critical section within a PREEMPT=y kernel, then if a schedule() occured within stop_one_task(), RCU would consider that critical section to be preempted. This means that any RCU grace period that is blocked by this RCU read-side critical section would remain blocked until stop_one_cpu() resumed, returned, and so on until the matching rcu_read_unlock() was reached. In other words, RCU would consider that RCU read-side critical section to span the call to stop_one_cpu() even if stop_one_cpu() invoked schedule().

On the other hand, within a PREEMPT=n kernel, the call to schedule() would split even an rcu_read_lock() critical section. Which is why I asked earlier if sleeping_lock_inc() and sleeping_lock_dec() are no-ops in !PREEMPT_RT_BASE kernels. We would after all want the usual lockdep complaints in that case.

Does that help, or am I missing the point?

Thanx, Paul

author
#23 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 54 lines · Paul E. McKenney
Quoted 29 lines · Sebastian Andrzej Siewior
Quoted 28 lines · Joel Fernandes
Quoted 7 lines · Scott Wood
Quoted 5 lines · Sebastian Andrzej Siewior

this looks like an ugly hack. This sleeping_lock_inc() is used where we
actually hold a sleeping lock and schedule() which is okay. But this
would mean we hold a RCU lock and schedule() anyway. Is that okay?

Quoted 13 lines

Perhaps the name should be changed, but the concept is the same -- RT-
specific sleeping which should be considered involuntary for the purpose of
debug checks. Voluntary sleeping is not allowed in an RCU critical section
because it will break the critical section on certain flavors of RCU, but
that doesn't apply to the flavor used on RT. Sleeping for a long time in an
RCU critical section would also be a bad thing, but that also doesn't apply
here.

I think the name should definitely be changed. At best, it is super confusing to
call it "sleeping_lock" for this scenario. In fact here, you are not even
blocking on a lock.

Quoted 4 lines
Quoted 1 line

Maybe "sleeping_allowed" or some such.

The mechanism that is used here may change in future. I just wanted to make sure that from RCU's side it is okay to schedule here.

Good point.

The effect from RCU's viewpoint will be to split any non-rcu_read_lock() RCU read-side critical section at this point. This alrady happens in a few places, for example, rcu_note_context_switch() constitutes an RCU quiescent state despite being invoked with interrupts disabled (as is required!). The __schedule() function just needs to understand (and does understand) that the RCU read-side critical section that would otherwise span that call to rcu_node_context_switch() is split in two by that call.

However, if this was instead an rcu_read_lock() critical section within a PREEMPT=y kernel, then if a schedule() occured within stop_one_task(), RCU would consider that critical section to be preempted. This means that any RCU grace period that is blocked by this RCU read-side critical section would remain blocked until stop_one_cpu() resumed, returned, and so on until the matching rcu_read_unlock() was reached. In other words, RCU would consider that RCU read-side critical section to span the call to stop_one_cpu() even if stop_one_cpu() invoked schedule().

Quoted 5 lines

On the other hand, within a PREEMPT=n kernel, the call to schedule() would split even an rcu_read_lock() critical section. Which is why I asked earlier if sleeping_lock_inc() and sleeping_lock_dec() are no-ops in !PREEMPT_RT_BASE kernels. We would after all want the usual lockdep complaints in that case.

migrate_enable() is PREEMPT_RT_BASE-specific -- this code won't execute at all with PREEMPT=n.

-Scott

#24 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 55 lines · Scott Wood
Quoted 54 lines · Paul E. McKenney
Quoted 29 lines · Sebastian Andrzej Siewior
Quoted 28 lines · Joel Fernandes
Quoted 7 lines · Scott Wood
Quoted 5 lines · Sebastian Andrzej Siewior

this looks like an ugly hack. This sleeping_lock_inc() is used where we
actually hold a sleeping lock and schedule() which is okay. But this
would mean we hold a RCU lock and schedule() anyway. Is that okay?

Quoted 13 lines

Perhaps the name should be changed, but the concept is the same -- RT-
specific sleeping which should be considered involuntary for the purpose of
debug checks. Voluntary sleeping is not allowed in an RCU critical section
because it will break the critical section on certain flavors of RCU, but
that doesn't apply to the flavor used on RT. Sleeping for a long time in an
RCU critical section would also be a bad thing, but that also doesn't apply
here.

I think the name should definitely be changed. At best, it is super confusing to
call it "sleeping_lock" for this scenario. In fact here, you are not even
blocking on a lock.

Quoted 4 lines
Quoted 1 line

Maybe "sleeping_allowed" or some such.

The mechanism that is used here may change in future. I just wanted to make sure that from RCU's side it is okay to schedule here.

Good point.

The effect from RCU's viewpoint will be to split any non-rcu_read_lock() RCU read-side critical section at this point. This alrady happens in a few places, for example, rcu_note_context_switch() constitutes an RCU quiescent state despite being invoked with interrupts disabled (as is required!). The __schedule() function just needs to understand (and does understand) that the RCU read-side critical section that would otherwise span that call to rcu_node_context_switch() is split in two by that call.

However, if this was instead an rcu_read_lock() critical section within a PREEMPT=y kernel, then if a schedule() occured within stop_one_task(), RCU would consider that critical section to be preempted. This means that any RCU grace period that is blocked by this RCU read-side critical section would remain blocked until stop_one_cpu() resumed, returned, and so on until the matching rcu_read_unlock() was reached. In other words, RCU would consider that RCU read-side critical section to span the call to stop_one_cpu() even if stop_one_cpu() invoked schedule().

Quoted 8 lines
Quoted 5 lines

On the other hand, within a PREEMPT=n kernel, the call to schedule() would split even an rcu_read_lock() critical section. Which is why I asked earlier if sleeping_lock_inc() and sleeping_lock_dec() are no-ops in !PREEMPT_RT_BASE kernels. We would after all want the usual lockdep complaints in that case.

migrate_enable() is PREEMPT_RT_BASE-specific -- this code won't execute at all with PREEMPT=n.

Understood! And yes, that was your answer to my question. Me, I was just answering Sebastian's question. ;-)

Thanx, Paul

#25 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

In reply to Paul E. McKenney
Quoted 5 lines · Paul E. McKenney
Quoted 2 lines

The mechanism that is used here may change in future. I just wanted to make sure that from RCU's side it is okay to schedule here.

Good point.

Quoted 7 lines

The effect from RCU's viewpoint will be to split any non-rcu_read_lock() RCU read-side critical section at this point. This alrady happens in a few places, for example, rcu_note_context_switch() constitutes an RCU quiescent state despite being invoked with interrupts disabled (as is required!). The __schedule() function just needs to understand (and does understand) that the RCU read-side critical section that would otherwise span that call to rcu_node_context_switch() is split in two by that call.

Okay. So I read this as invoking schedule() at this point is okay. Looking at this again, this could also happen on a PREEMPT=y kernel if the kernel decides to preempt a task within a rcu_read_lock() section and put it back later on another CPU.

Quoted 8 lines

However, if this was instead an rcu_read_lock() critical section within a PREEMPT=y kernel, then if a schedule() occured within stop_one_task(), RCU would consider that critical section to be preempted. This means that any RCU grace period that is blocked by this RCU read-side critical section would remain blocked until stop_one_cpu() resumed, returned, and so on until the matching rcu_read_unlock() was reached. In other words, RCU would consider that RCU read-side critical section to span the call to stop_one_cpu() even if stop_one_cpu() invoked schedule().

Isn't that my example from above and what we do in RT? My understanding is that this is the reason why we need BOOST on RT otherwise the RCU critical section could remain blocked for some time.

Quoted 5 lines

On the other hand, within a PREEMPT=n kernel, the call to schedule() would split even an rcu_read_lock() critical section. Which is why I asked earlier if sleeping_lock_inc() and sleeping_lock_dec() are no-ops in !PREEMPT_RT_BASE kernels. We would after all want the usual lockdep complaints in that case.

sleeping_lock_inc() +dec() is only RT specific. It is part of RT's spin_lock() implementation and used by RCU (rcu_note_context_switch()) to not complain if invoked within a critical section.

Quoted 3 lines

Does that help, or am I missing the point?

Thanx, Paul

Sebastian

#26 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

On Tue, Aug 27, 2019 at 11:23:33AM +0200, Sebastian Andrzej Siewior wrote:
[snip]

Quoted 9 lines
Quoted 8 lines

However, if this was instead an rcu_read_lock() critical section within a PREEMPT=y kernel, then if a schedule() occured within stop_one_task(), RCU would consider that critical section to be preempted. This means that any RCU grace period that is blocked by this RCU read-side critical section would remain blocked until stop_one_cpu() resumed, returned, and so on until the matching rcu_read_unlock() was reached. In other words, RCU would consider that RCU read-side critical section to span the call to stop_one_cpu() even if stop_one_cpu() invoked schedule().

Quoted 3 lines

Isn't that my example from above and what we do in RT? My understanding is that this is the reason why we need BOOST on RT otherwise the RCU critical section could remain blocked for some time.

Not just for boost, it is needed to block the grace period itself on PREEMPT=y. On PREEMPT=y, if rcu_note_context_switch() happens in middle of a rcu_read_lock() reader section, then the task is added to a blocked list (rcu_preempt_ctxt_queue). Then just after that, the CPU reports a QS state (rcu_qs()) as you can see in the PREEMPT=y implementation of rcu_note_context_switch(). Even though the CPU has reported a QS, the grace period will not end because the preempted (or block as could be in -rt) task is still blocking the grace period. This is fundamental to the function of Preemptible-RCU where there is the concept of tasks blocking a grace period, not just CPUs.

I think what Paul is trying to explain AIUI (Paul please let me know if I missed something):

(1) Anyone calling rcu_note_context_switch() and expecting it to respect RCU-readers that are readers as a result of interrupt disabled regions, have incorrect expectations. So calling rcu_note_context_switch() has to be done carefully.

(2) Disabling interrupts is "generally" implied as an RCU-sched flavor reader. However, invoking rcu_note_context_switch() from a disabled interrupt region is *required* for rcu_note_context_switch() to work correctly.

(3) On PREEMPT=y kernels, invoking rcu_note_context_switch() from an interrupt disabled region does not mean that that the task will be added to a blocked list (unless it is also in an RCU-preempt reader) so rcu_note_context_switch() may immediately report a quiescent state and nothing blockings the grace period.
So callers of rcu_note_context_switch() must be aware of this behavior.

(4) On PREEMPT=n, unlike PREEMPT=y, there is no blocked list handling and so nothing will block the grace period once rcu_note_context_switch() is called. So any path calling rcu_note_context_switch() on a PREEMPT=n kernel, in the middle of something that is expected to be an RCU reader would be really bad from an RCU view point.

Probably, we should add this all to documentation somewhere.

thanks!

- Joel

Quoted 14 lines
Quoted 5 lines

On the other hand, within a PREEMPT=n kernel, the call to schedule() would split even an rcu_read_lock() critical section. Which is why I asked earlier if sleeping_lock_inc() and sleeping_lock_dec() are no-ops in !PREEMPT_RT_BASE kernels. We would after all want the usual lockdep complaints in that case.

sleeping_lock_inc() +dec() is only RT specific. It is part of RT's spin_lock() implementation and used by RCU (rcu_note_context_switch()) to not complain if invoked within a critical section.

Quoted 3 lines

Does that help, or am I missing the point?

Thanx, Paul

Sebastian

maintainer
#27 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 45 lines · Joel Fernandes

On Tue, Aug 27, 2019 at 11:23:33AM +0200, Sebastian Andrzej Siewior wrote:
[snip]

Quoted 9 lines
Quoted 8 lines

However, if this was instead an rcu_read_lock() critical section within a PREEMPT=y kernel, then if a schedule() occured within stop_one_task(), RCU would consider that critical section to be preempted. This means that any RCU grace period that is blocked by this RCU read-side critical section would remain blocked until stop_one_cpu() resumed, returned, and so on until the matching rcu_read_unlock() was reached. In other words, RCU would consider that RCU read-side critical section to span the call to stop_one_cpu() even if stop_one_cpu() invoked schedule().

Quoted 3 lines

Isn't that my example from above and what we do in RT? My understanding is that this is the reason why we need BOOST on RT otherwise the RCU critical section could remain blocked for some time.

Not just for boost, it is needed to block the grace period itself on PREEMPT=y. On PREEMPT=y, if rcu_note_context_switch() happens in middle of a rcu_read_lock() reader section, then the task is added to a blocked list (rcu_preempt_ctxt_queue). Then just after that, the CPU reports a QS state (rcu_qs()) as you can see in the PREEMPT=y implementation of rcu_note_context_switch(). Even though the CPU has reported a QS, the grace period will not end because the preempted (or block as could be in -rt) task is still blocking the grace period. This is fundamental to the function of Preemptible-RCU where there is the concept of tasks blocking a grace period, not just CPUs.

I think what Paul is trying to explain AIUI (Paul please let me know if I missed something):

(1) Anyone calling rcu_note_context_switch() and expecting it to respect RCU-readers that are readers as a result of interrupt disabled regions, have incorrect expectations. So calling rcu_note_context_switch() has to be done carefully.

(2) Disabling interrupts is "generally" implied as an RCU-sched flavor reader. However, invoking rcu_note_context_switch() from a disabled interrupt region is *required* for rcu_note_context_switch() to work correctly.

(3) On PREEMPT=y kernels, invoking rcu_note_context_switch() from an interrupt disabled region does not mean that that the task will be added to a blocked list (unless it is also in an RCU-preempt reader) so rcu_note_context_switch() may immediately report a quiescent state and nothing blockings the grace period.
So callers of rcu_note_context_switch() must be aware of this behavior.

Quoted 7 lines

(4) On PREEMPT=n, unlike PREEMPT=y, there is no blocked list handling and so nothing will block the grace period once rcu_note_context_switch() is called. So any path calling rcu_note_context_switch() on a PREEMPT=n kernel, in the middle of something that is expected to be an RCU reader would be really bad from an RCU view point.

Probably, we should add this all to documentation somewhere.

I think that Sebastian understands this and was using the example of RCU priority boosting to confirm his understanding. But documentation would be good. Extremely difficult to keep current, but good. I believe that the requirements document does cover this.

Thanx, Paul

Quoted 19 lines

thanks!

- Joel

Quoted 14 lines
Quoted 5 lines

On the other hand, within a PREEMPT=n kernel, the call to schedule() would split even an rcu_read_lock() critical section. Which is why I asked earlier if sleeping_lock_inc() and sleeping_lock_dec() are no-ops in !PREEMPT_RT_BASE kernels. We would after all want the usual lockdep complaints in that case.

sleeping_lock_inc() +dec() is only RT specific. It is part of RT's spin_lock() implementation and used by RCU (rcu_note_context_switch()) to not complain if invoked within a critical section.

Quoted 3 lines

Does that help, or am I missing the point?

Thanx, Paul

Sebastian

#28 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 52 lines · Paul E. McKenney
Quoted 51 lines · Joel Fernandes

On Tue, Aug 27, 2019 at 11:23:33AM +0200, Sebastian Andrzej Siewior wrote:
[snip]

Quoted 9 lines
Quoted 8 lines

However, if this was instead an rcu_read_lock() critical section within a PREEMPT=y kernel, then if a schedule() occured within stop_one_task(), RCU would consider that critical section to be preempted. This means that any RCU grace period that is blocked by this RCU read-side critical section would remain blocked until stop_one_cpu() resumed, returned, and so on until the matching rcu_read_unlock() was reached. In other words, RCU would consider that RCU read-side critical section to span the call to stop_one_cpu() even if stop_one_cpu() invoked schedule().

Quoted 3 lines

Isn't that my example from above and what we do in RT? My understanding is that this is the reason why we need BOOST on RT otherwise the RCU critical section could remain blocked for some time.

Not just for boost, it is needed to block the grace period itself on PREEMPT=y. On PREEMPT=y, if rcu_note_context_switch() happens in middle of a rcu_read_lock() reader section, then the task is added to a blocked list (rcu_preempt_ctxt_queue). Then just after that, the CPU reports a QS state (rcu_qs()) as you can see in the PREEMPT=y implementation of rcu_note_context_switch(). Even though the CPU has reported a QS, the grace period will not end because the preempted (or block as could be in -rt) task is still blocking the grace period. This is fundamental to the function of Preemptible-RCU where there is the concept of tasks blocking a grace period, not just CPUs.

I think what Paul is trying to explain AIUI (Paul please let me know if I missed something):

(1) Anyone calling rcu_note_context_switch() and expecting it to respect RCU-readers that are readers as a result of interrupt disabled regions, have incorrect expectations. So calling rcu_note_context_switch() has to be done carefully.

(2) Disabling interrupts is "generally" implied as an RCU-sched flavor reader. However, invoking rcu_note_context_switch() from a disabled interrupt region is *required* for rcu_note_context_switch() to work correctly.

(3) On PREEMPT=y kernels, invoking rcu_note_context_switch() from an interrupt disabled region does not mean that that the task will be added to a blocked list (unless it is also in an RCU-preempt reader) so rcu_note_context_switch() may immediately report a quiescent state and nothing blockings the grace period.
So callers of rcu_note_context_switch() must be aware of this behavior.

(4) On PREEMPT=n, unlike PREEMPT=y, there is no blocked list handling and so nothing will block the grace period once rcu_note_context_switch() is called. So any path calling rcu_note_context_switch() on a PREEMPT=n kernel, in the middle of something that is expected to be an RCU reader would be really bad from an RCU view point.

Quoted 6 lines
Quoted 1 line

Probably, we should add this all to documentation somewhere.

I think that Sebastian understands this and was using the example of RCU priority boosting to confirm his understanding. But documentation would be good. Extremely difficult to keep current, but good. I believe that the requirements document does cover this.

Oh ok, got it. Sorry about the noise then!

(In a way, I was just thinking out loud since this is a slightly confusing
topic :-P and an archive link to this discussion serves a great purpose in my notes :-D :-)).

thanks!

- Joel

maintainer
#29 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

In reply to Sebastian Andrzej Siewior
Quoted 14 lines · Sebastian Andrzej Siewior
Quoted 5 lines · Paul E. McKenney
Quoted 2 lines

The mechanism that is used here may change in future. I just wanted to make sure that from RCU's side it is okay to schedule here.

Good point.

Quoted 7 lines

The effect from RCU's viewpoint will be to split any non-rcu_read_lock() RCU read-side critical section at this point. This alrady happens in a few places, for example, rcu_note_context_switch() constitutes an RCU quiescent state despite being invoked with interrupts disabled (as is required!). The __schedule() function just needs to understand (and does understand) that the RCU read-side critical section that would otherwise span that call to rcu_node_context_switch() is split in two by that call.

Quoted 1 line

Okay. So I read this as invoking schedule() at this point is okay.

As long as no one is relying on a non-rcu_read_lock() RCU read-side critical section (local_bh_disable(), preempt_disable(), local_irq_disable(), ...) spanning this call. But that depends on the calling code and on other code it interacts with it, not on any specific need on the part of RCU itself.

Quoted 3 lines

Looking at this again, this could also happen on a PREEMPT=y kernel if the kernel decides to preempt a task within a rcu_read_lock() section and put it back later on another CPU.

This is an rcu_read_lock() critical section, so yes, on a PREEMPT=y kernel, executing schedule() will cause the corresponding RCU read-side critical section to persist, following the preempted tasks. Give or take lockdep complaints.

On a PREEMPT=n kernel, schedule() within an RCU read-side critical section instead results in that critical section being split in two. And this will also results in lockdep complaints.

Quoted 9 lines
Quoted 8 lines

However, if this was instead an rcu_read_lock() critical section within a PREEMPT=y kernel, then if a schedule() occured within stop_one_task(), RCU would consider that critical section to be preempted. This means that any RCU grace period that is blocked by this RCU read-side critical section would remain blocked until stop_one_cpu() resumed, returned, and so on until the matching rcu_read_unlock() was reached. In other words, RCU would consider that RCU read-side critical section to span the call to stop_one_cpu() even if stop_one_cpu() invoked schedule().

Quoted 3 lines

Isn't that my example from above and what we do in RT? My understanding is that this is the reason why we need BOOST on RT otherwise the RCU critical section could remain blocked for some time.

At this point, I must confess that I have lost track of whose example it is. It was first reported in 2006, if I remember correctly. ;-)

But yes, you are correct, the point of RCU priority boosting is to cause tasks that have been preempted while within RCU read-side critical sections to be scheduled so that they can reach their rcu_read_unlock() calls, thus allowing the current grace period to end.

Quoted 9 lines
Quoted 5 lines

On the other hand, within a PREEMPT=n kernel, the call to schedule() would split even an rcu_read_lock() critical section. Which is why I asked earlier if sleeping_lock_inc() and sleeping_lock_dec() are no-ops in !PREEMPT_RT_BASE kernels. We would after all want the usual lockdep complaints in that case.

sleeping_lock_inc() +dec() is only RT specific. It is part of RT's spin_lock() implementation and used by RCU (rcu_note_context_switch()) to not complain if invoked within a critical section.

Then this is being called when we have something like this, correct?

	DEFINE_SPINLOCK(mylock); // As opposed to DEFINE_RAW_SPINLOCK().

	...

	rcu_read_lock();
	do_something();
	spin_lock(&mylock); // Can block in -rt, thus needs sleeping_lock_inc()
	...
	rcu_read_unlock();

Without sleeping_lock_inc(), lockdep would complain about a voluntary schedule within an RCU read-side critical section. But in -rt, voluntary schedules due to sleeping on a "spinlock" are OK.

Am I understanding this correctly?

Thanx, Paul

#30 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 22 lines · Paul E. McKenney
Quoted 9 lines
Quoted 5 lines

On the other hand, within a PREEMPT=n kernel, the call to schedule() would split even an rcu_read_lock() critical section. Which is why I asked earlier if sleeping_lock_inc() and sleeping_lock_dec() are no-ops in !PREEMPT_RT_BASE kernels. We would after all want the usual lockdep complaints in that case.

sleeping_lock_inc() +dec() is only RT specific. It is part of RT's spin_lock() implementation and used by RCU (rcu_note_context_switch()) to not complain if invoked within a critical section.

Then this is being called when we have something like this, correct?

	DEFINE_SPINLOCK(mylock); // As opposed to DEFINE_RAW_SPINLOCK().

	...

	rcu_read_lock();
	do_something();
	spin_lock(&mylock); // Can block in -rt, thus needs sleeping_lock_inc()
	...
	rcu_read_unlock();
Quoted 5 lines

Without sleeping_lock_inc(), lockdep would complain about a voluntary schedule within an RCU read-side critical section. But in -rt, voluntary schedules due to sleeping on a "spinlock" are OK.

Am I understanding this correctly?

Everything perfect except that it is not lockdep complaining but the WARN_ON_ONCE() in rcu_note_context_switch().

Quoted 2 lines

Thanx, Paul

Sebastian

maintainer
#31 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 23 lines · Sebastian Andrzej Siewior
Quoted 22 lines · Paul E. McKenney
Quoted 9 lines
Quoted 5 lines

On the other hand, within a PREEMPT=n kernel, the call to schedule() would split even an rcu_read_lock() critical section. Which is why I asked earlier if sleeping_lock_inc() and sleeping_lock_dec() are no-ops in !PREEMPT_RT_BASE kernels. We would after all want the usual lockdep complaints in that case.

sleeping_lock_inc() +dec() is only RT specific. It is part of RT's spin_lock() implementation and used by RCU (rcu_note_context_switch()) to not complain if invoked within a critical section.

Then this is being called when we have something like this, correct?

	DEFINE_SPINLOCK(mylock); // As opposed to DEFINE_RAW_SPINLOCK().

	...

	rcu_read_lock();
	do_something();
	spin_lock(&mylock); // Can block in -rt, thus needs sleeping_lock_inc()
	...
	rcu_read_unlock();
Quoted 8 lines
Quoted 5 lines

Without sleeping_lock_inc(), lockdep would complain about a voluntary schedule within an RCU read-side critical section. But in -rt, voluntary schedules due to sleeping on a "spinlock" are OK.

Am I understanding this correctly?

Everything perfect except that it is not lockdep complaining but the WARN_ON_ONCE() in rcu_note_context_switch().

This one, right?

	WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0);

Another approach would be to change that WARN_ON_ONCE(). This fix might be too extreme, as it would suppress other issues:

	WARN_ON_ONCE(IS_ENABLED(CONFIG_PREEMPT_RT_BASE) && !preempt && t->rcu_read_lock_nesting > 0);

But maybe what is happening under the covers is that preempt is being set when sleeping on a spinlock. Is that the case?

Thanx, Paul

#32 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 11 lines · Paul E. McKenney
Quoted 5 lines · Sebastian Andrzej Siewior
Quoted 1 line · Paul E. McKenney

Am I understanding this correctly?

Everything perfect except that it is not lockdep complaining but the WARN_ON_ONCE() in rcu_note_context_switch().

This one, right?

	WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0);
Quoted 7 lines

Another approach would be to change that WARN_ON_ONCE(). This fix might be too extreme, as it would suppress other issues:

	WARN_ON_ONCE(IS_ENABLED(CONFIG_PREEMPT_RT_BASE) && !preempt && t->rcu_read_lock_nesting > 0);

But maybe what is happening under the covers is that preempt is being set when sleeping on a spinlock. Is that the case?

I would like to keep that check and that is why we have:

|   #if defined(CONFIG_PREEMPT_RT_FULL)
|         sleeping_l = t->sleeping_lock;
|   #endif
|         WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0 && !sleeping_l);

in -RT and ->sleeping_lock is that counter that is incremented in spin_lock(). And the only reason why sleeping_lock_inc() was used in the patch was to disable _this_ warning.

Quoted 1 line

Thanx, Paul

Sebastian

#33 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 22 lines · Sebastian Andrzej Siewior
Quoted 11 lines · Paul E. McKenney
Quoted 5 lines · Sebastian Andrzej Siewior
Quoted 1 line · Paul E. McKenney

Am I understanding this correctly?

Everything perfect except that it is not lockdep complaining but the WARN_ON_ONCE() in rcu_note_context_switch().

This one, right?

	WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0);
Quoted 7 lines

Another approach would be to change that WARN_ON_ONCE(). This fix might be too extreme, as it would suppress other issues:

	WARN_ON_ONCE(IS_ENABLED(CONFIG_PREEMPT_RT_BASE) && !preempt && t->rcu_read_lock_nesting > 0);

But maybe what is happening under the covers is that preempt is being set when sleeping on a spinlock. Is that the case?

I would like to keep that check and that is why we have:

Quoted 8 lines
|   #if defined(CONFIG_PREEMPT_RT_FULL)
|         sleeping_l = t->sleeping_lock;
|   #endif
|         WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0 && !sleeping_l);

in -RT and ->sleeping_lock is that counter that is incremented in spin_lock(). And the only reason why sleeping_lock_inc() was used in the patch was to disable _this_ warning.

Makes sense, Sebastian.

Paul, you meant "!" in front of the IS_ENABLED right in your code snippet right?

The other issue with:
WARN_ON_ONCE(!IS_ENABLED(CONFIG_PREEMPT_RT_BASE) && !preempt && t->rcu_read_lock_nesting > 0);

.. could be that, the warning will be disabled for -rt entirely, not just for sleeping locks. And we probably do want to keep this warning for the cases in -rt where we are blocking but it is not a sleeping lock. Right?

thanks,

- Joel

maintainer
#34 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

Quoted 34 lines · Joel Fernandes
Quoted 22 lines · Sebastian Andrzej Siewior
Quoted 11 lines · Paul E. McKenney
Quoted 5 lines · Sebastian Andrzej Siewior
Quoted 1 line · Paul E. McKenney

Am I understanding this correctly?

Everything perfect except that it is not lockdep complaining but the WARN_ON_ONCE() in rcu_note_context_switch().

This one, right?

	WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0);
Quoted 7 lines

Another approach would be to change that WARN_ON_ONCE(). This fix might be too extreme, as it would suppress other issues:

	WARN_ON_ONCE(IS_ENABLED(CONFIG_PREEMPT_RT_BASE) && !preempt && t->rcu_read_lock_nesting > 0);

But maybe what is happening under the covers is that preempt is being set when sleeping on a spinlock. Is that the case?

I would like to keep that check and that is why we have:

Quoted 8 lines
|   #if defined(CONFIG_PREEMPT_RT_FULL)
|         sleeping_l = t->sleeping_lock;
|   #endif
|         WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0 && !sleeping_l);

in -RT and ->sleeping_lock is that counter that is incremented in spin_lock(). And the only reason why sleeping_lock_inc() was used in the patch was to disable _this_ warning.

Makes sense, Sebastian.

Quoted 8 lines

Paul, you meant "!" in front of the IS_ENABLED right in your code snippet right?

The other issue with:
WARN_ON_ONCE(!IS_ENABLED(CONFIG_PREEMPT_RT_BASE) && !preempt && t->rcu_read_lock_nesting > 0);

.. could be that, the warning will be disabled for -rt entirely, not just for sleeping locks. And we probably do want to keep this warning for the cases in -rt where we are blocking but it is not a sleeping lock. Right?

Yes, my code was missing a "!", but I prefer Sebastian's and Scott's approach to mine anyway. ;-)

Thanx, Paul

maintainer
#35 lore raw

Re: [PATCH RT v2 2/3] sched: migrate_enable: Use sleeping_lock to indicate involuntary sleep

In reply to Sebastian Andrzej Siewior
Quoted 22 lines · Sebastian Andrzej Siewior
Quoted 11 lines · Paul E. McKenney
Quoted 5 lines · Sebastian Andrzej Siewior
Quoted 1 line · Paul E. McKenney

Am I understanding this correctly?

Everything perfect except that it is not lockdep complaining but the WARN_ON_ONCE() in rcu_note_context_switch().

This one, right?

	WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0);
Quoted 7 lines

Another approach would be to change that WARN_ON_ONCE(). This fix might be too extreme, as it would suppress other issues:

	WARN_ON_ONCE(IS_ENABLED(CONFIG_PREEMPT_RT_BASE) && !preempt && t->rcu_read_lock_nesting > 0);

But maybe what is happening under the covers is that preempt is being set when sleeping on a spinlock. Is that the case?

I would like to keep that check and that is why we have:

Quoted 8 lines
|   #if defined(CONFIG_PREEMPT_RT_FULL)
|         sleeping_l = t->sleeping_lock;
|   #endif
|         WARN_ON_ONCE(!preempt && t->rcu_read_lock_nesting > 0 && !sleeping_l);

in -RT and ->sleeping_lock is that counter that is incremented in spin_lock(). And the only reason why sleeping_lock_inc() was used in the patch was to disable _this_ warning.

Very good! I would prefer an (one-line) access function to keep the number of #if uses down to dull roar, but other than that, looks good!

(Yeah, I know, this is tree_preempt.h, but still...)

Thanx, Paul

author
#36 lore raw

PATCH v2 3/3 rcu: Disable use_softirq on PREEMPT_RT

In reply to Scott Wood

Besides restoring behavior that used to be default on RT, this avoids a deadlock on scheduler locks:

[  136.894657] 039: ============================================
[  136.900401] 039: WARNING: possible recursive locking detected
[  136.906146] 039: 5.2.9-rt3.dbg+ #174 Tainted: G            E
[  136.912152] 039: --------------------------------------------
[  136.917896] 039: rcu_torture_rea/13474 is trying to acquire lock:
[  136.923990] 039: 000000005f25146d
[  136.927310] 039:  (
[  136.929414] 039: &p->pi_lock
[  136.932303] 039: ){-...}
[  136.934840] 039: , at: try_to_wake_up+0x39/0x920
[  136.939461] 039:
but task is already holding lock:
[  136.944425] 039: 000000005f25146d
[  136.947745] 039:  (
[  136.949852] 039: &p->pi_lock
[  136.952738] 039: ){-...}
[  136.955274] 039: , at: try_to_wake_up+0x39/0x920
[  136.959895] 039:
other info that might help us debug this:
[  136.965555] 039:  Possible unsafe locking scenario:
[  136.970608] 039:        CPU0
[  136.973493] 039:        ----
[  136.976378] 039:   lock(
[  136.978918] 039: &p->pi_lock
[  136.981806] 039: );
[  136.983911] 039:   lock(
[  136.986451] 039: &p->pi_lock
[  136.989336] 039: );
[  136.991444] 039:
 *** DEADLOCK ***
[  136.995194] 039:  May be due to missing lock nesting notation
[  137.001115] 039: 3 locks held by rcu_torture_rea/13474:
[  137.006341] 039:  #0:
[  137.008707] 039: 000000005f25146d
[  137.012024] 039:  (
[  137.014131] 039: &p->pi_lock
[  137.017015] 039: ){-...}
[  137.019558] 039: , at: try_to_wake_up+0x39/0x920
[  137.024175] 039:  #1:
[  137.026540] 039: 0000000011c8e51d
[  137.029859] 039:  (
[  137.031966] 039: &rq->lock
[  137.034679] 039: ){-...}
[  137.037217] 039: , at: try_to_wake_up+0x241/0x920
[  137.041924] 039:  #2:
[  137.044291] 039: 00000000098649b9
[  137.047610] 039:  (
[  137.049714] 039: rcu_read_lock
[  137.052774] 039: ){....}
[  137.055314] 039: , at: cpuacct_charge+0x33/0x1e0
[  137.059934] 039:
stack backtrace:
[  137.063425] 039: CPU: 39 PID: 13474 Comm: rcu_torture_rea Kdump: loaded Tainted: G            E     5.2.9-rt3.dbg+ #174
[  137.074197] 039: Hardware name: Intel Corporation S2600BT/S2600BT, BIOS SE5C620.86B.01.00.0763.022420181017 02/24/2018
[  137.084886] 039: Call Trace:
[  137.087773] 039:  <IRQ>
[  137.090226] 039:  dump_stack+0x5e/0x8b
[  137.093997] 039:  __lock_acquire+0x725/0x1100
[  137.098358] 039:  lock_acquire+0xc0/0x240
[  137.102374] 039:  ? try_to_wake_up+0x39/0x920
[  137.106737] 039:  _raw_spin_lock_irqsave+0x47/0x90
[  137.111534] 039:  ? try_to_wake_up+0x39/0x920
[  137.115910] 039:  try_to_wake_up+0x39/0x920
[  137.120098] 039:  rcu_read_unlock_special+0x65/0xb0
[  137.124977] 039:  __rcu_read_unlock+0x5d/0x70
[  137.129337] 039:  cpuacct_charge+0xd9/0x1e0
[  137.133522] 039:  ? cpuacct_charge+0x33/0x1e0
[  137.137880] 039:  update_curr+0x14b/0x420
[  137.141894] 039:  enqueue_entity+0x42/0x370
[  137.146080] 039:  enqueue_task_fair+0xa9/0x490
[  137.150528] 039:  activate_task+0x5a/0xf0
[  137.154539] 039:  ttwu_do_activate+0x4e/0x90
[  137.158813] 039:  try_to_wake_up+0x277/0x920
[  137.163086] 039:  irq_exit+0xb6/0xf0
[  137.166661] 039:  smp_apic_timer_interrupt+0xe3/0x3a0
[  137.171714] 039:  apic_timer_interrupt+0xf/0x20
[  137.176249] 039:  </IRQ>
[  137.178785] 039: RIP: 0010:__schedule+0x0/0x8e0
[  137.183319] 039: Code: 00 02 48 89 43 20 e8 0f 5a 00 00 48 8d 7b 28 e8 86 f2 fd ff 31 c0 5b 5d 41 5c c3 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 <55> 48 89 e5 41 57 41 56 49 c7 c6 c0 ca 1e 00 41 55 41 89 fd 41 54
[  137.202498] 039: RSP: 0018:ffffc9005835fbc0 EFLAGS: 00000246
[  137.208158] 039:  ORIG_RAX: ffffffffffffff13
[  137.212428] 039: RAX: 0000000000000000 RBX: ffff8897c3e1bb00 RCX: 0000000000000001
[  137.219994] 039: RDX: 0000000080004008 RSI: 0000000000000006 RDI: 0000000000000001
[  137.227560] 039: RBP: ffff8897c3e1bb00 R08: 0000000000000000 R09: 0000000000000000
[  137.235126] 039: R10: 0000000000000001 R11: 0000000000000001 R12: ffffffff81001fd1
[  137.242694] 039: R13: 0000000000000044 R14: 0000000000000000 R15: ffffc9005835fcac
[  137.250259] 039:  ? ___preempt_schedule+0x16/0x18
[  137.254969] 039:  preempt_schedule_common+0x32/0x80
[  137.259846] 039:  ___preempt_schedule+0x16/0x18
[  137.264379] 039:  rcutorture_one_extend+0x33a/0x510 [rcutorture]
[  137.270397] 039:  rcu_torture_one_read+0x18c/0x450 [rcutorture]
[  137.276334] 039:  rcu_torture_reader+0xac/0x1f0 [rcutorture]
[  137.281998] 039:  ? rcu_torture_reader+0x1f0/0x1f0 [rcutorture]
[  137.287920] 039:  kthread+0x106/0x140
[  137.291591] 039:  ? rcu_torture_one_read+0x450/0x450 [rcutorture]
[  137.297681] 039:  ? kthread_bind+0x10/0x10
[  137.301783] 039:  ret_from_fork+0x3a/0x50

---
I think the prohibition on use_softirq can be dropped once RT gets the latest RCU code, but the question of what use_softirq should default to on PREEMPT_RT remains.

---
 kernel/rcu/tree.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)
kernel/rcu/tree.c +8 -1
index fc8b00c61b32..12036d33e2f9 100644
@@ -98,9 +98,16 @@ struct rcu_state rcu_state = {
 /* Dump rcu_node combining tree at boot to verify correct setup. */
 static bool dump_tree;
 module_param(dump_tree, bool, 0444);
-/* By default, use RCU_SOFTIRQ instead of rcuc kthreads. */
+/*
+ * By default, use RCU_SOFTIRQ instead of rcuc kthreads.
+ * But, avoid RCU_SOFTIRQ on PREEMPT_RT due to pi/rq deadlocks.
+ */
+#ifdef CONFIG_PREEMPT_RT_FULL
+static bool use_softirq;
+#else
 static bool use_softirq = 1;
 module_param(use_softirq, bool, 0444);
+#endif
 /* Control rcu_node-tree auto-balancing at boot time. */
 static bool rcu_fanout_exact;
 module_param(rcu_fanout_exact, bool, 0444);
Signature · 1 line
1.8.3.1
#37 lore raw

Re: [PATCH RT v2 3/3] rcu: Disable use_softirq on PREEMPT_RT

Quoted 122 lines · Scott Wood

Besides restoring behavior that used to be default on RT, this avoids a deadlock on scheduler locks:

[  136.894657] 039: ============================================
[  136.900401] 039: WARNING: possible recursive locking detected
[  136.906146] 039: 5.2.9-rt3.dbg+ #174 Tainted: G            E
[  136.912152] 039: --------------------------------------------
[  136.917896] 039: rcu_torture_rea/13474 is trying to acquire lock:
[  136.923990] 039: 000000005f25146d
[  136.927310] 039:  (
[  136.929414] 039: &p->pi_lock
[  136.932303] 039: ){-...}
[  136.934840] 039: , at: try_to_wake_up+0x39/0x920
[  136.939461] 039:
but task is already holding lock:
[  136.944425] 039: 000000005f25146d
[  136.947745] 039:  (
[  136.949852] 039: &p->pi_lock
[  136.952738] 039: ){-...}
[  136.955274] 039: , at: try_to_wake_up+0x39/0x920
[  136.959895] 039:
other info that might help us debug this:
[  136.965555] 039:  Possible unsafe locking scenario:
[  136.970608] 039:        CPU0
[  136.973493] 039:        ----
[  136.976378] 039:   lock(
[  136.978918] 039: &p->pi_lock
[  136.981806] 039: );
[  136.983911] 039:   lock(
[  136.986451] 039: &p->pi_lock
[  136.989336] 039: );
[  136.991444] 039:
 *** DEADLOCK ***
[  136.995194] 039:  May be due to missing lock nesting notation
[  137.001115] 039: 3 locks held by rcu_torture_rea/13474:
[  137.006341] 039:  #0:
[  137.008707] 039: 000000005f25146d
[  137.012024] 039:  (
[  137.014131] 039: &p->pi_lock
[  137.017015] 039: ){-...}
[  137.019558] 039: , at: try_to_wake_up+0x39/0x920
[  137.024175] 039:  #1:
[  137.026540] 039: 0000000011c8e51d
[  137.029859] 039:  (
[  137.031966] 039: &rq->lock
[  137.034679] 039: ){-...}
[  137.037217] 039: , at: try_to_wake_up+0x241/0x920
[  137.041924] 039:  #2:
[  137.044291] 039: 00000000098649b9
[  137.047610] 039:  (
[  137.049714] 039: rcu_read_lock
[  137.052774] 039: ){....}
[  137.055314] 039: , at: cpuacct_charge+0x33/0x1e0
[  137.059934] 039:
stack backtrace:
[  137.063425] 039: CPU: 39 PID: 13474 Comm: rcu_torture_rea Kdump: loaded Tainted: G            E     5.2.9-rt3.dbg+ #174
[  137.074197] 039: Hardware name: Intel Corporation S2600BT/S2600BT, BIOS SE5C620.86B.01.00.0763.022420181017 02/24/2018
[  137.084886] 039: Call Trace:
[  137.087773] 039:  <IRQ>
[  137.090226] 039:  dump_stack+0x5e/0x8b
[  137.093997] 039:  __lock_acquire+0x725/0x1100
[  137.098358] 039:  lock_acquire+0xc0/0x240
[  137.102374] 039:  ? try_to_wake_up+0x39/0x920
[  137.106737] 039:  _raw_spin_lock_irqsave+0x47/0x90
[  137.111534] 039:  ? try_to_wake_up+0x39/0x920
[  137.115910] 039:  try_to_wake_up+0x39/0x920
[  137.120098] 039:  rcu_read_unlock_special+0x65/0xb0
[  137.124977] 039:  __rcu_read_unlock+0x5d/0x70
[  137.129337] 039:  cpuacct_charge+0xd9/0x1e0
[  137.133522] 039:  ? cpuacct_charge+0x33/0x1e0
[  137.137880] 039:  update_curr+0x14b/0x420
[  137.141894] 039:  enqueue_entity+0x42/0x370
[  137.146080] 039:  enqueue_task_fair+0xa9/0x490
[  137.150528] 039:  activate_task+0x5a/0xf0
[  137.154539] 039:  ttwu_do_activate+0x4e/0x90
[  137.158813] 039:  try_to_wake_up+0x277/0x920
[  137.163086] 039:  irq_exit+0xb6/0xf0
[  137.166661] 039:  smp_apic_timer_interrupt+0xe3/0x3a0
[  137.171714] 039:  apic_timer_interrupt+0xf/0x20
[  137.176249] 039:  </IRQ>
[  137.178785] 039: RIP: 0010:__schedule+0x0/0x8e0
[  137.183319] 039: Code: 00 02 48 89 43 20 e8 0f 5a 00 00 48 8d 7b 28 e8 86 f2 fd ff 31 c0 5b 5d 41 5c c3 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 <55> 48 89 e5 41 57 41 56 49 c7 c6 c0 ca 1e 00 41 55 41 89 fd 41 54
[  137.202498] 039: RSP: 0018:ffffc9005835fbc0 EFLAGS: 00000246
[  137.208158] 039:  ORIG_RAX: ffffffffffffff13
[  137.212428] 039: RAX: 0000000000000000 RBX: ffff8897c3e1bb00 RCX: 0000000000000001
[  137.219994] 039: RDX: 0000000080004008 RSI: 0000000000000006 RDI: 0000000000000001
[  137.227560] 039: RBP: ffff8897c3e1bb00 R08: 0000000000000000 R09: 0000000000000000
[  137.235126] 039: R10: 0000000000000001 R11: 0000000000000001 R12: ffffffff81001fd1
[  137.242694] 039: R13: 0000000000000044 R14: 0000000000000000 R15: ffffc9005835fcac
[  137.250259] 039:  ? ___preempt_schedule+0x16/0x18
[  137.254969] 039:  preempt_schedule_common+0x32/0x80
[  137.259846] 039:  ___preempt_schedule+0x16/0x18
[  137.264379] 039:  rcutorture_one_extend+0x33a/0x510 [rcutorture]
[  137.270397] 039:  rcu_torture_one_read+0x18c/0x450 [rcutorture]
[  137.276334] 039:  rcu_torture_reader+0xac/0x1f0 [rcutorture]
[  137.281998] 039:  ? rcu_torture_reader+0x1f0/0x1f0 [rcutorture]
[  137.287920] 039:  kthread+0x106/0x140
[  137.291591] 039:  ? rcu_torture_one_read+0x450/0x450 [rcutorture]
[  137.297681] 039:  ? kthread_bind+0x10/0x10
[  137.301783] 039:  ret_from_fork+0x3a/0x50

---
I think the prohibition on use_softirq can be dropped once RT gets the latest RCU code, but the question of what use_softirq should default to on PREEMPT_RT remains.

---
 kernel/rcu/tree.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)
kernel/rcu/tree.c +0 -1
index fc8b00c61b32..12036d33e2f9 100644
@@ -98,9 +98,16 @@ struct rcu_state rcu_state = {
 /* Dump rcu_node combining tree at boot to verify correct setup. */
 static bool dump_tree;
 module_param(dump_tree, bool, 0444);
-/* By default, use RCU_SOFTIRQ instead of rcuc kthreads. */

kernel/rcu/tree.c struct rcu_state rcu_state = { · line 110

Quoted 10 lines
kernel/rcu/tree.c +8 -0
+/*
+ * By default, use RCU_SOFTIRQ instead of rcuc kthreads.
+ * But, avoid RCU_SOFTIRQ on PREEMPT_RT due to pi/rq deadlocks.
+ */
+#ifdef CONFIG_PREEMPT_RT_FULL
+static bool use_softirq;
+#else
 static bool use_softirq = 1;
 module_param(use_softirq, bool, 0444);
+#endif

Save a couple of lines?

static bool use_softirq = !IS_ENABLED(CONFIG_PREEMPT_RT_FULL);

And if I understand your point above, the module_param() might be able to be the same either way given the new RCU. But if not, at least we get rid of the #else.

Thanx, Paul

Quoted 6 lines
kernel/rcu/tree.c +0 -0
 /* Control rcu_node-tree auto-balancing at boot time. */
 static bool rcu_fanout_exact;
 module_param(rcu_fanout_exact, bool, 0444);
Signature · 1 line
1.8.3.1
#38 lore raw

Re: [PATCH RT v2 3/3] rcu: Disable use_softirq on PREEMPT_RT

Quoted 7 lines · Paul E. McKenney

Save a couple of lines?

static bool use_softirq = !IS_ENABLED(CONFIG_PREEMPT_RT_FULL);

And if I understand your point above, the module_param() might be able to be the same either way given the new RCU. But if not, at least we get rid of the #else.

I *think* we wanted this. And while I took the RCU patches for v5.2 I forgot to enable it by default…

Quoted 1 line

Thanx, Paul

Sebastian

#39 lore raw

Re: [PATCH RT v2 3/3] rcu: Disable use_softirq on PREEMPT_RT

In reply to Scott Wood
Quoted 104 lines · Scott Wood

Besides restoring behavior that used to be default on RT, this avoids a deadlock on scheduler locks:

[  136.894657] 039: ============================================
[  136.900401] 039: WARNING: possible recursive locking detected
[  136.906146] 039: 5.2.9-rt3.dbg+ #174 Tainted: G            E
[  136.912152] 039: --------------------------------------------
[  136.917896] 039: rcu_torture_rea/13474 is trying to acquire lock:
[  136.923990] 039: 000000005f25146d
[  136.927310] 039:  (
[  136.929414] 039: &p->pi_lock
[  136.932303] 039: ){-...}
[  136.934840] 039: , at: try_to_wake_up+0x39/0x920
[  136.939461] 039:
but task is already holding lock:
[  136.944425] 039: 000000005f25146d
[  136.947745] 039:  (
[  136.949852] 039: &p->pi_lock
[  136.952738] 039: ){-...}
[  136.955274] 039: , at: try_to_wake_up+0x39/0x920
[  136.959895] 039:
other info that might help us debug this:
[  136.965555] 039:  Possible unsafe locking scenario:
[  136.970608] 039:        CPU0
[  136.973493] 039:        ----
[  136.976378] 039:   lock(
[  136.978918] 039: &p->pi_lock
[  136.981806] 039: );
[  136.983911] 039:   lock(
[  136.986451] 039: &p->pi_lock
[  136.989336] 039: );
[  136.991444] 039:
 *** DEADLOCK ***
[  136.995194] 039:  May be due to missing lock nesting notation
[  137.001115] 039: 3 locks held by rcu_torture_rea/13474:
[  137.006341] 039:  #0:
[  137.008707] 039: 000000005f25146d
[  137.012024] 039:  (
[  137.014131] 039: &p->pi_lock
[  137.017015] 039: ){-...}
[  137.019558] 039: , at: try_to_wake_up+0x39/0x920
[  137.024175] 039:  #1:
[  137.026540] 039: 0000000011c8e51d
[  137.029859] 039:  (
[  137.031966] 039: &rq->lock
[  137.034679] 039: ){-...}
[  137.037217] 039: , at: try_to_wake_up+0x241/0x920
[  137.041924] 039:  #2:
[  137.044291] 039: 00000000098649b9
[  137.047610] 039:  (
[  137.049714] 039: rcu_read_lock
[  137.052774] 039: ){....}
[  137.055314] 039: , at: cpuacct_charge+0x33/0x1e0
[  137.059934] 039:
stack backtrace:
[  137.063425] 039: CPU: 39 PID: 13474 Comm: rcu_torture_rea Kdump: loaded Tainted: G            E     5.2.9-rt3.dbg+ #174
[  137.074197] 039: Hardware name: Intel Corporation S2600BT/S2600BT, BIOS SE5C620.86B.01.00.0763.022420181017 02/24/2018
[  137.084886] 039: Call Trace:
[  137.087773] 039:  <IRQ>
[  137.090226] 039:  dump_stack+0x5e/0x8b
[  137.093997] 039:  __lock_acquire+0x725/0x1100
[  137.098358] 039:  lock_acquire+0xc0/0x240
[  137.102374] 039:  ? try_to_wake_up+0x39/0x920
[  137.106737] 039:  _raw_spin_lock_irqsave+0x47/0x90
[  137.111534] 039:  ? try_to_wake_up+0x39/0x920
[  137.115910] 039:  try_to_wake_up+0x39/0x920
[  137.120098] 039:  rcu_read_unlock_special+0x65/0xb0
[  137.124977] 039:  __rcu_read_unlock+0x5d/0x70
[  137.129337] 039:  cpuacct_charge+0xd9/0x1e0
[  137.133522] 039:  ? cpuacct_charge+0x33/0x1e0
[  137.137880] 039:  update_curr+0x14b/0x420
[  137.141894] 039:  enqueue_entity+0x42/0x370
[  137.146080] 039:  enqueue_task_fair+0xa9/0x490
[  137.150528] 039:  activate_task+0x5a/0xf0
[  137.154539] 039:  ttwu_do_activate+0x4e/0x90
[  137.158813] 039:  try_to_wake_up+0x277/0x920
[  137.163086] 039:  irq_exit+0xb6/0xf0
[  137.166661] 039:  smp_apic_timer_interrupt+0xe3/0x3a0
[  137.171714] 039:  apic_timer_interrupt+0xf/0x20
[  137.176249] 039:  </IRQ>
[  137.178785] 039: RIP: 0010:__schedule+0x0/0x8e0
[  137.183319] 039: Code: 00 02 48 89 43 20 e8 0f 5a 00 00 48 8d 7b 28 e8 86 f2 fd ff 31 c0 5b 5d 41 5c c3 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 <55> 48 89 e5 41 57 41 56 49 c7 c6 c0 ca 1e 00 41 55 41 89 fd 41 54
[  137.202498] 039: RSP: 0018:ffffc9005835fbc0 EFLAGS: 00000246
[  137.208158] 039:  ORIG_RAX: ffffffffffffff13
[  137.212428] 039: RAX: 0000000000000000 RBX: ffff8897c3e1bb00 RCX: 0000000000000001
[  137.219994] 039: RDX: 0000000080004008 RSI: 0000000000000006 RDI: 0000000000000001
[  137.227560] 039: RBP: ffff8897c3e1bb00 R08: 0000000000000000 R09: 0000000000000000
[  137.235126] 039: R10: 0000000000000001 R11: 0000000000000001 R12: ffffffff81001fd1
[  137.242694] 039: R13: 0000000000000044 R14: 0000000000000000 R15: ffffc9005835fcac
[  137.250259] 039:  ? ___preempt_schedule+0x16/0x18
[  137.254969] 039:  preempt_schedule_common+0x32/0x80
[  137.259846] 039:  ___preempt_schedule+0x16/0x18
[  137.264379] 039:  rcutorture_one_extend+0x33a/0x510 [rcutorture]
[  137.270397] 039:  rcu_torture_one_read+0x18c/0x450 [rcutorture]
[  137.276334] 039:  rcu_torture_reader+0xac/0x1f0 [rcutorture]
[  137.281998] 039:  ? rcu_torture_reader+0x1f0/0x1f0 [rcutorture]
[  137.287920] 039:  kthread+0x106/0x140
[  137.291591] 039:  ? rcu_torture_one_read+0x450/0x450 [rcutorture]
[  137.297681] 039:  ? kthread_bind+0x10/0x10
[  137.301783] 039:  ret_from_fork+0x3a/0x50
Quoted 5 lines

---
I think the prohibition on use_softirq can be dropped once RT gets the latest RCU code, but the question of what use_softirq should default to on PREEMPT_RT remains.

Independent of the question of what use_softirq should default to, could we test RT with latest RCU code now to check if the deadlock goes away? That way, maybe we can find any issues in current RCU that cause scheduler deadlocks in the situation you pointed. The reason I am asking is because recently additional commits [1] try to prevent deadlock and it'd be nice to ensure that other conditions are not lingering (I don't think they are but it'd be nice to be sure).

I am happy to do such testing myself if you want, however what does it take to apply the RT patchset to the latest mainline? Is it an achievable feat?

thanks,

- Joel

[1]
23634ebc1d94 ("rcu: Check for wakeup-safe conditions") 25102de ("rcu: Only do rcu_read_unlock_special() wakeups if expedited")

Quoted 28 lines
 kernel/rcu/tree.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)
kernel/rcu/tree.c +8 -1
index fc8b00c61b32..12036d33e2f9 100644
@@ -98,9 +98,16 @@ struct rcu_state rcu_state = {
 /* Dump rcu_node combining tree at boot to verify correct setup. */
 static bool dump_tree;
 module_param(dump_tree, bool, 0444);
-/* By default, use RCU_SOFTIRQ instead of rcuc kthreads. */
+/*
+ * By default, use RCU_SOFTIRQ instead of rcuc kthreads.
+ * But, avoid RCU_SOFTIRQ on PREEMPT_RT due to pi/rq deadlocks.
+ */
+#ifdef CONFIG_PREEMPT_RT_FULL
+static bool use_softirq;
+#else
 static bool use_softirq = 1;
 module_param(use_softirq, bool, 0444);
+#endif
 /* Control rcu_node-tree auto-balancing at boot time. */
 static bool rcu_fanout_exact;
 module_param(rcu_fanout_exact, bool, 0444);
Signature · 1 line
1.8.3.1
#40 lore raw

Re: [PATCH RT v2 3/3] rcu: Disable use_softirq on PREEMPT_RT

Quoted 119 lines · Joel Fernandes
Quoted 104 lines · Scott Wood

Besides restoring behavior that used to be default on RT, this avoids a deadlock on scheduler locks:

[  136.894657] 039: ============================================
[  136.900401] 039: WARNING: possible recursive locking detected
[  136.906146] 039: 5.2.9-rt3.dbg+ #174 Tainted: G            E
[  136.912152] 039: --------------------------------------------
[  136.917896] 039: rcu_torture_rea/13474 is trying to acquire lock:
[  136.923990] 039: 000000005f25146d
[  136.927310] 039:  (
[  136.929414] 039: &p->pi_lock
[  136.932303] 039: ){-...}
[  136.934840] 039: , at: try_to_wake_up+0x39/0x920
[  136.939461] 039:
but task is already holding lock:
[  136.944425] 039: 000000005f25146d
[  136.947745] 039:  (
[  136.949852] 039: &p->pi_lock
[  136.952738] 039: ){-...}
[  136.955274] 039: , at: try_to_wake_up+0x39/0x920
[  136.959895] 039:
other info that might help us debug this:
[  136.965555] 039:  Possible unsafe locking scenario:
[  136.970608] 039:        CPU0
[  136.973493] 039:        ----
[  136.976378] 039:   lock(
[  136.978918] 039: &p->pi_lock
[  136.981806] 039: );
[  136.983911] 039:   lock(
[  136.986451] 039: &p->pi_lock
[  136.989336] 039: );
[  136.991444] 039:
 *** DEADLOCK ***
[  136.995194] 039:  May be due to missing lock nesting notation
[  137.001115] 039: 3 locks held by rcu_torture_rea/13474:
[  137.006341] 039:  #0:
[  137.008707] 039: 000000005f25146d
[  137.012024] 039:  (
[  137.014131] 039: &p->pi_lock
[  137.017015] 039: ){-...}
[  137.019558] 039: , at: try_to_wake_up+0x39/0x920
[  137.024175] 039:  #1:
[  137.026540] 039: 0000000011c8e51d
[  137.029859] 039:  (
[  137.031966] 039: &rq->lock
[  137.034679] 039: ){-...}
[  137.037217] 039: , at: try_to_wake_up+0x241/0x920
[  137.041924] 039:  #2:
[  137.044291] 039: 00000000098649b9
[  137.047610] 039:  (
[  137.049714] 039: rcu_read_lock
[  137.052774] 039: ){....}
[  137.055314] 039: , at: cpuacct_charge+0x33/0x1e0
[  137.059934] 039:
stack backtrace:
[  137.063425] 039: CPU: 39 PID: 13474 Comm: rcu_torture_rea Kdump: loaded Tainted: G            E     5.2.9-rt3.dbg+ #174
[  137.074197] 039: Hardware name: Intel Corporation S2600BT/S2600BT, BIOS SE5C620.86B.01.00.0763.022420181017 02/24/2018
[  137.084886] 039: Call Trace:
[  137.087773] 039:  <IRQ>
[  137.090226] 039:  dump_stack+0x5e/0x8b
[  137.093997] 039:  __lock_acquire+0x725/0x1100
[  137.098358] 039:  lock_acquire+0xc0/0x240
[  137.102374] 039:  ? try_to_wake_up+0x39/0x920
[  137.106737] 039:  _raw_spin_lock_irqsave+0x47/0x90
[  137.111534] 039:  ? try_to_wake_up+0x39/0x920
[  137.115910] 039:  try_to_wake_up+0x39/0x920
[  137.120098] 039:  rcu_read_unlock_special+0x65/0xb0
[  137.124977] 039:  __rcu_read_unlock+0x5d/0x70
[  137.129337] 039:  cpuacct_charge+0xd9/0x1e0
[  137.133522] 039:  ? cpuacct_charge+0x33/0x1e0
[  137.137880] 039:  update_curr+0x14b/0x420
[  137.141894] 039:  enqueue_entity+0x42/0x370
[  137.146080] 039:  enqueue_task_fair+0xa9/0x490
[  137.150528] 039:  activate_task+0x5a/0xf0
[  137.154539] 039:  ttwu_do_activate+0x4e/0x90
[  137.158813] 039:  try_to_wake_up+0x277/0x920
[  137.163086] 039:  irq_exit+0xb6/0xf0
[  137.166661] 039:  smp_apic_timer_interrupt+0xe3/0x3a0
[  137.171714] 039:  apic_timer_interrupt+0xf/0x20
[  137.176249] 039:  </IRQ>
[  137.178785] 039: RIP: 0010:__schedule+0x0/0x8e0
[  137.183319] 039: Code: 00 02 48 89 43 20 e8 0f 5a 00 00 48 8d 7b 28 e8 86 f2 fd ff 31 c0 5b 5d 41 5c c3 90 90 90 90 90 90 90 90 90 90 90 90 90 90 90 <55> 48 89 e5 41 57 41 56 49 c7 c6 c0 ca 1e 00 41 55 41 89 fd 41 54
[  137.202498] 039: RSP: 0018:ffffc9005835fbc0 EFLAGS: 00000246
[  137.208158] 039:  ORIG_RAX: ffffffffffffff13
[  137.212428] 039: RAX: 0000000000000000 RBX: ffff8897c3e1bb00 RCX: 0000000000000001
[  137.219994] 039: RDX: 0000000080004008 RSI: 0000000000000006 RDI: 0000000000000001
[  137.227560] 039: RBP: ffff8897c3e1bb00 R08: 0000000000000000 R09: 0000000000000000
[  137.235126] 039: R10: 0000000000000001 R11: 0000000000000001 R12: ffffffff81001fd1
[  137.242694] 039: R13: 0000000000000044 R14: 0000000000000000 R15: ffffc9005835fcac
[  137.250259] 039:  ? ___preempt_schedule+0x16/0x18
[  137.254969] 039:  preempt_schedule_common+0x32/0x80
[  137.259846] 039:  ___preempt_schedule+0x16/0x18
[  137.264379] 039:  rcutorture_one_extend+0x33a/0x510 [rcutorture]
[  137.270397] 039:  rcu_torture_one_read+0x18c/0x450 [rcutorture]
[  137.276334] 039:  rcu_torture_reader+0xac/0x1f0 [rcutorture]
[  137.281998] 039:  ? rcu_torture_reader+0x1f0/0x1f0 [rcutorture]
[  137.287920] 039:  kthread+0x106/0x140
[  137.291591] 039:  ? rcu_torture_one_read+0x450/0x450 [rcutorture]
[  137.297681] 039:  ? kthread_bind+0x10/0x10
[  137.301783] 039:  ret_from_fork+0x3a/0x50
Quoted 5 lines

---
I think the prohibition on use_softirq can be dropped once RT gets the latest RCU code, but the question of what use_softirq should default to on PREEMPT_RT remains.

Independent of the question of what use_softirq should default to, could we test RT with latest RCU code now to check if the deadlock goes away? That way, maybe we can find any issues in current RCU that cause scheduler deadlocks in the situation you pointed. The reason I am asking is because recently additional commits [1] try to prevent deadlock and it'd be nice to ensure that other conditions are not lingering (I don't think they are but it'd be nice to be sure).

Quoted 2 lines

I am happy to do such testing myself if you want, however what does it take to apply the RT patchset to the latest mainline? Is it an achievable feat?

I suggest just using the -rt git tree, which I believe lives here:

https://git.kernel.org/pub/scm/linux/kernel/git/rt/linux-rt-devel.git

I would guess that branch linux-5.2.y-rt is the one you want, but I would ask Scott instead of blindly trusting my guess. ;-)

Thanx, Paul

author
#41 lore raw

Re: [PATCH RT v2 3/3] rcu: Disable use_softirq on PREEMPT_RT

In reply to Joel Fernandes
Quoted 15 lines · Joel Fernandes
Quoted 3 lines · Scott Wood

I think the prohibition on use_softirq can be dropped once RT gets the latest RCU code, but the question of what use_softirq should default to on PREEMPT_RT remains.

Independent of the question of what use_softirq should default to, could we
test RT with latest RCU code now to check if the deadlock goes away? That way, maybe we can find any issues in current RCU that cause scheduler deadlocks in the situation you pointed. The reason I am asking is because recently additional commits [1] try to prevent deadlock and it'd be nice to
ensure that other conditions are not lingering (I don't think they are but it'd be nice to be sure).

Quoted 3 lines

I am happy to do such testing myself if you want, however what does it take
to apply the RT patchset to the latest mainline? Is it an achievable feat?

I did run such a test (cherry picking all RCU patches that aren't already in RT, plus your RFC patch to rcu_read_unlock_special, rather than applying RT to current mainline) with rcutorture plus a looping kernel build overnight, and didn't see any splats with or without use_softirq.

-Scott

#42 lore raw

Re: [PATCH RT v2 3/3] rcu: Disable use_softirq on PREEMPT_RT

Quoted 16 lines · Scott Wood
Quoted 15 lines · Joel Fernandes
Quoted 3 lines · Scott Wood

I think the prohibition on use_softirq can be dropped once RT gets the latest RCU code, but the question of what use_softirq should default to on PREEMPT_RT remains.

Independent of the question of what use_softirq should default to, could we
test RT with latest RCU code now to check if the deadlock goes away? That way, maybe we can find any issues in current RCU that cause scheduler deadlocks in the situation you pointed. The reason I am asking is because recently additional commits [1] try to prevent deadlock and it'd be nice to
ensure that other conditions are not lingering (I don't think they are but it'd be nice to be sure).

Quoted 8 lines
Quoted 3 lines

I am happy to do such testing myself if you want, however what does it take
to apply the RT patchset to the latest mainline? Is it an achievable feat?

I did run such a test (cherry picking all RCU patches that aren't already in RT, plus your RFC patch to rcu_read_unlock_special, rather than applying RT to current mainline) with rcutorture plus a looping kernel build overnight, and didn't see any splats with or without use_softirq.

Cool, that's good to know you didn't see splats!

thanks,

- Joel