Commit de8f5e4f authored by Peter Zijlstra's avatar Peter Zijlstra
Browse files

lockdep: Introduce wait-type checks 



Extend lockdep to validate lock wait-type context.

The current wait-types are:

	LD_WAIT_FREE,		/* wait free, rcu etc.. */
	LD_WAIT_SPIN,		/* spin loops, raw_spinlock_t etc.. */
	LD_WAIT_CONFIG,		/* CONFIG_PREEMPT_LOCK, spinlock_t etc.. */
	LD_WAIT_SLEEP,		/* sleeping locks, mutex_t etc.. */

Where lockdep validates that the current lock (the one being acquired)
fits in the current wait-context (as generated by the held stack).

This ensures that there is no attempt to acquire mutexes while holding
spinlocks, to acquire spinlocks while holding raw_spinlocks and so on. In
other words, its a more fancy might_sleep().

Obviously RCU made the entire ordeal more complex than a simple single
value test because RCU can be acquired in (pretty much) any context and
while it presents a context to nested locks it is not the same as it
got acquired in.

Therefore its necessary to split the wait_type into two values, one
representing the acquire (outer) and one representing the nested context
(inner). For most 'normal' locks these two are the same.

[ To make static initialization easier we have the rule that:
  .outer == INV means .outer == .inner; because INV == 0. ]

It further means that its required to find the minimal .inner of the held
stack to compare against the outer of the new lock; because while 'normal'
RCU presents a CONFIG type to nested locks, if it is taken while already
holding a SPIN type it obviously doesn't relax the rules.

Below is an example output generated by the trivial test code:

  raw_spin_lock(&foo);
  spin_lock(&bar);
  spin_unlock(&bar);
  raw_spin_unlock(&foo);

 [ BUG: Invalid wait context ]
 -----------------------------
 swapper/0/1 is trying to lock:
 ffffc90000013f20 (&bar){....}-{3:3}, at: kernel_init+0xdb/0x187
 other info that might help us debug this:
 1 lock held by swapper/0/1:
  #0: ffffc90000013ee0 (&foo){+.+.}-{2:2}, at: kernel_init+0xd1/0x187

The way to read it is to look at the new -{n,m} part in the lock
description; -{3:3} for the attempted lock, and try and match that up to
the held locks, which in this case is the one: -{2,2}.

This tells that the acquiring lock requires a more relaxed environment than
presented by the lock stack.

Currently only the normal locks and RCU are converted, the rest of the
lockdep users defaults to .inner = INV which is ignored. More conversions
can be done when desired.

The check for spinlock_t nesting is not enabled by default. It's a separate
config option for now as there are known problems which are currently
addressed. The config option allows to identify these problems and to
verify that the solutions found are indeed solving them.

The config switch will be removed and the checks will permanently enabled
once the vast majority of issues has been addressed.

[ bigeasy: Move LD_WAIT_FREE,… out of CONFIG_LOCKDEP to avoid compile
	   failure with CONFIG_DEBUG_SPINLOCK + !CONFIG_LOCKDEP]
[ tglx: Add the config option ]

Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Signed-off-by: default avatarSebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: default avatarThomas Gleixner <tglx@linutronix.de>
Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Link: https://lkml.kernel.org/r/20200321113242.427089655@linutronix.de
parent a5c6234e

include/linux/irqflags.h

+7 −1
Original line number Diff line number Diff line
@@ -37,7 +37,12 @@ 
# define trace_softirqs_enabled(p)	((p)->softirqs_enabled)

# define trace_hardirq_enter()			\

do {						\

	current->hardirq_context++;		\

	if (!current->hardirq_context++)	\

		current->hardirq_threaded = 0;	\

} while (0)

# define trace_hardirq_threaded()		\

do {						\

	current->hardirq_threaded = 1;		\

} while (0)

# define trace_hardirq_exit()			\

