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