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