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