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/sched/mm.h>
19 #include <linux/delay.h>
20 #include <linux/lockdep.h>
21 #include <linux/spinlock.h>
22 #include <linux/kallsyms.h>
23 #include <linux/interrupt.h>
24 #include <linux/debug_locks.h>
25 #include <linux/irqflags.h>
26 #include <linux/rtmutex.h>
27 #include <linux/local_lock.h>
28
29 /*
30 * Change this to 1 if you want to see the failure printouts:
31 */
32 static unsigned int debug_locks_verbose;
33 unsigned int force_read_lock_recursive;
34
35 static DEFINE_WD_CLASS(ww_lockdep);
36
setup_debug_locks_verbose(char * str)37 static int __init setup_debug_locks_verbose(char *str)
38 {
39 get_option(&str, &debug_locks_verbose);
40
41 return 1;
42 }
43
44 __setup("debug_locks_verbose=", setup_debug_locks_verbose);
45
46 #define FAILURE 0
47 #define SUCCESS 1
48
49 #define LOCKTYPE_SPIN 0x1
50 #define LOCKTYPE_RWLOCK 0x2
51 #define LOCKTYPE_MUTEX 0x4
52 #define LOCKTYPE_RWSEM 0x8
53 #define LOCKTYPE_WW 0x10
54 #define LOCKTYPE_RTMUTEX 0x20
55 #define LOCKTYPE_LL 0x40
56
57 static struct ww_acquire_ctx t, t2;
58 static struct ww_mutex o, o2, o3;
59
60 /*
61 * Normal standalone locks, for the circular and irq-context
62 * dependency tests:
63 */
64 static DEFINE_SPINLOCK(lock_A);
65 static DEFINE_SPINLOCK(lock_B);
66 static DEFINE_SPINLOCK(lock_C);
67 static DEFINE_SPINLOCK(lock_D);
68
69 static DEFINE_RAW_SPINLOCK(raw_lock_A);
70 static DEFINE_RAW_SPINLOCK(raw_lock_B);
71
72 static DEFINE_RWLOCK(rwlock_A);
73 static DEFINE_RWLOCK(rwlock_B);
74 static DEFINE_RWLOCK(rwlock_C);
75 static DEFINE_RWLOCK(rwlock_D);
76
77 static DEFINE_MUTEX(mutex_A);
78 static DEFINE_MUTEX(mutex_B);
79 static DEFINE_MUTEX(mutex_C);
80 static DEFINE_MUTEX(mutex_D);
81
82 static DECLARE_RWSEM(rwsem_A);
83 static DECLARE_RWSEM(rwsem_B);
84 static DECLARE_RWSEM(rwsem_C);
85 static DECLARE_RWSEM(rwsem_D);
86
87 #ifdef CONFIG_RT_MUTEXES
88
89 static DEFINE_RT_MUTEX(rtmutex_A);
90 static DEFINE_RT_MUTEX(rtmutex_B);
91 static DEFINE_RT_MUTEX(rtmutex_C);
92 static DEFINE_RT_MUTEX(rtmutex_D);
93
94 #endif
95
96 /*
97 * Locks that we initialize dynamically as well so that
98 * e.g. X1 and X2 becomes two instances of the same class,
99 * but X* and Y* are different classes. We do this so that
100 * we do not trigger a real lockup:
101 */
102 static DEFINE_SPINLOCK(lock_X1);
103 static DEFINE_SPINLOCK(lock_X2);
104 static DEFINE_SPINLOCK(lock_Y1);
105 static DEFINE_SPINLOCK(lock_Y2);
106 static DEFINE_SPINLOCK(lock_Z1);
107 static DEFINE_SPINLOCK(lock_Z2);
108
109 static DEFINE_RWLOCK(rwlock_X1);
110 static DEFINE_RWLOCK(rwlock_X2);
111 static DEFINE_RWLOCK(rwlock_Y1);
112 static DEFINE_RWLOCK(rwlock_Y2);
113 static DEFINE_RWLOCK(rwlock_Z1);
114 static DEFINE_RWLOCK(rwlock_Z2);
115
116 static DEFINE_MUTEX(mutex_X1);
117 static DEFINE_MUTEX(mutex_X2);
118 static DEFINE_MUTEX(mutex_Y1);
119 static DEFINE_MUTEX(mutex_Y2);
120 static DEFINE_MUTEX(mutex_Z1);
121 static DEFINE_MUTEX(mutex_Z2);
122
123 static DECLARE_RWSEM(rwsem_X1);
124 static DECLARE_RWSEM(rwsem_X2);
125 static DECLARE_RWSEM(rwsem_Y1);
126 static DECLARE_RWSEM(rwsem_Y2);
127 static DECLARE_RWSEM(rwsem_Z1);
128 static DECLARE_RWSEM(rwsem_Z2);
129
130 #ifdef CONFIG_RT_MUTEXES
131
132 static DEFINE_RT_MUTEX(rtmutex_X1);
133 static DEFINE_RT_MUTEX(rtmutex_X2);
134 static DEFINE_RT_MUTEX(rtmutex_Y1);
135 static DEFINE_RT_MUTEX(rtmutex_Y2);
136 static DEFINE_RT_MUTEX(rtmutex_Z1);
137 static DEFINE_RT_MUTEX(rtmutex_Z2);
138
139 #endif
140
141 static local_lock_t local_A = INIT_LOCAL_LOCK(local_A);
142
143 /*
144 * non-inlined runtime initializers, to let separate locks share
145 * the same lock-class:
146 */
147 #define INIT_CLASS_FUNC(class) \
148 static noinline void \
149 init_class_##class(spinlock_t *lock, rwlock_t *rwlock, \
150 struct mutex *mutex, struct rw_semaphore *rwsem)\
151 { \
152 spin_lock_init(lock); \
153 rwlock_init(rwlock); \
154 mutex_init(mutex); \
155 init_rwsem(rwsem); \
156 }
157
158 INIT_CLASS_FUNC(X)
INIT_CLASS_FUNC(Y)159 INIT_CLASS_FUNC(Y)
160 INIT_CLASS_FUNC(Z)
161
162 static void init_shared_classes(void)
163 {
164 #ifdef CONFIG_RT_MUTEXES
165 static struct lock_class_key rt_X, rt_Y, rt_Z;
166
167 __rt_mutex_init(&rtmutex_X1, __func__, &rt_X);
168 __rt_mutex_init(&rtmutex_X2, __func__, &rt_X);
169 __rt_mutex_init(&rtmutex_Y1, __func__, &rt_Y);
170 __rt_mutex_init(&rtmutex_Y2, __func__, &rt_Y);
171 __rt_mutex_init(&rtmutex_Z1, __func__, &rt_Z);
172 __rt_mutex_init(&rtmutex_Z2, __func__, &rt_Z);
173 #endif
174
175 init_class_X(&lock_X1, &rwlock_X1, &mutex_X1, &rwsem_X1);
176 init_class_X(&lock_X2, &rwlock_X2, &mutex_X2, &rwsem_X2);
177
178 init_class_Y(&lock_Y1, &rwlock_Y1, &mutex_Y1, &rwsem_Y1);
179 init_class_Y(&lock_Y2, &rwlock_Y2, &mutex_Y2, &rwsem_Y2);
180
181 init_class_Z(&lock_Z1, &rwlock_Z1, &mutex_Z1, &rwsem_Z1);
182 init_class_Z(&lock_Z2, &rwlock_Z2, &mutex_Z2, &rwsem_Z2);
183 }
184
185 /*
186 * For spinlocks and rwlocks we also do hardirq-safe / softirq-safe tests.
187 * The following functions use a lock from a simulated hardirq/softirq
188 * context, causing the locks to be marked as hardirq-safe/softirq-safe:
189 */
190
191 #define HARDIRQ_DISABLE local_irq_disable
192 #define HARDIRQ_ENABLE local_irq_enable
193
194 #define HARDIRQ_ENTER() \
195 local_irq_disable(); \
196 __irq_enter(); \
197 WARN_ON(!in_irq());
198
199 #define HARDIRQ_EXIT() \
200 __irq_exit(); \
201 local_irq_enable();
202
203 #define SOFTIRQ_DISABLE local_bh_disable
204 #define SOFTIRQ_ENABLE local_bh_enable
205
206 #define SOFTIRQ_ENTER() \
207 local_bh_disable(); \
208 local_irq_disable(); \
209 lockdep_softirq_enter(); \
210 WARN_ON(!in_softirq());
211
212 #define SOFTIRQ_EXIT() \
213 lockdep_softirq_exit(); \
214 local_irq_enable(); \
215 local_bh_enable();
216
217 /*
218 * Shortcuts for lock/unlock API variants, to keep
219 * the testcases compact:
220 */
221 #define L(x) spin_lock(&lock_##x)
222 #define U(x) spin_unlock(&lock_##x)
223 #define LU(x) L(x); U(x)
224 #define SI(x) spin_lock_init(&lock_##x)
225
226 #define WL(x) write_lock(&rwlock_##x)
227 #define WU(x) write_unlock(&rwlock_##x)
228 #define WLU(x) WL(x); WU(x)
229
230 #define RL(x) read_lock(&rwlock_##x)
231 #define RU(x) read_unlock(&rwlock_##x)
232 #define RLU(x) RL(x); RU(x)
233 #define RWI(x) rwlock_init(&rwlock_##x)
234
235 #define ML(x) mutex_lock(&mutex_##x)
236 #define MU(x) mutex_unlock(&mutex_##x)
237 #define MI(x) mutex_init(&mutex_##x)
238
239 #define RTL(x) rt_mutex_lock(&rtmutex_##x)
240 #define RTU(x) rt_mutex_unlock(&rtmutex_##x)
241 #define RTI(x) rt_mutex_init(&rtmutex_##x)
242
243 #define WSL(x) down_write(&rwsem_##x)
244 #define WSU(x) up_write(&rwsem_##x)
245
246 #define RSL(x) down_read(&rwsem_##x)
247 #define RSU(x) up_read(&rwsem_##x)
248 #define RWSI(x) init_rwsem(&rwsem_##x)
249
250 #ifndef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
251 #define WWAI(x) ww_acquire_init(x, &ww_lockdep)
252 #else
253 #define WWAI(x) do { ww_acquire_init(x, &ww_lockdep); (x)->deadlock_inject_countdown = ~0U; } while (0)
254 #endif
255 #define WWAD(x) ww_acquire_done(x)
256 #define WWAF(x) ww_acquire_fini(x)
257
258 #define WWL(x, c) ww_mutex_lock(x, c)
259 #define WWT(x) ww_mutex_trylock(x)
260 #define WWL1(x) ww_mutex_lock(x, NULL)
261 #define WWU(x) ww_mutex_unlock(x)
262
263
264 #define LOCK_UNLOCK_2(x,y) LOCK(x); LOCK(y); UNLOCK(y); UNLOCK(x)
265
266 /*
267 * Generate different permutations of the same testcase, using
268 * the same basic lock-dependency/state events:
269 */
270
271 #define GENERATE_TESTCASE(name) \
272 \
273 static void name(void) { E(); }
274
275 #define GENERATE_PERMUTATIONS_2_EVENTS(name) \
276 \
277 static void name##_12(void) { E1(); E2(); } \
278 static void name##_21(void) { E2(); E1(); }
279
280 #define GENERATE_PERMUTATIONS_3_EVENTS(name) \
281 \
282 static void name##_123(void) { E1(); E2(); E3(); } \
283 static void name##_132(void) { E1(); E3(); E2(); } \
284 static void name##_213(void) { E2(); E1(); E3(); } \
285 static void name##_231(void) { E2(); E3(); E1(); } \
286 static void name##_312(void) { E3(); E1(); E2(); } \
287 static void name##_321(void) { E3(); E2(); E1(); }
288
289 /*
290 * AA deadlock:
291 */
292
293 #define E() \
294 \
295 LOCK(X1); \
296 LOCK(X2); /* this one should fail */
297
298 /*
299 * 6 testcases:
300 */
301 #include "locking-selftest-spin.h"
302 GENERATE_TESTCASE(AA_spin)
303 #include "locking-selftest-wlock.h"
304 GENERATE_TESTCASE(AA_wlock)
305 #include "locking-selftest-rlock.h"
306 GENERATE_TESTCASE(AA_rlock)
307 #include "locking-selftest-mutex.h"
308 GENERATE_TESTCASE(AA_mutex)
309 #include "locking-selftest-wsem.h"
310 GENERATE_TESTCASE(AA_wsem)
311 #include "locking-selftest-rsem.h"
312 GENERATE_TESTCASE(AA_rsem)
313
314 #ifdef CONFIG_RT_MUTEXES
315 #include "locking-selftest-rtmutex.h"
316 GENERATE_TESTCASE(AA_rtmutex);
317 #endif
318
319 #undef E
320
321 /*
322 * Special-case for read-locking, they are
323 * allowed to recurse on the same lock class:
324 */
rlock_AA1(void)325 static void rlock_AA1(void)
326 {
327 RL(X1);
328 RL(X1); // this one should NOT fail
329 }
330
rlock_AA1B(void)331 static void rlock_AA1B(void)
332 {
333 RL(X1);
334 RL(X2); // this one should NOT fail
335 }
336
rsem_AA1(void)337 static void rsem_AA1(void)
338 {
339 RSL(X1);
340 RSL(X1); // this one should fail
341 }
342
rsem_AA1B(void)343 static void rsem_AA1B(void)
344 {
345 RSL(X1);
346 RSL(X2); // this one should fail
347 }
348 /*
349 * The mixing of read and write locks is not allowed:
350 */
rlock_AA2(void)351 static void rlock_AA2(void)
352 {
353 RL(X1);
354 WL(X2); // this one should fail
355 }
356
rsem_AA2(void)357 static void rsem_AA2(void)
358 {
359 RSL(X1);
360 WSL(X2); // this one should fail
361 }
362
rlock_AA3(void)363 static void rlock_AA3(void)
364 {
365 WL(X1);
366 RL(X2); // this one should fail
367 }
368
rsem_AA3(void)369 static void rsem_AA3(void)
370 {
371 WSL(X1);
372 RSL(X2); // this one should fail
373 }
374
375 /*
376 * read_lock(A)
377 * spin_lock(B)
378 * spin_lock(B)
379 * write_lock(A)
380 */
rlock_ABBA1(void)381 static void rlock_ABBA1(void)
382 {
383 RL(X1);
384 L(Y1);
385 U(Y1);
386 RU(X1);
387
388 L(Y1);
389 WL(X1);
390 WU(X1);
391 U(Y1); // should fail
392 }
393
rwsem_ABBA1(void)394 static void rwsem_ABBA1(void)
395 {
396 RSL(X1);
397 ML(Y1);
398 MU(Y1);
399 RSU(X1);
400
401 ML(Y1);
402 WSL(X1);
403 WSU(X1);
404 MU(Y1); // should fail
405 }
406
407 /*
408 * read_lock(A)
409 * spin_lock(B)
410 * spin_lock(B)
411 * write_lock(A)
412 *
413 * This test case is aimed at poking whether the chain cache prevents us from
414 * detecting a read-lock/lock-write deadlock: if the chain cache doesn't differ
415 * read/write locks, the following case may happen
416 *
417 * { read_lock(A)->lock(B) dependency exists }
418 *
419 * P0:
420 * lock(B);
421 * read_lock(A);
422 *
423 * { Not a deadlock, B -> A is added in the chain cache }
424 *
425 * P1:
426 * lock(B);
427 * write_lock(A);
428 *
429 * { B->A found in chain cache, not reported as a deadlock }
430 *
431 */
rlock_chaincache_ABBA1(void)432 static void rlock_chaincache_ABBA1(void)
433 {
434 RL(X1);
435 L(Y1);
436 U(Y1);
437 RU(X1);
438
439 L(Y1);
440 RL(X1);
441 RU(X1);
442 U(Y1);
443
444 L(Y1);
445 WL(X1);
446 WU(X1);
447 U(Y1); // should fail
448 }
449
450 /*
451 * read_lock(A)
452 * spin_lock(B)
453 * spin_lock(B)
454 * read_lock(A)
455 */
rlock_ABBA2(void)456 static void rlock_ABBA2(void)
457 {
458 RL(X1);
459 L(Y1);
460 U(Y1);
461 RU(X1);
462
463 L(Y1);
464 RL(X1);
465 RU(X1);
466 U(Y1); // should NOT fail
467 }
468
rwsem_ABBA2(void)469 static void rwsem_ABBA2(void)
470 {
471 RSL(X1);
472 ML(Y1);
473 MU(Y1);
474 RSU(X1);
475
476 ML(Y1);
477 RSL(X1);
478 RSU(X1);
479 MU(Y1); // should fail
480 }
481
482
483 /*
484 * write_lock(A)
485 * spin_lock(B)
486 * spin_lock(B)
487 * write_lock(A)
488 */
rlock_ABBA3(void)489 static void rlock_ABBA3(void)
490 {
491 WL(X1);
492 L(Y1);
493 U(Y1);
494 WU(X1);
495
496 L(Y1);
497 WL(X1);
498 WU(X1);
499 U(Y1); // should fail
500 }
501
rwsem_ABBA3(void)502 static void rwsem_ABBA3(void)
503 {
504 WSL(X1);
505 ML(Y1);
506 MU(Y1);
507 WSU(X1);
508
509 ML(Y1);
510 WSL(X1);
511 WSU(X1);
512 MU(Y1); // should fail
513 }
514
515 /*
516 * ABBA deadlock:
517 */
518
519 #define E() \
520 \
521 LOCK_UNLOCK_2(A, B); \
522 LOCK_UNLOCK_2(B, A); /* fail */
523
524 /*
525 * 6 testcases:
526 */
527 #include "locking-selftest-spin.h"
528 GENERATE_TESTCASE(ABBA_spin)
529 #include "locking-selftest-wlock.h"
530 GENERATE_TESTCASE(ABBA_wlock)
531 #include "locking-selftest-rlock.h"
532 GENERATE_TESTCASE(ABBA_rlock)
533 #include "locking-selftest-mutex.h"
534 GENERATE_TESTCASE(ABBA_mutex)
535 #include "locking-selftest-wsem.h"
536 GENERATE_TESTCASE(ABBA_wsem)
537 #include "locking-selftest-rsem.h"
538 GENERATE_TESTCASE(ABBA_rsem)
539
540 #ifdef CONFIG_RT_MUTEXES
541 #include "locking-selftest-rtmutex.h"
542 GENERATE_TESTCASE(ABBA_rtmutex);
543 #endif
544
545 #undef E
546
547 /*
548 * AB BC CA deadlock:
549 */
550
551 #define E() \
552 \
553 LOCK_UNLOCK_2(A, B); \
554 LOCK_UNLOCK_2(B, C); \
555 LOCK_UNLOCK_2(C, A); /* fail */
556
557 /*
558 * 6 testcases:
559 */
560 #include "locking-selftest-spin.h"
561 GENERATE_TESTCASE(ABBCCA_spin)
562 #include "locking-selftest-wlock.h"
563 GENERATE_TESTCASE(ABBCCA_wlock)
564 #include "locking-selftest-rlock.h"
565 GENERATE_TESTCASE(ABBCCA_rlock)
566 #include "locking-selftest-mutex.h"
567 GENERATE_TESTCASE(ABBCCA_mutex)
568 #include "locking-selftest-wsem.h"
569 GENERATE_TESTCASE(ABBCCA_wsem)
570 #include "locking-selftest-rsem.h"
571 GENERATE_TESTCASE(ABBCCA_rsem)
572
573 #ifdef CONFIG_RT_MUTEXES
574 #include "locking-selftest-rtmutex.h"
575 GENERATE_TESTCASE(ABBCCA_rtmutex);
576 #endif
577
578 #undef E
579
580 /*
581 * AB CA BC deadlock:
582 */
583
584 #define E() \
585 \
586 LOCK_UNLOCK_2(A, B); \
587 LOCK_UNLOCK_2(C, A); \
588 LOCK_UNLOCK_2(B, C); /* fail */
589
590 /*
591 * 6 testcases:
592 */
593 #include "locking-selftest-spin.h"
594 GENERATE_TESTCASE(ABCABC_spin)
595 #include "locking-selftest-wlock.h"
596 GENERATE_TESTCASE(ABCABC_wlock)
597 #include "locking-selftest-rlock.h"
598 GENERATE_TESTCASE(ABCABC_rlock)
599 #include "locking-selftest-mutex.h"
600 GENERATE_TESTCASE(ABCABC_mutex)
601 #include "locking-selftest-wsem.h"
602 GENERATE_TESTCASE(ABCABC_wsem)
603 #include "locking-selftest-rsem.h"
604 GENERATE_TESTCASE(ABCABC_rsem)
605
606 #ifdef CONFIG_RT_MUTEXES
607 #include "locking-selftest-rtmutex.h"
608 GENERATE_TESTCASE(ABCABC_rtmutex);
609 #endif
610
611 #undef E
612
613 /*
614 * AB BC CD DA deadlock:
615 */
616
617 #define E() \
618 \
619 LOCK_UNLOCK_2(A, B); \
620 LOCK_UNLOCK_2(B, C); \
621 LOCK_UNLOCK_2(C, D); \
622 LOCK_UNLOCK_2(D, A); /* fail */
623
624 /*
625 * 6 testcases:
626 */
627 #include "locking-selftest-spin.h"
628 GENERATE_TESTCASE(ABBCCDDA_spin)
629 #include "locking-selftest-wlock.h"
630 GENERATE_TESTCASE(ABBCCDDA_wlock)
631 #include "locking-selftest-rlock.h"
632 GENERATE_TESTCASE(ABBCCDDA_rlock)
633 #include "locking-selftest-mutex.h"
634 GENERATE_TESTCASE(ABBCCDDA_mutex)
635 #include "locking-selftest-wsem.h"
636 GENERATE_TESTCASE(ABBCCDDA_wsem)
637 #include "locking-selftest-rsem.h"
638 GENERATE_TESTCASE(ABBCCDDA_rsem)
639
640 #ifdef CONFIG_RT_MUTEXES
641 #include "locking-selftest-rtmutex.h"
642 GENERATE_TESTCASE(ABBCCDDA_rtmutex);
643 #endif
644
645 #undef E
646
647 /*
648 * AB CD BD DA deadlock:
649 */
650 #define E() \
651 \
652 LOCK_UNLOCK_2(A, B); \
653 LOCK_UNLOCK_2(C, D); \
654 LOCK_UNLOCK_2(B, D); \
655 LOCK_UNLOCK_2(D, A); /* fail */
656
657 /*
658 * 6 testcases:
659 */
660 #include "locking-selftest-spin.h"
661 GENERATE_TESTCASE(ABCDBDDA_spin)
662 #include "locking-selftest-wlock.h"
663 GENERATE_TESTCASE(ABCDBDDA_wlock)
664 #include "locking-selftest-rlock.h"
665 GENERATE_TESTCASE(ABCDBDDA_rlock)
666 #include "locking-selftest-mutex.h"
667 GENERATE_TESTCASE(ABCDBDDA_mutex)
668 #include "locking-selftest-wsem.h"
669 GENERATE_TESTCASE(ABCDBDDA_wsem)
670 #include "locking-selftest-rsem.h"
671 GENERATE_TESTCASE(ABCDBDDA_rsem)
672
673 #ifdef CONFIG_RT_MUTEXES
674 #include "locking-selftest-rtmutex.h"
675 GENERATE_TESTCASE(ABCDBDDA_rtmutex);
676 #endif
677
678 #undef E
679
680 /*
681 * AB CD BC DA deadlock:
682 */
683 #define E() \
684 \
685 LOCK_UNLOCK_2(A, B); \
686 LOCK_UNLOCK_2(C, D); \
687 LOCK_UNLOCK_2(B, C); \
688 LOCK_UNLOCK_2(D, A); /* fail */
689
690 /*
691 * 6 testcases:
692 */
693 #include "locking-selftest-spin.h"
694 GENERATE_TESTCASE(ABCDBCDA_spin)
695 #include "locking-selftest-wlock.h"
696 GENERATE_TESTCASE(ABCDBCDA_wlock)
697 #include "locking-selftest-rlock.h"
698 GENERATE_TESTCASE(ABCDBCDA_rlock)
699 #include "locking-selftest-mutex.h"
700 GENERATE_TESTCASE(ABCDBCDA_mutex)
701 #include "locking-selftest-wsem.h"
702 GENERATE_TESTCASE(ABCDBCDA_wsem)
703 #include "locking-selftest-rsem.h"
704 GENERATE_TESTCASE(ABCDBCDA_rsem)
705
706 #ifdef CONFIG_RT_MUTEXES
707 #include "locking-selftest-rtmutex.h"
708 GENERATE_TESTCASE(ABCDBCDA_rtmutex);
709 #endif
710
711 #undef E
712
713 /*
714 * Double unlock:
715 */
716 #define E() \
717 \
718 LOCK(A); \
719 UNLOCK(A); \
720 UNLOCK(A); /* fail */
721
722 /*
723 * 6 testcases:
724 */
725 #include "locking-selftest-spin.h"
726 GENERATE_TESTCASE(double_unlock_spin)
727 #include "locking-selftest-wlock.h"
728 GENERATE_TESTCASE(double_unlock_wlock)
729 #include "locking-selftest-rlock.h"
730 GENERATE_TESTCASE(double_unlock_rlock)
731 #include "locking-selftest-mutex.h"
732 GENERATE_TESTCASE(double_unlock_mutex)
733 #include "locking-selftest-wsem.h"
734 GENERATE_TESTCASE(double_unlock_wsem)
735 #include "locking-selftest-rsem.h"
736 GENERATE_TESTCASE(double_unlock_rsem)
737
738 #ifdef CONFIG_RT_MUTEXES
739 #include "locking-selftest-rtmutex.h"
740 GENERATE_TESTCASE(double_unlock_rtmutex);
741 #endif
742
743 #undef E
744
745 /*
746 * initializing a held lock:
747 */
748 #define E() \
749 \
750 LOCK(A); \
751 INIT(A); /* fail */
752
753 /*
754 * 6 testcases:
755 */
756 #include "locking-selftest-spin.h"
757 GENERATE_TESTCASE(init_held_spin)
758 #include "locking-selftest-wlock.h"
759 GENERATE_TESTCASE(init_held_wlock)
760 #include "locking-selftest-rlock.h"
761 GENERATE_TESTCASE(init_held_rlock)
762 #include "locking-selftest-mutex.h"
763 GENERATE_TESTCASE(init_held_mutex)
764 #include "locking-selftest-wsem.h"
765 GENERATE_TESTCASE(init_held_wsem)
766 #include "locking-selftest-rsem.h"
767 GENERATE_TESTCASE(init_held_rsem)
768
769 #ifdef CONFIG_RT_MUTEXES
770 #include "locking-selftest-rtmutex.h"
771 GENERATE_TESTCASE(init_held_rtmutex);
772 #endif
773
774 #undef E
775
776 /*
777 * locking an irq-safe lock with irqs enabled:
778 */
779 #define E1() \
780 \
781 IRQ_ENTER(); \
782 LOCK(A); \
783 UNLOCK(A); \
784 IRQ_EXIT();
785
786 #define E2() \
787 \
788 LOCK(A); \
789 UNLOCK(A);
790
791 /*
792 * Generate 24 testcases:
793 */
794 #include "locking-selftest-spin-hardirq.h"
795 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_spin)
796
797 #include "locking-selftest-rlock-hardirq.h"
GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_rlock)798 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_rlock)
799
800 #include "locking-selftest-wlock-hardirq.h"
801 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_wlock)
802
803 #include "locking-selftest-spin-softirq.h"
804 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_spin)
805
806 #include "locking-selftest-rlock-softirq.h"
807 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_rlock)
808
809 #include "locking-selftest-wlock-softirq.h"
810 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_wlock)
811
812 #undef E1
813 #undef E2
814
815 /*
816 * Enabling hardirqs with a softirq-safe lock held:
817 */
818 #define E1() \
819 \
820 SOFTIRQ_ENTER(); \
821 LOCK(A); \
822 UNLOCK(A); \
823 SOFTIRQ_EXIT();
824
825 #define E2() \
826 \
827 HARDIRQ_DISABLE(); \
828 LOCK(A); \
829 HARDIRQ_ENABLE(); \
830 UNLOCK(A);
831
832 /*
833 * Generate 12 testcases:
834 */
835 #include "locking-selftest-spin.h"
836 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_spin)
837
838 #include "locking-selftest-wlock.h"
839 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_wlock)
840
841 #include "locking-selftest-rlock.h"
842 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_rlock)
843
844 #undef E1
845 #undef E2
846
847 /*
848 * Enabling irqs with an irq-safe lock held:
849 */
850 #define E1() \
851 \
852 IRQ_ENTER(); \
853 LOCK(A); \
854 UNLOCK(A); \
855 IRQ_EXIT();
856
857 #define E2() \
858 \
859 IRQ_DISABLE(); \
860 LOCK(A); \
861 IRQ_ENABLE(); \
862 UNLOCK(A);
863
864 /*
865 * Generate 24 testcases:
866 */
867 #include "locking-selftest-spin-hardirq.h"
868 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_spin)
869
870 #include "locking-selftest-rlock-hardirq.h"
871 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_rlock)
872
873 #include "locking-selftest-wlock-hardirq.h"
874 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_wlock)
875
876 #include "locking-selftest-spin-softirq.h"
877 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_spin)
878
879 #include "locking-selftest-rlock-softirq.h"
880 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_rlock)
881
882 #include "locking-selftest-wlock-softirq.h"
883 GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_wlock)
884
885 #undef E1
886 #undef E2
887
888 /*
889 * Acquiring a irq-unsafe lock while holding an irq-safe-lock:
890 */
891 #define E1() \
892 \
893 LOCK(A); \
894 LOCK(B); \
895 UNLOCK(B); \
896 UNLOCK(A); \
897
898 #define E2() \
899 \
900 LOCK(B); \
901 UNLOCK(B);
902
903 #define E3() \
904 \
905 IRQ_ENTER(); \
906 LOCK(A); \
907 UNLOCK(A); \
908 IRQ_EXIT();
909
910 /*
911 * Generate 36 testcases:
912 */
913 #include "locking-selftest-spin-hardirq.h"
914 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_spin)
915
916 #include "locking-selftest-rlock-hardirq.h"
917 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_rlock)
918
919 #include "locking-selftest-wlock-hardirq.h"
920 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_wlock)
921
922 #include "locking-selftest-spin-softirq.h"
923 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_spin)
924
925 #include "locking-selftest-rlock-softirq.h"
926 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_rlock)
927
928 #include "locking-selftest-wlock-softirq.h"
929 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_wlock)
930
931 #undef E1
932 #undef E2
933 #undef E3
934
935 /*
936 * If a lock turns into softirq-safe, but earlier it took
937 * a softirq-unsafe lock:
938 */
939
940 #define E1() \
941 IRQ_DISABLE(); \
942 LOCK(A); \
943 LOCK(B); \
944 UNLOCK(B); \
945 UNLOCK(A); \
946 IRQ_ENABLE();
947
948 #define E2() \
949 LOCK(B); \
950 UNLOCK(B);
951
952 #define E3() \
953 IRQ_ENTER(); \
954 LOCK(A); \
955 UNLOCK(A); \
956 IRQ_EXIT();
957
958 /*
959 * Generate 36 testcases:
960 */
961 #include "locking-selftest-spin-hardirq.h"
962 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_spin)
963
964 #include "locking-selftest-rlock-hardirq.h"
965 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_rlock)
966
967 #include "locking-selftest-wlock-hardirq.h"
968 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_wlock)
969
970 #include "locking-selftest-spin-softirq.h"
971 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_spin)
972
973 #include "locking-selftest-rlock-softirq.h"
974 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_rlock)
975
976 #include "locking-selftest-wlock-softirq.h"
977 GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_wlock)
978
979 #undef E1
980 #undef E2
981 #undef E3
982
983 /*
984 * read-lock / write-lock irq inversion.
985 *
986 * Deadlock scenario:
987 *
988 * CPU#1 is at #1, i.e. it has write-locked A, but has not
989 * taken B yet.
990 *
991 * CPU#2 is at #2, i.e. it has locked B.
992 *
993 * Hardirq hits CPU#2 at point #2 and is trying to read-lock A.
994 *
995 * The deadlock occurs because CPU#1 will spin on B, and CPU#2
996 * will spin on A.
997 */
998
999 #define E1() \
1000 \
1001 IRQ_DISABLE(); \
1002 WL(A); \
1003 LOCK(B); \
1004 UNLOCK(B); \
1005 WU(A); \
1006 IRQ_ENABLE();
1007
1008 #define E2() \
1009 \
1010 LOCK(B); \
1011 UNLOCK(B);
1012
1013 #define E3() \
1014 \
1015 IRQ_ENTER(); \
1016 RL(A); \
1017 RU(A); \
1018 IRQ_EXIT();
1019
1020 /*
1021 * Generate 36 testcases:
1022 */
1023 #include "locking-selftest-spin-hardirq.h"
1024 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_spin)
1025
1026 #include "locking-selftest-rlock-hardirq.h"
1027 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_rlock)
1028
1029 #include "locking-selftest-wlock-hardirq.h"
1030 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_wlock)
1031
1032 #include "locking-selftest-spin-softirq.h"
1033 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_spin)
1034
1035 #include "locking-selftest-rlock-softirq.h"
1036 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_rlock)
1037
1038 #include "locking-selftest-wlock-softirq.h"
1039 GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_wlock)
1040
1041 #undef E1
1042 #undef E2
1043 #undef E3
1044
1045 /*
1046 * write-read / write-read / write-read deadlock even if read is recursive
1047 */
1048
1049 #define E1() \
1050 \
1051 WL(X1); \
1052 RL(Y1); \
1053 RU(Y1); \
1054 WU(X1);
1055
1056 #define E2() \
1057 \
1058 WL(Y1); \
1059 RL(Z1); \
1060 RU(Z1); \
1061 WU(Y1);
1062
1063 #define E3() \
1064 \
1065 WL(Z1); \
1066 RL(X1); \
1067 RU(X1); \
1068 WU(Z1);
1069
1070 #include "locking-selftest-rlock.h"
1071 GENERATE_PERMUTATIONS_3_EVENTS(W1R2_W2R3_W3R1)
1072
1073 #undef E1
1074 #undef E2
1075 #undef E3
1076
1077 /*
1078 * write-write / read-read / write-read deadlock even if read is recursive
1079 */
1080
1081 #define E1() \
1082 \
1083 WL(X1); \
1084 WL(Y1); \
1085 WU(Y1); \
1086 WU(X1);
1087
1088 #define E2() \
1089 \
1090 RL(Y1); \
1091 RL(Z1); \
1092 RU(Z1); \
1093 RU(Y1);
1094
1095 #define E3() \
1096 \
1097 WL(Z1); \
1098 RL(X1); \
1099 RU(X1); \
1100 WU(Z1);
1101
1102 #include "locking-selftest-rlock.h"
1103 GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_W3R1)
1104
1105 #undef E1
1106 #undef E2
1107 #undef E3
1108
1109 /*
1110 * write-write / read-read / read-write is not deadlock when read is recursive
1111 */
1112
1113 #define E1() \
1114 \
1115 WL(X1); \
1116 WL(Y1); \
1117 WU(Y1); \
1118 WU(X1);
1119
1120 #define E2() \
1121 \
1122 RL(Y1); \
1123 RL(Z1); \
1124 RU(Z1); \
1125 RU(Y1);
1126
1127 #define E3() \
1128 \
1129 RL(Z1); \
1130 WL(X1); \
1131 WU(X1); \
1132 RU(Z1);
1133
1134 #include "locking-selftest-rlock.h"
1135 GENERATE_PERMUTATIONS_3_EVENTS(W1R2_R2R3_W3W1)
1136
1137 #undef E1
1138 #undef E2
1139 #undef E3
1140
1141 /*
1142 * write-read / read-read / write-write is not deadlock when read is recursive
1143 */
1144
1145 #define E1() \
1146 \
1147 WL(X1); \
1148 RL(Y1); \
1149 RU(Y1); \
1150 WU(X1);
1151
1152 #define E2() \
1153 \
1154 RL(Y1); \
1155 RL(Z1); \
1156 RU(Z1); \
1157 RU(Y1);
1158
1159 #define E3() \
1160 \
1161 WL(Z1); \
1162 WL(X1); \
1163 WU(X1); \
1164 WU(Z1);
1165
1166 #include "locking-selftest-rlock.h"
1167 GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_R3W1)
1168
1169 #undef E1
1170 #undef E2
1171 #undef E3
1172 /*
1173 * read-lock / write-lock recursion that is actually safe.
1174 */
1175
1176 #define E1() \
1177 \
1178 IRQ_DISABLE(); \
1179 WL(A); \
1180 WU(A); \
1181 IRQ_ENABLE();
1182
1183 #define E2() \
1184 \
1185 RL(A); \
1186 RU(A); \
1187
1188 #define E3() \
1189 \
1190 IRQ_ENTER(); \
1191 LOCK(A); \
1192 L(B); \
1193 U(B); \
1194 UNLOCK(A); \
1195 IRQ_EXIT();
1196
1197 /*
1198 * Generate 24 testcases:
1199 */
1200 #include "locking-selftest-hardirq.h"
1201 #include "locking-selftest-rlock.h"
1202 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_rlock)
1203
1204 #include "locking-selftest-wlock.h"
1205 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_wlock)
1206
1207 #include "locking-selftest-softirq.h"
1208 #include "locking-selftest-rlock.h"
1209 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_rlock)
1210
1211 #include "locking-selftest-wlock.h"
1212 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_wlock)
1213
1214 #undef E1
1215 #undef E2
1216 #undef E3
1217
1218 /*
1219 * read-lock / write-lock recursion that is unsafe.
1220 */
1221
1222 #define E1() \
1223 \
1224 IRQ_DISABLE(); \
1225 L(B); \
1226 LOCK(A); \
1227 UNLOCK(A); \
1228 U(B); \
1229 IRQ_ENABLE();
1230
1231 #define E2() \
1232 \
1233 RL(A); \
1234 RU(A); \
1235
1236 #define E3() \
1237 \
1238 IRQ_ENTER(); \
1239 L(B); \
1240 U(B); \
1241 IRQ_EXIT();
1242
1243 /*
1244 * Generate 24 testcases:
1245 */
1246 #include "locking-selftest-hardirq.h"
1247 #include "locking-selftest-rlock.h"
1248 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_rlock)
1249
1250 #include "locking-selftest-wlock.h"
1251 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_wlock)
1252
1253 #include "locking-selftest-softirq.h"
1254 #include "locking-selftest-rlock.h"
1255 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_rlock)
1256
1257 #include "locking-selftest-wlock.h"
1258 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_wlock)
1259
1260 #undef E1
1261 #undef E2
1262 #undef E3
1263 /*
1264 * read-lock / write-lock recursion that is unsafe.
1265 *
1266 * A is a ENABLED_*_READ lock
1267 * B is a USED_IN_*_READ lock
1268 *
1269 * read_lock(A);
1270 * write_lock(B);
1271 * <interrupt>
1272 * read_lock(B);
1273 * write_lock(A); // if this one is read_lock(), no deadlock
1274 */
1275
1276 #define E1() \
1277 \
1278 IRQ_DISABLE(); \
1279 WL(B); \
1280 LOCK(A); \
1281 UNLOCK(A); \
1282 WU(B); \
1283 IRQ_ENABLE();
1284
1285 #define E2() \
1286 \
1287 RL(A); \
1288 RU(A); \
1289
1290 #define E3() \
1291 \
1292 IRQ_ENTER(); \
1293 RL(B); \
1294 RU(B); \
1295 IRQ_EXIT();
1296
1297 /*
1298 * Generate 24 testcases:
1299 */
1300 #include "locking-selftest-hardirq.h"
1301 #include "locking-selftest-rlock.h"
1302 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_rlock)
1303
1304 #include "locking-selftest-wlock.h"
1305 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_wlock)
1306
1307 #include "locking-selftest-softirq.h"
1308 #include "locking-selftest-rlock.h"
1309 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_rlock)
1310
1311 #include "locking-selftest-wlock.h"
1312 GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_wlock)
1313
1314 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1315 # define I_SPINLOCK(x) lockdep_reset_lock(&lock_##x.dep_map)
1316 # define I_RAW_SPINLOCK(x) lockdep_reset_lock(&raw_lock_##x.dep_map)
1317 # define I_RWLOCK(x) lockdep_reset_lock(&rwlock_##x.dep_map)
1318 # define I_MUTEX(x) lockdep_reset_lock(&mutex_##x.dep_map)
1319 # define I_RWSEM(x) lockdep_reset_lock(&rwsem_##x.dep_map)
1320 # define I_WW(x) lockdep_reset_lock(&x.dep_map)
1321 # define I_LOCAL_LOCK(x) lockdep_reset_lock(&local_##x.dep_map)
1322 #ifdef CONFIG_RT_MUTEXES
1323 # define I_RTMUTEX(x) lockdep_reset_lock(&rtmutex_##x.dep_map)
1324 #endif
1325 #else
1326 # define I_SPINLOCK(x)
1327 # define I_RAW_SPINLOCK(x)
1328 # define I_RWLOCK(x)
1329 # define I_MUTEX(x)
1330 # define I_RWSEM(x)
1331 # define I_WW(x)
1332 # define I_LOCAL_LOCK(x)
1333 #endif
1334
1335 #ifndef I_RTMUTEX
1336 # define I_RTMUTEX(x)
1337 #endif
1338
1339 #ifdef CONFIG_RT_MUTEXES
1340 #define I2_RTMUTEX(x) rt_mutex_init(&rtmutex_##x)
1341 #else
1342 #define I2_RTMUTEX(x)
1343 #endif
1344
1345 #define I1(x) \
1346 do { \
1347 I_SPINLOCK(x); \
1348 I_RWLOCK(x); \
1349 I_MUTEX(x); \
1350 I_RWSEM(x); \
1351 I_RTMUTEX(x); \
1352 } while (0)
1353
1354 #define I2(x) \
1355 do { \
1356 spin_lock_init(&lock_##x); \
1357 rwlock_init(&rwlock_##x); \
1358 mutex_init(&mutex_##x); \
1359 init_rwsem(&rwsem_##x); \
1360 I2_RTMUTEX(x); \
1361 } while (0)
1362
1363 static void reset_locks(void)
1364 {
1365 local_irq_disable();
1366 lockdep_free_key_range(&ww_lockdep.acquire_key, 1);
1367 lockdep_free_key_range(&ww_lockdep.mutex_key, 1);
1368
1369 I1(A); I1(B); I1(C); I1(D);
1370 I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);
1371 I_WW(t); I_WW(t2); I_WW(o.base); I_WW(o2.base); I_WW(o3.base);
1372 I_RAW_SPINLOCK(A); I_RAW_SPINLOCK(B);
1373 I_LOCAL_LOCK(A);
1374
1375 lockdep_reset();
1376
1377 I2(A); I2(B); I2(C); I2(D);
1378 init_shared_classes();
1379 raw_spin_lock_init(&raw_lock_A);
1380 raw_spin_lock_init(&raw_lock_B);
1381 local_lock_init(&local_A);
1382
1383 ww_mutex_init(&o, &ww_lockdep); ww_mutex_init(&o2, &ww_lockdep); ww_mutex_init(&o3, &ww_lockdep);
1384 memset(&t, 0, sizeof(t)); memset(&t2, 0, sizeof(t2));
1385 memset(&ww_lockdep.acquire_key, 0, sizeof(ww_lockdep.acquire_key));
1386 memset(&ww_lockdep.mutex_key, 0, sizeof(ww_lockdep.mutex_key));
1387 local_irq_enable();
1388 }
1389
1390 #undef I
1391
1392 static int testcase_total;
1393 static int testcase_successes;
1394 static int expected_testcase_failures;
1395 static int unexpected_testcase_failures;
1396
dotest(void (* testcase_fn)(void),int expected,int lockclass_mask)1397 static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
1398 {
1399 unsigned long saved_preempt_count = preempt_count();
1400
1401 WARN_ON(irqs_disabled());
1402
1403 debug_locks_silent = !(debug_locks_verbose & lockclass_mask);
1404
1405 testcase_fn();
1406 /*
1407 * Filter out expected failures:
1408 */
1409 #ifndef CONFIG_PROVE_LOCKING
1410 if (expected == FAILURE && debug_locks) {
1411 expected_testcase_failures++;
1412 pr_cont("failed|");
1413 }
1414 else
1415 #endif
1416 if (debug_locks != expected) {
1417 unexpected_testcase_failures++;
1418 pr_cont("FAILED|");
1419 } else {
1420 testcase_successes++;
1421 pr_cont(" ok |");
1422 }
1423 testcase_total++;
1424
1425 if (debug_locks_verbose & lockclass_mask)
1426 pr_cont(" lockclass mask: %x, debug_locks: %d, expected: %d\n",
1427 lockclass_mask, debug_locks, expected);
1428 /*
1429 * Some tests (e.g. double-unlock) might corrupt the preemption
1430 * count, so restore it:
1431 */
1432 preempt_count_set(saved_preempt_count);
1433 #ifdef CONFIG_TRACE_IRQFLAGS
1434 if (softirq_count())
1435 current->softirqs_enabled = 0;
1436 else
1437 current->softirqs_enabled = 1;
1438 #endif
1439
1440 reset_locks();
1441 }
1442
1443 #ifdef CONFIG_RT_MUTEXES
1444 #define dotest_rt(fn, e, m) dotest((fn), (e), (m))
1445 #else
1446 #define dotest_rt(fn, e, m)
1447 #endif
1448
print_testname(const char * testname)1449 static inline void print_testname(const char *testname)
1450 {
1451 printk("%33s:", testname);
1452 }
1453
1454 #define DO_TESTCASE_1(desc, name, nr) \
1455 print_testname(desc"/"#nr); \
1456 dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
1457 pr_cont("\n");
1458
1459 #define DO_TESTCASE_1B(desc, name, nr) \
1460 print_testname(desc"/"#nr); \
1461 dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1462 pr_cont("\n");
1463
1464 #define DO_TESTCASE_1RR(desc, name, nr) \
1465 print_testname(desc"/"#nr); \
1466 pr_cont(" |"); \
1467 dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
1468 pr_cont("\n");
1469
1470 #define DO_TESTCASE_1RRB(desc, name, nr) \
1471 print_testname(desc"/"#nr); \
1472 pr_cont(" |"); \
1473 dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1474 pr_cont("\n");
1475
1476
1477 #define DO_TESTCASE_3(desc, name, nr) \
1478 print_testname(desc"/"#nr); \
1479 dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN); \
1480 dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1481 dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
1482 pr_cont("\n");
1483
1484 #define DO_TESTCASE_3RW(desc, name, nr) \
1485 print_testname(desc"/"#nr); \
1486 dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN|LOCKTYPE_RWLOCK);\
1487 dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1488 dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
1489 pr_cont("\n");
1490
1491 #define DO_TESTCASE_2RW(desc, name, nr) \
1492 print_testname(desc"/"#nr); \
1493 pr_cont(" |"); \
1494 dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1495 dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
1496 pr_cont("\n");
1497
1498 #define DO_TESTCASE_2x2RW(desc, name, nr) \
1499 DO_TESTCASE_2RW("hard-"desc, name##_hard, nr) \
1500 DO_TESTCASE_2RW("soft-"desc, name##_soft, nr) \
1501
1502 #define DO_TESTCASE_6x2x2RW(desc, name) \
1503 DO_TESTCASE_2x2RW(desc, name, 123); \
1504 DO_TESTCASE_2x2RW(desc, name, 132); \
1505 DO_TESTCASE_2x2RW(desc, name, 213); \
1506 DO_TESTCASE_2x2RW(desc, name, 231); \
1507 DO_TESTCASE_2x2RW(desc, name, 312); \
1508 DO_TESTCASE_2x2RW(desc, name, 321);
1509
1510 #define DO_TESTCASE_6(desc, name) \
1511 print_testname(desc); \
1512 dotest(name##_spin, FAILURE, LOCKTYPE_SPIN); \
1513 dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK); \
1514 dotest(name##_rlock, FAILURE, LOCKTYPE_RWLOCK); \
1515 dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \
1516 dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
1517 dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
1518 dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX); \
1519 pr_cont("\n");
1520
1521 #define DO_TESTCASE_6_SUCCESS(desc, name) \
1522 print_testname(desc); \
1523 dotest(name##_spin, SUCCESS, LOCKTYPE_SPIN); \
1524 dotest(name##_wlock, SUCCESS, LOCKTYPE_RWLOCK); \
1525 dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK); \
1526 dotest(name##_mutex, SUCCESS, LOCKTYPE_MUTEX); \
1527 dotest(name##_wsem, SUCCESS, LOCKTYPE_RWSEM); \
1528 dotest(name##_rsem, SUCCESS, LOCKTYPE_RWSEM); \
1529 dotest_rt(name##_rtmutex, SUCCESS, LOCKTYPE_RTMUTEX); \
1530 pr_cont("\n");
1531
1532 /*
1533 * 'read' variant: rlocks must not trigger.
1534 */
1535 #define DO_TESTCASE_6R(desc, name) \
1536 print_testname(desc); \
1537 dotest(name##_spin, FAILURE, LOCKTYPE_SPIN); \
1538 dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK); \
1539 dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK); \
1540 dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \
1541 dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
1542 dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
1543 dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX); \
1544 pr_cont("\n");
1545
1546 #define DO_TESTCASE_2I(desc, name, nr) \
1547 DO_TESTCASE_1("hard-"desc, name##_hard, nr); \
1548 DO_TESTCASE_1("soft-"desc, name##_soft, nr);
1549
1550 #define DO_TESTCASE_2IB(desc, name, nr) \
1551 DO_TESTCASE_1B("hard-"desc, name##_hard, nr); \
1552 DO_TESTCASE_1B("soft-"desc, name##_soft, nr);
1553
1554 #define DO_TESTCASE_6I(desc, name, nr) \
1555 DO_TESTCASE_3("hard-"desc, name##_hard, nr); \
1556 DO_TESTCASE_3("soft-"desc, name##_soft, nr);
1557
1558 #define DO_TESTCASE_6IRW(desc, name, nr) \
1559 DO_TESTCASE_3RW("hard-"desc, name##_hard, nr); \
1560 DO_TESTCASE_3RW("soft-"desc, name##_soft, nr);
1561
1562 #define DO_TESTCASE_2x3(desc, name) \
1563 DO_TESTCASE_3(desc, name, 12); \
1564 DO_TESTCASE_3(desc, name, 21);
1565
1566 #define DO_TESTCASE_2x6(desc, name) \
1567 DO_TESTCASE_6I(desc, name, 12); \
1568 DO_TESTCASE_6I(desc, name, 21);
1569
1570 #define DO_TESTCASE_6x2(desc, name) \
1571 DO_TESTCASE_2I(desc, name, 123); \
1572 DO_TESTCASE_2I(desc, name, 132); \
1573 DO_TESTCASE_2I(desc, name, 213); \
1574 DO_TESTCASE_2I(desc, name, 231); \
1575 DO_TESTCASE_2I(desc, name, 312); \
1576 DO_TESTCASE_2I(desc, name, 321);
1577
1578 #define DO_TESTCASE_6x2B(desc, name) \
1579 DO_TESTCASE_2IB(desc, name, 123); \
1580 DO_TESTCASE_2IB(desc, name, 132); \
1581 DO_TESTCASE_2IB(desc, name, 213); \
1582 DO_TESTCASE_2IB(desc, name, 231); \
1583 DO_TESTCASE_2IB(desc, name, 312); \
1584 DO_TESTCASE_2IB(desc, name, 321);
1585
1586 #define DO_TESTCASE_6x1RR(desc, name) \
1587 DO_TESTCASE_1RR(desc, name, 123); \
1588 DO_TESTCASE_1RR(desc, name, 132); \
1589 DO_TESTCASE_1RR(desc, name, 213); \
1590 DO_TESTCASE_1RR(desc, name, 231); \
1591 DO_TESTCASE_1RR(desc, name, 312); \
1592 DO_TESTCASE_1RR(desc, name, 321);
1593
1594 #define DO_TESTCASE_6x1RRB(desc, name) \
1595 DO_TESTCASE_1RRB(desc, name, 123); \
1596 DO_TESTCASE_1RRB(desc, name, 132); \
1597 DO_TESTCASE_1RRB(desc, name, 213); \
1598 DO_TESTCASE_1RRB(desc, name, 231); \
1599 DO_TESTCASE_1RRB(desc, name, 312); \
1600 DO_TESTCASE_1RRB(desc, name, 321);
1601
1602 #define DO_TESTCASE_6x6(desc, name) \
1603 DO_TESTCASE_6I(desc, name, 123); \
1604 DO_TESTCASE_6I(desc, name, 132); \
1605 DO_TESTCASE_6I(desc, name, 213); \
1606 DO_TESTCASE_6I(desc, name, 231); \
1607 DO_TESTCASE_6I(desc, name, 312); \
1608 DO_TESTCASE_6I(desc, name, 321);
1609
1610 #define DO_TESTCASE_6x6RW(desc, name) \
1611 DO_TESTCASE_6IRW(desc, name, 123); \
1612 DO_TESTCASE_6IRW(desc, name, 132); \
1613 DO_TESTCASE_6IRW(desc, name, 213); \
1614 DO_TESTCASE_6IRW(desc, name, 231); \
1615 DO_TESTCASE_6IRW(desc, name, 312); \
1616 DO_TESTCASE_6IRW(desc, name, 321);
1617
ww_test_fail_acquire(void)1618 static void ww_test_fail_acquire(void)
1619 {
1620 int ret;
1621
1622 WWAI(&t);
1623 t.stamp++;
1624
1625 ret = WWL(&o, &t);
1626
1627 if (WARN_ON(!o.ctx) ||
1628 WARN_ON(ret))
1629 return;
1630
1631 /* No lockdep test, pure API */
1632 ret = WWL(&o, &t);
1633 WARN_ON(ret != -EALREADY);
1634
1635 ret = WWT(&o);
1636 WARN_ON(ret);
1637
1638 t2 = t;
1639 t2.stamp++;
1640 ret = WWL(&o, &t2);
1641 WARN_ON(ret != -EDEADLK);
1642 WWU(&o);
1643
1644 if (WWT(&o))
1645 WWU(&o);
1646 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1647 else
1648 DEBUG_LOCKS_WARN_ON(1);
1649 #endif
1650 }
1651
ww_test_normal(void)1652 static void ww_test_normal(void)
1653 {
1654 int ret;
1655
1656 WWAI(&t);
1657
1658 /*
1659 * None of the ww_mutex codepaths should be taken in the 'normal'
1660 * mutex calls. The easiest way to verify this is by using the
1661 * normal mutex calls, and making sure o.ctx is unmodified.
1662 */
1663
1664 /* mutex_lock (and indirectly, mutex_lock_nested) */
1665 o.ctx = (void *)~0UL;
1666 mutex_lock(&o.base);
1667 mutex_unlock(&o.base);
1668 WARN_ON(o.ctx != (void *)~0UL);
1669
1670 /* mutex_lock_interruptible (and *_nested) */
1671 o.ctx = (void *)~0UL;
1672 ret = mutex_lock_interruptible(&o.base);
1673 if (!ret)
1674 mutex_unlock(&o.base);
1675 else
1676 WARN_ON(1);
1677 WARN_ON(o.ctx != (void *)~0UL);
1678
1679 /* mutex_lock_killable (and *_nested) */
1680 o.ctx = (void *)~0UL;
1681 ret = mutex_lock_killable(&o.base);
1682 if (!ret)
1683 mutex_unlock(&o.base);
1684 else
1685 WARN_ON(1);
1686 WARN_ON(o.ctx != (void *)~0UL);
1687
1688 /* trylock, succeeding */
1689 o.ctx = (void *)~0UL;
1690 ret = mutex_trylock(&o.base);
1691 WARN_ON(!ret);
1692 if (ret)
1693 mutex_unlock(&o.base);
1694 else
1695 WARN_ON(1);
1696 WARN_ON(o.ctx != (void *)~0UL);
1697
1698 /* trylock, failing */
1699 o.ctx = (void *)~0UL;
1700 mutex_lock(&o.base);
1701 ret = mutex_trylock(&o.base);
1702 WARN_ON(ret);
1703 mutex_unlock(&o.base);
1704 WARN_ON(o.ctx != (void *)~0UL);
1705
1706 /* nest_lock */
1707 o.ctx = (void *)~0UL;
1708 mutex_lock_nest_lock(&o.base, &t);
1709 mutex_unlock(&o.base);
1710 WARN_ON(o.ctx != (void *)~0UL);
1711 }
1712
ww_test_two_contexts(void)1713 static void ww_test_two_contexts(void)
1714 {
1715 WWAI(&t);
1716 WWAI(&t2);
1717 }
1718
ww_test_diff_class(void)1719 static void ww_test_diff_class(void)
1720 {
1721 WWAI(&t);
1722 #ifdef CONFIG_DEBUG_MUTEXES
1723 t.ww_class = NULL;
1724 #endif
1725 WWL(&o, &t);
1726 }
1727
ww_test_context_done_twice(void)1728 static void ww_test_context_done_twice(void)
1729 {
1730 WWAI(&t);
1731 WWAD(&t);
1732 WWAD(&t);
1733 WWAF(&t);
1734 }
1735
ww_test_context_unlock_twice(void)1736 static void ww_test_context_unlock_twice(void)
1737 {
1738 WWAI(&t);
1739 WWAD(&t);
1740 WWAF(&t);
1741 WWAF(&t);
1742 }
1743
ww_test_context_fini_early(void)1744 static void ww_test_context_fini_early(void)
1745 {
1746 WWAI(&t);
1747 WWL(&o, &t);
1748 WWAD(&t);
1749 WWAF(&t);
1750 }
1751
ww_test_context_lock_after_done(void)1752 static void ww_test_context_lock_after_done(void)
1753 {
1754 WWAI(&t);
1755 WWAD(&t);
1756 WWL(&o, &t);
1757 }
1758
ww_test_object_unlock_twice(void)1759 static void ww_test_object_unlock_twice(void)
1760 {
1761 WWL1(&o);
1762 WWU(&o);
1763 WWU(&o);
1764 }
1765
ww_test_object_lock_unbalanced(void)1766 static void ww_test_object_lock_unbalanced(void)
1767 {
1768 WWAI(&t);
1769 WWL(&o, &t);
1770 t.acquired = 0;
1771 WWU(&o);
1772 WWAF(&t);
1773 }
1774
ww_test_object_lock_stale_context(void)1775 static void ww_test_object_lock_stale_context(void)
1776 {
1777 WWAI(&t);
1778 o.ctx = &t2;
1779 WWL(&o, &t);
1780 }
1781
ww_test_edeadlk_normal(void)1782 static void ww_test_edeadlk_normal(void)
1783 {
1784 int ret;
1785
1786 mutex_lock(&o2.base);
1787 o2.ctx = &t2;
1788 mutex_release(&o2.base.dep_map, _THIS_IP_);
1789
1790 WWAI(&t);
1791 t2 = t;
1792 t2.stamp--;
1793
1794 ret = WWL(&o, &t);
1795 WARN_ON(ret);
1796
1797 ret = WWL(&o2, &t);
1798 WARN_ON(ret != -EDEADLK);
1799
1800 o2.ctx = NULL;
1801 mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1802 mutex_unlock(&o2.base);
1803 WWU(&o);
1804
1805 WWL(&o2, &t);
1806 }
1807
ww_test_edeadlk_normal_slow(void)1808 static void ww_test_edeadlk_normal_slow(void)
1809 {
1810 int ret;
1811
1812 mutex_lock(&o2.base);
1813 mutex_release(&o2.base.dep_map, _THIS_IP_);
1814 o2.ctx = &t2;
1815
1816 WWAI(&t);
1817 t2 = t;
1818 t2.stamp--;
1819
1820 ret = WWL(&o, &t);
1821 WARN_ON(ret);
1822
1823 ret = WWL(&o2, &t);
1824 WARN_ON(ret != -EDEADLK);
1825
1826 o2.ctx = NULL;
1827 mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1828 mutex_unlock(&o2.base);
1829 WWU(&o);
1830
1831 ww_mutex_lock_slow(&o2, &t);
1832 }
1833
ww_test_edeadlk_no_unlock(void)1834 static void ww_test_edeadlk_no_unlock(void)
1835 {
1836 int ret;
1837
1838 mutex_lock(&o2.base);
1839 o2.ctx = &t2;
1840 mutex_release(&o2.base.dep_map, _THIS_IP_);
1841
1842 WWAI(&t);
1843 t2 = t;
1844 t2.stamp--;
1845
1846 ret = WWL(&o, &t);
1847 WARN_ON(ret);
1848
1849 ret = WWL(&o2, &t);
1850 WARN_ON(ret != -EDEADLK);
1851
1852 o2.ctx = NULL;
1853 mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1854 mutex_unlock(&o2.base);
1855
1856 WWL(&o2, &t);
1857 }
1858
ww_test_edeadlk_no_unlock_slow(void)1859 static void ww_test_edeadlk_no_unlock_slow(void)
1860 {
1861 int ret;
1862
1863 mutex_lock(&o2.base);
1864 mutex_release(&o2.base.dep_map, _THIS_IP_);
1865 o2.ctx = &t2;
1866
1867 WWAI(&t);
1868 t2 = t;
1869 t2.stamp--;
1870
1871 ret = WWL(&o, &t);
1872 WARN_ON(ret);
1873
1874 ret = WWL(&o2, &t);
1875 WARN_ON(ret != -EDEADLK);
1876
1877 o2.ctx = NULL;
1878 mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1879 mutex_unlock(&o2.base);
1880
1881 ww_mutex_lock_slow(&o2, &t);
1882 }
1883
ww_test_edeadlk_acquire_more(void)1884 static void ww_test_edeadlk_acquire_more(void)
1885 {
1886 int ret;
1887
1888 mutex_lock(&o2.base);
1889 mutex_release(&o2.base.dep_map, _THIS_IP_);
1890 o2.ctx = &t2;
1891
1892 WWAI(&t);
1893 t2 = t;
1894 t2.stamp--;
1895
1896 ret = WWL(&o, &t);
1897 WARN_ON(ret);
1898
1899 ret = WWL(&o2, &t);
1900 WARN_ON(ret != -EDEADLK);
1901
1902 ret = WWL(&o3, &t);
1903 }
1904
ww_test_edeadlk_acquire_more_slow(void)1905 static void ww_test_edeadlk_acquire_more_slow(void)
1906 {
1907 int ret;
1908
1909 mutex_lock(&o2.base);
1910 mutex_release(&o2.base.dep_map, _THIS_IP_);
1911 o2.ctx = &t2;
1912
1913 WWAI(&t);
1914 t2 = t;
1915 t2.stamp--;
1916
1917 ret = WWL(&o, &t);
1918 WARN_ON(ret);
1919
1920 ret = WWL(&o2, &t);
1921 WARN_ON(ret != -EDEADLK);
1922
1923 ww_mutex_lock_slow(&o3, &t);
1924 }
1925
ww_test_edeadlk_acquire_more_edeadlk(void)1926 static void ww_test_edeadlk_acquire_more_edeadlk(void)
1927 {
1928 int ret;
1929
1930 mutex_lock(&o2.base);
1931 mutex_release(&o2.base.dep_map, _THIS_IP_);
1932 o2.ctx = &t2;
1933
1934 mutex_lock(&o3.base);
1935 mutex_release(&o3.base.dep_map, _THIS_IP_);
1936 o3.ctx = &t2;
1937
1938 WWAI(&t);
1939 t2 = t;
1940 t2.stamp--;
1941
1942 ret = WWL(&o, &t);
1943 WARN_ON(ret);
1944
1945 ret = WWL(&o2, &t);
1946 WARN_ON(ret != -EDEADLK);
1947
1948 ret = WWL(&o3, &t);
1949 WARN_ON(ret != -EDEADLK);
1950 }
1951
ww_test_edeadlk_acquire_more_edeadlk_slow(void)1952 static void ww_test_edeadlk_acquire_more_edeadlk_slow(void)
1953 {
1954 int ret;
1955
1956 mutex_lock(&o2.base);
1957 mutex_release(&o2.base.dep_map, _THIS_IP_);
1958 o2.ctx = &t2;
1959
1960 mutex_lock(&o3.base);
1961 mutex_release(&o3.base.dep_map, _THIS_IP_);
1962 o3.ctx = &t2;
1963
1964 WWAI(&t);
1965 t2 = t;
1966 t2.stamp--;
1967
1968 ret = WWL(&o, &t);
1969 WARN_ON(ret);
1970
1971 ret = WWL(&o2, &t);
1972 WARN_ON(ret != -EDEADLK);
1973
1974 ww_mutex_lock_slow(&o3, &t);
1975 }
1976
ww_test_edeadlk_acquire_wrong(void)1977 static void ww_test_edeadlk_acquire_wrong(void)
1978 {
1979 int ret;
1980
1981 mutex_lock(&o2.base);
1982 mutex_release(&o2.base.dep_map, _THIS_IP_);
1983 o2.ctx = &t2;
1984
1985 WWAI(&t);
1986 t2 = t;
1987 t2.stamp--;
1988
1989 ret = WWL(&o, &t);
1990 WARN_ON(ret);
1991
1992 ret = WWL(&o2, &t);
1993 WARN_ON(ret != -EDEADLK);
1994 if (!ret)
1995 WWU(&o2);
1996
1997 WWU(&o);
1998
1999 ret = WWL(&o3, &t);
2000 }
2001
ww_test_edeadlk_acquire_wrong_slow(void)2002 static void ww_test_edeadlk_acquire_wrong_slow(void)
2003 {
2004 int ret;
2005
2006 mutex_lock(&o2.base);
2007 mutex_release(&o2.base.dep_map, _THIS_IP_);
2008 o2.ctx = &t2;
2009
2010 WWAI(&t);
2011 t2 = t;
2012 t2.stamp--;
2013
2014 ret = WWL(&o, &t);
2015 WARN_ON(ret);
2016
2017 ret = WWL(&o2, &t);
2018 WARN_ON(ret != -EDEADLK);
2019 if (!ret)
2020 WWU(&o2);
2021
2022 WWU(&o);
2023
2024 ww_mutex_lock_slow(&o3, &t);
2025 }
2026
ww_test_spin_nest_unlocked(void)2027 static void ww_test_spin_nest_unlocked(void)
2028 {
2029 spin_lock_nest_lock(&lock_A, &o.base);
2030 U(A);
2031 }
2032
2033 /* This is not a deadlock, because we have X1 to serialize Y1 and Y2 */
ww_test_spin_nest_lock(void)2034 static void ww_test_spin_nest_lock(void)
2035 {
2036 spin_lock(&lock_X1);
2037 spin_lock_nest_lock(&lock_Y1, &lock_X1);
2038 spin_lock(&lock_A);
2039 spin_lock_nest_lock(&lock_Y2, &lock_X1);
2040 spin_unlock(&lock_A);
2041 spin_unlock(&lock_Y2);
2042 spin_unlock(&lock_Y1);
2043 spin_unlock(&lock_X1);
2044 }
2045
ww_test_unneeded_slow(void)2046 static void ww_test_unneeded_slow(void)
2047 {
2048 WWAI(&t);
2049
2050 ww_mutex_lock_slow(&o, &t);
2051 }
2052
ww_test_context_block(void)2053 static void ww_test_context_block(void)
2054 {
2055 int ret;
2056
2057 WWAI(&t);
2058
2059 ret = WWL(&o, &t);
2060 WARN_ON(ret);
2061 WWL1(&o2);
2062 }
2063
ww_test_context_try(void)2064 static void ww_test_context_try(void)
2065 {
2066 int ret;
2067
2068 WWAI(&t);
2069
2070 ret = WWL(&o, &t);
2071 WARN_ON(ret);
2072
2073 ret = WWT(&o2);
2074 WARN_ON(!ret);
2075 WWU(&o2);
2076 WWU(&o);
2077 }
2078
ww_test_context_context(void)2079 static void ww_test_context_context(void)
2080 {
2081 int ret;
2082
2083 WWAI(&t);
2084
2085 ret = WWL(&o, &t);
2086 WARN_ON(ret);
2087
2088 ret = WWL(&o2, &t);
2089 WARN_ON(ret);
2090
2091 WWU(&o2);
2092 WWU(&o);
2093 }
2094
ww_test_try_block(void)2095 static void ww_test_try_block(void)
2096 {
2097 bool ret;
2098
2099 ret = WWT(&o);
2100 WARN_ON(!ret);
2101
2102 WWL1(&o2);
2103 WWU(&o2);
2104 WWU(&o);
2105 }
2106
ww_test_try_try(void)2107 static void ww_test_try_try(void)
2108 {
2109 bool ret;
2110
2111 ret = WWT(&o);
2112 WARN_ON(!ret);
2113 ret = WWT(&o2);
2114 WARN_ON(!ret);
2115 WWU(&o2);
2116 WWU(&o);
2117 }
2118
ww_test_try_context(void)2119 static void ww_test_try_context(void)
2120 {
2121 int ret;
2122
2123 ret = WWT(&o);
2124 WARN_ON(!ret);
2125
2126 WWAI(&t);
2127
2128 ret = WWL(&o2, &t);
2129 WARN_ON(ret);
2130 }
2131
ww_test_block_block(void)2132 static void ww_test_block_block(void)
2133 {
2134 WWL1(&o);
2135 WWL1(&o2);
2136 }
2137
ww_test_block_try(void)2138 static void ww_test_block_try(void)
2139 {
2140 bool ret;
2141
2142 WWL1(&o);
2143 ret = WWT(&o2);
2144 WARN_ON(!ret);
2145 }
2146
ww_test_block_context(void)2147 static void ww_test_block_context(void)
2148 {
2149 int ret;
2150
2151 WWL1(&o);
2152 WWAI(&t);
2153
2154 ret = WWL(&o2, &t);
2155 WARN_ON(ret);
2156 }
2157
ww_test_spin_block(void)2158 static void ww_test_spin_block(void)
2159 {
2160 L(A);
2161 U(A);
2162
2163 WWL1(&o);
2164 L(A);
2165 U(A);
2166 WWU(&o);
2167
2168 L(A);
2169 WWL1(&o);
2170 WWU(&o);
2171 U(A);
2172 }
2173
ww_test_spin_try(void)2174 static void ww_test_spin_try(void)
2175 {
2176 bool ret;
2177
2178 L(A);
2179 U(A);
2180
2181 ret = WWT(&o);
2182 WARN_ON(!ret);
2183 L(A);
2184 U(A);
2185 WWU(&o);
2186
2187 L(A);
2188 ret = WWT(&o);
2189 WARN_ON(!ret);
2190 WWU(&o);
2191 U(A);
2192 }
2193
ww_test_spin_context(void)2194 static void ww_test_spin_context(void)
2195 {
2196 int ret;
2197
2198 L(A);
2199 U(A);
2200
2201 WWAI(&t);
2202
2203 ret = WWL(&o, &t);
2204 WARN_ON(ret);
2205 L(A);
2206 U(A);
2207 WWU(&o);
2208
2209 L(A);
2210 ret = WWL(&o, &t);
2211 WARN_ON(ret);
2212 WWU(&o);
2213 U(A);
2214 }
2215
ww_tests(void)2216 static void ww_tests(void)
2217 {
2218 printk(" --------------------------------------------------------------------------\n");
2219 printk(" | Wound/wait tests |\n");
2220 printk(" ---------------------\n");
2221
2222 print_testname("ww api failures");
2223 dotest(ww_test_fail_acquire, SUCCESS, LOCKTYPE_WW);
2224 dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW);
2225 dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW);
2226 pr_cont("\n");
2227
2228 print_testname("ww contexts mixing");
2229 dotest(ww_test_two_contexts, FAILURE, LOCKTYPE_WW);
2230 dotest(ww_test_diff_class, FAILURE, LOCKTYPE_WW);
2231 pr_cont("\n");
2232
2233 print_testname("finishing ww context");
2234 dotest(ww_test_context_done_twice, FAILURE, LOCKTYPE_WW);
2235 dotest(ww_test_context_unlock_twice, FAILURE, LOCKTYPE_WW);
2236 dotest(ww_test_context_fini_early, FAILURE, LOCKTYPE_WW);
2237 dotest(ww_test_context_lock_after_done, FAILURE, LOCKTYPE_WW);
2238 pr_cont("\n");
2239
2240 print_testname("locking mismatches");
2241 dotest(ww_test_object_unlock_twice, FAILURE, LOCKTYPE_WW);
2242 dotest(ww_test_object_lock_unbalanced, FAILURE, LOCKTYPE_WW);
2243 dotest(ww_test_object_lock_stale_context, FAILURE, LOCKTYPE_WW);
2244 pr_cont("\n");
2245
2246 print_testname("EDEADLK handling");
2247 dotest(ww_test_edeadlk_normal, SUCCESS, LOCKTYPE_WW);
2248 dotest(ww_test_edeadlk_normal_slow, SUCCESS, LOCKTYPE_WW);
2249 dotest(ww_test_edeadlk_no_unlock, FAILURE, LOCKTYPE_WW);
2250 dotest(ww_test_edeadlk_no_unlock_slow, FAILURE, LOCKTYPE_WW);
2251 dotest(ww_test_edeadlk_acquire_more, FAILURE, LOCKTYPE_WW);
2252 dotest(ww_test_edeadlk_acquire_more_slow, FAILURE, LOCKTYPE_WW);
2253 dotest(ww_test_edeadlk_acquire_more_edeadlk, FAILURE, LOCKTYPE_WW);
2254 dotest(ww_test_edeadlk_acquire_more_edeadlk_slow, FAILURE, LOCKTYPE_WW);
2255 dotest(ww_test_edeadlk_acquire_wrong, FAILURE, LOCKTYPE_WW);
2256 dotest(ww_test_edeadlk_acquire_wrong_slow, FAILURE, LOCKTYPE_WW);
2257 pr_cont("\n");
2258
2259 print_testname("spinlock nest unlocked");
2260 dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);
2261 pr_cont("\n");
2262
2263 print_testname("spinlock nest test");
2264 dotest(ww_test_spin_nest_lock, SUCCESS, LOCKTYPE_WW);
2265 pr_cont("\n");
2266
2267 printk(" -----------------------------------------------------\n");
2268 printk(" |block | try |context|\n");
2269 printk(" -----------------------------------------------------\n");
2270
2271 print_testname("context");
2272 dotest(ww_test_context_block, FAILURE, LOCKTYPE_WW);
2273 dotest(ww_test_context_try, SUCCESS, LOCKTYPE_WW);
2274 dotest(ww_test_context_context, SUCCESS, LOCKTYPE_WW);
2275 pr_cont("\n");
2276
2277 print_testname("try");
2278 dotest(ww_test_try_block, FAILURE, LOCKTYPE_WW);
2279 dotest(ww_test_try_try, SUCCESS, LOCKTYPE_WW);
2280 dotest(ww_test_try_context, FAILURE, LOCKTYPE_WW);
2281 pr_cont("\n");
2282
2283 print_testname("block");
2284 dotest(ww_test_block_block, FAILURE, LOCKTYPE_WW);
2285 dotest(ww_test_block_try, SUCCESS, LOCKTYPE_WW);
2286 dotest(ww_test_block_context, FAILURE, LOCKTYPE_WW);
2287 pr_cont("\n");
2288
2289 print_testname("spinlock");
2290 dotest(ww_test_spin_block, FAILURE, LOCKTYPE_WW);
2291 dotest(ww_test_spin_try, SUCCESS, LOCKTYPE_WW);
2292 dotest(ww_test_spin_context, FAILURE, LOCKTYPE_WW);
2293 pr_cont("\n");
2294 }
2295
2296
2297 /*
2298 * <in hardirq handler>
2299 * read_lock(&A);
2300 * <hardirq disable>
2301 * spin_lock(&B);
2302 * spin_lock(&B);
2303 * read_lock(&A);
2304 *
2305 * is a deadlock.
2306 */
queued_read_lock_hardirq_RE_Er(void)2307 static void queued_read_lock_hardirq_RE_Er(void)
2308 {
2309 HARDIRQ_ENTER();
2310 read_lock(&rwlock_A);
2311 LOCK(B);
2312 UNLOCK(B);
2313 read_unlock(&rwlock_A);
2314 HARDIRQ_EXIT();
2315
2316 HARDIRQ_DISABLE();
2317 LOCK(B);
2318 read_lock(&rwlock_A);
2319 read_unlock(&rwlock_A);
2320 UNLOCK(B);
2321 HARDIRQ_ENABLE();
2322 }
2323
2324 /*
2325 * <in hardirq handler>
2326 * spin_lock(&B);
2327 * <hardirq disable>
2328 * read_lock(&A);
2329 * read_lock(&A);
2330 * spin_lock(&B);
2331 *
2332 * is not a deadlock.
2333 */
queued_read_lock_hardirq_ER_rE(void)2334 static void queued_read_lock_hardirq_ER_rE(void)
2335 {
2336 HARDIRQ_ENTER();
2337 LOCK(B);
2338 read_lock(&rwlock_A);
2339 read_unlock(&rwlock_A);
2340 UNLOCK(B);
2341 HARDIRQ_EXIT();
2342
2343 HARDIRQ_DISABLE();
2344 read_lock(&rwlock_A);
2345 LOCK(B);
2346 UNLOCK(B);
2347 read_unlock(&rwlock_A);
2348 HARDIRQ_ENABLE();
2349 }
2350
2351 /*
2352 * <hardirq disable>
2353 * spin_lock(&B);
2354 * read_lock(&A);
2355 * <in hardirq handler>
2356 * spin_lock(&B);
2357 * read_lock(&A);
2358 *
2359 * is a deadlock. Because the two read_lock()s are both non-recursive readers.
2360 */
queued_read_lock_hardirq_inversion(void)2361 static void queued_read_lock_hardirq_inversion(void)
2362 {
2363
2364 HARDIRQ_ENTER();
2365 LOCK(B);
2366 UNLOCK(B);
2367 HARDIRQ_EXIT();
2368
2369 HARDIRQ_DISABLE();
2370 LOCK(B);
2371 read_lock(&rwlock_A);
2372 read_unlock(&rwlock_A);
2373 UNLOCK(B);
2374 HARDIRQ_ENABLE();
2375
2376 read_lock(&rwlock_A);
2377 read_unlock(&rwlock_A);
2378 }
2379
queued_read_lock_tests(void)2380 static void queued_read_lock_tests(void)
2381 {
2382 printk(" --------------------------------------------------------------------------\n");
2383 printk(" | queued read lock tests |\n");
2384 printk(" ---------------------------\n");
2385 print_testname("hardirq read-lock/lock-read");
2386 dotest(queued_read_lock_hardirq_RE_Er, FAILURE, LOCKTYPE_RWLOCK);
2387 pr_cont("\n");
2388
2389 print_testname("hardirq lock-read/read-lock");
2390 dotest(queued_read_lock_hardirq_ER_rE, SUCCESS, LOCKTYPE_RWLOCK);
2391 pr_cont("\n");
2392
2393 print_testname("hardirq inversion");
2394 dotest(queued_read_lock_hardirq_inversion, FAILURE, LOCKTYPE_RWLOCK);
2395 pr_cont("\n");
2396 }
2397
fs_reclaim_correct_nesting(void)2398 static void fs_reclaim_correct_nesting(void)
2399 {
2400 fs_reclaim_acquire(GFP_KERNEL);
2401 might_alloc(GFP_NOFS);
2402 fs_reclaim_release(GFP_KERNEL);
2403 }
2404
fs_reclaim_wrong_nesting(void)2405 static void fs_reclaim_wrong_nesting(void)
2406 {
2407 fs_reclaim_acquire(GFP_KERNEL);
2408 might_alloc(GFP_KERNEL);
2409 fs_reclaim_release(GFP_KERNEL);
2410 }
2411
fs_reclaim_protected_nesting(void)2412 static void fs_reclaim_protected_nesting(void)
2413 {
2414 unsigned int flags;
2415
2416 fs_reclaim_acquire(GFP_KERNEL);
2417 flags = memalloc_nofs_save();
2418 might_alloc(GFP_KERNEL);
2419 memalloc_nofs_restore(flags);
2420 fs_reclaim_release(GFP_KERNEL);
2421 }
2422
fs_reclaim_tests(void)2423 static void fs_reclaim_tests(void)
2424 {
2425 printk(" --------------------\n");
2426 printk(" | fs_reclaim tests |\n");
2427 printk(" --------------------\n");
2428
2429 print_testname("correct nesting");
2430 dotest(fs_reclaim_correct_nesting, SUCCESS, 0);
2431 pr_cont("\n");
2432
2433 print_testname("wrong nesting");
2434 dotest(fs_reclaim_wrong_nesting, FAILURE, 0);
2435 pr_cont("\n");
2436
2437 print_testname("protected nesting");
2438 dotest(fs_reclaim_protected_nesting, SUCCESS, 0);
2439 pr_cont("\n");
2440 }
2441
2442 #define __guard(cleanup) __maybe_unused __attribute__((__cleanup__(cleanup)))
2443
hardirq_exit(int * _)2444 static void hardirq_exit(int *_)
2445 {
2446 HARDIRQ_EXIT();
2447 }
2448
2449 #define HARDIRQ_CONTEXT(name, ...) \
2450 int hardirq_guard_##name __guard(hardirq_exit); \
2451 HARDIRQ_ENTER();
2452
2453 #define NOTTHREADED_HARDIRQ_CONTEXT(name, ...) \
2454 int notthreaded_hardirq_guard_##name __guard(hardirq_exit); \
2455 local_irq_disable(); \
2456 __irq_enter(); \
2457 WARN_ON(!in_irq());
2458
softirq_exit(int * _)2459 static void softirq_exit(int *_)
2460 {
2461 SOFTIRQ_EXIT();
2462 }
2463
2464 #define SOFTIRQ_CONTEXT(name, ...) \
2465 int softirq_guard_##name __guard(softirq_exit); \
2466 SOFTIRQ_ENTER();
2467
rcu_exit(int * _)2468 static void rcu_exit(int *_)
2469 {
2470 rcu_read_unlock();
2471 }
2472
2473 #define RCU_CONTEXT(name, ...) \
2474 int rcu_guard_##name __guard(rcu_exit); \
2475 rcu_read_lock();
2476
rcu_bh_exit(int * _)2477 static void rcu_bh_exit(int *_)
2478 {
2479 rcu_read_unlock_bh();
2480 }
2481
2482 #define RCU_BH_CONTEXT(name, ...) \
2483 int rcu_bh_guard_##name __guard(rcu_bh_exit); \
2484 rcu_read_lock_bh();
2485
rcu_sched_exit(int * _)2486 static void rcu_sched_exit(int *_)
2487 {
2488 rcu_read_unlock_sched();
2489 }
2490
2491 #define RCU_SCHED_CONTEXT(name, ...) \
2492 int rcu_sched_guard_##name __guard(rcu_sched_exit); \
2493 rcu_read_lock_sched();
2494
rcu_callback_exit(int * _)2495 static void rcu_callback_exit(int *_)
2496 {
2497 rcu_lock_release(&rcu_callback_map);
2498 }
2499
2500 #define RCU_CALLBACK_CONTEXT(name, ...) \
2501 int rcu_callback_guard_##name __guard(rcu_callback_exit); \
2502 rcu_lock_acquire(&rcu_callback_map);
2503
2504
raw_spinlock_exit(raw_spinlock_t ** lock)2505 static void raw_spinlock_exit(raw_spinlock_t **lock)
2506 {
2507 raw_spin_unlock(*lock);
2508 }
2509
2510 #define RAW_SPINLOCK_CONTEXT(name, lock) \
2511 raw_spinlock_t *raw_spinlock_guard_##name __guard(raw_spinlock_exit) = &(lock); \
2512 raw_spin_lock(&(lock));
2513
spinlock_exit(spinlock_t ** lock)2514 static void spinlock_exit(spinlock_t **lock)
2515 {
2516 spin_unlock(*lock);
2517 }
2518
2519 #define SPINLOCK_CONTEXT(name, lock) \
2520 spinlock_t *spinlock_guard_##name __guard(spinlock_exit) = &(lock); \
2521 spin_lock(&(lock));
2522
mutex_exit(struct mutex ** lock)2523 static void mutex_exit(struct mutex **lock)
2524 {
2525 mutex_unlock(*lock);
2526 }
2527
2528 #define MUTEX_CONTEXT(name, lock) \
2529 struct mutex *mutex_guard_##name __guard(mutex_exit) = &(lock); \
2530 mutex_lock(&(lock));
2531
2532 #define GENERATE_2_CONTEXT_TESTCASE(outer, outer_lock, inner, inner_lock) \
2533 \
2534 static void __maybe_unused inner##_in_##outer(void) \
2535 { \
2536 outer##_CONTEXT(_, outer_lock); \
2537 { \
2538 inner##_CONTEXT(_, inner_lock); \
2539 } \
2540 }
2541
2542 /*
2543 * wait contexts (considering PREEMPT_RT)
2544 *
2545 * o: inner is allowed in outer
2546 * x: inner is disallowed in outer
2547 *
2548 * \ inner | RCU | RAW_SPIN | SPIN | MUTEX
2549 * outer \ | | | |
2550 * ---------------+-------+----------+------+-------
2551 * HARDIRQ | o | o | o | x
2552 * ---------------+-------+----------+------+-------
2553 * NOTTHREADED_IRQ| o | o | x | x
2554 * ---------------+-------+----------+------+-------
2555 * SOFTIRQ | o | o | o | x
2556 * ---------------+-------+----------+------+-------
2557 * RCU | o | o | o | x
2558 * ---------------+-------+----------+------+-------
2559 * RCU_BH | o | o | o | x
2560 * ---------------+-------+----------+------+-------
2561 * RCU_CALLBACK | o | o | o | x
2562 * ---------------+-------+----------+------+-------
2563 * RCU_SCHED | o | o | x | x
2564 * ---------------+-------+----------+------+-------
2565 * RAW_SPIN | o | o | x | x
2566 * ---------------+-------+----------+------+-------
2567 * SPIN | o | o | o | x
2568 * ---------------+-------+----------+------+-------
2569 * MUTEX | o | o | o | o
2570 * ---------------+-------+----------+------+-------
2571 */
2572
2573 #define GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(inner, inner_lock) \
2574 GENERATE_2_CONTEXT_TESTCASE(HARDIRQ, , inner, inner_lock) \
2575 GENERATE_2_CONTEXT_TESTCASE(NOTTHREADED_HARDIRQ, , inner, inner_lock) \
2576 GENERATE_2_CONTEXT_TESTCASE(SOFTIRQ, , inner, inner_lock) \
2577 GENERATE_2_CONTEXT_TESTCASE(RCU, , inner, inner_lock) \
2578 GENERATE_2_CONTEXT_TESTCASE(RCU_BH, , inner, inner_lock) \
2579 GENERATE_2_CONTEXT_TESTCASE(RCU_CALLBACK, , inner, inner_lock) \
2580 GENERATE_2_CONTEXT_TESTCASE(RCU_SCHED, , inner, inner_lock) \
2581 GENERATE_2_CONTEXT_TESTCASE(RAW_SPINLOCK, raw_lock_A, inner, inner_lock) \
2582 GENERATE_2_CONTEXT_TESTCASE(SPINLOCK, lock_A, inner, inner_lock) \
2583 GENERATE_2_CONTEXT_TESTCASE(MUTEX, mutex_A, inner, inner_lock)
2584
2585 GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(RCU, )
GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(RAW_SPINLOCK,raw_lock_B)2586 GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(RAW_SPINLOCK, raw_lock_B)
2587 GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(SPINLOCK, lock_B)
2588 GENERATE_2_CONTEXT_TESTCASE_FOR_ALL_OUTER(MUTEX, mutex_B)
2589
2590 /* the outer context allows all kinds of preemption */
2591 #define DO_CONTEXT_TESTCASE_OUTER_PREEMPTIBLE(outer) \
2592 dotest(RCU_in_##outer, SUCCESS, LOCKTYPE_RWLOCK); \
2593 dotest(RAW_SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN); \
2594 dotest(SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN); \
2595 dotest(MUTEX_in_##outer, SUCCESS, LOCKTYPE_MUTEX); \
2596
2597 /*
2598 * the outer context only allows the preemption introduced by spinlock_t (which
2599 * is a sleepable lock for PREEMPT_RT)
2600 */
2601 #define DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(outer) \
2602 dotest(RCU_in_##outer, SUCCESS, LOCKTYPE_RWLOCK); \
2603 dotest(RAW_SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN); \
2604 dotest(SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN); \
2605 dotest(MUTEX_in_##outer, FAILURE, LOCKTYPE_MUTEX); \
2606
2607 /* the outer doesn't allows any kind of preemption */
2608 #define DO_CONTEXT_TESTCASE_OUTER_NOT_PREEMPTIBLE(outer) \
2609 dotest(RCU_in_##outer, SUCCESS, LOCKTYPE_RWLOCK); \
2610 dotest(RAW_SPINLOCK_in_##outer, SUCCESS, LOCKTYPE_SPIN); \
2611 dotest(SPINLOCK_in_##outer, FAILURE, LOCKTYPE_SPIN); \
2612 dotest(MUTEX_in_##outer, FAILURE, LOCKTYPE_MUTEX); \
2613
2614 static void wait_context_tests(void)
2615 {
2616 printk(" --------------------------------------------------------------------------\n");
2617 printk(" | wait context tests |\n");
2618 printk(" --------------------------------------------------------------------------\n");
2619 printk(" | rcu | raw | spin |mutex |\n");
2620 printk(" --------------------------------------------------------------------------\n");
2621 print_testname("in hardirq context");
2622 DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(HARDIRQ);
2623 pr_cont("\n");
2624
2625 print_testname("in hardirq context (not threaded)");
2626 DO_CONTEXT_TESTCASE_OUTER_NOT_PREEMPTIBLE(NOTTHREADED_HARDIRQ);
2627 pr_cont("\n");
2628
2629 print_testname("in softirq context");
2630 DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(SOFTIRQ);
2631 pr_cont("\n");
2632
2633 print_testname("in RCU context");
2634 DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(RCU);
2635 pr_cont("\n");
2636
2637 print_testname("in RCU-bh context");
2638 DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(RCU_BH);
2639 pr_cont("\n");
2640
2641 print_testname("in RCU callback context");
2642 DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(RCU_CALLBACK);
2643 pr_cont("\n");
2644
2645 print_testname("in RCU-sched context");
2646 DO_CONTEXT_TESTCASE_OUTER_NOT_PREEMPTIBLE(RCU_SCHED);
2647 pr_cont("\n");
2648
2649 print_testname("in RAW_SPINLOCK context");
2650 DO_CONTEXT_TESTCASE_OUTER_NOT_PREEMPTIBLE(RAW_SPINLOCK);
2651 pr_cont("\n");
2652
2653 print_testname("in SPINLOCK context");
2654 DO_CONTEXT_TESTCASE_OUTER_LIMITED_PREEMPTIBLE(SPINLOCK);
2655 pr_cont("\n");
2656
2657 print_testname("in MUTEX context");
2658 DO_CONTEXT_TESTCASE_OUTER_PREEMPTIBLE(MUTEX);
2659 pr_cont("\n");
2660 }
2661
local_lock_2(void)2662 static void local_lock_2(void)
2663 {
2664 local_lock_acquire(&local_A); /* IRQ-ON */
2665 local_lock_release(&local_A);
2666
2667 HARDIRQ_ENTER();
2668 spin_lock(&lock_A); /* IN-IRQ */
2669 spin_unlock(&lock_A);
2670 HARDIRQ_EXIT()
2671
2672 HARDIRQ_DISABLE();
2673 spin_lock(&lock_A);
2674 local_lock_acquire(&local_A); /* IN-IRQ <-> IRQ-ON cycle, false */
2675 local_lock_release(&local_A);
2676 spin_unlock(&lock_A);
2677 HARDIRQ_ENABLE();
2678 }
2679
local_lock_3A(void)2680 static void local_lock_3A(void)
2681 {
2682 local_lock_acquire(&local_A); /* IRQ-ON */
2683 spin_lock(&lock_B); /* IRQ-ON */
2684 spin_unlock(&lock_B);
2685 local_lock_release(&local_A);
2686
2687 HARDIRQ_ENTER();
2688 spin_lock(&lock_A); /* IN-IRQ */
2689 spin_unlock(&lock_A);
2690 HARDIRQ_EXIT()
2691
2692 HARDIRQ_DISABLE();
2693 spin_lock(&lock_A);
2694 local_lock_acquire(&local_A); /* IN-IRQ <-> IRQ-ON cycle only if we count local_lock(), false */
2695 local_lock_release(&local_A);
2696 spin_unlock(&lock_A);
2697 HARDIRQ_ENABLE();
2698 }
2699
local_lock_3B(void)2700 static void local_lock_3B(void)
2701 {
2702 local_lock_acquire(&local_A); /* IRQ-ON */
2703 spin_lock(&lock_B); /* IRQ-ON */
2704 spin_unlock(&lock_B);
2705 local_lock_release(&local_A);
2706
2707 HARDIRQ_ENTER();
2708 spin_lock(&lock_A); /* IN-IRQ */
2709 spin_unlock(&lock_A);
2710 HARDIRQ_EXIT()
2711
2712 HARDIRQ_DISABLE();
2713 spin_lock(&lock_A);
2714 local_lock_acquire(&local_A); /* IN-IRQ <-> IRQ-ON cycle only if we count local_lock(), false */
2715 local_lock_release(&local_A);
2716 spin_unlock(&lock_A);
2717 HARDIRQ_ENABLE();
2718
2719 HARDIRQ_DISABLE();
2720 spin_lock(&lock_A);
2721 spin_lock(&lock_B); /* IN-IRQ <-> IRQ-ON cycle, true */
2722 spin_unlock(&lock_B);
2723 spin_unlock(&lock_A);
2724 HARDIRQ_DISABLE();
2725
2726 }
2727
local_lock_tests(void)2728 static void local_lock_tests(void)
2729 {
2730 printk(" --------------------------------------------------------------------------\n");
2731 printk(" | local_lock tests |\n");
2732 printk(" ---------------------\n");
2733
2734 print_testname("local_lock inversion 2");
2735 dotest(local_lock_2, SUCCESS, LOCKTYPE_LL);
2736 pr_cont("\n");
2737
2738 print_testname("local_lock inversion 3A");
2739 dotest(local_lock_3A, SUCCESS, LOCKTYPE_LL);
2740 pr_cont("\n");
2741
2742 print_testname("local_lock inversion 3B");
2743 dotest(local_lock_3B, FAILURE, LOCKTYPE_LL);
2744 pr_cont("\n");
2745 }
2746
locking_selftest(void)2747 void locking_selftest(void)
2748 {
2749 /*
2750 * Got a locking failure before the selftest ran?
2751 */
2752 if (!debug_locks) {
2753 printk("----------------------------------\n");
2754 printk("| Locking API testsuite disabled |\n");
2755 printk("----------------------------------\n");
2756 return;
2757 }
2758
2759 /*
2760 * treats read_lock() as recursive read locks for testing purpose
2761 */
2762 force_read_lock_recursive = 1;
2763
2764 /*
2765 * Run the testsuite:
2766 */
2767 printk("------------------------\n");
2768 printk("| Locking API testsuite:\n");
2769 printk("----------------------------------------------------------------------------\n");
2770 printk(" | spin |wlock |rlock |mutex | wsem | rsem |\n");
2771 printk(" --------------------------------------------------------------------------\n");
2772
2773 init_shared_classes();
2774 lockdep_set_selftest_task(current);
2775
2776 DO_TESTCASE_6R("A-A deadlock", AA);
2777 DO_TESTCASE_6R("A-B-B-A deadlock", ABBA);
2778 DO_TESTCASE_6R("A-B-B-C-C-A deadlock", ABBCCA);
2779 DO_TESTCASE_6R("A-B-C-A-B-C deadlock", ABCABC);
2780 DO_TESTCASE_6R("A-B-B-C-C-D-D-A deadlock", ABBCCDDA);
2781 DO_TESTCASE_6R("A-B-C-D-B-D-D-A deadlock", ABCDBDDA);
2782 DO_TESTCASE_6R("A-B-C-D-B-C-D-A deadlock", ABCDBCDA);
2783 DO_TESTCASE_6("double unlock", double_unlock);
2784 DO_TESTCASE_6("initialize held", init_held);
2785
2786 printk(" --------------------------------------------------------------------------\n");
2787 print_testname("recursive read-lock");
2788 pr_cont(" |");
2789 dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
2790 pr_cont(" |");
2791 dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
2792 pr_cont("\n");
2793
2794 print_testname("recursive read-lock #2");
2795 pr_cont(" |");
2796 dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
2797 pr_cont(" |");
2798 dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
2799 pr_cont("\n");
2800
2801 print_testname("mixed read-write-lock");
2802 pr_cont(" |");
2803 dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
2804 pr_cont(" |");
2805 dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
2806 pr_cont("\n");
2807
2808 print_testname("mixed write-read-lock");
2809 pr_cont(" |");
2810 dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
2811 pr_cont(" |");
2812 dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
2813 pr_cont("\n");
2814
2815 print_testname("mixed read-lock/lock-write ABBA");
2816 pr_cont(" |");
2817 dotest(rlock_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
2818 pr_cont(" |");
2819 dotest(rwsem_ABBA1, FAILURE, LOCKTYPE_RWSEM);
2820
2821 print_testname("mixed read-lock/lock-read ABBA");
2822 pr_cont(" |");
2823 dotest(rlock_ABBA2, SUCCESS, LOCKTYPE_RWLOCK);
2824 pr_cont(" |");
2825 dotest(rwsem_ABBA2, FAILURE, LOCKTYPE_RWSEM);
2826
2827 print_testname("mixed write-lock/lock-write ABBA");
2828 pr_cont(" |");
2829 dotest(rlock_ABBA3, FAILURE, LOCKTYPE_RWLOCK);
2830 pr_cont(" |");
2831 dotest(rwsem_ABBA3, FAILURE, LOCKTYPE_RWSEM);
2832
2833 print_testname("chain cached mixed R-L/L-W ABBA");
2834 pr_cont(" |");
2835 dotest(rlock_chaincache_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
2836
2837 DO_TESTCASE_6x1RRB("rlock W1R2/W2R3/W3R1", W1R2_W2R3_W3R1);
2838 DO_TESTCASE_6x1RRB("rlock W1W2/R2R3/W3R1", W1W2_R2R3_W3R1);
2839 DO_TESTCASE_6x1RR("rlock W1W2/R2R3/R3W1", W1W2_R2R3_R3W1);
2840 DO_TESTCASE_6x1RR("rlock W1R2/R2R3/W3W1", W1R2_R2R3_W3W1);
2841
2842 printk(" --------------------------------------------------------------------------\n");
2843
2844 /*
2845 * irq-context testcases:
2846 */
2847 DO_TESTCASE_2x6("irqs-on + irq-safe-A", irqsafe1);
2848 DO_TESTCASE_2x3("sirq-safe-A => hirqs-on", irqsafe2A);
2849 DO_TESTCASE_2x6("safe-A + irqs-on", irqsafe2B);
2850 DO_TESTCASE_6x6("safe-A + unsafe-B #1", irqsafe3);
2851 DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4);
2852 DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion);
2853
2854 DO_TESTCASE_6x2x2RW("irq read-recursion", irq_read_recursion);
2855 DO_TESTCASE_6x2x2RW("irq read-recursion #2", irq_read_recursion2);
2856 DO_TESTCASE_6x2x2RW("irq read-recursion #3", irq_read_recursion3);
2857
2858 ww_tests();
2859
2860 force_read_lock_recursive = 0;
2861 /*
2862 * queued_read_lock() specific test cases can be put here
2863 */
2864 if (IS_ENABLED(CONFIG_QUEUED_RWLOCKS))
2865 queued_read_lock_tests();
2866
2867 fs_reclaim_tests();
2868
2869 /* Wait context test cases that are specific for RAW_LOCK_NESTING */
2870 if (IS_ENABLED(CONFIG_PROVE_RAW_LOCK_NESTING))
2871 wait_context_tests();
2872
2873 local_lock_tests();
2874
2875 if (unexpected_testcase_failures) {
2876 printk("-----------------------------------------------------------------\n");
2877 debug_locks = 0;
2878 printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
2879 unexpected_testcase_failures, testcase_total);
2880 printk("-----------------------------------------------------------------\n");
2881 } else if (expected_testcase_failures && testcase_successes) {
2882 printk("--------------------------------------------------------\n");
2883 printk("%3d out of %3d testcases failed, as expected. |\n",
2884 expected_testcase_failures, testcase_total);
2885 printk("----------------------------------------------------\n");
2886 debug_locks = 1;
2887 } else if (expected_testcase_failures && !testcase_successes) {
2888 printk("--------------------------------------------------------\n");
2889 printk("All %3d testcases failed, as expected. |\n",
2890 expected_testcase_failures);
2891 printk("----------------------------------------\n");
2892 debug_locks = 1;
2893 } else {
2894 printk("-------------------------------------------------------\n");
2895 printk("Good, all %3d testcases passed! |\n",
2896 testcase_successes);
2897 printk("---------------------------------\n");
2898 debug_locks = 1;
2899 }
2900 lockdep_set_selftest_task(NULL);
2901 debug_locks_silent = 0;
2902 }
2903