Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ff195cb6 authored by Paul E. McKenney's avatar Paul E. McKenney Committed by Paul E. McKenney
Browse files

rcu: Warn when srcu_read_lock() is used in an extended quiescent state 



Catch SRCU up to the other variants of RCU by making PROVE_RCU
complain if either srcu_read_lock() or srcu_read_lock_held() are
used from within RCU-idle mode.

Frederic reworked this to allow for the new versions of his patches
that check for extended quiescent states.

Signed-off-by: default avatarPaul E. McKenney <paul.mckenney@linaro.org>
Signed-off-by: default avatarFrederic Weisbecker <fweisbec@gmail.com>
Signed-off-by: default avatarPaul E. McKenney <paulmck@linux.vnet.ibm.com>
Reviewed-by: default avatarJosh Triplett <josh@joshtriplett.org>
parent d8ab29f8

include/linux/srcu.h

+23 −13
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
#define _LINUX_SRCU_H



#include <linux/mutex.h>

#include <linux/rcupdate.h>



struct srcu_struct_array {

	int c[2];
@@ -60,18 +61,10 @@ int __init_srcu_struct(struct srcu_struct *sp, const char *name, 
	__init_srcu_struct((sp), #sp, &__srcu_key); \

})



# define srcu_read_acquire(sp) \

		lock_acquire(&(sp)->dep_map, 0, 0, 2, 1, NULL, _THIS_IP_)

# define srcu_read_release(sp) \

		lock_release(&(sp)->dep_map, 1, _THIS_IP_)



#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */



int init_srcu_struct(struct srcu_struct *sp);



# define srcu_read_acquire(sp)  do { } while (0)

# define srcu_read_release(sp)  do { } while (0)



#endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */



void cleanup_srcu_struct(struct srcu_struct *sp);
@@ -90,12 +83,29 @@ long srcu_batches_completed(struct srcu_struct *sp); 
 * read-side critical section.  In absence of CONFIG_DEBUG_LOCK_ALLOC,

 * this assumes we are in an SRCU read-side critical section unless it can

 * prove otherwise.

 *

 * Note that if the CPU is in the idle loop from an RCU point of view

 * (ie: that we are in the section between rcu_idle_enter() and

 * rcu_idle_exit()) then srcu_read_lock_held() returns false even if

 * the CPU did an srcu_read_lock().  The reason for this is that RCU

 * ignores CPUs that are in such a section, considering these as in

 * extended quiescent state, so such a CPU is effectively never in an

 * RCU read-side critical section regardless of what RCU primitives it

 * invokes.  This state of affairs is required --- we need to keep an

 * RCU-free window in idle where the CPU may possibly enter into low

 * power mode. This way we can notice an extended quiescent state to

 * other CPUs that started a grace period. Otherwise we would delay any

 * grace period as long as we run in the idle task.

 */

static inline int srcu_read_lock_held(struct srcu_struct *sp)

{

	if (debug_locks)

		return lock_is_held(&sp->dep_map);

	if (rcu_is_cpu_idle())

		return 0;



	if (!debug_locks)

		return 1;



	return lock_is_held(&sp->dep_map);

}



#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
@@ -150,7 +160,7 @@ static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp) 
{

	int retval = __srcu_read_lock(sp);



	srcu_read_acquire(sp);

	rcu_lock_acquire(&(sp)->dep_map);

	return retval;

}
@@ -164,7 +174,7 @@ 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)

{

	srcu_read_release(sp);

	rcu_lock_release(&(sp)->dep_map);

	__srcu_read_unlock(sp, idx);

}