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