do {						\
@@ -59,6 +64,7 @@ do { \ 
# define trace_hardirqs_enabled(p)	0

# define trace_softirqs_enabled(p)	0

# define trace_hardirq_enter()		do { } while (0)

# define trace_hardirq_threaded()	do { } while (0)

# define trace_hardirq_exit()		do { } while (0)

# define lockdep_softirq_enter()	do { } while (0)

# define lockdep_softirq_exit()		do { } while (0)

include/linux/lockdep.h

+60 −11
Original line number Diff line number Diff line
@@ -21,6 +21,22 @@ extern int lock_stat; 


#include <linux/types.h>



enum lockdep_wait_type {

	LD_WAIT_INV = 0,	/* not checked, catch all */



	LD_WAIT_FREE,		/* wait free, rcu etc.. */

	LD_WAIT_SPIN,		/* spin loops, raw_spinlock_t etc.. */



#ifdef CONFIG_PROVE_RAW_LOCK_NESTING

	LD_WAIT_CONFIG,		/* CONFIG_PREEMPT_LOCK, spinlock_t etc.. */

#else

	LD_WAIT_CONFIG = LD_WAIT_SPIN,

#endif

	LD_WAIT_SLEEP,		/* sleeping locks, mutex_t etc.. */



	LD_WAIT_MAX,		/* must be last */

};



#ifdef CONFIG_LOCKDEP



#include <linux/linkage.h>
@@ -111,6 +127,9 @@ struct lock_class { 
	int				name_version;

	const char			*name;



	short				wait_type_inner;

	short				wait_type_outer;



#ifdef CONFIG_LOCK_STAT

	unsigned long			contention_point[LOCKSTAT_POINTS];

	unsigned long			contending_point[LOCKSTAT_POINTS];
@@ -158,6 +177,8 @@ struct lockdep_map { 
	struct lock_class_key		*key;

	struct lock_class		*class_cache[NR_LOCKDEP_CACHING_CLASSES];

	const char			*name;

	short				wait_type_outer; /* can be taken in this context */

	short				wait_type_inner; /* presents this context */

#ifdef CONFIG_LOCK_STAT

	int				cpu;

	unsigned long			ip;
@@ -299,8 +320,21 @@ extern void lockdep_unregister_key(struct lock_class_key *key); 
 * to lockdep:

 */



extern void lockdep_init_map(struct lockdep_map *lock, const char *name,

			     struct lock_class_key *key, int subclass);

extern void lockdep_init_map_waits(struct lockdep_map *lock, const char *name,

	struct lock_class_key *key, int subclass, short inner, short outer);



static inline void

lockdep_init_map_wait(struct lockdep_map *lock, const char *name,

		      struct lock_class_key *key, int subclass, short inner)

{

	lockdep_init_map_waits(lock, name, key, subclass, inner, LD_WAIT_INV);

}



static inline void lockdep_init_map(struct lockdep_map *lock, const char *name,

			     struct lock_class_key *key, int subclass)

{

	lockdep_init_map_wait(lock, name, key, subclass, LD_WAIT_INV);

}



/*

 * Reinitialize a lock key - for cases where there is special locking or
@@ -309,17 +343,28 @@ extern void lockdep_init_map(struct lockdep_map *lock, const char *name, 
 * or they are too narrow (they suffer from a false class-split):

 */

#define lockdep_set_class(lock, key)				\

		lockdep_init_map(&(lock)->dep_map, #key, key, 0)

	lockdep_init_map_waits(&(lock)->dep_map, #key, key, 0,	\

			       (lock)->dep_map.wait_type_inner,	\

			       (lock)->dep_map.wait_type_outer)



#define lockdep_set_class_and_name(lock, key, name)		\

		lockdep_init_map(&(lock)->dep_map, name, key, 0)

	lockdep_init_map_waits(&(lock)->dep_map, name, key, 0,	\

			       (lock)->dep_map.wait_type_inner,	\

			       (lock)->dep_map.wait_type_outer)



#define lockdep_set_class_and_subclass(lock, key, sub)		\

		lockdep_init_map(&(lock)->dep_map, #key, key, sub)

	lockdep_init_map_waits(&(lock)->dep_map, #key, key, sub,\

			       (lock)->dep_map.wait_type_inner,	\

			       (lock)->dep_map.wait_type_outer)



#define lockdep_set_subclass(lock, sub)					\

		lockdep_init_map(&(lock)->dep_map, #lock, \

				 (lock)->dep_map.key, sub)

	lockdep_init_map_waits(&(lock)->dep_map, #lock, (lock)->dep_map.key, sub,\

			       (lock)->dep_map.wait_type_inner,		\

			       (lock)->dep_map.wait_type_outer)



#define lockdep_set_novalidate_class(lock) \

	lockdep_set_class_and_name(lock, &__lockdep_no_validate__, #lock)



/*

 * Compare locking classes

 */
@@ -432,6 +477,10 @@ static inline void lockdep_set_selftest_task(struct task_struct *task) 
# define lock_set_class(l, n, k, s, i)		do { } while (0)

# define lock_set_subclass(l, s, i)		do { } while (0)

# define lockdep_init()				do { } while (0)

# define lockdep_init_map_waits(lock, name, key, sub, inner, outer) \

		do { (void)(name); (void)(key); } while (0)

# define lockdep_init_map_wait(lock, name, key, sub, inner) \

		do { (void)(name); (void)(key); } while (0)

# define lockdep_init_map(lock, name, key, sub) \

		do { (void)(name); (void)(key); } while (0)

# define lockdep_set_class(lock, key)		do { (void)(key); } while (0)

include/linux/mutex.h

+5 −2
Original line number Diff line number Diff line
@@ -110,7 +110,10 @@ do { \ 


#ifdef CONFIG_DEBUG_LOCK_ALLOC

# define __DEP_MAP_MUTEX_INITIALIZER(lockname)			\

		, .dep_map = { .name = #lockname }

		, .dep_map = {					\

			.name = #lockname,			\

			.wait_type_inner = LD_WAIT_SLEEP,	\

		}

#else

# define __DEP_MAP_MUTEX_INITIALIZER(lockname)

#endif

include/linux/rwlock_types.h

+5 −1
Original line number Diff line number Diff line
@@ -22,7 +22,11 @@ typedef struct { 
#define RWLOCK_MAGIC		0xdeaf1eed



#ifdef CONFIG_DEBUG_LOCK_ALLOC

# define RW_DEP_MAP_INIT(lockname)	.dep_map = { .name = #lockname }

# define RW_DEP_MAP_INIT(lockname)					\

	.dep_map = {							\

		.name = #lockname,					\

		.wait_type_inner = LD_WAIT_CONFIG,			\

	}

#else

# define RW_DEP_MAP_INIT(lockname)

#endif

include/linux/rwsem.h

+5 −1
Original line number Diff line number Diff line
@@ -65,7 +65,11 @@ static inline int rwsem_is_locked(struct rw_semaphore *sem) 
/* Common initializer macros and functions */



#ifdef CONFIG_DEBUG_LOCK_ALLOC

# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }

# define __RWSEM_DEP_MAP_INIT(lockname)			\

	, .dep_map = {					\

		.name = #lockname,			\

		.wait_type_inner = LD_WAIT_SLEEP,	\

	}

#else

# define __RWSEM_DEP_MAP_INIT(lockname)

#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE