rcu: Convert WARN_ON_ONCE() in rcu_lock_acquire() to lockdep

The WARN_ON_ONCE() in rcu_lock_acquire() results in infinite recursion
on S390, and also doesn't print very much information.  Remove this.

Updated patch to add lockdep-RCU assertions to RCU's read-side primitives.

Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>

2 files changed, 16 insertions, 2 deletions

diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 146d37d31778..6ee663c8745a 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -248,13 +248,11 @@ static inline int rcu_is_cpu_idle(void)
 
 static inline void rcu_lock_acquire(struct lockdep_map *map)
 {
-        WARN_ON_ONCE(rcu_is_cpu_idle());
         lock_acquire(map, 0, 0, 2, 1, NULL, _THIS_IP_);
 }
 
 static inline void rcu_lock_release(struct lockdep_map *map)
 {
-        WARN_ON_ONCE(rcu_is_cpu_idle());
         lock_release(map, 1, _THIS_IP_);
 }
 
@@ -699,6 +697,8 @@ static inline void rcu_read_lock(void)
         __rcu_read_lock();
         __acquire(RCU);
         rcu_lock_acquire(&rcu_lock_map);
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_lock() used illegally while idle");
 }
 
 /*
@@ -718,6 +718,8 @@ static inline void rcu_read_lock(void)
  */
 static inline void rcu_read_unlock(void)
 {
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_unlock() used illegally while idle");
         rcu_lock_release(&rcu_lock_map);
         __release(RCU);
         __rcu_read_unlock();
@@ -745,6 +747,8 @@ static inline void rcu_read_lock_bh(void)
         local_bh_disable();
         __acquire(RCU_BH);
         rcu_lock_acquire(&rcu_bh_lock_map);
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_lock_bh() used illegally while idle");
 }
 
 /*
@@ -754,6 +758,8 @@ static inline void rcu_read_lock_bh(void)
  */
 static inline void rcu_read_unlock_bh(void)
 {
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_unlock_bh() used illegally while idle");
         rcu_lock_release(&rcu_bh_lock_map);
         __release(RCU_BH);
         local_bh_enable();
@@ -777,6 +783,8 @@ static inline void rcu_read_lock_sched(void)
         preempt_disable();
         __acquire(RCU_SCHED);
         rcu_lock_acquire(&rcu_sched_lock_map);
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_lock_sched() used illegally while idle");
 }
 
 /* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
@@ -793,6 +801,8 @@ static inline notrace void rcu_read_lock_sched_notrace(void)
  */
 static inline void rcu_read_unlock_sched(void)
 {
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_unlock_sched() used illegally while idle");
         rcu_lock_release(&rcu_sched_lock_map);
         __release(RCU_SCHED);
         preempt_enable();
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index 9a323728e60c..d3d5fa54f25e 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -172,6 +172,8 @@ static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
         int retval = __srcu_read_lock(sp);
 
         rcu_lock_acquire(&(sp)->dep_map);
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "srcu_read_lock() used illegally while idle");
         return retval;
 }
 
@@ -185,6 +187,8 @@ static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
 static inline void srcu_read_unlock(struct srcu_struct *sp, int idx)
         __releases(sp)
 {
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "srcu_read_unlock() used illegally while idle");
         rcu_lock_release(&(sp)->dep_map);
         __srcu_read_unlock(sp, idx);
 }