xref: /openbmc/linux/lib/locking-selftest.c (revision 0b26ca68)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * lib/locking-selftest.c
4  *
5  * Testsuite for various locking APIs: spinlocks, rwlocks,
6  * mutexes and rw-semaphores.
7  *
8  * It is checking both false positives and false negatives.
9  *
10  * Started by Ingo Molnar:
11  *
12  *  Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
13  */
14 #include <linux/rwsem.h>
15 #include <linux/mutex.h>
16 #include <linux/ww_mutex.h>
17 #include <linux/sched.h>
18 #include <linux/sched/mm.h>
19 #include <linux/delay.h>
20 #include <linux/lockdep.h>
21 #include <linux/spinlock.h>
22 #include <linux/kallsyms.h>
23 #include <linux/interrupt.h>
24 #include <linux/debug_locks.h>
25 #include <linux/irqflags.h>
26 #include <linux/rtmutex.h>
27 
28 /*
29  * Change this to 1 if you want to see the failure printouts:
30  */
31 static unsigned int debug_locks_verbose;
32 unsigned int force_read_lock_recursive;
33 
34 static DEFINE_WD_CLASS(ww_lockdep);
35 
36 static int __init setup_debug_locks_verbose(char *str)
37 {
38 	get_option(&str, &debug_locks_verbose);
39 
40 	return 1;
41 }
42 
43 __setup("debug_locks_verbose=", setup_debug_locks_verbose);
44 
45 #define FAILURE		0
46 #define SUCCESS		1
47 
48 #define LOCKTYPE_SPIN	0x1
49 #define LOCKTYPE_RWLOCK	0x2
50 #define LOCKTYPE_MUTEX	0x4
51 #define LOCKTYPE_RWSEM	0x8
52 #define LOCKTYPE_WW	0x10
53 #define LOCKTYPE_RTMUTEX 0x20
54 
55 static struct ww_acquire_ctx t, t2;
56 static struct ww_mutex o, o2, o3;
57 
58 /*
59  * Normal standalone locks, for the circular and irq-context
60  * dependency tests:
61  */
62 static DEFINE_SPINLOCK(lock_A);
63 static DEFINE_SPINLOCK(lock_B);
64 static DEFINE_SPINLOCK(lock_C);
65 static DEFINE_SPINLOCK(lock_D);
66 
67 static DEFINE_RWLOCK(rwlock_A);
68 static DEFINE_RWLOCK(rwlock_B);
69 static DEFINE_RWLOCK(rwlock_C);
70 static DEFINE_RWLOCK(rwlock_D);
71 
72 static DEFINE_MUTEX(mutex_A);
73 static DEFINE_MUTEX(mutex_B);
74 static DEFINE_MUTEX(mutex_C);
75 static DEFINE_MUTEX(mutex_D);
76 
77 static DECLARE_RWSEM(rwsem_A);
78 static DECLARE_RWSEM(rwsem_B);
79 static DECLARE_RWSEM(rwsem_C);
80 static DECLARE_RWSEM(rwsem_D);
81 
82 #ifdef CONFIG_RT_MUTEXES
83 
84 static DEFINE_RT_MUTEX(rtmutex_A);
85 static DEFINE_RT_MUTEX(rtmutex_B);
86 static DEFINE_RT_MUTEX(rtmutex_C);
87 static DEFINE_RT_MUTEX(rtmutex_D);
88 
89 #endif
90 
91 /*
92  * Locks that we initialize dynamically as well so that
93  * e.g. X1 and X2 becomes two instances of the same class,
94  * but X* and Y* are different classes. We do this so that
95  * we do not trigger a real lockup:
96  */
97 static DEFINE_SPINLOCK(lock_X1);
98 static DEFINE_SPINLOCK(lock_X2);
99 static DEFINE_SPINLOCK(lock_Y1);
100 static DEFINE_SPINLOCK(lock_Y2);
101 static DEFINE_SPINLOCK(lock_Z1);
102 static DEFINE_SPINLOCK(lock_Z2);
103 
104 static DEFINE_RWLOCK(rwlock_X1);
105 static DEFINE_RWLOCK(rwlock_X2);
106 static DEFINE_RWLOCK(rwlock_Y1);
107 static DEFINE_RWLOCK(rwlock_Y2);
108 static DEFINE_RWLOCK(rwlock_Z1);
109 static DEFINE_RWLOCK(rwlock_Z2);
110 
111 static DEFINE_MUTEX(mutex_X1);
112 static DEFINE_MUTEX(mutex_X2);
113 static DEFINE_MUTEX(mutex_Y1);
114 static DEFINE_MUTEX(mutex_Y2);
115 static DEFINE_MUTEX(mutex_Z1);
116 static DEFINE_MUTEX(mutex_Z2);
117 
118 static DECLARE_RWSEM(rwsem_X1);
119 static DECLARE_RWSEM(rwsem_X2);
120 static DECLARE_RWSEM(rwsem_Y1);
121 static DECLARE_RWSEM(rwsem_Y2);
122 static DECLARE_RWSEM(rwsem_Z1);
123 static DECLARE_RWSEM(rwsem_Z2);
124 
125 #ifdef CONFIG_RT_MUTEXES
126 
127 static DEFINE_RT_MUTEX(rtmutex_X1);
128 static DEFINE_RT_MUTEX(rtmutex_X2);
129 static DEFINE_RT_MUTEX(rtmutex_Y1);
130 static DEFINE_RT_MUTEX(rtmutex_Y2);
131 static DEFINE_RT_MUTEX(rtmutex_Z1);
132 static DEFINE_RT_MUTEX(rtmutex_Z2);
133 
134 #endif
135 
136 /*
137  * non-inlined runtime initializers, to let separate locks share
138  * the same lock-class:
139  */
140 #define INIT_CLASS_FUNC(class) 				\
141 static noinline void					\
142 init_class_##class(spinlock_t *lock, rwlock_t *rwlock, \
143 	struct mutex *mutex, struct rw_semaphore *rwsem)\
144 {							\
145 	spin_lock_init(lock);			\
146 	rwlock_init(rwlock);				\
147 	mutex_init(mutex);				\
148 	init_rwsem(rwsem);				\
149 }
150 
151 INIT_CLASS_FUNC(X)
152 INIT_CLASS_FUNC(Y)
153 INIT_CLASS_FUNC(Z)
154 
155 static void init_shared_classes(void)
156 {
157 #ifdef CONFIG_RT_MUTEXES
158 	static struct lock_class_key rt_X, rt_Y, rt_Z;
159 
160 	__rt_mutex_init(&rtmutex_X1, __func__, &rt_X);
161 	__rt_mutex_init(&rtmutex_X2, __func__, &rt_X);
162 	__rt_mutex_init(&rtmutex_Y1, __func__, &rt_Y);
163 	__rt_mutex_init(&rtmutex_Y2, __func__, &rt_Y);
164 	__rt_mutex_init(&rtmutex_Z1, __func__, &rt_Z);
165 	__rt_mutex_init(&rtmutex_Z2, __func__, &rt_Z);
166 #endif
167 
168 	init_class_X(&lock_X1, &rwlock_X1, &mutex_X1, &rwsem_X1);
169 	init_class_X(&lock_X2, &rwlock_X2, &mutex_X2, &rwsem_X2);
170 
171 	init_class_Y(&lock_Y1, &rwlock_Y1, &mutex_Y1, &rwsem_Y1);
172 	init_class_Y(&lock_Y2, &rwlock_Y2, &mutex_Y2, &rwsem_Y2);
173 
174 	init_class_Z(&lock_Z1, &rwlock_Z1, &mutex_Z1, &rwsem_Z1);
175 	init_class_Z(&lock_Z2, &rwlock_Z2, &mutex_Z2, &rwsem_Z2);
176 }
177 
178 /*
179  * For spinlocks and rwlocks we also do hardirq-safe / softirq-safe tests.
180  * The following functions use a lock from a simulated hardirq/softirq
181  * context, causing the locks to be marked as hardirq-safe/softirq-safe:
182  */
183 
184 #define HARDIRQ_DISABLE		local_irq_disable
185 #define HARDIRQ_ENABLE		local_irq_enable
186 
187 #define HARDIRQ_ENTER()				\
188 	local_irq_disable();			\
189 	__irq_enter();				\
190 	WARN_ON(!in_irq());
191 
192 #define HARDIRQ_EXIT()				\
193 	__irq_exit();				\
194 	local_irq_enable();
195 
196 #define SOFTIRQ_DISABLE		local_bh_disable
197 #define SOFTIRQ_ENABLE		local_bh_enable
198 
199 #define SOFTIRQ_ENTER()				\
200 		local_bh_disable();		\
201 		local_irq_disable();		\
202 		lockdep_softirq_enter();	\
203 		WARN_ON(!in_softirq());
204 
205 #define SOFTIRQ_EXIT()				\
206 		lockdep_softirq_exit();		\
207 		local_irq_enable();		\
208 		local_bh_enable();
209 
210 /*
211  * Shortcuts for lock/unlock API variants, to keep
212  * the testcases compact:
213  */
214 #define L(x)			spin_lock(&lock_##x)
215 #define U(x)			spin_unlock(&lock_##x)
216 #define LU(x)			L(x); U(x)
217 #define SI(x)			spin_lock_init(&lock_##x)
218 
219 #define WL(x)			write_lock(&rwlock_##x)
220 #define WU(x)			write_unlock(&rwlock_##x)
221 #define WLU(x)			WL(x); WU(x)
222 
223 #define RL(x)			read_lock(&rwlock_##x)
224 #define RU(x)			read_unlock(&rwlock_##x)
225 #define RLU(x)			RL(x); RU(x)
226 #define RWI(x)			rwlock_init(&rwlock_##x)
227 
228 #define ML(x)			mutex_lock(&mutex_##x)
229 #define MU(x)			mutex_unlock(&mutex_##x)
230 #define MI(x)			mutex_init(&mutex_##x)
231 
232 #define RTL(x)			rt_mutex_lock(&rtmutex_##x)
233 #define RTU(x)			rt_mutex_unlock(&rtmutex_##x)
234 #define RTI(x)			rt_mutex_init(&rtmutex_##x)
235 
236 #define WSL(x)			down_write(&rwsem_##x)
237 #define WSU(x)			up_write(&rwsem_##x)
238 
239 #define RSL(x)			down_read(&rwsem_##x)
240 #define RSU(x)			up_read(&rwsem_##x)
241 #define RWSI(x)			init_rwsem(&rwsem_##x)
242 
243 #ifndef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
244 #define WWAI(x)			ww_acquire_init(x, &ww_lockdep)
245 #else
246 #define WWAI(x)			do { ww_acquire_init(x, &ww_lockdep); (x)->deadlock_inject_countdown = ~0U; } while (0)
247 #endif
248 #define WWAD(x)			ww_acquire_done(x)
249 #define WWAF(x)			ww_acquire_fini(x)
250 
251 #define WWL(x, c)		ww_mutex_lock(x, c)
252 #define WWT(x)			ww_mutex_trylock(x)
253 #define WWL1(x)			ww_mutex_lock(x, NULL)
254 #define WWU(x)			ww_mutex_unlock(x)
255 
256 
257 #define LOCK_UNLOCK_2(x,y)	LOCK(x); LOCK(y); UNLOCK(y); UNLOCK(x)
258 
259 /*
260  * Generate different permutations of the same testcase, using
261  * the same basic lock-dependency/state events:
262  */
263 
264 #define GENERATE_TESTCASE(name)			\
265 						\
266 static void name(void) { E(); }
267 
268 #define GENERATE_PERMUTATIONS_2_EVENTS(name)	\
269 						\
270 static void name##_12(void) { E1(); E2(); }	\
271 static void name##_21(void) { E2(); E1(); }
272 
273 #define GENERATE_PERMUTATIONS_3_EVENTS(name)		\
274 							\
275 static void name##_123(void) { E1(); E2(); E3(); }	\
276 static void name##_132(void) { E1(); E3(); E2(); }	\
277 static void name##_213(void) { E2(); E1(); E3(); }	\
278 static void name##_231(void) { E2(); E3(); E1(); }	\
279 static void name##_312(void) { E3(); E1(); E2(); }	\
280 static void name##_321(void) { E3(); E2(); E1(); }
281 
282 /*
283  * AA deadlock:
284  */
285 
286 #define E()					\
287 						\
288 	LOCK(X1);				\
289 	LOCK(X2); /* this one should fail */
290 
291 /*
292  * 6 testcases:
293  */
294 #include "locking-selftest-spin.h"
295 GENERATE_TESTCASE(AA_spin)
296 #include "locking-selftest-wlock.h"
297 GENERATE_TESTCASE(AA_wlock)
298 #include "locking-selftest-rlock.h"
299 GENERATE_TESTCASE(AA_rlock)
300 #include "locking-selftest-mutex.h"
301 GENERATE_TESTCASE(AA_mutex)
302 #include "locking-selftest-wsem.h"
303 GENERATE_TESTCASE(AA_wsem)
304 #include "locking-selftest-rsem.h"
305 GENERATE_TESTCASE(AA_rsem)
306 
307 #ifdef CONFIG_RT_MUTEXES
308 #include "locking-selftest-rtmutex.h"
309 GENERATE_TESTCASE(AA_rtmutex);
310 #endif
311 
312 #undef E
313 
314 /*
315  * Special-case for read-locking, they are
316  * allowed to recurse on the same lock class:
317  */
318 static void rlock_AA1(void)
319 {
320 	RL(X1);
321 	RL(X1); // this one should NOT fail
322 }
323 
324 static void rlock_AA1B(void)
325 {
326 	RL(X1);
327 	RL(X2); // this one should NOT fail
328 }
329 
330 static void rsem_AA1(void)
331 {
332 	RSL(X1);
333 	RSL(X1); // this one should fail
334 }
335 
336 static void rsem_AA1B(void)
337 {
338 	RSL(X1);
339 	RSL(X2); // this one should fail
340 }
341 /*
342  * The mixing of read and write locks is not allowed:
343  */
344 static void rlock_AA2(void)
345 {
346 	RL(X1);
347 	WL(X2); // this one should fail
348 }
349 
350 static void rsem_AA2(void)
351 {
352 	RSL(X1);
353 	WSL(X2); // this one should fail
354 }
355 
356 static void rlock_AA3(void)
357 {
358 	WL(X1);
359 	RL(X2); // this one should fail
360 }
361 
362 static void rsem_AA3(void)
363 {
364 	WSL(X1);
365 	RSL(X2); // this one should fail
366 }
367 
368 /*
369  * read_lock(A)
370  * spin_lock(B)
371  *		spin_lock(B)
372  *		write_lock(A)
373  */
374 static void rlock_ABBA1(void)
375 {
376 	RL(X1);
377 	L(Y1);
378 	U(Y1);
379 	RU(X1);
380 
381 	L(Y1);
382 	WL(X1);
383 	WU(X1);
384 	U(Y1); // should fail
385 }
386 
387 static void rwsem_ABBA1(void)
388 {
389 	RSL(X1);
390 	ML(Y1);
391 	MU(Y1);
392 	RSU(X1);
393 
394 	ML(Y1);
395 	WSL(X1);
396 	WSU(X1);
397 	MU(Y1); // should fail
398 }
399 
400 /*
401  * read_lock(A)
402  * spin_lock(B)
403  *		spin_lock(B)
404  *		write_lock(A)
405  *
406  * This test case is aimed at poking whether the chain cache prevents us from
407  * detecting a read-lock/lock-write deadlock: if the chain cache doesn't differ
408  * read/write locks, the following case may happen
409  *
410  * 	{ read_lock(A)->lock(B) dependency exists }
411  *
412  * 	P0:
413  * 	lock(B);
414  * 	read_lock(A);
415  *
416  *	{ Not a deadlock, B -> A is added in the chain cache }
417  *
418  *	P1:
419  *	lock(B);
420  *	write_lock(A);
421  *
422  *	{ B->A found in chain cache, not reported as a deadlock }
423  *
424  */
425 static void rlock_chaincache_ABBA1(void)
426 {
427 	RL(X1);
428 	L(Y1);
429 	U(Y1);
430 	RU(X1);
431 
432 	L(Y1);
433 	RL(X1);
434 	RU(X1);
435 	U(Y1);
436 
437 	L(Y1);
438 	WL(X1);
439 	WU(X1);
440 	U(Y1); // should fail
441 }
442 
443 /*
444  * read_lock(A)
445  * spin_lock(B)
446  *		spin_lock(B)
447  *		read_lock(A)
448  */
449 static void rlock_ABBA2(void)
450 {
451 	RL(X1);
452 	L(Y1);
453 	U(Y1);
454 	RU(X1);
455 
456 	L(Y1);
457 	RL(X1);
458 	RU(X1);
459 	U(Y1); // should NOT fail
460 }
461 
462 static void rwsem_ABBA2(void)
463 {
464 	RSL(X1);
465 	ML(Y1);
466 	MU(Y1);
467 	RSU(X1);
468 
469 	ML(Y1);
470 	RSL(X1);
471 	RSU(X1);
472 	MU(Y1); // should fail
473 }
474 
475 
476 /*
477  * write_lock(A)
478  * spin_lock(B)
479  *		spin_lock(B)
480  *		write_lock(A)
481  */
482 static void rlock_ABBA3(void)
483 {
484 	WL(X1);
485 	L(Y1);
486 	U(Y1);
487 	WU(X1);
488 
489 	L(Y1);
490 	WL(X1);
491 	WU(X1);
492 	U(Y1); // should fail
493 }
494 
495 static void rwsem_ABBA3(void)
496 {
497 	WSL(X1);
498 	ML(Y1);
499 	MU(Y1);
500 	WSU(X1);
501 
502 	ML(Y1);
503 	WSL(X1);
504 	WSU(X1);
505 	MU(Y1); // should fail
506 }
507 
508 /*
509  * ABBA deadlock:
510  */
511 
512 #define E()					\
513 						\
514 	LOCK_UNLOCK_2(A, B);			\
515 	LOCK_UNLOCK_2(B, A); /* fail */
516 
517 /*
518  * 6 testcases:
519  */
520 #include "locking-selftest-spin.h"
521 GENERATE_TESTCASE(ABBA_spin)
522 #include "locking-selftest-wlock.h"
523 GENERATE_TESTCASE(ABBA_wlock)
524 #include "locking-selftest-rlock.h"
525 GENERATE_TESTCASE(ABBA_rlock)
526 #include "locking-selftest-mutex.h"
527 GENERATE_TESTCASE(ABBA_mutex)
528 #include "locking-selftest-wsem.h"
529 GENERATE_TESTCASE(ABBA_wsem)
530 #include "locking-selftest-rsem.h"
531 GENERATE_TESTCASE(ABBA_rsem)
532 
533 #ifdef CONFIG_RT_MUTEXES
534 #include "locking-selftest-rtmutex.h"
535 GENERATE_TESTCASE(ABBA_rtmutex);
536 #endif
537 
538 #undef E
539 
540 /*
541  * AB BC CA deadlock:
542  */
543 
544 #define E()					\
545 						\
546 	LOCK_UNLOCK_2(A, B);			\
547 	LOCK_UNLOCK_2(B, C);			\
548 	LOCK_UNLOCK_2(C, A); /* fail */
549 
550 /*
551  * 6 testcases:
552  */
553 #include "locking-selftest-spin.h"
554 GENERATE_TESTCASE(ABBCCA_spin)
555 #include "locking-selftest-wlock.h"
556 GENERATE_TESTCASE(ABBCCA_wlock)
557 #include "locking-selftest-rlock.h"
558 GENERATE_TESTCASE(ABBCCA_rlock)
559 #include "locking-selftest-mutex.h"
560 GENERATE_TESTCASE(ABBCCA_mutex)
561 #include "locking-selftest-wsem.h"
562 GENERATE_TESTCASE(ABBCCA_wsem)
563 #include "locking-selftest-rsem.h"
564 GENERATE_TESTCASE(ABBCCA_rsem)
565 
566 #ifdef CONFIG_RT_MUTEXES
567 #include "locking-selftest-rtmutex.h"
568 GENERATE_TESTCASE(ABBCCA_rtmutex);
569 #endif
570 
571 #undef E
572 
573 /*
574  * AB CA BC deadlock:
575  */
576 
577 #define E()					\
578 						\
579 	LOCK_UNLOCK_2(A, B);			\
580 	LOCK_UNLOCK_2(C, A);			\
581 	LOCK_UNLOCK_2(B, C); /* fail */
582 
583 /*
584  * 6 testcases:
585  */
586 #include "locking-selftest-spin.h"
587 GENERATE_TESTCASE(ABCABC_spin)
588 #include "locking-selftest-wlock.h"
589 GENERATE_TESTCASE(ABCABC_wlock)
590 #include "locking-selftest-rlock.h"
591 GENERATE_TESTCASE(ABCABC_rlock)
592 #include "locking-selftest-mutex.h"
593 GENERATE_TESTCASE(ABCABC_mutex)
594 #include "locking-selftest-wsem.h"
595 GENERATE_TESTCASE(ABCABC_wsem)
596 #include "locking-selftest-rsem.h"
597 GENERATE_TESTCASE(ABCABC_rsem)
598 
599 #ifdef CONFIG_RT_MUTEXES
600 #include "locking-selftest-rtmutex.h"
601 GENERATE_TESTCASE(ABCABC_rtmutex);
602 #endif
603 
604 #undef E
605 
606 /*
607  * AB BC CD DA deadlock:
608  */
609 
610 #define E()					\
611 						\
612 	LOCK_UNLOCK_2(A, B);			\
613 	LOCK_UNLOCK_2(B, C);			\
614 	LOCK_UNLOCK_2(C, D);			\
615 	LOCK_UNLOCK_2(D, A); /* fail */
616 
617 /*
618  * 6 testcases:
619  */
620 #include "locking-selftest-spin.h"
621 GENERATE_TESTCASE(ABBCCDDA_spin)
622 #include "locking-selftest-wlock.h"
623 GENERATE_TESTCASE(ABBCCDDA_wlock)
624 #include "locking-selftest-rlock.h"
625 GENERATE_TESTCASE(ABBCCDDA_rlock)
626 #include "locking-selftest-mutex.h"
627 GENERATE_TESTCASE(ABBCCDDA_mutex)
628 #include "locking-selftest-wsem.h"
629 GENERATE_TESTCASE(ABBCCDDA_wsem)
630 #include "locking-selftest-rsem.h"
631 GENERATE_TESTCASE(ABBCCDDA_rsem)
632 
633 #ifdef CONFIG_RT_MUTEXES
634 #include "locking-selftest-rtmutex.h"
635 GENERATE_TESTCASE(ABBCCDDA_rtmutex);
636 #endif
637 
638 #undef E
639 
640 /*
641  * AB CD BD DA deadlock:
642  */
643 #define E()					\
644 						\
645 	LOCK_UNLOCK_2(A, B);			\
646 	LOCK_UNLOCK_2(C, D);			\
647 	LOCK_UNLOCK_2(B, D);			\
648 	LOCK_UNLOCK_2(D, A); /* fail */
649 
650 /*
651  * 6 testcases:
652  */
653 #include "locking-selftest-spin.h"
654 GENERATE_TESTCASE(ABCDBDDA_spin)
655 #include "locking-selftest-wlock.h"
656 GENERATE_TESTCASE(ABCDBDDA_wlock)
657 #include "locking-selftest-rlock.h"
658 GENERATE_TESTCASE(ABCDBDDA_rlock)
659 #include "locking-selftest-mutex.h"
660 GENERATE_TESTCASE(ABCDBDDA_mutex)
661 #include "locking-selftest-wsem.h"
662 GENERATE_TESTCASE(ABCDBDDA_wsem)
663 #include "locking-selftest-rsem.h"
664 GENERATE_TESTCASE(ABCDBDDA_rsem)
665 
666 #ifdef CONFIG_RT_MUTEXES
667 #include "locking-selftest-rtmutex.h"
668 GENERATE_TESTCASE(ABCDBDDA_rtmutex);
669 #endif
670 
671 #undef E
672 
673 /*
674  * AB CD BC DA deadlock:
675  */
676 #define E()					\
677 						\
678 	LOCK_UNLOCK_2(A, B);			\
679 	LOCK_UNLOCK_2(C, D);			\
680 	LOCK_UNLOCK_2(B, C);			\
681 	LOCK_UNLOCK_2(D, A); /* fail */
682 
683 /*
684  * 6 testcases:
685  */
686 #include "locking-selftest-spin.h"
687 GENERATE_TESTCASE(ABCDBCDA_spin)
688 #include "locking-selftest-wlock.h"
689 GENERATE_TESTCASE(ABCDBCDA_wlock)
690 #include "locking-selftest-rlock.h"
691 GENERATE_TESTCASE(ABCDBCDA_rlock)
692 #include "locking-selftest-mutex.h"
693 GENERATE_TESTCASE(ABCDBCDA_mutex)
694 #include "locking-selftest-wsem.h"
695 GENERATE_TESTCASE(ABCDBCDA_wsem)
696 #include "locking-selftest-rsem.h"
697 GENERATE_TESTCASE(ABCDBCDA_rsem)
698 
699 #ifdef CONFIG_RT_MUTEXES
700 #include "locking-selftest-rtmutex.h"
701 GENERATE_TESTCASE(ABCDBCDA_rtmutex);
702 #endif
703 
704 #undef E
705 
706 /*
707  * Double unlock:
708  */
709 #define E()					\
710 						\
711 	LOCK(A);				\
712 	UNLOCK(A);				\
713 	UNLOCK(A); /* fail */
714 
715 /*
716  * 6 testcases:
717  */
718 #include "locking-selftest-spin.h"
719 GENERATE_TESTCASE(double_unlock_spin)
720 #include "locking-selftest-wlock.h"
721 GENERATE_TESTCASE(double_unlock_wlock)
722 #include "locking-selftest-rlock.h"
723 GENERATE_TESTCASE(double_unlock_rlock)
724 #include "locking-selftest-mutex.h"
725 GENERATE_TESTCASE(double_unlock_mutex)
726 #include "locking-selftest-wsem.h"
727 GENERATE_TESTCASE(double_unlock_wsem)
728 #include "locking-selftest-rsem.h"
729 GENERATE_TESTCASE(double_unlock_rsem)
730 
731 #ifdef CONFIG_RT_MUTEXES
732 #include "locking-selftest-rtmutex.h"
733 GENERATE_TESTCASE(double_unlock_rtmutex);
734 #endif
735 
736 #undef E
737 
738 /*
739  * initializing a held lock:
740  */
741 #define E()					\
742 						\
743 	LOCK(A);				\
744 	INIT(A); /* fail */
745 
746 /*
747  * 6 testcases:
748  */
749 #include "locking-selftest-spin.h"
750 GENERATE_TESTCASE(init_held_spin)
751 #include "locking-selftest-wlock.h"
752 GENERATE_TESTCASE(init_held_wlock)
753 #include "locking-selftest-rlock.h"
754 GENERATE_TESTCASE(init_held_rlock)
755 #include "locking-selftest-mutex.h"
756 GENERATE_TESTCASE(init_held_mutex)
757 #include "locking-selftest-wsem.h"
758 GENERATE_TESTCASE(init_held_wsem)
759 #include "locking-selftest-rsem.h"
760 GENERATE_TESTCASE(init_held_rsem)
761 
762 #ifdef CONFIG_RT_MUTEXES
763 #include "locking-selftest-rtmutex.h"
764 GENERATE_TESTCASE(init_held_rtmutex);
765 #endif
766 
767 #undef E
768 
769 /*
770  * locking an irq-safe lock with irqs enabled:
771  */
772 #define E1()				\
773 					\
774 	IRQ_ENTER();			\
775 	LOCK(A);			\
776 	UNLOCK(A);			\
777 	IRQ_EXIT();
778 
779 #define E2()				\
780 					\
781 	LOCK(A);			\
782 	UNLOCK(A);
783 
784 /*
785  * Generate 24 testcases:
786  */
787 #include "locking-selftest-spin-hardirq.h"
788 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_spin)
789 
790 #include "locking-selftest-rlock-hardirq.h"
791 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_rlock)
792 
793 #include "locking-selftest-wlock-hardirq.h"
794 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_wlock)
795 
796 #include "locking-selftest-spin-softirq.h"
797 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_spin)
798 
799 #include "locking-selftest-rlock-softirq.h"
800 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_rlock)
801 
802 #include "locking-selftest-wlock-softirq.h"
803 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_wlock)
804 
805 #undef E1
806 #undef E2
807 
808 /*
809  * Enabling hardirqs with a softirq-safe lock held:
810  */
811 #define E1()				\
812 					\
813 	SOFTIRQ_ENTER();		\
814 	LOCK(A);			\
815 	UNLOCK(A);			\
816 	SOFTIRQ_EXIT();
817 
818 #define E2()				\
819 					\
820 	HARDIRQ_DISABLE();		\
821 	LOCK(A);			\
822 	HARDIRQ_ENABLE();		\
823 	UNLOCK(A);
824 
825 /*
826  * Generate 12 testcases:
827  */
828 #include "locking-selftest-spin.h"
829 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_spin)
830 
831 #include "locking-selftest-wlock.h"
832 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_wlock)
833 
834 #include "locking-selftest-rlock.h"
835 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_rlock)
836 
837 #undef E1
838 #undef E2
839 
840 /*
841  * Enabling irqs with an irq-safe lock held:
842  */
843 #define E1()				\
844 					\
845 	IRQ_ENTER();			\
846 	LOCK(A);			\
847 	UNLOCK(A);			\
848 	IRQ_EXIT();
849 
850 #define E2()				\
851 					\
852 	IRQ_DISABLE();			\
853 	LOCK(A);			\
854 	IRQ_ENABLE();			\
855 	UNLOCK(A);
856 
857 /*
858  * Generate 24 testcases:
859  */
860 #include "locking-selftest-spin-hardirq.h"
861 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_spin)
862 
863 #include "locking-selftest-rlock-hardirq.h"
864 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_rlock)
865 
866 #include "locking-selftest-wlock-hardirq.h"
867 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_wlock)
868 
869 #include "locking-selftest-spin-softirq.h"
870 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_spin)
871 
872 #include "locking-selftest-rlock-softirq.h"
873 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_rlock)
874 
875 #include "locking-selftest-wlock-softirq.h"
876 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_wlock)
877 
878 #undef E1
879 #undef E2
880 
881 /*
882  * Acquiring a irq-unsafe lock while holding an irq-safe-lock:
883  */
884 #define E1()				\
885 					\
886 	LOCK(A);			\
887 	LOCK(B);			\
888 	UNLOCK(B);			\
889 	UNLOCK(A);			\
890 
891 #define E2()				\
892 					\
893 	LOCK(B);			\
894 	UNLOCK(B);
895 
896 #define E3()				\
897 					\
898 	IRQ_ENTER();			\
899 	LOCK(A);			\
900 	UNLOCK(A);			\
901 	IRQ_EXIT();
902 
903 /*
904  * Generate 36 testcases:
905  */
906 #include "locking-selftest-spin-hardirq.h"
907 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_spin)
908 
909 #include "locking-selftest-rlock-hardirq.h"
910 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_rlock)
911 
912 #include "locking-selftest-wlock-hardirq.h"
913 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_wlock)
914 
915 #include "locking-selftest-spin-softirq.h"
916 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_spin)
917 
918 #include "locking-selftest-rlock-softirq.h"
919 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_rlock)
920 
921 #include "locking-selftest-wlock-softirq.h"
922 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_wlock)
923 
924 #undef E1
925 #undef E2
926 #undef E3
927 
928 /*
929  * If a lock turns into softirq-safe, but earlier it took
930  * a softirq-unsafe lock:
931  */
932 
933 #define E1()				\
934 	IRQ_DISABLE();			\
935 	LOCK(A);			\
936 	LOCK(B);			\
937 	UNLOCK(B);			\
938 	UNLOCK(A);			\
939 	IRQ_ENABLE();
940 
941 #define E2()				\
942 	LOCK(B);			\
943 	UNLOCK(B);
944 
945 #define E3()				\
946 	IRQ_ENTER();			\
947 	LOCK(A);			\
948 	UNLOCK(A);			\
949 	IRQ_EXIT();
950 
951 /*
952  * Generate 36 testcases:
953  */
954 #include "locking-selftest-spin-hardirq.h"
955 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_spin)
956 
957 #include "locking-selftest-rlock-hardirq.h"
958 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_rlock)
959 
960 #include "locking-selftest-wlock-hardirq.h"
961 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_wlock)
962 
963 #include "locking-selftest-spin-softirq.h"
964 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_spin)
965 
966 #include "locking-selftest-rlock-softirq.h"
967 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_rlock)
968 
969 #include "locking-selftest-wlock-softirq.h"
970 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_wlock)
971 
972 #undef E1
973 #undef E2
974 #undef E3
975 
976 /*
977  * read-lock / write-lock irq inversion.
978  *
979  * Deadlock scenario:
980  *
981  * CPU#1 is at #1, i.e. it has write-locked A, but has not
982  * taken B yet.
983  *
984  * CPU#2 is at #2, i.e. it has locked B.
985  *
986  * Hardirq hits CPU#2 at point #2 and is trying to read-lock A.
987  *
988  * The deadlock occurs because CPU#1 will spin on B, and CPU#2
989  * will spin on A.
990  */
991 
992 #define E1()				\
993 					\
994 	IRQ_DISABLE();			\
995 	WL(A);				\
996 	LOCK(B);			\
997 	UNLOCK(B);			\
998 	WU(A);				\
999 	IRQ_ENABLE();
1000 
1001 #define E2()				\
1002 					\
1003 	LOCK(B);			\
1004 	UNLOCK(B);
1005 
1006 #define E3()				\
1007 					\
1008 	IRQ_ENTER();			\
1009 	RL(A);				\
1010 	RU(A);				\
1011 	IRQ_EXIT();
1012 
1013 /*
1014  * Generate 36 testcases:
1015  */
1016 #include "locking-selftest-spin-hardirq.h"
1017 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_spin)
1018 
1019 #include "locking-selftest-rlock-hardirq.h"
1020 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_rlock)
1021 
1022 #include "locking-selftest-wlock-hardirq.h"
1023 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_wlock)
1024 
1025 #include "locking-selftest-spin-softirq.h"
1026 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_spin)
1027 
1028 #include "locking-selftest-rlock-softirq.h"
1029 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_rlock)
1030 
1031 #include "locking-selftest-wlock-softirq.h"
1032 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_wlock)
1033 
1034 #undef E1
1035 #undef E2
1036 #undef E3
1037 
1038 /*
1039  * write-read / write-read / write-read deadlock even if read is recursive
1040  */
1041 
1042 #define E1()				\
1043 					\
1044 	WL(X1);				\
1045 	RL(Y1);				\
1046 	RU(Y1);				\
1047 	WU(X1);
1048 
1049 #define E2()				\
1050 					\
1051 	WL(Y1);				\
1052 	RL(Z1);				\
1053 	RU(Z1);				\
1054 	WU(Y1);
1055 
1056 #define E3()				\
1057 					\
1058 	WL(Z1);				\
1059 	RL(X1);				\
1060 	RU(X1);				\
1061 	WU(Z1);
1062 
1063 #include "locking-selftest-rlock.h"
1064 GENERATE_PERMUTATIONS_3_EVENTS(W1R2_W2R3_W3R1)
1065 
1066 #undef E1
1067 #undef E2
1068 #undef E3
1069 
1070 /*
1071  * write-write / read-read / write-read deadlock even if read is recursive
1072  */
1073 
1074 #define E1()				\
1075 					\
1076 	WL(X1);				\
1077 	WL(Y1);				\
1078 	WU(Y1);				\
1079 	WU(X1);
1080 
1081 #define E2()				\
1082 					\
1083 	RL(Y1);				\
1084 	RL(Z1);				\
1085 	RU(Z1);				\
1086 	RU(Y1);
1087 
1088 #define E3()				\
1089 					\
1090 	WL(Z1);				\
1091 	RL(X1);				\
1092 	RU(X1);				\
1093 	WU(Z1);
1094 
1095 #include "locking-selftest-rlock.h"
1096 GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_W3R1)
1097 
1098 #undef E1
1099 #undef E2
1100 #undef E3
1101 
1102 /*
1103  * write-write / read-read / read-write is not deadlock when read is recursive
1104  */
1105 
1106 #define E1()				\
1107 					\
1108 	WL(X1);				\
1109 	WL(Y1);				\
1110 	WU(Y1);				\
1111 	WU(X1);
1112 
1113 #define E2()				\
1114 					\
1115 	RL(Y1);				\
1116 	RL(Z1);				\
1117 	RU(Z1);				\
1118 	RU(Y1);
1119 
1120 #define E3()				\
1121 					\
1122 	RL(Z1);				\
1123 	WL(X1);				\
1124 	WU(X1);				\
1125 	RU(Z1);
1126 
1127 #include "locking-selftest-rlock.h"
1128 GENERATE_PERMUTATIONS_3_EVENTS(W1R2_R2R3_W3W1)
1129 
1130 #undef E1
1131 #undef E2
1132 #undef E3
1133 
1134 /*
1135  * write-read / read-read / write-write is not deadlock when read is recursive
1136  */
1137 
1138 #define E1()				\
1139 					\
1140 	WL(X1);				\
1141 	RL(Y1);				\
1142 	RU(Y1);				\
1143 	WU(X1);
1144 
1145 #define E2()				\
1146 					\
1147 	RL(Y1);				\
1148 	RL(Z1);				\
1149 	RU(Z1);				\
1150 	RU(Y1);
1151 
1152 #define E3()				\
1153 					\
1154 	WL(Z1);				\
1155 	WL(X1);				\
1156 	WU(X1);				\
1157 	WU(Z1);
1158 
1159 #include "locking-selftest-rlock.h"
1160 GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_R3W1)
1161 
1162 #undef E1
1163 #undef E2
1164 #undef E3
1165 /*
1166  * read-lock / write-lock recursion that is actually safe.
1167  */
1168 
1169 #define E1()				\
1170 					\
1171 	IRQ_DISABLE();			\
1172 	WL(A);				\
1173 	WU(A);				\
1174 	IRQ_ENABLE();
1175 
1176 #define E2()				\
1177 					\
1178 	RL(A);				\
1179 	RU(A);				\
1180 
1181 #define E3()				\
1182 					\
1183 	IRQ_ENTER();			\
1184 	LOCK(A);			\
1185 	L(B);				\
1186 	U(B);				\
1187 	UNLOCK(A);			\
1188 	IRQ_EXIT();
1189 
1190 /*
1191  * Generate 24 testcases:
1192  */
1193 #include "locking-selftest-hardirq.h"
1194 #include "locking-selftest-rlock.h"
1195 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_rlock)
1196 
1197 #include "locking-selftest-wlock.h"
1198 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_wlock)
1199 
1200 #include "locking-selftest-softirq.h"
1201 #include "locking-selftest-rlock.h"
1202 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_rlock)
1203 
1204 #include "locking-selftest-wlock.h"
1205 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_wlock)
1206 
1207 #undef E1
1208 #undef E2
1209 #undef E3
1210 
1211 /*
1212  * read-lock / write-lock recursion that is unsafe.
1213  */
1214 
1215 #define E1()				\
1216 					\
1217 	IRQ_DISABLE();			\
1218 	L(B);				\
1219 	LOCK(A);			\
1220 	UNLOCK(A);			\
1221 	U(B);				\
1222 	IRQ_ENABLE();
1223 
1224 #define E2()				\
1225 					\
1226 	RL(A);				\
1227 	RU(A);				\
1228 
1229 #define E3()				\
1230 					\
1231 	IRQ_ENTER();			\
1232 	L(B);				\
1233 	U(B);				\
1234 	IRQ_EXIT();
1235 
1236 /*
1237  * Generate 24 testcases:
1238  */
1239 #include "locking-selftest-hardirq.h"
1240 #include "locking-selftest-rlock.h"
1241 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_rlock)
1242 
1243 #include "locking-selftest-wlock.h"
1244 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_wlock)
1245 
1246 #include "locking-selftest-softirq.h"
1247 #include "locking-selftest-rlock.h"
1248 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_rlock)
1249 
1250 #include "locking-selftest-wlock.h"
1251 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_wlock)
1252 
1253 #undef E1
1254 #undef E2
1255 #undef E3
1256 /*
1257  * read-lock / write-lock recursion that is unsafe.
1258  *
1259  * A is a ENABLED_*_READ lock
1260  * B is a USED_IN_*_READ lock
1261  *
1262  * read_lock(A);
1263  *			write_lock(B);
1264  * <interrupt>
1265  * read_lock(B);
1266  * 			write_lock(A); // if this one is read_lock(), no deadlock
1267  */
1268 
1269 #define E1()				\
1270 					\
1271 	IRQ_DISABLE();			\
1272 	WL(B);				\
1273 	LOCK(A);			\
1274 	UNLOCK(A);			\
1275 	WU(B);				\
1276 	IRQ_ENABLE();
1277 
1278 #define E2()				\
1279 					\
1280 	RL(A);				\
1281 	RU(A);				\
1282 
1283 #define E3()				\
1284 					\
1285 	IRQ_ENTER();			\
1286 	RL(B);				\
1287 	RU(B);				\
1288 	IRQ_EXIT();
1289 
1290 /*
1291  * Generate 24 testcases:
1292  */
1293 #include "locking-selftest-hardirq.h"
1294 #include "locking-selftest-rlock.h"
1295 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_rlock)
1296 
1297 #include "locking-selftest-wlock.h"
1298 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_wlock)
1299 
1300 #include "locking-selftest-softirq.h"
1301 #include "locking-selftest-rlock.h"
1302 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_rlock)
1303 
1304 #include "locking-selftest-wlock.h"
1305 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_wlock)
1306 
1307 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1308 # define I_SPINLOCK(x)	lockdep_reset_lock(&lock_##x.dep_map)
1309 # define I_RWLOCK(x)	lockdep_reset_lock(&rwlock_##x.dep_map)
1310 # define I_MUTEX(x)	lockdep_reset_lock(&mutex_##x.dep_map)
1311 # define I_RWSEM(x)	lockdep_reset_lock(&rwsem_##x.dep_map)
1312 # define I_WW(x)	lockdep_reset_lock(&x.dep_map)
1313 #ifdef CONFIG_RT_MUTEXES
1314 # define I_RTMUTEX(x)	lockdep_reset_lock(&rtmutex_##x.dep_map)
1315 #endif
1316 #else
1317 # define I_SPINLOCK(x)
1318 # define I_RWLOCK(x)
1319 # define I_MUTEX(x)
1320 # define I_RWSEM(x)
1321 # define I_WW(x)
1322 #endif
1323 
1324 #ifndef I_RTMUTEX
1325 # define I_RTMUTEX(x)
1326 #endif
1327 
1328 #ifdef CONFIG_RT_MUTEXES
1329 #define I2_RTMUTEX(x)	rt_mutex_init(&rtmutex_##x)
1330 #else
1331 #define I2_RTMUTEX(x)
1332 #endif
1333 
1334 #define I1(x)					\
1335 	do {					\
1336 		I_SPINLOCK(x);			\
1337 		I_RWLOCK(x);			\
1338 		I_MUTEX(x);			\
1339 		I_RWSEM(x);			\
1340 		I_RTMUTEX(x);			\
1341 	} while (0)
1342 
1343 #define I2(x)					\
1344 	do {					\
1345 		spin_lock_init(&lock_##x);	\
1346 		rwlock_init(&rwlock_##x);	\
1347 		mutex_init(&mutex_##x);		\
1348 		init_rwsem(&rwsem_##x);		\
1349 		I2_RTMUTEX(x);			\
1350 	} while (0)
1351 
1352 static void reset_locks(void)
1353 {
1354 	local_irq_disable();
1355 	lockdep_free_key_range(&ww_lockdep.acquire_key, 1);
1356 	lockdep_free_key_range(&ww_lockdep.mutex_key, 1);
1357 
1358 	I1(A); I1(B); I1(C); I1(D);
1359 	I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);
1360 	I_WW(t); I_WW(t2); I_WW(o.base); I_WW(o2.base); I_WW(o3.base);
1361 	lockdep_reset();
1362 	I2(A); I2(B); I2(C); I2(D);
1363 	init_shared_classes();
1364 
1365 	ww_mutex_init(&o, &ww_lockdep); ww_mutex_init(&o2, &ww_lockdep); ww_mutex_init(&o3, &ww_lockdep);
1366 	memset(&t, 0, sizeof(t)); memset(&t2, 0, sizeof(t2));
1367 	memset(&ww_lockdep.acquire_key, 0, sizeof(ww_lockdep.acquire_key));
1368 	memset(&ww_lockdep.mutex_key, 0, sizeof(ww_lockdep.mutex_key));
1369 	local_irq_enable();
1370 }
1371 
1372 #undef I
1373 
1374 static int testcase_total;
1375 static int testcase_successes;
1376 static int expected_testcase_failures;
1377 static int unexpected_testcase_failures;
1378 
1379 static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
1380 {
1381 	unsigned long saved_preempt_count = preempt_count();
1382 
1383 	WARN_ON(irqs_disabled());
1384 
1385 	testcase_fn();
1386 	/*
1387 	 * Filter out expected failures:
1388 	 */
1389 #ifndef CONFIG_PROVE_LOCKING
1390 	if (expected == FAILURE && debug_locks) {
1391 		expected_testcase_failures++;
1392 		pr_cont("failed|");
1393 	}
1394 	else
1395 #endif
1396 	if (debug_locks != expected) {
1397 		unexpected_testcase_failures++;
1398 		pr_cont("FAILED|");
1399 	} else {
1400 		testcase_successes++;
1401 		pr_cont("  ok  |");
1402 	}
1403 	testcase_total++;
1404 
1405 	if (debug_locks_verbose)
1406 		pr_cont(" lockclass mask: %x, debug_locks: %d, expected: %d\n",
1407 			lockclass_mask, debug_locks, expected);
1408 	/*
1409 	 * Some tests (e.g. double-unlock) might corrupt the preemption
1410 	 * count, so restore it:
1411 	 */
1412 	preempt_count_set(saved_preempt_count);
1413 #ifdef CONFIG_TRACE_IRQFLAGS
1414 	if (softirq_count())
1415 		current->softirqs_enabled = 0;
1416 	else
1417 		current->softirqs_enabled = 1;
1418 #endif
1419 
1420 	reset_locks();
1421 }
1422 
1423 #ifdef CONFIG_RT_MUTEXES
1424 #define dotest_rt(fn, e, m)	dotest((fn), (e), (m))
1425 #else
1426 #define dotest_rt(fn, e, m)
1427 #endif
1428 
1429 static inline void print_testname(const char *testname)
1430 {
1431 	printk("%33s:", testname);
1432 }
1433 
1434 #define DO_TESTCASE_1(desc, name, nr)				\
1435 	print_testname(desc"/"#nr);				\
1436 	dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK);		\
1437 	pr_cont("\n");
1438 
1439 #define DO_TESTCASE_1B(desc, name, nr)				\
1440 	print_testname(desc"/"#nr);				\
1441 	dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK);		\
1442 	pr_cont("\n");
1443 
1444 #define DO_TESTCASE_1RR(desc, name, nr)				\
1445 	print_testname(desc"/"#nr);				\
1446 	pr_cont("             |");				\
1447 	dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK);		\
1448 	pr_cont("\n");
1449 
1450 #define DO_TESTCASE_1RRB(desc, name, nr)			\
1451 	print_testname(desc"/"#nr);				\
1452 	pr_cont("             |");				\
1453 	dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK);		\
1454 	pr_cont("\n");
1455 
1456 
1457 #define DO_TESTCASE_3(desc, name, nr)				\
1458 	print_testname(desc"/"#nr);				\
1459 	dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN);	\
1460 	dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK);	\
1461 	dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK);	\
1462 	pr_cont("\n");
1463 
1464 #define DO_TESTCASE_3RW(desc, name, nr)				\
1465 	print_testname(desc"/"#nr);				\
1466 	dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN|LOCKTYPE_RWLOCK);\
1467 	dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK);	\
1468 	dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK);	\
1469 	pr_cont("\n");
1470 
1471 #define DO_TESTCASE_2RW(desc, name, nr)				\
1472 	print_testname(desc"/"#nr);				\
1473 	pr_cont("      |");					\
1474 	dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK);	\
1475 	dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK);	\
1476 	pr_cont("\n");
1477 
1478 #define DO_TESTCASE_2x2RW(desc, name, nr)			\
1479 	DO_TESTCASE_2RW("hard-"desc, name##_hard, nr)		\
1480 	DO_TESTCASE_2RW("soft-"desc, name##_soft, nr)		\
1481 
1482 #define DO_TESTCASE_6x2x2RW(desc, name)				\
1483 	DO_TESTCASE_2x2RW(desc, name, 123);			\
1484 	DO_TESTCASE_2x2RW(desc, name, 132);			\
1485 	DO_TESTCASE_2x2RW(desc, name, 213);			\
1486 	DO_TESTCASE_2x2RW(desc, name, 231);			\
1487 	DO_TESTCASE_2x2RW(desc, name, 312);			\
1488 	DO_TESTCASE_2x2RW(desc, name, 321);
1489 
1490 #define DO_TESTCASE_6(desc, name)				\
1491 	print_testname(desc);					\
1492 	dotest(name##_spin, FAILURE, LOCKTYPE_SPIN);		\
1493 	dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK);		\
1494 	dotest(name##_rlock, FAILURE, LOCKTYPE_RWLOCK);		\
1495 	dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX);		\
1496 	dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM);		\
1497 	dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM);		\
1498 	dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX);	\
1499 	pr_cont("\n");
1500 
1501 #define DO_TESTCASE_6_SUCCESS(desc, name)			\
1502 	print_testname(desc);					\
1503 	dotest(name##_spin, SUCCESS, LOCKTYPE_SPIN);		\
1504 	dotest(name##_wlock, SUCCESS, LOCKTYPE_RWLOCK);		\
1505 	dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK);		\
1506 	dotest(name##_mutex, SUCCESS, LOCKTYPE_MUTEX);		\
1507 	dotest(name##_wsem, SUCCESS, LOCKTYPE_RWSEM);		\
1508 	dotest(name##_rsem, SUCCESS, LOCKTYPE_RWSEM);		\
1509 	dotest_rt(name##_rtmutex, SUCCESS, LOCKTYPE_RTMUTEX);	\
1510 	pr_cont("\n");
1511 
1512 /*
1513  * 'read' variant: rlocks must not trigger.
1514  */
1515 #define DO_TESTCASE_6R(desc, name)				\
1516 	print_testname(desc);					\
1517 	dotest(name##_spin, FAILURE, LOCKTYPE_SPIN);		\
1518 	dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK);		\
1519 	dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK);		\
1520 	dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX);		\
1521 	dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM);		\
1522 	dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM);		\
1523 	dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX);	\
1524 	pr_cont("\n");
1525 
1526 #define DO_TESTCASE_2I(desc, name, nr)				\
1527 	DO_TESTCASE_1("hard-"desc, name##_hard, nr);		\
1528 	DO_TESTCASE_1("soft-"desc, name##_soft, nr);
1529 
1530 #define DO_TESTCASE_2IB(desc, name, nr)				\
1531 	DO_TESTCASE_1B("hard-"desc, name##_hard, nr);		\
1532 	DO_TESTCASE_1B("soft-"desc, name##_soft, nr);
1533 
1534 #define DO_TESTCASE_6I(desc, name, nr)				\
1535 	DO_TESTCASE_3("hard-"desc, name##_hard, nr);		\
1536 	DO_TESTCASE_3("soft-"desc, name##_soft, nr);
1537 
1538 #define DO_TESTCASE_6IRW(desc, name, nr)			\
1539 	DO_TESTCASE_3RW("hard-"desc, name##_hard, nr);		\
1540 	DO_TESTCASE_3RW("soft-"desc, name##_soft, nr);
1541 
1542 #define DO_TESTCASE_2x3(desc, name)				\
1543 	DO_TESTCASE_3(desc, name, 12);				\
1544 	DO_TESTCASE_3(desc, name, 21);
1545 
1546 #define DO_TESTCASE_2x6(desc, name)				\
1547 	DO_TESTCASE_6I(desc, name, 12);				\
1548 	DO_TESTCASE_6I(desc, name, 21);
1549 
1550 #define DO_TESTCASE_6x2(desc, name)				\
1551 	DO_TESTCASE_2I(desc, name, 123);			\
1552 	DO_TESTCASE_2I(desc, name, 132);			\
1553 	DO_TESTCASE_2I(desc, name, 213);			\
1554 	DO_TESTCASE_2I(desc, name, 231);			\
1555 	DO_TESTCASE_2I(desc, name, 312);			\
1556 	DO_TESTCASE_2I(desc, name, 321);
1557 
1558 #define DO_TESTCASE_6x2B(desc, name)				\
1559 	DO_TESTCASE_2IB(desc, name, 123);			\
1560 	DO_TESTCASE_2IB(desc, name, 132);			\
1561 	DO_TESTCASE_2IB(desc, name, 213);			\
1562 	DO_TESTCASE_2IB(desc, name, 231);			\
1563 	DO_TESTCASE_2IB(desc, name, 312);			\
1564 	DO_TESTCASE_2IB(desc, name, 321);
1565 
1566 #define DO_TESTCASE_6x1RR(desc, name)				\
1567 	DO_TESTCASE_1RR(desc, name, 123);			\
1568 	DO_TESTCASE_1RR(desc, name, 132);			\
1569 	DO_TESTCASE_1RR(desc, name, 213);			\
1570 	DO_TESTCASE_1RR(desc, name, 231);			\
1571 	DO_TESTCASE_1RR(desc, name, 312);			\
1572 	DO_TESTCASE_1RR(desc, name, 321);
1573 
1574 #define DO_TESTCASE_6x1RRB(desc, name)				\
1575 	DO_TESTCASE_1RRB(desc, name, 123);			\
1576 	DO_TESTCASE_1RRB(desc, name, 132);			\
1577 	DO_TESTCASE_1RRB(desc, name, 213);			\
1578 	DO_TESTCASE_1RRB(desc, name, 231);			\
1579 	DO_TESTCASE_1RRB(desc, name, 312);			\
1580 	DO_TESTCASE_1RRB(desc, name, 321);
1581 
1582 #define DO_TESTCASE_6x6(desc, name)				\
1583 	DO_TESTCASE_6I(desc, name, 123);			\
1584 	DO_TESTCASE_6I(desc, name, 132);			\
1585 	DO_TESTCASE_6I(desc, name, 213);			\
1586 	DO_TESTCASE_6I(desc, name, 231);			\
1587 	DO_TESTCASE_6I(desc, name, 312);			\
1588 	DO_TESTCASE_6I(desc, name, 321);
1589 
1590 #define DO_TESTCASE_6x6RW(desc, name)				\
1591 	DO_TESTCASE_6IRW(desc, name, 123);			\
1592 	DO_TESTCASE_6IRW(desc, name, 132);			\
1593 	DO_TESTCASE_6IRW(desc, name, 213);			\
1594 	DO_TESTCASE_6IRW(desc, name, 231);			\
1595 	DO_TESTCASE_6IRW(desc, name, 312);			\
1596 	DO_TESTCASE_6IRW(desc, name, 321);
1597 
1598 static void ww_test_fail_acquire(void)
1599 {
1600 	int ret;
1601 
1602 	WWAI(&t);
1603 	t.stamp++;
1604 
1605 	ret = WWL(&o, &t);
1606 
1607 	if (WARN_ON(!o.ctx) ||
1608 	    WARN_ON(ret))
1609 		return;
1610 
1611 	/* No lockdep test, pure API */
1612 	ret = WWL(&o, &t);
1613 	WARN_ON(ret != -EALREADY);
1614 
1615 	ret = WWT(&o);
1616 	WARN_ON(ret);
1617 
1618 	t2 = t;
1619 	t2.stamp++;
1620 	ret = WWL(&o, &t2);
1621 	WARN_ON(ret != -EDEADLK);
1622 	WWU(&o);
1623 
1624 	if (WWT(&o))
1625 		WWU(&o);
1626 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1627 	else
1628 		DEBUG_LOCKS_WARN_ON(1);
1629 #endif
1630 }
1631 
1632 static void ww_test_normal(void)
1633 {
1634 	int ret;
1635 
1636 	WWAI(&t);
1637 
1638 	/*
1639 	 * None of the ww_mutex codepaths should be taken in the 'normal'
1640 	 * mutex calls. The easiest way to verify this is by using the
1641 	 * normal mutex calls, and making sure o.ctx is unmodified.
1642 	 */
1643 
1644 	/* mutex_lock (and indirectly, mutex_lock_nested) */
1645 	o.ctx = (void *)~0UL;
1646 	mutex_lock(&o.base);
1647 	mutex_unlock(&o.base);
1648 	WARN_ON(o.ctx != (void *)~0UL);
1649 
1650 	/* mutex_lock_interruptible (and *_nested) */
1651 	o.ctx = (void *)~0UL;
1652 	ret = mutex_lock_interruptible(&o.base);
1653 	if (!ret)
1654 		mutex_unlock(&o.base);
1655 	else
1656 		WARN_ON(1);
1657 	WARN_ON(o.ctx != (void *)~0UL);
1658 
1659 	/* mutex_lock_killable (and *_nested) */
1660 	o.ctx = (void *)~0UL;
1661 	ret = mutex_lock_killable(&o.base);
1662 	if (!ret)
1663 		mutex_unlock(&o.base);
1664 	else
1665 		WARN_ON(1);
1666 	WARN_ON(o.ctx != (void *)~0UL);
1667 
1668 	/* trylock, succeeding */
1669 	o.ctx = (void *)~0UL;
1670 	ret = mutex_trylock(&o.base);
1671 	WARN_ON(!ret);
1672 	if (ret)
1673 		mutex_unlock(&o.base);
1674 	else
1675 		WARN_ON(1);
1676 	WARN_ON(o.ctx != (void *)~0UL);
1677 
1678 	/* trylock, failing */
1679 	o.ctx = (void *)~0UL;
1680 	mutex_lock(&o.base);
1681 	ret = mutex_trylock(&o.base);
1682 	WARN_ON(ret);
1683 	mutex_unlock(&o.base);
1684 	WARN_ON(o.ctx != (void *)~0UL);
1685 
1686 	/* nest_lock */
1687 	o.ctx = (void *)~0UL;
1688 	mutex_lock_nest_lock(&o.base, &t);
1689 	mutex_unlock(&o.base);
1690 	WARN_ON(o.ctx != (void *)~0UL);
1691 }
1692 
1693 static void ww_test_two_contexts(void)
1694 {
1695 	WWAI(&t);
1696 	WWAI(&t2);
1697 }
1698 
1699 static void ww_test_diff_class(void)
1700 {
1701 	WWAI(&t);
1702 #ifdef CONFIG_DEBUG_MUTEXES
1703 	t.ww_class = NULL;
1704 #endif
1705 	WWL(&o, &t);
1706 }
1707 
1708 static void ww_test_context_done_twice(void)
1709 {
1710 	WWAI(&t);
1711 	WWAD(&t);
1712 	WWAD(&t);
1713 	WWAF(&t);
1714 }
1715 
1716 static void ww_test_context_unlock_twice(void)
1717 {
1718 	WWAI(&t);
1719 	WWAD(&t);
1720 	WWAF(&t);
1721 	WWAF(&t);
1722 }
1723 
1724 static void ww_test_context_fini_early(void)
1725 {
1726 	WWAI(&t);
1727 	WWL(&o, &t);
1728 	WWAD(&t);
1729 	WWAF(&t);
1730 }
1731 
1732 static void ww_test_context_lock_after_done(void)
1733 {
1734 	WWAI(&t);
1735 	WWAD(&t);
1736 	WWL(&o, &t);
1737 }
1738 
1739 static void ww_test_object_unlock_twice(void)
1740 {
1741 	WWL1(&o);
1742 	WWU(&o);
1743 	WWU(&o);
1744 }
1745 
1746 static void ww_test_object_lock_unbalanced(void)
1747 {
1748 	WWAI(&t);
1749 	WWL(&o, &t);
1750 	t.acquired = 0;
1751 	WWU(&o);
1752 	WWAF(&t);
1753 }
1754 
1755 static void ww_test_object_lock_stale_context(void)
1756 {
1757 	WWAI(&t);
1758 	o.ctx = &t2;
1759 	WWL(&o, &t);
1760 }
1761 
1762 static void ww_test_edeadlk_normal(void)
1763 {
1764 	int ret;
1765 
1766 	mutex_lock(&o2.base);
1767 	o2.ctx = &t2;
1768 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1769 
1770 	WWAI(&t);
1771 	t2 = t;
1772 	t2.stamp--;
1773 
1774 	ret = WWL(&o, &t);
1775 	WARN_ON(ret);
1776 
1777 	ret = WWL(&o2, &t);
1778 	WARN_ON(ret != -EDEADLK);
1779 
1780 	o2.ctx = NULL;
1781 	mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1782 	mutex_unlock(&o2.base);
1783 	WWU(&o);
1784 
1785 	WWL(&o2, &t);
1786 }
1787 
1788 static void ww_test_edeadlk_normal_slow(void)
1789 {
1790 	int ret;
1791 
1792 	mutex_lock(&o2.base);
1793 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1794 	o2.ctx = &t2;
1795 
1796 	WWAI(&t);
1797 	t2 = t;
1798 	t2.stamp--;
1799 
1800 	ret = WWL(&o, &t);
1801 	WARN_ON(ret);
1802 
1803 	ret = WWL(&o2, &t);
1804 	WARN_ON(ret != -EDEADLK);
1805 
1806 	o2.ctx = NULL;
1807 	mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1808 	mutex_unlock(&o2.base);
1809 	WWU(&o);
1810 
1811 	ww_mutex_lock_slow(&o2, &t);
1812 }
1813 
1814 static void ww_test_edeadlk_no_unlock(void)
1815 {
1816 	int ret;
1817 
1818 	mutex_lock(&o2.base);
1819 	o2.ctx = &t2;
1820 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1821 
1822 	WWAI(&t);
1823 	t2 = t;
1824 	t2.stamp--;
1825 
1826 	ret = WWL(&o, &t);
1827 	WARN_ON(ret);
1828 
1829 	ret = WWL(&o2, &t);
1830 	WARN_ON(ret != -EDEADLK);
1831 
1832 	o2.ctx = NULL;
1833 	mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1834 	mutex_unlock(&o2.base);
1835 
1836 	WWL(&o2, &t);
1837 }
1838 
1839 static void ww_test_edeadlk_no_unlock_slow(void)
1840 {
1841 	int ret;
1842 
1843 	mutex_lock(&o2.base);
1844 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1845 	o2.ctx = &t2;
1846 
1847 	WWAI(&t);
1848 	t2 = t;
1849 	t2.stamp--;
1850 
1851 	ret = WWL(&o, &t);
1852 	WARN_ON(ret);
1853 
1854 	ret = WWL(&o2, &t);
1855 	WARN_ON(ret != -EDEADLK);
1856 
1857 	o2.ctx = NULL;
1858 	mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1859 	mutex_unlock(&o2.base);
1860 
1861 	ww_mutex_lock_slow(&o2, &t);
1862 }
1863 
1864 static void ww_test_edeadlk_acquire_more(void)
1865 {
1866 	int ret;
1867 
1868 	mutex_lock(&o2.base);
1869 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1870 	o2.ctx = &t2;
1871 
1872 	WWAI(&t);
1873 	t2 = t;
1874 	t2.stamp--;
1875 
1876 	ret = WWL(&o, &t);
1877 	WARN_ON(ret);
1878 
1879 	ret = WWL(&o2, &t);
1880 	WARN_ON(ret != -EDEADLK);
1881 
1882 	ret = WWL(&o3, &t);
1883 }
1884 
1885 static void ww_test_edeadlk_acquire_more_slow(void)
1886 {
1887 	int ret;
1888 
1889 	mutex_lock(&o2.base);
1890 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1891 	o2.ctx = &t2;
1892 
1893 	WWAI(&t);
1894 	t2 = t;
1895 	t2.stamp--;
1896 
1897 	ret = WWL(&o, &t);
1898 	WARN_ON(ret);
1899 
1900 	ret = WWL(&o2, &t);
1901 	WARN_ON(ret != -EDEADLK);
1902 
1903 	ww_mutex_lock_slow(&o3, &t);
1904 }
1905 
1906 static void ww_test_edeadlk_acquire_more_edeadlk(void)
1907 {
1908 	int ret;
1909 
1910 	mutex_lock(&o2.base);
1911 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1912 	o2.ctx = &t2;
1913 
1914 	mutex_lock(&o3.base);
1915 	mutex_release(&o3.base.dep_map, _THIS_IP_);
1916 	o3.ctx = &t2;
1917 
1918 	WWAI(&t);
1919 	t2 = t;
1920 	t2.stamp--;
1921 
1922 	ret = WWL(&o, &t);
1923 	WARN_ON(ret);
1924 
1925 	ret = WWL(&o2, &t);
1926 	WARN_ON(ret != -EDEADLK);
1927 
1928 	ret = WWL(&o3, &t);
1929 	WARN_ON(ret != -EDEADLK);
1930 }
1931 
1932 static void ww_test_edeadlk_acquire_more_edeadlk_slow(void)
1933 {
1934 	int ret;
1935 
1936 	mutex_lock(&o2.base);
1937 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1938 	o2.ctx = &t2;
1939 
1940 	mutex_lock(&o3.base);
1941 	mutex_release(&o3.base.dep_map, _THIS_IP_);
1942 	o3.ctx = &t2;
1943 
1944 	WWAI(&t);
1945 	t2 = t;
1946 	t2.stamp--;
1947 
1948 	ret = WWL(&o, &t);
1949 	WARN_ON(ret);
1950 
1951 	ret = WWL(&o2, &t);
1952 	WARN_ON(ret != -EDEADLK);
1953 
1954 	ww_mutex_lock_slow(&o3, &t);
1955 }
1956 
1957 static void ww_test_edeadlk_acquire_wrong(void)
1958 {
1959 	int ret;
1960 
1961 	mutex_lock(&o2.base);
1962 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1963 	o2.ctx = &t2;
1964 
1965 	WWAI(&t);
1966 	t2 = t;
1967 	t2.stamp--;
1968 
1969 	ret = WWL(&o, &t);
1970 	WARN_ON(ret);
1971 
1972 	ret = WWL(&o2, &t);
1973 	WARN_ON(ret != -EDEADLK);
1974 	if (!ret)
1975 		WWU(&o2);
1976 
1977 	WWU(&o);
1978 
1979 	ret = WWL(&o3, &t);
1980 }
1981 
1982 static void ww_test_edeadlk_acquire_wrong_slow(void)
1983 {
1984 	int ret;
1985 
1986 	mutex_lock(&o2.base);
1987 	mutex_release(&o2.base.dep_map, _THIS_IP_);
1988 	o2.ctx = &t2;
1989 
1990 	WWAI(&t);
1991 	t2 = t;
1992 	t2.stamp--;
1993 
1994 	ret = WWL(&o, &t);
1995 	WARN_ON(ret);
1996 
1997 	ret = WWL(&o2, &t);
1998 	WARN_ON(ret != -EDEADLK);
1999 	if (!ret)
2000 		WWU(&o2);
2001 
2002 	WWU(&o);
2003 
2004 	ww_mutex_lock_slow(&o3, &t);
2005 }
2006 
2007 static void ww_test_spin_nest_unlocked(void)
2008 {
2009 	spin_lock_nest_lock(&lock_A, &o.base);
2010 	U(A);
2011 }
2012 
2013 /* This is not a deadlock, because we have X1 to serialize Y1 and Y2 */
2014 static void ww_test_spin_nest_lock(void)
2015 {
2016 	spin_lock(&lock_X1);
2017 	spin_lock_nest_lock(&lock_Y1, &lock_X1);
2018 	spin_lock(&lock_A);
2019 	spin_lock_nest_lock(&lock_Y2, &lock_X1);
2020 	spin_unlock(&lock_A);
2021 	spin_unlock(&lock_Y2);
2022 	spin_unlock(&lock_Y1);
2023 	spin_unlock(&lock_X1);
2024 }
2025 
2026 static void ww_test_unneeded_slow(void)
2027 {
2028 	WWAI(&t);
2029 
2030 	ww_mutex_lock_slow(&o, &t);
2031 }
2032 
2033 static void ww_test_context_block(void)
2034 {
2035 	int ret;
2036 
2037 	WWAI(&t);
2038 
2039 	ret = WWL(&o, &t);
2040 	WARN_ON(ret);
2041 	WWL1(&o2);
2042 }
2043 
2044 static void ww_test_context_try(void)
2045 {
2046 	int ret;
2047 
2048 	WWAI(&t);
2049 
2050 	ret = WWL(&o, &t);
2051 	WARN_ON(ret);
2052 
2053 	ret = WWT(&o2);
2054 	WARN_ON(!ret);
2055 	WWU(&o2);
2056 	WWU(&o);
2057 }
2058 
2059 static void ww_test_context_context(void)
2060 {
2061 	int ret;
2062 
2063 	WWAI(&t);
2064 
2065 	ret = WWL(&o, &t);
2066 	WARN_ON(ret);
2067 
2068 	ret = WWL(&o2, &t);
2069 	WARN_ON(ret);
2070 
2071 	WWU(&o2);
2072 	WWU(&o);
2073 }
2074 
2075 static void ww_test_try_block(void)
2076 {
2077 	bool ret;
2078 
2079 	ret = WWT(&o);
2080 	WARN_ON(!ret);
2081 
2082 	WWL1(&o2);
2083 	WWU(&o2);
2084 	WWU(&o);
2085 }
2086 
2087 static void ww_test_try_try(void)
2088 {
2089 	bool ret;
2090 
2091 	ret = WWT(&o);
2092 	WARN_ON(!ret);
2093 	ret = WWT(&o2);
2094 	WARN_ON(!ret);
2095 	WWU(&o2);
2096 	WWU(&o);
2097 }
2098 
2099 static void ww_test_try_context(void)
2100 {
2101 	int ret;
2102 
2103 	ret = WWT(&o);
2104 	WARN_ON(!ret);
2105 
2106 	WWAI(&t);
2107 
2108 	ret = WWL(&o2, &t);
2109 	WARN_ON(ret);
2110 }
2111 
2112 static void ww_test_block_block(void)
2113 {
2114 	WWL1(&o);
2115 	WWL1(&o2);
2116 }
2117 
2118 static void ww_test_block_try(void)
2119 {
2120 	bool ret;
2121 
2122 	WWL1(&o);
2123 	ret = WWT(&o2);
2124 	WARN_ON(!ret);
2125 }
2126 
2127 static void ww_test_block_context(void)
2128 {
2129 	int ret;
2130 
2131 	WWL1(&o);
2132 	WWAI(&t);
2133 
2134 	ret = WWL(&o2, &t);
2135 	WARN_ON(ret);
2136 }
2137 
2138 static void ww_test_spin_block(void)
2139 {
2140 	L(A);
2141 	U(A);
2142 
2143 	WWL1(&o);
2144 	L(A);
2145 	U(A);
2146 	WWU(&o);
2147 
2148 	L(A);
2149 	WWL1(&o);
2150 	WWU(&o);
2151 	U(A);
2152 }
2153 
2154 static void ww_test_spin_try(void)
2155 {
2156 	bool ret;
2157 
2158 	L(A);
2159 	U(A);
2160 
2161 	ret = WWT(&o);
2162 	WARN_ON(!ret);
2163 	L(A);
2164 	U(A);
2165 	WWU(&o);
2166 
2167 	L(A);
2168 	ret = WWT(&o);
2169 	WARN_ON(!ret);
2170 	WWU(&o);
2171 	U(A);
2172 }
2173 
2174 static void ww_test_spin_context(void)
2175 {
2176 	int ret;
2177 
2178 	L(A);
2179 	U(A);
2180 
2181 	WWAI(&t);
2182 
2183 	ret = WWL(&o, &t);
2184 	WARN_ON(ret);
2185 	L(A);
2186 	U(A);
2187 	WWU(&o);
2188 
2189 	L(A);
2190 	ret = WWL(&o, &t);
2191 	WARN_ON(ret);
2192 	WWU(&o);
2193 	U(A);
2194 }
2195 
2196 static void ww_tests(void)
2197 {
2198 	printk("  --------------------------------------------------------------------------\n");
2199 	printk("  | Wound/wait tests |\n");
2200 	printk("  ---------------------\n");
2201 
2202 	print_testname("ww api failures");
2203 	dotest(ww_test_fail_acquire, SUCCESS, LOCKTYPE_WW);
2204 	dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW);
2205 	dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW);
2206 	pr_cont("\n");
2207 
2208 	print_testname("ww contexts mixing");
2209 	dotest(ww_test_two_contexts, FAILURE, LOCKTYPE_WW);
2210 	dotest(ww_test_diff_class, FAILURE, LOCKTYPE_WW);
2211 	pr_cont("\n");
2212 
2213 	print_testname("finishing ww context");
2214 	dotest(ww_test_context_done_twice, FAILURE, LOCKTYPE_WW);
2215 	dotest(ww_test_context_unlock_twice, FAILURE, LOCKTYPE_WW);
2216 	dotest(ww_test_context_fini_early, FAILURE, LOCKTYPE_WW);
2217 	dotest(ww_test_context_lock_after_done, FAILURE, LOCKTYPE_WW);
2218 	pr_cont("\n");
2219 
2220 	print_testname("locking mismatches");
2221 	dotest(ww_test_object_unlock_twice, FAILURE, LOCKTYPE_WW);
2222 	dotest(ww_test_object_lock_unbalanced, FAILURE, LOCKTYPE_WW);
2223 	dotest(ww_test_object_lock_stale_context, FAILURE, LOCKTYPE_WW);
2224 	pr_cont("\n");
2225 
2226 	print_testname("EDEADLK handling");
2227 	dotest(ww_test_edeadlk_normal, SUCCESS, LOCKTYPE_WW);
2228 	dotest(ww_test_edeadlk_normal_slow, SUCCESS, LOCKTYPE_WW);
2229 	dotest(ww_test_edeadlk_no_unlock, FAILURE, LOCKTYPE_WW);
2230 	dotest(ww_test_edeadlk_no_unlock_slow, FAILURE, LOCKTYPE_WW);
2231 	dotest(ww_test_edeadlk_acquire_more, FAILURE, LOCKTYPE_WW);
2232 	dotest(ww_test_edeadlk_acquire_more_slow, FAILURE, LOCKTYPE_WW);
2233 	dotest(ww_test_edeadlk_acquire_more_edeadlk, FAILURE, LOCKTYPE_WW);
2234 	dotest(ww_test_edeadlk_acquire_more_edeadlk_slow, FAILURE, LOCKTYPE_WW);
2235 	dotest(ww_test_edeadlk_acquire_wrong, FAILURE, LOCKTYPE_WW);
2236 	dotest(ww_test_edeadlk_acquire_wrong_slow, FAILURE, LOCKTYPE_WW);
2237 	pr_cont("\n");
2238 
2239 	print_testname("spinlock nest unlocked");
2240 	dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);
2241 	pr_cont("\n");
2242 
2243 	print_testname("spinlock nest test");
2244 	dotest(ww_test_spin_nest_lock, SUCCESS, LOCKTYPE_WW);
2245 	pr_cont("\n");
2246 
2247 	printk("  -----------------------------------------------------\n");
2248 	printk("                                 |block | try  |context|\n");
2249 	printk("  -----------------------------------------------------\n");
2250 
2251 	print_testname("context");
2252 	dotest(ww_test_context_block, FAILURE, LOCKTYPE_WW);
2253 	dotest(ww_test_context_try, SUCCESS, LOCKTYPE_WW);
2254 	dotest(ww_test_context_context, SUCCESS, LOCKTYPE_WW);
2255 	pr_cont("\n");
2256 
2257 	print_testname("try");
2258 	dotest(ww_test_try_block, FAILURE, LOCKTYPE_WW);
2259 	dotest(ww_test_try_try, SUCCESS, LOCKTYPE_WW);
2260 	dotest(ww_test_try_context, FAILURE, LOCKTYPE_WW);
2261 	pr_cont("\n");
2262 
2263 	print_testname("block");
2264 	dotest(ww_test_block_block, FAILURE, LOCKTYPE_WW);
2265 	dotest(ww_test_block_try, SUCCESS, LOCKTYPE_WW);
2266 	dotest(ww_test_block_context, FAILURE, LOCKTYPE_WW);
2267 	pr_cont("\n");
2268 
2269 	print_testname("spinlock");
2270 	dotest(ww_test_spin_block, FAILURE, LOCKTYPE_WW);
2271 	dotest(ww_test_spin_try, SUCCESS, LOCKTYPE_WW);
2272 	dotest(ww_test_spin_context, FAILURE, LOCKTYPE_WW);
2273 	pr_cont("\n");
2274 }
2275 
2276 
2277 /*
2278  * <in hardirq handler>
2279  * read_lock(&A);
2280  *			<hardirq disable>
2281  *			spin_lock(&B);
2282  * spin_lock(&B);
2283  *			read_lock(&A);
2284  *
2285  * is a deadlock.
2286  */
2287 static void queued_read_lock_hardirq_RE_Er(void)
2288 {
2289 	HARDIRQ_ENTER();
2290 	read_lock(&rwlock_A);
2291 	LOCK(B);
2292 	UNLOCK(B);
2293 	read_unlock(&rwlock_A);
2294 	HARDIRQ_EXIT();
2295 
2296 	HARDIRQ_DISABLE();
2297 	LOCK(B);
2298 	read_lock(&rwlock_A);
2299 	read_unlock(&rwlock_A);
2300 	UNLOCK(B);
2301 	HARDIRQ_ENABLE();
2302 }
2303 
2304 /*
2305  * <in hardirq handler>
2306  * spin_lock(&B);
2307  *			<hardirq disable>
2308  *			read_lock(&A);
2309  * read_lock(&A);
2310  *			spin_lock(&B);
2311  *
2312  * is not a deadlock.
2313  */
2314 static void queued_read_lock_hardirq_ER_rE(void)
2315 {
2316 	HARDIRQ_ENTER();
2317 	LOCK(B);
2318 	read_lock(&rwlock_A);
2319 	read_unlock(&rwlock_A);
2320 	UNLOCK(B);
2321 	HARDIRQ_EXIT();
2322 
2323 	HARDIRQ_DISABLE();
2324 	read_lock(&rwlock_A);
2325 	LOCK(B);
2326 	UNLOCK(B);
2327 	read_unlock(&rwlock_A);
2328 	HARDIRQ_ENABLE();
2329 }
2330 
2331 /*
2332  * <hardirq disable>
2333  * spin_lock(&B);
2334  *			read_lock(&A);
2335  *			<in hardirq handler>
2336  *			spin_lock(&B);
2337  * read_lock(&A);
2338  *
2339  * is a deadlock. Because the two read_lock()s are both non-recursive readers.
2340  */
2341 static void queued_read_lock_hardirq_inversion(void)
2342 {
2343 
2344 	HARDIRQ_ENTER();
2345 	LOCK(B);
2346 	UNLOCK(B);
2347 	HARDIRQ_EXIT();
2348 
2349 	HARDIRQ_DISABLE();
2350 	LOCK(B);
2351 	read_lock(&rwlock_A);
2352 	read_unlock(&rwlock_A);
2353 	UNLOCK(B);
2354 	HARDIRQ_ENABLE();
2355 
2356 	read_lock(&rwlock_A);
2357 	read_unlock(&rwlock_A);
2358 }
2359 
2360 static void queued_read_lock_tests(void)
2361 {
2362 	printk("  --------------------------------------------------------------------------\n");
2363 	printk("  | queued read lock tests |\n");
2364 	printk("  ---------------------------\n");
2365 	print_testname("hardirq read-lock/lock-read");
2366 	dotest(queued_read_lock_hardirq_RE_Er, FAILURE, LOCKTYPE_RWLOCK);
2367 	pr_cont("\n");
2368 
2369 	print_testname("hardirq lock-read/read-lock");
2370 	dotest(queued_read_lock_hardirq_ER_rE, SUCCESS, LOCKTYPE_RWLOCK);
2371 	pr_cont("\n");
2372 
2373 	print_testname("hardirq inversion");
2374 	dotest(queued_read_lock_hardirq_inversion, FAILURE, LOCKTYPE_RWLOCK);
2375 	pr_cont("\n");
2376 }
2377 
2378 static void fs_reclaim_correct_nesting(void)
2379 {
2380 	fs_reclaim_acquire(GFP_KERNEL);
2381 	might_alloc(GFP_NOFS);
2382 	fs_reclaim_release(GFP_KERNEL);
2383 }
2384 
2385 static void fs_reclaim_wrong_nesting(void)
2386 {
2387 	fs_reclaim_acquire(GFP_KERNEL);
2388 	might_alloc(GFP_KERNEL);
2389 	fs_reclaim_release(GFP_KERNEL);
2390 }
2391 
2392 static void fs_reclaim_protected_nesting(void)
2393 {
2394 	unsigned int flags;
2395 
2396 	fs_reclaim_acquire(GFP_KERNEL);
2397 	flags = memalloc_nofs_save();
2398 	might_alloc(GFP_KERNEL);
2399 	memalloc_nofs_restore(flags);
2400 	fs_reclaim_release(GFP_KERNEL);
2401 }
2402 
2403 static void fs_reclaim_tests(void)
2404 {
2405 	printk("  --------------------\n");
2406 	printk("  | fs_reclaim tests |\n");
2407 	printk("  --------------------\n");
2408 
2409 	print_testname("correct nesting");
2410 	dotest(fs_reclaim_correct_nesting, SUCCESS, 0);
2411 	pr_cont("\n");
2412 
2413 	print_testname("wrong nesting");
2414 	dotest(fs_reclaim_wrong_nesting, FAILURE, 0);
2415 	pr_cont("\n");
2416 
2417 	print_testname("protected nesting");
2418 	dotest(fs_reclaim_protected_nesting, SUCCESS, 0);
2419 	pr_cont("\n");
2420 }
2421 
2422 void locking_selftest(void)
2423 {
2424 	/*
2425 	 * Got a locking failure before the selftest ran?
2426 	 */
2427 	if (!debug_locks) {
2428 		printk("----------------------------------\n");
2429 		printk("| Locking API testsuite disabled |\n");
2430 		printk("----------------------------------\n");
2431 		return;
2432 	}
2433 
2434 	/*
2435 	 * treats read_lock() as recursive read locks for testing purpose
2436 	 */
2437 	force_read_lock_recursive = 1;
2438 
2439 	/*
2440 	 * Run the testsuite:
2441 	 */
2442 	printk("------------------------\n");
2443 	printk("| Locking API testsuite:\n");
2444 	printk("----------------------------------------------------------------------------\n");
2445 	printk("                                 | spin |wlock |rlock |mutex | wsem | rsem |\n");
2446 	printk("  --------------------------------------------------------------------------\n");
2447 
2448 	init_shared_classes();
2449 	debug_locks_silent = !debug_locks_verbose;
2450 	lockdep_set_selftest_task(current);
2451 
2452 	DO_TESTCASE_6R("A-A deadlock", AA);
2453 	DO_TESTCASE_6R("A-B-B-A deadlock", ABBA);
2454 	DO_TESTCASE_6R("A-B-B-C-C-A deadlock", ABBCCA);
2455 	DO_TESTCASE_6R("A-B-C-A-B-C deadlock", ABCABC);
2456 	DO_TESTCASE_6R("A-B-B-C-C-D-D-A deadlock", ABBCCDDA);
2457 	DO_TESTCASE_6R("A-B-C-D-B-D-D-A deadlock", ABCDBDDA);
2458 	DO_TESTCASE_6R("A-B-C-D-B-C-D-A deadlock", ABCDBCDA);
2459 	DO_TESTCASE_6("double unlock", double_unlock);
2460 	DO_TESTCASE_6("initialize held", init_held);
2461 
2462 	printk("  --------------------------------------------------------------------------\n");
2463 	print_testname("recursive read-lock");
2464 	pr_cont("             |");
2465 	dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
2466 	pr_cont("             |");
2467 	dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
2468 	pr_cont("\n");
2469 
2470 	print_testname("recursive read-lock #2");
2471 	pr_cont("             |");
2472 	dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
2473 	pr_cont("             |");
2474 	dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
2475 	pr_cont("\n");
2476 
2477 	print_testname("mixed read-write-lock");
2478 	pr_cont("             |");
2479 	dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
2480 	pr_cont("             |");
2481 	dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
2482 	pr_cont("\n");
2483 
2484 	print_testname("mixed write-read-lock");
2485 	pr_cont("             |");
2486 	dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
2487 	pr_cont("             |");
2488 	dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
2489 	pr_cont("\n");
2490 
2491 	print_testname("mixed read-lock/lock-write ABBA");
2492 	pr_cont("             |");
2493 	dotest(rlock_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
2494 	pr_cont("             |");
2495 	dotest(rwsem_ABBA1, FAILURE, LOCKTYPE_RWSEM);
2496 
2497 	print_testname("mixed read-lock/lock-read ABBA");
2498 	pr_cont("             |");
2499 	dotest(rlock_ABBA2, SUCCESS, LOCKTYPE_RWLOCK);
2500 	pr_cont("             |");
2501 	dotest(rwsem_ABBA2, FAILURE, LOCKTYPE_RWSEM);
2502 
2503 	print_testname("mixed write-lock/lock-write ABBA");
2504 	pr_cont("             |");
2505 	dotest(rlock_ABBA3, FAILURE, LOCKTYPE_RWLOCK);
2506 	pr_cont("             |");
2507 	dotest(rwsem_ABBA3, FAILURE, LOCKTYPE_RWSEM);
2508 
2509 	print_testname("chain cached mixed R-L/L-W ABBA");
2510 	pr_cont("             |");
2511 	dotest(rlock_chaincache_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
2512 
2513 	DO_TESTCASE_6x1RRB("rlock W1R2/W2R3/W3R1", W1R2_W2R3_W3R1);
2514 	DO_TESTCASE_6x1RRB("rlock W1W2/R2R3/W3R1", W1W2_R2R3_W3R1);
2515 	DO_TESTCASE_6x1RR("rlock W1W2/R2R3/R3W1", W1W2_R2R3_R3W1);
2516 	DO_TESTCASE_6x1RR("rlock W1R2/R2R3/W3W1", W1R2_R2R3_W3W1);
2517 
2518 	printk("  --------------------------------------------------------------------------\n");
2519 
2520 	/*
2521 	 * irq-context testcases:
2522 	 */
2523 	DO_TESTCASE_2x6("irqs-on + irq-safe-A", irqsafe1);
2524 	DO_TESTCASE_2x3("sirq-safe-A => hirqs-on", irqsafe2A);
2525 	DO_TESTCASE_2x6("safe-A + irqs-on", irqsafe2B);
2526 	DO_TESTCASE_6x6("safe-A + unsafe-B #1", irqsafe3);
2527 	DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4);
2528 	DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion);
2529 
2530 	DO_TESTCASE_6x2x2RW("irq read-recursion", irq_read_recursion);
2531 	DO_TESTCASE_6x2x2RW("irq read-recursion #2", irq_read_recursion2);
2532 	DO_TESTCASE_6x2x2RW("irq read-recursion #3", irq_read_recursion3);
2533 
2534 	ww_tests();
2535 
2536 	force_read_lock_recursive = 0;
2537 	/*
2538 	 * queued_read_lock() specific test cases can be put here
2539 	 */
2540 	if (IS_ENABLED(CONFIG_QUEUED_RWLOCKS))
2541 		queued_read_lock_tests();
2542 
2543 	fs_reclaim_tests();
2544 
2545 	if (unexpected_testcase_failures) {
2546 		printk("-----------------------------------------------------------------\n");
2547 		debug_locks = 0;
2548 		printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
2549 			unexpected_testcase_failures, testcase_total);
2550 		printk("-----------------------------------------------------------------\n");
2551 	} else if (expected_testcase_failures && testcase_successes) {
2552 		printk("--------------------------------------------------------\n");
2553 		printk("%3d out of %3d testcases failed, as expected. |\n",
2554 			expected_testcase_failures, testcase_total);
2555 		printk("----------------------------------------------------\n");
2556 		debug_locks = 1;
2557 	} else if (expected_testcase_failures && !testcase_successes) {
2558 		printk("--------------------------------------------------------\n");
2559 		printk("All %3d testcases failed, as expected. |\n",
2560 			expected_testcase_failures);
2561 		printk("----------------------------------------\n");
2562 		debug_locks = 1;
2563 	} else {
2564 		printk("-------------------------------------------------------\n");
2565 		printk("Good, all %3d testcases passed! |\n",
2566 			testcase_successes);
2567 		printk("---------------------------------\n");
2568 		debug_locks = 1;
2569 	}
2570 	lockdep_set_selftest_task(NULL);
2571 	debug_locks_silent = 0;
2572 }
2573