Commit 9271a40d authored by Boqun Feng's avatar Boqun Feng Committed by Peter Zijlstra
Browse files

lockdep/selftest: Add wait context selftests 



These tests are added for two purposes:

*	Test the implementation of wait context checks and related
	annotations.

*	Semi-document the rules for wait context nesting when
	PROVE_RAW_LOCK_NESTING=y.

The test cases are only avaible for PROVE_RAW_LOCK_NESTING=y, as wait
context checking makes more sense for that configuration.

Signed-off-by: default avatarBoqun Feng <boqun.feng@gmail.com>
Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Link: https://lkml.kernel.org/r/20201208103112.2838119-5-boqun.feng@gmail.com
parent e71ba945

lib/locking-selftest.c

+232 −0
Original line number Diff line number Diff line
@@ -64,6 +64,9 @@ static DEFINE_SPINLOCK(lock_B); 
static DEFINE_SPINLOCK(lock_C);

static DEFINE_SPINLOCK(lock_D);



static DEFINE_RAW_SPINLOCK(raw_lock_A);

static DEFINE_RAW_SPINLOCK(raw_lock_B);



static DEFINE_RWLOCK(rwlock_A);

static DEFINE_RWLOCK(rwlock_B);

static DEFINE_RWLOCK(rwlock_C);
@@ -1306,6 +1309,7 @@ GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_wlock) 


#ifdef CONFIG_DEBUG_LOCK_ALLOC

# define I_SPINLOCK(x)	lockdep_reset_lock(&lock_##x.dep_map)

# define I_RAW_SPINLOCK(x)	lockdep_reset_lock(&raw_lock_##x.dep_map)

# define I_RWLOCK(x)	lockdep_reset_lock(&rwlock_##x.dep_map)

# define I_MUTEX(x)	lockdep_reset_lock(&mutex_##x.dep_map)

# define I_RWSEM(x)	lockdep_reset_lock(&rwsem_##x.dep_map)
@@ -1315,6 +1319,7 @@ GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_wlock) 
#endif

#else

# define I_SPINLOCK(x)

# define I_RAW_SPINLOCK(x)

# define I_RWLOCK(x)

# define I_MUTEX(x)

# define I_RWSEM(x)
@@ -1358,9 +1363,12 @@ static void reset_locks(void) 
	I1(A); I1(B); I1(C); I1(D);

	I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);

	I_WW(t); I_WW(t2); I_WW(o.base); I_WW(o2.base); I_WW(o3.base);

	I_RAW_SPINLOCK(A); I_RAW_SPINLOCK(B);

	lockdep_reset();

	I2(A); I2(B); I2(C); I2(D);

	init_shared_classes();

	raw_spin_lock_init(&raw_lock_A);

	raw_spin_lock_init(&raw_lock_B);



	ww_mutex_init(&o, &ww_lockdep); ww_mutex_init(&o2, &ww_lockdep); ww_mutex_init(&o3, &ww_lockdep);

	memset(&t, 0, sizeof(t)); memset(&t2, 0, sizeof(t2));
@@ -2419,6 +2427,226 @@ static void fs_reclaim_tests(void) 
	pr_cont("\n");

}



#define __guard(cleanup) __maybe_unused __attribute__((__cleanup__(cleanup)))



static void hardirq_exit(int *_)

{

	HARDIRQ_EXIT();

}



#define HARDIRQ_CONTEXT(name, ...)					\

	int hardirq_guard_##name __guard(hardirq_exit);			\

	HARDIRQ_ENTER();



#define NOTTHREADED_HARDIRQ_CONTEXT(name, ...)				\

	int notthreaded_hardirq_guard_##name __guard(hardirq_exit);	\

	local_irq_disable();						\

	__irq_enter();							\

	WARN_ON(!in_irq());



static void softirq_exit(int *_)

{

	SOFTIRQ_EXIT();

}



#define SOFTIRQ_CONTEXT(name, ...)				\

	int softirq_guard_##name __guard(softirq_exit);		\

	SOFTIRQ_ENTER();



static void rcu_exit(int *_)

{

	rcu_read_unlock();

}



#define RCU_CONTEXT(name, ...)					\

	int rcu_guard_##name __guard(rcu_exit);			\

	rcu_read_lock();



