projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'akpm' (patches from Andrew)
[linux-2.6-block.git] / lib / locking-selftest.c
CommitLineData
b2441318 1// SPDX-License-Identifier: GPL-2.0
cae2ed9a
IM		 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>
1b375dc3 16#include <linux/ww_mutex.h>
cae2ed9a 17#include <linux/sched.h>
d5037d1d 18#include <linux/sched/mm.h>
cae2ed9a 19#include <linux/delay.h>
fbb9ce95 20#include <linux/lockdep.h>
cae2ed9a
IM		 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>
018956d6 26#include <linux/rtmutex.h>
cae2ed9a
IM		 27
28/*
29 * Change this to 1 if you want to see the failure printouts:
30 */
31static unsigned int debug_locks_verbose;
e9181886 32unsigned int force_read_lock_recursive;
cae2ed9a 33
08295b3b 34static DEFINE_WD_CLASS(ww_lockdep);
1de99445 35
cae2ed9a
IM		 36static 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
1de99445 52#define LOCKTYPE_WW 0x10
018956d6 53#define LOCKTYPE_RTMUTEX 0x20
1de99445
ML		 54
55static struct ww_acquire_ctx t, t2;
f3cf139e 56static struct ww_mutex o, o2, o3;
cae2ed9a
IM		 57
58/*
59 * Normal standalone locks, for the circular and irq-context
60 * dependency tests:
61 */
a2e9ae58
PZ		 62static DEFINE_SPINLOCK(lock_A);
63static DEFINE_SPINLOCK(lock_B);
64static DEFINE_SPINLOCK(lock_C);
65static DEFINE_SPINLOCK(lock_D);
cae2ed9a
IM		 66
67static DEFINE_RWLOCK(rwlock_A);
68static DEFINE_RWLOCK(rwlock_B);
69static DEFINE_RWLOCK(rwlock_C);
70static DEFINE_RWLOCK(rwlock_D);
71
72static DEFINE_MUTEX(mutex_A);
73static DEFINE_MUTEX(mutex_B);
74static DEFINE_MUTEX(mutex_C);
75static DEFINE_MUTEX(mutex_D);
76
77static DECLARE_RWSEM(rwsem_A);
78static DECLARE_RWSEM(rwsem_B);
79static DECLARE_RWSEM(rwsem_C);
80static DECLARE_RWSEM(rwsem_D);
81
018956d6
PZ		 82#ifdef CONFIG_RT_MUTEXES
83
84static DEFINE_RT_MUTEX(rtmutex_A);
85static DEFINE_RT_MUTEX(rtmutex_B);
86static DEFINE_RT_MUTEX(rtmutex_C);
87static DEFINE_RT_MUTEX(rtmutex_D);
88
89#endif
90
cae2ed9a
IM		 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 */
a2e9ae58
PZ		 97static DEFINE_SPINLOCK(lock_X1);
98static DEFINE_SPINLOCK(lock_X2);
99static DEFINE_SPINLOCK(lock_Y1);
100static DEFINE_SPINLOCK(lock_Y2);
101static DEFINE_SPINLOCK(lock_Z1);
102static DEFINE_SPINLOCK(lock_Z2);
cae2ed9a
IM		 103
104static DEFINE_RWLOCK(rwlock_X1);
105static DEFINE_RWLOCK(rwlock_X2);
106static DEFINE_RWLOCK(rwlock_Y1);
107static DEFINE_RWLOCK(rwlock_Y2);
108static DEFINE_RWLOCK(rwlock_Z1);
109static DEFINE_RWLOCK(rwlock_Z2);
110
111static DEFINE_MUTEX(mutex_X1);
112static DEFINE_MUTEX(mutex_X2);
113static DEFINE_MUTEX(mutex_Y1);
114static DEFINE_MUTEX(mutex_Y2);
115static DEFINE_MUTEX(mutex_Z1);
116static DEFINE_MUTEX(mutex_Z2);
117
118static DECLARE_RWSEM(rwsem_X1);
119static DECLARE_RWSEM(rwsem_X2);
120static DECLARE_RWSEM(rwsem_Y1);
121static DECLARE_RWSEM(rwsem_Y2);
122static DECLARE_RWSEM(rwsem_Z1);
123static DECLARE_RWSEM(rwsem_Z2);
124
018956d6
PZ		 125#ifdef CONFIG_RT_MUTEXES
126
127static DEFINE_RT_MUTEX(rtmutex_X1);
128static DEFINE_RT_MUTEX(rtmutex_X2);
129static DEFINE_RT_MUTEX(rtmutex_Y1);
130static DEFINE_RT_MUTEX(rtmutex_Y2);
131static DEFINE_RT_MUTEX(rtmutex_Z1);
132static DEFINE_RT_MUTEX(rtmutex_Z2);
133
134#endif
135
cae2ed9a
IM		 136/*
137 * non-inlined runtime initializers, to let separate locks share
138 * the same lock-class:
139 */
140#define INIT_CLASS_FUNC(class) \
141static noinline void \
a2e9ae58 142init_class_##class(spinlock_t *lock, rwlock_t *rwlock, \
9fb1b90c 143 struct mutex *mutex, struct rw_semaphore *rwsem)\
cae2ed9a 144{ \
a2e9ae58 145 spin_lock_init(lock); \
cae2ed9a
IM		 146 rwlock_init(rwlock); \
147 mutex_init(mutex); \
148 init_rwsem(rwsem); \
149}
150
151INIT_CLASS_FUNC(X)
152INIT_CLASS_FUNC(Y)
153INIT_CLASS_FUNC(Z)
154
155static void init_shared_classes(void)
156{
018956d6
PZ		 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
cae2ed9a
IM		 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(); \
ba9f207c 189 __irq_enter(); \
cae2ed9a
IM		 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(); \
d820ac4c 202 lockdep_softirq_enter(); \
cae2ed9a
IM		 203 WARN_ON(!in_softirq());
204
205#define SOFTIRQ_EXIT() \
d820ac4c 206 lockdep_softirq_exit(); \
cae2ed9a
IM		 207 local_irq_enable(); \
208 local_bh_enable();
209
210/*
211 * Shortcuts for lock/unlock API variants, to keep
212 * the testcases compact:
213 */
a2e9ae58
PZ		 214#define L(x) spin_lock(&lock_##x)
215#define U(x) spin_unlock(&lock_##x)
cae2ed9a 216#define LU(x) L(x); U(x)
a2e9ae58 217#define SI(x) spin_lock_init(&lock_##x)
cae2ed9a
IM		 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
018956d6
PZ		 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
cae2ed9a
IM		 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
1de99445
ML		 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
cae2ed9a
IM		 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 \
266static void name(void) { E(); }
267
268#define GENERATE_PERMUTATIONS_2_EVENTS(name) \
269 \
270static void name##_12(void) { E1(); E2(); } \
271static void name##_21(void) { E2(); E1(); }
272
273#define GENERATE_PERMUTATIONS_3_EVENTS(name) \
274 \
275static void name##_123(void) { E1(); E2(); E3(); } \
276static void name##_132(void) { E1(); E3(); E2(); } \
277static void name##_213(void) { E2(); E1(); E3(); } \
278static void name##_231(void) { E2(); E3(); E1(); } \
279static void name##_312(void) { E3(); E1(); E2(); } \
280static 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"
295GENERATE_TESTCASE(AA_spin)
296#include "locking-selftest-wlock.h"
297GENERATE_TESTCASE(AA_wlock)
298#include "locking-selftest-rlock.h"
299GENERATE_TESTCASE(AA_rlock)
300#include "locking-selftest-mutex.h"
301GENERATE_TESTCASE(AA_mutex)
302#include "locking-selftest-wsem.h"
303GENERATE_TESTCASE(AA_wsem)
304#include "locking-selftest-rsem.h"
305GENERATE_TESTCASE(AA_rsem)
306
018956d6
PZ		 307#ifdef CONFIG_RT_MUTEXES
308#include "locking-selftest-rtmutex.h"
309GENERATE_TESTCASE(AA_rtmutex);
310#endif
311
cae2ed9a
IM		 312#undef E
313
314/*
315 * Special-case for read-locking, they are
6c9076ec 316 * allowed to recurse on the same lock class:
cae2ed9a
IM		 317 */
318static void rlock_AA1(void)
319{
320 RL(X1);
321 RL(X1); // this one should NOT fail
322}
323
324static void rlock_AA1B(void)
325{
326 RL(X1);
6c9076ec 327 RL(X2); // this one should NOT fail
cae2ed9a
IM		 328}
329
330static void rsem_AA1(void)
331{
332 RSL(X1);
333 RSL(X1); // this one should fail
334}
335
336static 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 */
344static void rlock_AA2(void)
345{
346 RL(X1);
347 WL(X2); // this one should fail
348}
349
350static void rsem_AA2(void)
351{
352 RSL(X1);
353 WSL(X2); // this one should fail
354}
355
356static void rlock_AA3(void)
357{
358 WL(X1);
359 RL(X2); // this one should fail
360}
361
362static void rsem_AA3(void)
363{
364 WSL(X1);
365 RSL(X2); // this one should fail
366}
367
e9149858
PZ		 368/*
369 * read_lock(A)
370 * spin_lock(B)
371 * spin_lock(B)
372 * write_lock(A)
373 */
374static 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
387static 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
d4f200e5
BF		 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 */
425static 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
e9149858
PZ		 443/*
444 * read_lock(A)
445 * spin_lock(B)
446 * spin_lock(B)
447 * read_lock(A)
448 */
449static 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
462static 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 */
482static 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
495static 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
cae2ed9a
IM		 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"
521GENERATE_TESTCASE(ABBA_spin)
522#include "locking-selftest-wlock.h"
523GENERATE_TESTCASE(ABBA_wlock)
524#include "locking-selftest-rlock.h"
525GENERATE_TESTCASE(ABBA_rlock)
526#include "locking-selftest-mutex.h"
527GENERATE_TESTCASE(ABBA_mutex)
528#include "locking-selftest-wsem.h"
529GENERATE_TESTCASE(ABBA_wsem)
530#include "locking-selftest-rsem.h"
531GENERATE_TESTCASE(ABBA_rsem)
532
018956d6
PZ		 533#ifdef CONFIG_RT_MUTEXES
534#include "locking-selftest-rtmutex.h"
535GENERATE_TESTCASE(ABBA_rtmutex);
536#endif
537
cae2ed9a
IM		 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"
554GENERATE_TESTCASE(ABBCCA_spin)
555#include "locking-selftest-wlock.h"
556GENERATE_TESTCASE(ABBCCA_wlock)
557#include "locking-selftest-rlock.h"
558GENERATE_TESTCASE(ABBCCA_rlock)
559#include "locking-selftest-mutex.h"
560GENERATE_TESTCASE(ABBCCA_mutex)
561#include "locking-selftest-wsem.h"
562GENERATE_TESTCASE(ABBCCA_wsem)
563#include "locking-selftest-rsem.h"
564GENERATE_TESTCASE(ABBCCA_rsem)
565
018956d6
PZ		 566#ifdef CONFIG_RT_MUTEXES
567#include "locking-selftest-rtmutex.h"
568GENERATE_TESTCASE(ABBCCA_rtmutex);
569#endif
570
cae2ed9a
IM		 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"
587GENERATE_TESTCASE(ABCABC_spin)
588#include "locking-selftest-wlock.h"
589GENERATE_TESTCASE(ABCABC_wlock)
590#include "locking-selftest-rlock.h"
591GENERATE_TESTCASE(ABCABC_rlock)
592#include "locking-selftest-mutex.h"
593GENERATE_TESTCASE(ABCABC_mutex)
594#include "locking-selftest-wsem.h"
595GENERATE_TESTCASE(ABCABC_wsem)
596#include "locking-selftest-rsem.h"
597GENERATE_TESTCASE(ABCABC_rsem)
598
018956d6
PZ		 599#ifdef CONFIG_RT_MUTEXES
600#include "locking-selftest-rtmutex.h"
601GENERATE_TESTCASE(ABCABC_rtmutex);
602#endif
603
cae2ed9a
IM		 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"
621GENERATE_TESTCASE(ABBCCDDA_spin)
622#include "locking-selftest-wlock.h"
623GENERATE_TESTCASE(ABBCCDDA_wlock)
624#include "locking-selftest-rlock.h"
625GENERATE_TESTCASE(ABBCCDDA_rlock)
626#include "locking-selftest-mutex.h"
627GENERATE_TESTCASE(ABBCCDDA_mutex)
628#include "locking-selftest-wsem.h"
629GENERATE_TESTCASE(ABBCCDDA_wsem)
630#include "locking-selftest-rsem.h"
631GENERATE_TESTCASE(ABBCCDDA_rsem)
632
018956d6
PZ		 633#ifdef CONFIG_RT_MUTEXES
634#include "locking-selftest-rtmutex.h"
635GENERATE_TESTCASE(ABBCCDDA_rtmutex);
636#endif
637
cae2ed9a
IM		 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"
654GENERATE_TESTCASE(ABCDBDDA_spin)
655#include "locking-selftest-wlock.h"
656GENERATE_TESTCASE(ABCDBDDA_wlock)
657#include "locking-selftest-rlock.h"
658GENERATE_TESTCASE(ABCDBDDA_rlock)
659#include "locking-selftest-mutex.h"
660GENERATE_TESTCASE(ABCDBDDA_mutex)
661#include "locking-selftest-wsem.h"
662GENERATE_TESTCASE(ABCDBDDA_wsem)
663#include "locking-selftest-rsem.h"
664GENERATE_TESTCASE(ABCDBDDA_rsem)
665
018956d6
PZ		 666#ifdef CONFIG_RT_MUTEXES
667#include "locking-selftest-rtmutex.h"
668GENERATE_TESTCASE(ABCDBDDA_rtmutex);
669#endif
670
cae2ed9a
IM		 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"
687GENERATE_TESTCASE(ABCDBCDA_spin)
688#include "locking-selftest-wlock.h"
689GENERATE_TESTCASE(ABCDBCDA_wlock)
690#include "locking-selftest-rlock.h"
691GENERATE_TESTCASE(ABCDBCDA_rlock)
692#include "locking-selftest-mutex.h"
693GENERATE_TESTCASE(ABCDBCDA_mutex)
694#include "locking-selftest-wsem.h"
695GENERATE_TESTCASE(ABCDBCDA_wsem)
696#include "locking-selftest-rsem.h"
697GENERATE_TESTCASE(ABCDBCDA_rsem)
698
018956d6
PZ		 699#ifdef CONFIG_RT_MUTEXES
700#include "locking-selftest-rtmutex.h"
701GENERATE_TESTCASE(ABCDBCDA_rtmutex);
702#endif
703
cae2ed9a
IM		 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"
719GENERATE_TESTCASE(double_unlock_spin)
720#include "locking-selftest-wlock.h"
721GENERATE_TESTCASE(double_unlock_wlock)
722#include "locking-selftest-rlock.h"
723GENERATE_TESTCASE(double_unlock_rlock)
724#include "locking-selftest-mutex.h"
725GENERATE_TESTCASE(double_unlock_mutex)
726#include "locking-selftest-wsem.h"
727GENERATE_TESTCASE(double_unlock_wsem)
728#include "locking-selftest-rsem.h"
729GENERATE_TESTCASE(double_unlock_rsem)
730
018956d6
PZ		 731#ifdef CONFIG_RT_MUTEXES
732#include "locking-selftest-rtmutex.h"
733GENERATE_TESTCASE(double_unlock_rtmutex);
734#endif
735
cae2ed9a
IM		 736#undef E
737
cae2ed9a
IM		 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"
750GENERATE_TESTCASE(init_held_spin)
751#include "locking-selftest-wlock.h"
752GENERATE_TESTCASE(init_held_wlock)
753#include "locking-selftest-rlock.h"
754GENERATE_TESTCASE(init_held_rlock)
755#include "locking-selftest-mutex.h"
756GENERATE_TESTCASE(init_held_mutex)
757#include "locking-selftest-wsem.h"
758GENERATE_TESTCASE(init_held_wsem)
759#include "locking-selftest-rsem.h"
760GENERATE_TESTCASE(init_held_rsem)
761
018956d6
PZ		 762#ifdef CONFIG_RT_MUTEXES
763#include "locking-selftest-rtmutex.h"
764GENERATE_TESTCASE(init_held_rtmutex);
765#endif
766
cae2ed9a
IM		 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"
788GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_spin)
789
790#include "locking-selftest-rlock-hardirq.h"
791GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_rlock)
792
793#include "locking-selftest-wlock-hardirq.h"
794GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_wlock)
795
796#include "locking-selftest-spin-softirq.h"
797GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_spin)
798
799#include "locking-selftest-rlock-softirq.h"
800GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_rlock)
801
802#include "locking-selftest-wlock-softirq.h"
803GENERATE_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"
829GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_spin)
830
831#include "locking-selftest-wlock.h"
832GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_wlock)
833
834#include "locking-selftest-rlock.h"
835GENERATE_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"
861GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_spin)
862
863#include "locking-selftest-rlock-hardirq.h"
864GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_rlock)
865
866#include "locking-selftest-wlock-hardirq.h"
867GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_wlock)
868
869#include "locking-selftest-spin-softirq.h"
870GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_spin)
871
872#include "locking-selftest-rlock-softirq.h"
873GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_rlock)
874
875#include "locking-selftest-wlock-softirq.h"
876GENERATE_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"
907GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_spin)
908
909#include "locking-selftest-rlock-hardirq.h"
910GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_rlock)
911
912#include "locking-selftest-wlock-hardirq.h"
913GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_wlock)
914
915#include "locking-selftest-spin-softirq.h"
916GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_spin)
917
918#include "locking-selftest-rlock-softirq.h"
919GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_rlock)
920
921#include "locking-selftest-wlock-softirq.h"
922GENERATE_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"
955GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_spin)
956
957#include "locking-selftest-rlock-hardirq.h"
958GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_rlock)
959
960#include "locking-selftest-wlock-hardirq.h"
961GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_wlock)
962
963#include "locking-selftest-spin-softirq.h"
964GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_spin)
965
966#include "locking-selftest-rlock-softirq.h"
967GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_rlock)
968
969#include "locking-selftest-wlock-softirq.h"
970GENERATE_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"
1017GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_spin)
1018
1019#include "locking-selftest-rlock-hardirq.h"
1020GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_rlock)
1021
1022#include "locking-selftest-wlock-hardirq.h"
1023GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_wlock)
1024
1025#include "locking-selftest-spin-softirq.h"
1026GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_spin)
1027
1028#include "locking-selftest-rlock-softirq.h"
1029GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_rlock)
1030
1031#include "locking-selftest-wlock-softirq.h"
1032GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_wlock)
1033
1034#undef E1
1035#undef E2
1036#undef E3
1037
8ef7ca75
BF		 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"
1064GENERATE_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"
1096GENERATE_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"
1128GENERATE_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"
1160GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_R3W1)
1161
1162#undef E1
1163#undef E2
1164#undef E3
cae2ed9a
IM		 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(); \
31e0d747 1184 LOCK(A); \
cae2ed9a
IM		 1185 L(B); \
1186 U(B); \
31e0d747 1187 UNLOCK(A); \
cae2ed9a
IM		 1188 IRQ_EXIT();
1189
1190/*
31e0d747 1191 * Generate 24 testcases:
cae2ed9a
IM		 1192 */
1193#include "locking-selftest-hardirq.h"
31e0d747
BF		 1194#include "locking-selftest-rlock.h"
1195GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_rlock)
1196
1197#include "locking-selftest-wlock.h"
1198GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_wlock)
cae2ed9a
IM		 1199
1200#include "locking-selftest-softirq.h"
31e0d747
BF		 1201#include "locking-selftest-rlock.h"
1202GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_rlock)
1203
1204#include "locking-selftest-wlock.h"
1205GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_wlock)
cae2ed9a
IM		 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); \
31e0d747
BF		 1219 LOCK(A); \
1220 UNLOCK(A); \
cae2ed9a
IM		 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/*
31e0d747 1237 * Generate 24 testcases:
cae2ed9a
IM		 1238 */
1239#include "locking-selftest-hardirq.h"
31e0d747
BF		 1240#include "locking-selftest-rlock.h"
1241GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_rlock)
1242
1243#include "locking-selftest-wlock.h"
1244GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_wlock)
cae2ed9a
IM		 1245
1246#include "locking-selftest-softirq.h"
31e0d747
BF		 1247#include "locking-selftest-rlock.h"
1248GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_rlock)
1249
1250#include "locking-selftest-wlock.h"
1251GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_wlock)
cae2ed9a 1252
96a16f45
BF		 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"
1295GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_rlock)
1296
1297#include "locking-selftest-wlock.h"
1298GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_wlock)
1299
1300#include "locking-selftest-softirq.h"
1301#include "locking-selftest-rlock.h"
1302GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_rlock)
1303
1304#include "locking-selftest-wlock.h"
1305GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_wlock)
1306
cae2ed9a
IM		 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)
1de99445 1312# define I_WW(x) lockdep_reset_lock(&x.dep_map)
018956d6
PZ		 1313#ifdef CONFIG_RT_MUTEXES
1314# define I_RTMUTEX(x) lockdep_reset_lock(&rtmutex_##x.dep_map)
1315#endif
cae2ed9a
IM		 1316#else
1317# define I_SPINLOCK(x)
1318# define I_RWLOCK(x)
1319# define I_MUTEX(x)
1320# define I_RWSEM(x)
1de99445 1321# define I_WW(x)
cae2ed9a
IM		 1322#endif
1323
018956d6
PZ		 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
cae2ed9a
IM		 1334#define I1(x) \
1335 do { \
1336 I_SPINLOCK(x); \
1337 I_RWLOCK(x); \
1338 I_MUTEX(x); \
1339 I_RWSEM(x); \
018956d6 1340 I_RTMUTEX(x); \
cae2ed9a
IM		 1341 } while (0)
1342
1343#define I2(x) \
1344 do { \
a2e9ae58 1345 spin_lock_init(&lock_##x); \
cae2ed9a
IM		 1346 rwlock_init(&rwlock_##x); \
1347 mutex_init(&mutex_##x); \
1348 init_rwsem(&rwsem_##x); \
018956d6 1349 I2_RTMUTEX(x); \
cae2ed9a
IM		 1350 } while (0)
1351
1352static void reset_locks(void)
1353{
1354 local_irq_disable();
1de99445
ML		 1355 lockdep_free_key_range(&ww_lockdep.acquire_key, 1);
1356 lockdep_free_key_range(&ww_lockdep.mutex_key, 1);
1357
cae2ed9a
IM		 1358 I1(A); I1(B); I1(C); I1(D);
1359 I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);
f3cf139e 1360 I_WW(t); I_WW(t2); I_WW(o.base); I_WW(o2.base); I_WW(o3.base);
cae2ed9a
IM		 1361 lockdep_reset();
1362 I2(A); I2(B); I2(C); I2(D);
1363 init_shared_classes();
1de99445 1364
f3cf139e 1365 ww_mutex_init(&o, &ww_lockdep); ww_mutex_init(&o2, &ww_lockdep); ww_mutex_init(&o3, &ww_lockdep);
1de99445
ML		 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));
cae2ed9a
IM		 1369 local_irq_enable();
1370}
1371
1372#undef I
1373
1374static int testcase_total;
1375static int testcase_successes;
1376static int expected_testcase_failures;
1377static int unexpected_testcase_failures;
1378
1379static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
1380{
1381 unsigned long saved_preempt_count = preempt_count();
cae2ed9a
IM		 1382
1383 WARN_ON(irqs_disabled());
1384
1385 testcase_fn();
1386 /*
1387 * Filter out expected failures:
1388 */
1389#ifndef CONFIG_PROVE_LOCKING
166989e3 1390 if (expected == FAILURE && debug_locks) {
1de99445 1391 expected_testcase_failures++;
25139409 1392 pr_cont("failed|");
166989e3
ML		 1393 }
1394 else
1395#endif
1396 if (debug_locks != expected) {
1de99445 1397 unexpected_testcase_failures++;
25139409 1398 pr_cont("FAILED|");
cae2ed9a
IM		 1399 } else {
1400 testcase_successes++;
25139409 1401 pr_cont(" ok |");
cae2ed9a
IM		 1402 }
1403 testcase_total++;
1404
1405 if (debug_locks_verbose)
25139409 1406 pr_cont(" lockclass mask: %x, debug_locks: %d, expected: %d\n",
cae2ed9a
IM		 1407 lockclass_mask, debug_locks, expected);
1408 /*
1409 * Some tests (e.g. double-unlock) might corrupt the preemption
1410 * count, so restore it:
1411 */
4a2b4b22 1412 preempt_count_set(saved_preempt_count);
cae2ed9a
IM		 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
018956d6
PZ		 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
cae2ed9a
IM		 1429static 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); \
25139409 1437 pr_cont("\n");
cae2ed9a
IM		 1438
1439#define DO_TESTCASE_1B(desc, name, nr) \
1440 print_testname(desc"/"#nr); \
1441 dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \
25139409 1442 pr_cont("\n");
cae2ed9a 1443
8ef7ca75
BF		 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
cae2ed9a
IM		 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); \
25139409 1462 pr_cont("\n");
cae2ed9a
IM		 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); \
25139409 1469 pr_cont("\n");
cae2ed9a 1470
31e0d747
BF		 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
cae2ed9a
IM		 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); \
018956d6 1498 dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX); \
25139409 1499 pr_cont("\n");
cae2ed9a
IM		 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); \
018956d6 1509 dotest_rt(name##_rtmutex, SUCCESS, LOCKTYPE_RTMUTEX); \
25139409 1510 pr_cont("\n");
cae2ed9a
IM		 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); \
018956d6 1523 dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX); \
25139409 1524 pr_cont("\n");
cae2ed9a
IM		 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
8ef7ca75
BF		 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
cae2ed9a
IM		 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
1de99445
ML		 1598static 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
2fe3d4b1
ML		 1632static 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
1de99445
ML		 1693static void ww_test_two_contexts(void)
1694{
1695 WWAI(&t);
1696 WWAI(&t2);
1697}
1698
1699static 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
1708static void ww_test_context_done_twice(void)
1709{
1710 WWAI(&t);
1711 WWAD(&t);
1712 WWAD(&t);
1713 WWAF(&t);
1714}
1715
1716static void ww_test_context_unlock_twice(void)
1717{
1718 WWAI(&t);
1719 WWAD(&t);
1720 WWAF(&t);
1721 WWAF(&t);
1722}
1723
1724static void ww_test_context_fini_early(void)
1725{
1726 WWAI(&t);
1727 WWL(&o, &t);
1728 WWAD(&t);
1729 WWAF(&t);
1730}
1731
1732static void ww_test_context_lock_after_done(void)
1733{
1734 WWAI(&t);
1735 WWAD(&t);
1736 WWL(&o, &t);
1737}
1738
1739static void ww_test_object_unlock_twice(void)
1740{
1741 WWL1(&o);
1742 WWU(&o);
1743 WWU(&o);
1744}
1745
1746static 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
1755static void ww_test_object_lock_stale_context(void)
1756{
1757 WWAI(&t);
1758 o.ctx = &t2;
1759 WWL(&o, &t);
1760}
1761
f3cf139e
ML		 1762static void ww_test_edeadlk_normal(void)
1763{
1764 int ret;
1765
1766 mutex_lock(&o2.base);
1767 o2.ctx = &t2;
5facae4f 1768 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1788static void ww_test_edeadlk_normal_slow(void)
1789{
1790 int ret;
1791
1792 mutex_lock(&o2.base);
5facae4f 1793 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1814static void ww_test_edeadlk_no_unlock(void)
1815{
1816 int ret;
1817
1818 mutex_lock(&o2.base);
1819 o2.ctx = &t2;
5facae4f 1820 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1839static void ww_test_edeadlk_no_unlock_slow(void)
1840{
1841 int ret;
1842
1843 mutex_lock(&o2.base);
5facae4f 1844 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1864static void ww_test_edeadlk_acquire_more(void)
1865{
1866 int ret;
1867
1868 mutex_lock(&o2.base);
5facae4f 1869 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1885static void ww_test_edeadlk_acquire_more_slow(void)
1886{
1887 int ret;
1888
1889 mutex_lock(&o2.base);
5facae4f 1890 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1906static void ww_test_edeadlk_acquire_more_edeadlk(void)
1907{
1908 int ret;
1909
1910 mutex_lock(&o2.base);
5facae4f 1911 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 1912 o2.ctx = &t2;
1913
1914 mutex_lock(&o3.base);
5facae4f 1915 mutex_release(&o3.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1932static void ww_test_edeadlk_acquire_more_edeadlk_slow(void)
1933{
1934 int ret;
1935
1936 mutex_lock(&o2.base);
5facae4f 1937 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 1938 o2.ctx = &t2;
1939
1940 mutex_lock(&o3.base);
5facae4f 1941 mutex_release(&o3.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1957static void ww_test_edeadlk_acquire_wrong(void)
1958{
1959 int ret;
1960
1961 mutex_lock(&o2.base);
5facae4f 1962 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1982static void ww_test_edeadlk_acquire_wrong_slow(void)
1983{
1984 int ret;
1985
1986 mutex_lock(&o2.base);
5facae4f 1987 mutex_release(&o2.base.dep_map, _THIS_IP_);
f3cf139e
ML		 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
1de99445
ML		 2007static void ww_test_spin_nest_unlocked(void)
2008{
a2e9ae58 2009 spin_lock_nest_lock(&lock_A, &o.base);
1de99445
ML		 2010 U(A);
2011}
2012
e04ce676
BF		 2013/* This is not a deadlock, because we have X1 to serialize Y1 and Y2 */
2014static 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
1de99445
ML		 2026static void ww_test_unneeded_slow(void)
2027{
2028 WWAI(&t);
2029
2030 ww_mutex_lock_slow(&o, &t);
2031}
2032
2033static 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
2044static 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
2059static 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
2075static 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
2087static 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
2099static 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
2112static void ww_test_block_block(void)
2113{
2114 WWL1(&o);
2115 WWL1(&o2);
2116}
2117
2118static void ww_test_block_try(void)
2119{
2120 bool ret;
2121
2122 WWL1(&o);
2123 ret = WWT(&o2);
2124 WARN_ON(!ret);
2125}
2126
2127static 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
2138static 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
2154static 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
2174static 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
2196static 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);
2fe3d4b1 2204 dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW);
1de99445 2205 dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW);
25139409 2206 pr_cont("\n");
1de99445
ML		 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);
25139409 2211 pr_cont("\n");
1de99445
ML		 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);
25139409 2218 pr_cont("\n");
1de99445
ML		 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);
25139409 2224 pr_cont("\n");
1de99445 2225
f3cf139e
ML		 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);
25139409 2237 pr_cont("\n");
f3cf139e 2238
1de99445
ML		 2239 print_testname("spinlock nest unlocked");
2240 dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);
25139409 2241 pr_cont("\n");
1de99445 2242
e04ce676
BF		 2243 print_testname("spinlock nest test");
2244 dotest(ww_test_spin_nest_lock, SUCCESS, LOCKTYPE_WW);
2245 pr_cont("\n");
2246
1de99445
ML		 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);
25139409 2255 pr_cont("\n");
1de99445
ML		 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);
25139409 2261 pr_cont("\n");
1de99445
ML		 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);
25139409 2267 pr_cont("\n");
1de99445
ML		 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);
25139409 2273 pr_cont("\n");
1de99445 2274}
cae2ed9a 2275
ad56450d
BF		 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 */
2287static 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 */
2314static 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 */
2341static 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
2360static 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
d5037d1d
DV		 2378static 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
2385static 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
2392static 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
2403static 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
cae2ed9a
IM		 2422void 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
e9181886
BF		 2434 /*
2435 * treats read_lock() as recursive read locks for testing purpose
2436 */
2437 force_read_lock_recursive = 1;
2438
cae2ed9a
IM		 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;
cdc84d79 2450 lockdep_set_selftest_task(current);
cae2ed9a 2451
6c9076ec 2452 DO_TESTCASE_6R("A-A deadlock", AA);
cae2ed9a
IM		 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);
cae2ed9a
IM		 2461
2462 printk(" --------------------------------------------------------------------------\n");
2463 print_testname("recursive read-lock");
25139409 2464 pr_cont(" |");
cae2ed9a 2465 dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
25139409 2466 pr_cont(" |");
cae2ed9a 2467 dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
25139409 2468 pr_cont("\n");
cae2ed9a
IM		 2469
2470 print_testname("recursive read-lock #2");
25139409 2471 pr_cont(" |");
6c9076ec 2472 dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
25139409 2473 pr_cont(" |");
cae2ed9a 2474 dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
25139409 2475 pr_cont("\n");
cae2ed9a
IM		 2476
2477 print_testname("mixed read-write-lock");
25139409 2478 pr_cont(" |");
cae2ed9a 2479 dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
25139409 2480 pr_cont(" |");
cae2ed9a 2481 dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
25139409 2482 pr_cont("\n");
cae2ed9a
IM		 2483
2484 print_testname("mixed write-read-lock");
25139409 2485 pr_cont(" |");
cae2ed9a 2486 dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
25139409 2487 pr_cont(" |");
cae2ed9a 2488 dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
25139409 2489 pr_cont("\n");
cae2ed9a 2490
e9149858
PZ		 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
d4f200e5
BF		 2509 print_testname("chain cached mixed R-L/L-W ABBA");
2510 pr_cont(" |");
2511 dotest(rlock_chaincache_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
2512
8ef7ca75
BF		 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
cae2ed9a
IM		 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
31e0d747
BF		 2530 DO_TESTCASE_6x2x2RW("irq read-recursion", irq_read_recursion);
2531 DO_TESTCASE_6x2x2RW("irq read-recursion #2", irq_read_recursion2);
96a16f45 2532 DO_TESTCASE_6x2x2RW("irq read-recursion #3", irq_read_recursion3);
cae2ed9a 2533
1de99445
ML		 2534 ww_tests();
2535
e9181886
BF		 2536 force_read_lock_recursive = 0;
2537 /*
2538 * queued_read_lock() specific test cases can be put here
2539 */
ad56450d
BF		 2540 if (IS_ENABLED(CONFIG_QUEUED_RWLOCKS))
2541 queued_read_lock_tests();
e9181886 2542
d5037d1d
DV		 2543 fs_reclaim_tests();
2544
cae2ed9a
IM		 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 }
cdc84d79 2570 lockdep_set_selftest_task(NULL);
cae2ed9a
IM		 2571 debug_locks_silent = 0;
2572}
Linux 6.x block layer and io_uring tree(s)