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