static void rcu_bh_exit(int *_)

{

	rcu_read_unlock_bh();

}



#define RCU_BH_CONTEXT(name, ...)				\

	int rcu_bh_guard_##name __guard(rcu_bh_exit);		\

	rcu_read_lock_bh();



static void rcu_sched_exit(int *_)

{

	rcu_read_unlock_sched();

}



#define RCU_SCHED_CONTEXT(name, ...)				\

	int rcu_sched_guard_##name __guard(rcu_sched_exit);	\

	rcu_read_lock_sched();



static void rcu_callback_exit(int *_)

{

	rcu_lock_release(&rcu_callback_map);

}



#define RCU_CALLBACK_CONTEXT(name, ...)					\

	int rcu_callback_guard_##name __guard(rcu_callback_exit);	\

	rcu_lock_acquire(&rcu_callback_map);





static void raw_spinlock_exit(raw_spinlock_t **lock)

{

	raw_spin_unlock(*lock);

}



#define RAW_SPINLOCK_CONTEXT(name, lock)						\

	raw_spinlock_t *raw_spinlock_guard_##name __guard(raw_spinlock_exit) = &(lock);	\

	raw_spin_lock(&(lock));



static void spinlock_exit(spinlock_t **lock)

{

	spin_unlock(*lock);

}



#define SPINLOCK_CONTEXT(name, lock)						\

	spinlock_t *spinlock_guard_##name __guard(spinlock_exit) = &(lock);	\

	spin_lock(&(lock));



static void mutex_exit(struct mutex **lock)

{

	mutex_unlock(*lock);

}



#define MUTEX_CONTEXT(name, lock)					\

	struct mutex *mutex_guard_##name __guard(mutex_exit) = &(lock);	\

	mutex_lock(&(lock));



#define GENERATE_2_CONTEXT_TESTCASE(outer, outer_lock, inner, inner_lock)	\

										\

static void __maybe_unused inner##_in_##outer(void)				\

{										\

	outer##_CONTEXT(_, outer_lock);						\

	{									\

		inner##_CONTEXT(_, inner_lock);					\

	}									\

}



/*

 * wait contexts (considering PREEMPT_RT)

 *

 * o: inner is allowed in outer

 * x: inner is disallowed in outer

 *

 *       \  inner |  RCU  | RAW_SPIN | SPIN | MUTEX

 * outer  \       |       |          |      |

 * ---------------+-------+----------+------+-------

 * HARDIRQ        |   o   |    o     |  o   |  x

 * ---------------+-------+----------+------+-------

 * NOTTHREADED_IRQ|   o   |    o     |  x   |  x

 * ---------------+-------+----------+------+-------

 * SOFTIRQ        |   o   |    o     |  o   |  x

 * ---------------+-------+----------+------+-------

 * RCU            |   o   |    o     |  o   |  x

 * ---------------+-------+----------+------+-------

 * RCU_BH         |   o   |    o     |  o   |  x

 * ---------------+-------+----------+------+-------

 * RCU_CALLBACK   |   o   |    o     |  o   |  x

 * ---------------+-------+----------+------+-------

 * RCU_SCHED      |   o   |    o     |  x   |  x

 * ---------------+-------+----------+------+-------

 * RAW_SPIN       |   o   |    o     |  x   |  x

 * ---------------+-------+----------+------+-------

 * SPIN           |   o   |    o     |  o   |  x

 * ---------------+-------+----------+------+-------

 * MUTEX          |   o   |    o     |  o   |  o

 * ---------------+-------+----------+------+-------

 */



#define GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(inner, inner_lock)		\

GENERATE_2_CONTEXT_TESTCASE(HARDIRQ, , inner, inner_lock)			\

GENERATE_2_CONTEXT_TESTCASE(NOTTHREADED_HARDIRQ, , inner, inner_lock)		\

GENERATE_2_CONTEXT_TESTCASE(SOFTIRQ, , inner, inner_lock)			\

GENERATE_2_CONTEXT_TESTCASE(RCU, , inner, inner_lock)				\

GENERATE_2_CONTEXT_TESTCASE(RCU_BH, , inner, inner_lock)			\

GENERATE_2_CONTEXT_TESTCASE(RCU_CALLBACK, , inner, inner_lock)			\

