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