?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / lib / locking-selftest.c
blob14f44f59e73381f00c4aeab1ec27107ec2bc2254
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, _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, _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, _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, _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, _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, _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, _THIS_IP_);
1622 o2.ctx = &t2;
1623
1624 mutex_lock(&o3.base);
1625 mutex_release(&o3.base.dep_map, _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, _THIS_IP_);
1648 o2.ctx = &t2;
1649
1650 mutex_lock(&o3.base);
1651 mutex_release(&o3.base.dep_map, _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, _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, _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 lockdep_set_selftest_task(current);
1993
1994 DO_TESTCASE_6R("A-A deadlock", AA);
1995 DO_TESTCASE_6R("A-B-B-A deadlock", ABBA);
1996 DO_TESTCASE_6R("A-B-B-C-C-A deadlock", ABBCCA);
1997 DO_TESTCASE_6R("A-B-C-A-B-C deadlock", ABCABC);
1998 DO_TESTCASE_6R("A-B-B-C-C-D-D-A deadlock", ABBCCDDA);
1999 DO_TESTCASE_6R("A-B-C-D-B-D-D-A deadlock", ABCDBDDA);
2000 DO_TESTCASE_6R("A-B-C-D-B-C-D-A deadlock", ABCDBCDA);
2001 DO_TESTCASE_6("double unlock", double_unlock);
2002 DO_TESTCASE_6("initialize held", init_held);
2003
2004 printk(" --------------------------------------------------------------------------\n");
2005 print_testname("recursive read-lock");
2006 pr_cont(" |");
2007 dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
2008 pr_cont(" |");
2009 dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
2010 pr_cont("\n");
2011
2012 print_testname("recursive read-lock #2");
2013 pr_cont(" |");
2014 dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
2015 pr_cont(" |");
2016 dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
2017 pr_cont("\n");
2018
2019 print_testname("mixed read-write-lock");
2020 pr_cont(" |");
2021 dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
2022 pr_cont(" |");
2023 dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
2024 pr_cont("\n");
2025
2026 print_testname("mixed write-read-lock");
2027 pr_cont(" |");
2028 dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
2029 pr_cont(" |");
2030 dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
2031 pr_cont("\n");
2032
2033 print_testname("mixed read-lock/lock-write ABBA");
2034 pr_cont(" |");
2035 dotest(rlock_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
2036 #ifdef CONFIG_PROVE_LOCKING
2037 /*
2038 * Lockdep does indeed fail here, but there's nothing we can do about
2039 * that now. Don't kill lockdep for it.
2040 */
2041 unexpected_testcase_failures--;
2042 #endif
2043
2044 pr_cont(" |");
2045 dotest(rwsem_ABBA1, FAILURE, LOCKTYPE_RWSEM);
2046
2047 print_testname("mixed read-lock/lock-read ABBA");
2048 pr_cont(" |");
2049 dotest(rlock_ABBA2, SUCCESS, LOCKTYPE_RWLOCK);
2050 pr_cont(" |");
2051 dotest(rwsem_ABBA2, FAILURE, LOCKTYPE_RWSEM);
2052
2053 print_testname("mixed write-lock/lock-write ABBA");
2054 pr_cont(" |");
2055 dotest(rlock_ABBA3, FAILURE, LOCKTYPE_RWLOCK);
2056 pr_cont(" |");
2057 dotest(rwsem_ABBA3, FAILURE, LOCKTYPE_RWSEM);
2058
2059 printk(" --------------------------------------------------------------------------\n");
2060
2061 /*
2062 * irq-context testcases:
2063 */
2064 DO_TESTCASE_2x6("irqs-on + irq-safe-A", irqsafe1);
2065 DO_TESTCASE_2x3("sirq-safe-A => hirqs-on", irqsafe2A);
2066 DO_TESTCASE_2x6("safe-A + irqs-on", irqsafe2B);
2067 DO_TESTCASE_6x6("safe-A + unsafe-B #1", irqsafe3);
2068 DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4);
2069 DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion);
2070
2071 DO_TESTCASE_6x2("irq read-recursion", irq_read_recursion);
2072 // DO_TESTCASE_6x2B("irq read-recursion #2", irq_read_recursion2);
2073
2074 ww_tests();
2075
2076 if (unexpected_testcase_failures) {
2077 printk("-----------------------------------------------------------------\n");
2078 debug_locks = 0;
2079 printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
2080 unexpected_testcase_failures, testcase_total);
2081 printk("-----------------------------------------------------------------\n");
2082 } else if (expected_testcase_failures && testcase_successes) {
2083 printk("--------------------------------------------------------\n");
2084 printk("%3d out of %3d testcases failed, as expected. |\n",
2085 expected_testcase_failures, testcase_total);
2086 printk("----------------------------------------------------\n");
2087 debug_locks = 1;
2088 } else if (expected_testcase_failures && !testcase_successes) {
2089 printk("--------------------------------------------------------\n");
2090 printk("All %3d testcases failed, as expected. |\n",
2091 expected_testcase_failures);
2092 printk("----------------------------------------\n");
2093 debug_locks = 1;
2094 } else {
2095 printk("-------------------------------------------------------\n");
2096 printk("Good, all %3d testcases passed! |\n",
2097 testcase_successes);
2098 printk("---------------------------------\n");
2099 debug_locks = 1;
2100 }
2101 lockdep_set_selftest_task(NULL);
2102 debug_locks_silent = 0;
2103 }
Linux with added FPC-III support