GENERATE_2_CONTEXT_TESTCASE(RCU_SCHED, , inner, inner_lock)			\

GENERATE_2_CONTEXT_TESTCASE(RAW_SPINLOCK, raw_lock_A, inner, inner_lock)	\

GENERATE_2_CONTEXT_TESTCASE(SPINLOCK, lock_A, inner, inner_lock)		\

GENERATE_2_CONTEXT_TESTCASE(MUTEX, mutex_A, inner, inner_lock)



GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(RCU, )

GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(RAW_SPINLOCK, raw_lock_B)

GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(SPINLOCK, lock_B)

GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(MUTEX, mutex_B)



/* the outer context allows all kinds of preemption */

#define DO_CONTEXT_TESTCASE_OUTER_PREEMPTIBLE(outer)			\

	dotest(RCU_in_##outer, SUCCESS, LOCKTYPE_RWLOCK);		\

	dotest(RAW_SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN);	\

	dotest(SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN);		\

	dotest(MUTEX_in_##outer, SUCCESS, LOCKTYPE_MUTEX);		\



/*

 * the outer context only allows the preemption introduced by spinlock_t (which

 * is a sleepable lock for PREEMPT_RT)

 */

#define DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(outer)		\

	dotest(RCU_in_##outer, SUCCESS, LOCKTYPE_RWLOCK);		\

	dotest(RAW_SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN);	\

	dotest(SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN);		\

	dotest(MUTEX_in_##outer, FAILURE, LOCKTYPE_MUTEX);		\



/* the outer doesn't allows any kind of preemption */

#define DO_CONTEXT_TESTCASE_OUTER_NOT_PREEMPTIBLE(outer)			\

	dotest(RCU_in_##outer, SUCCESS, LOCKTYPE_RWLOCK);		\

	dotest(RAW_SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN);	\

	dotest(SPINLOCK_in_##outer, FAILURE, LOCKTYPE_SPIN);		\

	dotest(MUTEX_in_##outer, FAILURE, LOCKTYPE_MUTEX);		\



static void wait_context_tests(void)

{

	printk("  --------------------------------------------------------------------------\n");

	printk("  | wait context tests |\n");

	printk("  --------------------------------------------------------------------------\n");

	printk("                                 | rcu  | raw  | spin |mutex |\n");

	printk("  --------------------------------------------------------------------------\n");

	print_testname("in hardirq context");

	DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(HARDIRQ);

	pr_cont("\n");



	print_testname("in hardirq context (not threaded)");

	DO_CONTEXT_TESTCASE_OUTER_NOT_PREEMPTIBLE(NOTTHREADED_HARDIRQ);

	pr_cont("\n");



	print_testname("in softirq context");

	DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(SOFTIRQ);

	pr_cont("\n");



	print_testname("in RCU context");

	DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(RCU);

	pr_cont("\n");



	print_testname("in RCU-bh context");

	DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(RCU_BH);

	pr_cont("\n");



	print_testname("in RCU callback context");

	DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(RCU_CALLBACK);

	pr_cont("\n");



	print_testname("in RCU-sched context");

	DO_CONTEXT_TESTCASE_OUTER_NOT_PREEMPTIBLE(RCU_SCHED);

	pr_cont("\n");



	print_testname("in RAW_SPINLOCK context");

	DO_CONTEXT_TESTCASE_OUTER_NOT_PREEMPTIBLE(RAW_SPINLOCK);

	pr_cont("\n");



	print_testname("in SPINLOCK context");

	DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(SPINLOCK);

	pr_cont("\n");



	print_testname("in MUTEX context");

	DO_CONTEXT_TESTCASE_OUTER_PREEMPTIBLE(MUTEX);

	pr_cont("\n");

}



void locking_selftest(void)

{

	/*
@@ -2542,6 +2770,10 @@ void locking_selftest(void) 


	fs_reclaim_tests();



	/* Wait context test cases that are specific for RAW_LOCK_NESTING */

	if (IS_ENABLED(CONFIG_PROVE_RAW_LOCK_NESTING))

		wait_context_tests();



	if (unexpected_testcase_failures) {

		printk("-----------------------------------------------------------------\n");

		debug_locks = 0;