]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - lib/locking-selftest.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'trace-v4.13-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt...
[mirror_ubuntu-artful-kernel.git] / lib / locking-selftest.c
CommitLineData
cae2ed9a
IM		 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>
1b375dc3 15#include <linux/ww_mutex.h>
cae2ed9a
IM		 16#include <linux/sched.h>
17#include <linux/delay.h>
fbb9ce95 18#include <linux/lockdep.h>
cae2ed9a
IM		 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>
018956d6 24#include <linux/rtmutex.h>
cae2ed9a
IM		 25
26/*
27 * Change this to 1 if you want to see the failure printouts:
28 */
29static unsigned int debug_locks_verbose;
30
1de99445
ML		 31static DEFINE_WW_CLASS(ww_lockdep);
32
cae2ed9a
IM		 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
1de99445 49#define LOCKTYPE_WW 0x10
018956d6 50#define LOCKTYPE_RTMUTEX 0x20
1de99445
ML		 51
52static struct ww_acquire_ctx t, t2;
f3cf139e 53static struct ww_mutex o, o2, o3;
cae2ed9a
IM		 54
55/*
56 * Normal standalone locks, for the circular and irq-context
57 * dependency tests:
58 */
9fb1b90c
YZ		 59static DEFINE_RAW_SPINLOCK(lock_A);
60static DEFINE_RAW_SPINLOCK(lock_B);
61static DEFINE_RAW_SPINLOCK(lock_C);
62static DEFINE_RAW_SPINLOCK(lock_D);
cae2ed9a
IM		 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
018956d6
PZ		 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
cae2ed9a
IM		 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 */
9fb1b90c
YZ		 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);
cae2ed9a
IM		 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
018956d6
PZ		 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
cae2ed9a
IM		 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 \
9fb1b90c
YZ		 139init_class_##class(raw_spinlock_t *lock, rwlock_t *rwlock, \
140 struct mutex *mutex, struct rw_semaphore *rwsem)\
cae2ed9a 141{ \
9fb1b90c 142 raw_spin_lock_init(lock); \
cae2ed9a
IM		 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{
018956d6
PZ		 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
cae2ed9a
IM		 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(); \
ba9f207c 186 __irq_enter(); \
cae2ed9a
IM		 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(); \
d820ac4c 199 lockdep_softirq_enter(); \
cae2ed9a
IM		 200 WARN_ON(!in_softirq());
201
202#define SOFTIRQ_EXIT() \
d820ac4c 203 lockdep_softirq_exit(); \
cae2ed9a
IM		 204 local_irq_enable(); \
205 local_bh_enable();
206
207/*
208 * Shortcuts for lock/unlock API variants, to keep
209 * the testcases compact:
210 */
9fb1b90c
YZ		 211#define L(x) raw_spin_lock(&lock_##x)
212#define U(x) raw_spin_unlock(&lock_##x)
cae2ed9a 213#define LU(x) L(x); U(x)
9fb1b90c 214#define SI(x) raw_spin_lock_init(&lock_##x)
cae2ed9a
IM		 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
018956d6
PZ		 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
cae2ed9a
IM		 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
1de99445
ML		 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
cae2ed9a
IM		 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
018956d6
PZ		 304#ifdef CONFIG_RT_MUTEXES
305#include "locking-selftest-rtmutex.h"
306GENERATE_TESTCASE(AA_rtmutex);
307#endif
308
cae2ed9a
IM		 309#undef E
310
311/*
312 * Special-case for read-locking, they are
6c9076ec 313 * allowed to recurse on the same lock class:
cae2ed9a
IM		 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);
6c9076ec 324 RL(X2); // this one should NOT fail
cae2ed9a
IM		 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 * ABBA deadlock:
367 */
368
369#define E() \
370 \
371 LOCK_UNLOCK_2(A, B); \
372 LOCK_UNLOCK_2(B, A); /* fail */
373
374/*
375 * 6 testcases:
376 */
377#include "locking-selftest-spin.h"
378GENERATE_TESTCASE(ABBA_spin)
379#include "locking-selftest-wlock.h"
380GENERATE_TESTCASE(ABBA_wlock)
381#include "locking-selftest-rlock.h"
382GENERATE_TESTCASE(ABBA_rlock)
383#include "locking-selftest-mutex.h"
384GENERATE_TESTCASE(ABBA_mutex)
385#include "locking-selftest-wsem.h"
386GENERATE_TESTCASE(ABBA_wsem)
387#include "locking-selftest-rsem.h"
388GENERATE_TESTCASE(ABBA_rsem)
389
018956d6
PZ		 390#ifdef CONFIG_RT_MUTEXES
391#include "locking-selftest-rtmutex.h"
392GENERATE_TESTCASE(ABBA_rtmutex);
393#endif
394
cae2ed9a
IM		 395#undef E
396
397/*
398 * AB BC CA deadlock:
399 */
400
401#define E() \
402 \
403 LOCK_UNLOCK_2(A, B); \
404 LOCK_UNLOCK_2(B, C); \
405 LOCK_UNLOCK_2(C, A); /* fail */
406
407/*
408 * 6 testcases:
409 */
410#include "locking-selftest-spin.h"
411GENERATE_TESTCASE(ABBCCA_spin)
412#include "locking-selftest-wlock.h"
413GENERATE_TESTCASE(ABBCCA_wlock)
414#include "locking-selftest-rlock.h"
415GENERATE_TESTCASE(ABBCCA_rlock)
416#include "locking-selftest-mutex.h"
417GENERATE_TESTCASE(ABBCCA_mutex)
418#include "locking-selftest-wsem.h"
419GENERATE_TESTCASE(ABBCCA_wsem)
420#include "locking-selftest-rsem.h"
421GENERATE_TESTCASE(ABBCCA_rsem)
422
018956d6
PZ		 423#ifdef CONFIG_RT_MUTEXES
424#include "locking-selftest-rtmutex.h"
425GENERATE_TESTCASE(ABBCCA_rtmutex);
426#endif
427
cae2ed9a
IM		 428#undef E
429
430/*
431 * AB CA BC deadlock:
432 */
433
434#define E() \
435 \
436 LOCK_UNLOCK_2(A, B); \
437 LOCK_UNLOCK_2(C, A); \
438 LOCK_UNLOCK_2(B, C); /* fail */
439
440/*
441 * 6 testcases:
442 */
443#include "locking-selftest-spin.h"
444GENERATE_TESTCASE(ABCABC_spin)
445#include "locking-selftest-wlock.h"
446GENERATE_TESTCASE(ABCABC_wlock)
447#include "locking-selftest-rlock.h"
448GENERATE_TESTCASE(ABCABC_rlock)
449#include "locking-selftest-mutex.h"
450GENERATE_TESTCASE(ABCABC_mutex)
451#include "locking-selftest-wsem.h"
452GENERATE_TESTCASE(ABCABC_wsem)
453#include "locking-selftest-rsem.h"
454GENERATE_TESTCASE(ABCABC_rsem)
455
018956d6
PZ		 456#ifdef CONFIG_RT_MUTEXES
457#include "locking-selftest-rtmutex.h"
458GENERATE_TESTCASE(ABCABC_rtmutex);
459#endif
460
cae2ed9a
IM		 461#undef E
462
463/*
464 * AB BC CD DA deadlock:
465 */
466
467#define E() \
468 \
469 LOCK_UNLOCK_2(A, B); \
470 LOCK_UNLOCK_2(B, C); \
471 LOCK_UNLOCK_2(C, D); \
472 LOCK_UNLOCK_2(D, A); /* fail */
473
474/*
475 * 6 testcases:
476 */
477#include "locking-selftest-spin.h"
478GENERATE_TESTCASE(ABBCCDDA_spin)
479#include "locking-selftest-wlock.h"
480GENERATE_TESTCASE(ABBCCDDA_wlock)
481#include "locking-selftest-rlock.h"
482GENERATE_TESTCASE(ABBCCDDA_rlock)
483#include "locking-selftest-mutex.h"
484GENERATE_TESTCASE(ABBCCDDA_mutex)
485#include "locking-selftest-wsem.h"
486GENERATE_TESTCASE(ABBCCDDA_wsem)
487#include "locking-selftest-rsem.h"
488GENERATE_TESTCASE(ABBCCDDA_rsem)
489
018956d6
PZ		 490#ifdef CONFIG_RT_MUTEXES
491#include "locking-selftest-rtmutex.h"
492GENERATE_TESTCASE(ABBCCDDA_rtmutex);
493#endif
494
cae2ed9a
IM		 495#undef E
496
497/*
498 * AB CD BD DA deadlock:
499 */
500#define E() \
501 \
502 LOCK_UNLOCK_2(A, B); \
503 LOCK_UNLOCK_2(C, D); \
504 LOCK_UNLOCK_2(B, D); \
505 LOCK_UNLOCK_2(D, A); /* fail */
506
507/*
508 * 6 testcases:
509 */
510#include "locking-selftest-spin.h"
511GENERATE_TESTCASE(ABCDBDDA_spin)
512#include "locking-selftest-wlock.h"
513GENERATE_TESTCASE(ABCDBDDA_wlock)
514#include "locking-selftest-rlock.h"
515GENERATE_TESTCASE(ABCDBDDA_rlock)
516#include "locking-selftest-mutex.h"
517GENERATE_TESTCASE(ABCDBDDA_mutex)
518#include "locking-selftest-wsem.h"
519GENERATE_TESTCASE(ABCDBDDA_wsem)
520#include "locking-selftest-rsem.h"
521GENERATE_TESTCASE(ABCDBDDA_rsem)
522
018956d6
PZ		 523#ifdef CONFIG_RT_MUTEXES
524#include "locking-selftest-rtmutex.h"
525GENERATE_TESTCASE(ABCDBDDA_rtmutex);
526#endif
527
cae2ed9a
IM		 528#undef E
529
530/*
531 * AB CD BC DA deadlock:
532 */
533#define E() \
534 \
535 LOCK_UNLOCK_2(A, B); \
536 LOCK_UNLOCK_2(C, D); \
537 LOCK_UNLOCK_2(B, C); \
538 LOCK_UNLOCK_2(D, A); /* fail */
539
540/*
541 * 6 testcases:
542 */
543#include "locking-selftest-spin.h"
544GENERATE_TESTCASE(ABCDBCDA_spin)
545#include "locking-selftest-wlock.h"
546GENERATE_TESTCASE(ABCDBCDA_wlock)
547#include "locking-selftest-rlock.h"
548GENERATE_TESTCASE(ABCDBCDA_rlock)
549#include "locking-selftest-mutex.h"
550GENERATE_TESTCASE(ABCDBCDA_mutex)
551#include "locking-selftest-wsem.h"
552GENERATE_TESTCASE(ABCDBCDA_wsem)
553#include "locking-selftest-rsem.h"
554GENERATE_TESTCASE(ABCDBCDA_rsem)
555
018956d6
PZ		 556#ifdef CONFIG_RT_MUTEXES
557#include "locking-selftest-rtmutex.h"
558GENERATE_TESTCASE(ABCDBCDA_rtmutex);
559#endif
560
cae2ed9a
IM		 561#undef E
562
563/*
564 * Double unlock:
565 */
566#define E() \
567 \
568 LOCK(A); \
569 UNLOCK(A); \
570 UNLOCK(A); /* fail */
571
572/*
573 * 6 testcases:
574 */
575#include "locking-selftest-spin.h"
576GENERATE_TESTCASE(double_unlock_spin)
577#include "locking-selftest-wlock.h"
578GENERATE_TESTCASE(double_unlock_wlock)
579#include "locking-selftest-rlock.h"
580GENERATE_TESTCASE(double_unlock_rlock)
581#include "locking-selftest-mutex.h"
582GENERATE_TESTCASE(double_unlock_mutex)
583#include "locking-selftest-wsem.h"
584GENERATE_TESTCASE(double_unlock_wsem)
585#include "locking-selftest-rsem.h"
586GENERATE_TESTCASE(double_unlock_rsem)
587
018956d6
PZ		 588#ifdef CONFIG_RT_MUTEXES
589#include "locking-selftest-rtmutex.h"
590GENERATE_TESTCASE(double_unlock_rtmutex);
591#endif
592
cae2ed9a
IM		 593#undef E
594
cae2ed9a
IM		 595/*
596 * initializing a held lock:
597 */
598#define E() \
599 \
600 LOCK(A); \
601 INIT(A); /* fail */
602
603/*
604 * 6 testcases:
605 */
606#include "locking-selftest-spin.h"
607GENERATE_TESTCASE(init_held_spin)
608#include "locking-selftest-wlock.h"
609GENERATE_TESTCASE(init_held_wlock)
610#include "locking-selftest-rlock.h"
611GENERATE_TESTCASE(init_held_rlock)
612#include "locking-selftest-mutex.h"
613GENERATE_TESTCASE(init_held_mutex)
614#include "locking-selftest-wsem.h"
615GENERATE_TESTCASE(init_held_wsem)
616#include "locking-selftest-rsem.h"
617GENERATE_TESTCASE(init_held_rsem)
618
018956d6
PZ		 619#ifdef CONFIG_RT_MUTEXES
620#include "locking-selftest-rtmutex.h"
621GENERATE_TESTCASE(init_held_rtmutex);
622#endif
623
cae2ed9a
IM		 624#undef E
625
626/*
627 * locking an irq-safe lock with irqs enabled:
628 */
629#define E1() \
630 \
631 IRQ_ENTER(); \
632 LOCK(A); \
633 UNLOCK(A); \
634 IRQ_EXIT();
635
636#define E2() \
637 \
638 LOCK(A); \
639 UNLOCK(A);
640
641/*
642 * Generate 24 testcases:
643 */
644#include "locking-selftest-spin-hardirq.h"
645GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_spin)
646
647#include "locking-selftest-rlock-hardirq.h"
648GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_rlock)
649
650#include "locking-selftest-wlock-hardirq.h"
651GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_wlock)
652
653#include "locking-selftest-spin-softirq.h"
654GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_spin)
655
656#include "locking-selftest-rlock-softirq.h"
657GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_rlock)
658
659#include "locking-selftest-wlock-softirq.h"
660GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_wlock)
661
662#undef E1
663#undef E2
664
665/*
666 * Enabling hardirqs with a softirq-safe lock held:
667 */
668#define E1() \
669 \
670 SOFTIRQ_ENTER(); \
671 LOCK(A); \
672 UNLOCK(A); \
673 SOFTIRQ_EXIT();
674
675#define E2() \
676 \
677 HARDIRQ_DISABLE(); \
678 LOCK(A); \
679 HARDIRQ_ENABLE(); \
680 UNLOCK(A);
681
682/*
683 * Generate 12 testcases:
684 */
685#include "locking-selftest-spin.h"
686GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_spin)
687
688#include "locking-selftest-wlock.h"
689GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_wlock)
690
691#include "locking-selftest-rlock.h"
692GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_rlock)
693
694#undef E1
695#undef E2
696
697/*
698 * Enabling irqs with an irq-safe lock held:
699 */
700#define E1() \
701 \
702 IRQ_ENTER(); \
703 LOCK(A); \
704 UNLOCK(A); \
705 IRQ_EXIT();
706
707#define E2() \
708 \
709 IRQ_DISABLE(); \
710 LOCK(A); \
711 IRQ_ENABLE(); \
712 UNLOCK(A);
713
714/*
715 * Generate 24 testcases:
716 */
717#include "locking-selftest-spin-hardirq.h"
718GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_spin)
719
720#include "locking-selftest-rlock-hardirq.h"
721GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_rlock)
722
723#include "locking-selftest-wlock-hardirq.h"
724GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_wlock)
725
726#include "locking-selftest-spin-softirq.h"
727GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_spin)
728
729#include "locking-selftest-rlock-softirq.h"
730GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_rlock)
731
732#include "locking-selftest-wlock-softirq.h"
733GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_wlock)
734
735#undef E1
736#undef E2
737
738/*
739 * Acquiring a irq-unsafe lock while holding an irq-safe-lock:
740 */
741#define E1() \
742 \
743 LOCK(A); \
744 LOCK(B); \
745 UNLOCK(B); \
746 UNLOCK(A); \
747
748#define E2() \
749 \
750 LOCK(B); \
751 UNLOCK(B);
752
753#define E3() \
754 \
755 IRQ_ENTER(); \
756 LOCK(A); \
757 UNLOCK(A); \
758 IRQ_EXIT();
759
760/*
761 * Generate 36 testcases:
762 */
763#include "locking-selftest-spin-hardirq.h"
764GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_spin)
765
766#include "locking-selftest-rlock-hardirq.h"
767GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_rlock)
768
769#include "locking-selftest-wlock-hardirq.h"
770GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_wlock)
771
772#include "locking-selftest-spin-softirq.h"
773GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_spin)
774
775#include "locking-selftest-rlock-softirq.h"
776GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_rlock)
777
778#include "locking-selftest-wlock-softirq.h"
779GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_wlock)
780
781#undef E1
782#undef E2
783#undef E3
784
785/*
786 * If a lock turns into softirq-safe, but earlier it took
787 * a softirq-unsafe lock:
788 */
789
790#define E1() \
791 IRQ_DISABLE(); \
792 LOCK(A); \
793 LOCK(B); \
794 UNLOCK(B); \
795 UNLOCK(A); \
796 IRQ_ENABLE();
797
798#define E2() \
799 LOCK(B); \
800 UNLOCK(B);
801
802#define E3() \
803 IRQ_ENTER(); \
804 LOCK(A); \
805 UNLOCK(A); \
806 IRQ_EXIT();
807
808/*
809 * Generate 36 testcases:
810 */
811#include "locking-selftest-spin-hardirq.h"
812GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_spin)
813
814#include "locking-selftest-rlock-hardirq.h"
815GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_rlock)
816
817#include "locking-selftest-wlock-hardirq.h"
818GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_wlock)
819
820#include "locking-selftest-spin-softirq.h"
821GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_spin)
822
823#include "locking-selftest-rlock-softirq.h"
824GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_rlock)
825
826#include "locking-selftest-wlock-softirq.h"
827GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_wlock)
828
829#undef E1
830#undef E2
831#undef E3
832
833/*
834 * read-lock / write-lock irq inversion.
835 *
836 * Deadlock scenario:
837 *
838 * CPU#1 is at #1, i.e. it has write-locked A, but has not
839 * taken B yet.
840 *
841 * CPU#2 is at #2, i.e. it has locked B.
842 *
843 * Hardirq hits CPU#2 at point #2 and is trying to read-lock A.
844 *
845 * The deadlock occurs because CPU#1 will spin on B, and CPU#2
846 * will spin on A.
847 */
848
849#define E1() \
850 \
851 IRQ_DISABLE(); \
852 WL(A); \
853 LOCK(B); \
854 UNLOCK(B); \
855 WU(A); \
856 IRQ_ENABLE();
857
858#define E2() \
859 \
860 LOCK(B); \
861 UNLOCK(B);
862
863#define E3() \
864 \
865 IRQ_ENTER(); \
866 RL(A); \
867 RU(A); \
868 IRQ_EXIT();
869
870/*
871 * Generate 36 testcases:
872 */
873#include "locking-selftest-spin-hardirq.h"
874GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_spin)
875
876#include "locking-selftest-rlock-hardirq.h"
877GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_rlock)
878
879#include "locking-selftest-wlock-hardirq.h"
880GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_wlock)
881
882#include "locking-selftest-spin-softirq.h"
883GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_spin)
884
885#include "locking-selftest-rlock-softirq.h"
886GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_rlock)
887
888#include "locking-selftest-wlock-softirq.h"
889GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_wlock)
890
891#undef E1
892#undef E2
893#undef E3
894
895/*
896 * read-lock / write-lock recursion that is actually safe.
897 */
898
899#define E1() \
900 \
901 IRQ_DISABLE(); \
902 WL(A); \
903 WU(A); \
904 IRQ_ENABLE();
905
906#define E2() \
907 \
908 RL(A); \
909 RU(A); \
910
911#define E3() \
912 \
913 IRQ_ENTER(); \
914 RL(A); \
915 L(B); \
916 U(B); \
917 RU(A); \
918 IRQ_EXIT();
919
920/*
921 * Generate 12 testcases:
922 */
923#include "locking-selftest-hardirq.h"
924GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard)
925
926#include "locking-selftest-softirq.h"
927GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft)
928
929#undef E1
930#undef E2
931#undef E3
932
933/*
934 * read-lock / write-lock recursion that is unsafe.
935 */
936
937#define E1() \
938 \
939 IRQ_DISABLE(); \
940 L(B); \
941 WL(A); \
942 WU(A); \
943 U(B); \
944 IRQ_ENABLE();
945
946#define E2() \
947 \
948 RL(A); \
949 RU(A); \
950
951#define E3() \
952 \
953 IRQ_ENTER(); \
954 L(B); \
955 U(B); \
956 IRQ_EXIT();
957
958/*
959 * Generate 12 testcases:
960 */
961#include "locking-selftest-hardirq.h"
962// GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard)
963
964#include "locking-selftest-softirq.h"
965// GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft)
966
cae2ed9a
IM		 967#ifdef CONFIG_DEBUG_LOCK_ALLOC
968# define I_SPINLOCK(x) lockdep_reset_lock(&lock_##x.dep_map)
969# define I_RWLOCK(x) lockdep_reset_lock(&rwlock_##x.dep_map)
970# define I_MUTEX(x) lockdep_reset_lock(&mutex_##x.dep_map)
971# define I_RWSEM(x) lockdep_reset_lock(&rwsem_##x.dep_map)
1de99445 972# define I_WW(x) lockdep_reset_lock(&x.dep_map)
018956d6
PZ		 973#ifdef CONFIG_RT_MUTEXES
974# define I_RTMUTEX(x) lockdep_reset_lock(&rtmutex_##x.dep_map)
975#endif
cae2ed9a
IM		 976#else
977# define I_SPINLOCK(x)
978# define I_RWLOCK(x)
979# define I_MUTEX(x)
980# define I_RWSEM(x)
1de99445 981# define I_WW(x)
cae2ed9a
IM		 982#endif
983
018956d6
PZ		 984#ifndef I_RTMUTEX
985# define I_RTMUTEX(x)
986#endif
987
988#ifdef CONFIG_RT_MUTEXES
989#define I2_RTMUTEX(x) rt_mutex_init(&rtmutex_##x)
990#else
991#define I2_RTMUTEX(x)
992#endif
993
cae2ed9a
IM		 994#define I1(x) \
995 do { \
996 I_SPINLOCK(x); \
997 I_RWLOCK(x); \
998 I_MUTEX(x); \
999 I_RWSEM(x); \
018956d6 1000 I_RTMUTEX(x); \
cae2ed9a
IM		 1001 } while (0)
1002
1003#define I2(x) \
1004 do { \
9fb1b90c 1005 raw_spin_lock_init(&lock_##x); \
cae2ed9a
IM		 1006 rwlock_init(&rwlock_##x); \
1007 mutex_init(&mutex_##x); \
1008 init_rwsem(&rwsem_##x); \
018956d6 1009 I2_RTMUTEX(x); \
cae2ed9a
IM		 1010 } while (0)
1011
1012static void reset_locks(void)
1013{
1014 local_irq_disable();
1de99445
ML		 1015 lockdep_free_key_range(&ww_lockdep.acquire_key, 1);
1016 lockdep_free_key_range(&ww_lockdep.mutex_key, 1);
1017
cae2ed9a
IM		 1018 I1(A); I1(B); I1(C); I1(D);
1019 I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);
f3cf139e 1020 I_WW(t); I_WW(t2); I_WW(o.base); I_WW(o2.base); I_WW(o3.base);
cae2ed9a
IM		 1021 lockdep_reset();
1022 I2(A); I2(B); I2(C); I2(D);
1023 init_shared_classes();
1de99445 1024
f3cf139e 1025 ww_mutex_init(&o, &ww_lockdep); ww_mutex_init(&o2, &ww_lockdep); ww_mutex_init(&o3, &ww_lockdep);
1de99445
ML		 1026 memset(&t, 0, sizeof(t)); memset(&t2, 0, sizeof(t2));
1027 memset(&ww_lockdep.acquire_key, 0, sizeof(ww_lockdep.acquire_key));
1028 memset(&ww_lockdep.mutex_key, 0, sizeof(ww_lockdep.mutex_key));
cae2ed9a
IM		 1029 local_irq_enable();
1030}
1031
1032#undef I
1033
1034static int testcase_total;
1035static int testcase_successes;
1036static int expected_testcase_failures;
1037static int unexpected_testcase_failures;
1038
1039static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
1040{
1041 unsigned long saved_preempt_count = preempt_count();
cae2ed9a
IM		 1042
1043 WARN_ON(irqs_disabled());
1044
1045 testcase_fn();
1046 /*
1047 * Filter out expected failures:
1048 */
1049#ifndef CONFIG_PROVE_LOCKING
166989e3 1050 if (expected == FAILURE && debug_locks) {
1de99445 1051 expected_testcase_failures++;
25139409 1052 pr_cont("failed|");
166989e3
ML		 1053 }
1054 else
1055#endif
1056 if (debug_locks != expected) {
1de99445 1057 unexpected_testcase_failures++;
25139409 1058 pr_cont("FAILED|");
1de99445
ML		 1059
1060 dump_stack();
cae2ed9a
IM		 1061 } else {
1062 testcase_successes++;
25139409 1063 pr_cont(" ok |");
cae2ed9a
IM		 1064 }
1065 testcase_total++;
1066
1067 if (debug_locks_verbose)
25139409 1068 pr_cont(" lockclass mask: %x, debug_locks: %d, expected: %d\n",
cae2ed9a
IM		 1069 lockclass_mask, debug_locks, expected);
1070 /*
1071 * Some tests (e.g. double-unlock) might corrupt the preemption
1072 * count, so restore it:
1073 */
4a2b4b22 1074 preempt_count_set(saved_preempt_count);
cae2ed9a
IM		 1075#ifdef CONFIG_TRACE_IRQFLAGS
1076 if (softirq_count())
1077 current->softirqs_enabled = 0;
1078 else
1079 current->softirqs_enabled = 1;
1080#endif
1081
1082 reset_locks();
1083}
1084
018956d6
PZ		 1085#ifdef CONFIG_RT_MUTEXES
1086#define dotest_rt(fn, e, m) dotest((fn), (e), (m))
1087#else
1088#define dotest_rt(fn, e, m)
1089#endif
1090
cae2ed9a
IM		 1091static inline void print_testname(const char *testname)
1092{
1093 printk("%33s:", testname);
1094}
1095
1096#define DO_TESTCASE_1(desc, name, nr) \
1097 print_testname(desc"/"#nr); \
1098 dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
25139409 1099 pr_cont("\n");
cae2ed9a
IM		 1100
1101#define DO_TESTCASE_1B(desc, name, nr) \
1102 print_testname(desc"/"#nr); \
1103 dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \
25139409 1104 pr_cont("\n");
cae2ed9a
IM		 1105
1106#define DO_TESTCASE_3(desc, name, nr) \
1107 print_testname(desc"/"#nr); \
1108 dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN); \
1109 dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1110 dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
25139409 1111 pr_cont("\n");
cae2ed9a
IM		 1112
1113#define DO_TESTCASE_3RW(desc, name, nr) \
1114 print_testname(desc"/"#nr); \
1115 dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN|LOCKTYPE_RWLOCK);\
1116 dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
1117 dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
25139409 1118 pr_cont("\n");
cae2ed9a
IM		 1119
1120#define DO_TESTCASE_6(desc, name) \
1121 print_testname(desc); \
1122 dotest(name##_spin, FAILURE, LOCKTYPE_SPIN); \
1123 dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK); \
1124 dotest(name##_rlock, FAILURE, LOCKTYPE_RWLOCK); \
1125 dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \
1126 dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
1127 dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
018956d6 1128 dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX); \
25139409 1129 pr_cont("\n");
cae2ed9a
IM		 1130
1131#define DO_TESTCASE_6_SUCCESS(desc, name) \
1132 print_testname(desc); \
1133 dotest(name##_spin, SUCCESS, LOCKTYPE_SPIN); \
1134 dotest(name##_wlock, SUCCESS, LOCKTYPE_RWLOCK); \
1135 dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK); \
1136 dotest(name##_mutex, SUCCESS, LOCKTYPE_MUTEX); \
1137 dotest(name##_wsem, SUCCESS, LOCKTYPE_RWSEM); \
1138 dotest(name##_rsem, SUCCESS, LOCKTYPE_RWSEM); \
018956d6 1139 dotest_rt(name##_rtmutex, SUCCESS, LOCKTYPE_RTMUTEX); \
25139409 1140 pr_cont("\n");
cae2ed9a
IM		 1141
1142/*
1143 * 'read' variant: rlocks must not trigger.
1144 */
1145#define DO_TESTCASE_6R(desc, name) \
1146 print_testname(desc); \
1147 dotest(name##_spin, FAILURE, LOCKTYPE_SPIN); \
1148 dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK); \
1149 dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK); \
1150 dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \
1151 dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
1152 dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
018956d6 1153 dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX); \
25139409 1154 pr_cont("\n");
cae2ed9a
IM		 1155
1156#define DO_TESTCASE_2I(desc, name, nr) \
1157 DO_TESTCASE_1("hard-"desc, name##_hard, nr); \
1158 DO_TESTCASE_1("soft-"desc, name##_soft, nr);
1159
1160#define DO_TESTCASE_2IB(desc, name, nr) \
1161 DO_TESTCASE_1B("hard-"desc, name##_hard, nr); \
1162 DO_TESTCASE_1B("soft-"desc, name##_soft, nr);
1163
1164#define DO_TESTCASE_6I(desc, name, nr) \
1165 DO_TESTCASE_3("hard-"desc, name##_hard, nr); \
1166 DO_TESTCASE_3("soft-"desc, name##_soft, nr);
1167
1168#define DO_TESTCASE_6IRW(desc, name, nr) \
1169 DO_TESTCASE_3RW("hard-"desc, name##_hard, nr); \
1170 DO_TESTCASE_3RW("soft-"desc, name##_soft, nr);
1171
1172#define DO_TESTCASE_2x3(desc, name) \
1173 DO_TESTCASE_3(desc, name, 12); \
1174 DO_TESTCASE_3(desc, name, 21);
1175
1176#define DO_TESTCASE_2x6(desc, name) \
1177 DO_TESTCASE_6I(desc, name, 12); \
1178 DO_TESTCASE_6I(desc, name, 21);
1179
1180#define DO_TESTCASE_6x2(desc, name) \
1181 DO_TESTCASE_2I(desc, name, 123); \
1182 DO_TESTCASE_2I(desc, name, 132); \
1183 DO_TESTCASE_2I(desc, name, 213); \
1184 DO_TESTCASE_2I(desc, name, 231); \
1185 DO_TESTCASE_2I(desc, name, 312); \
1186 DO_TESTCASE_2I(desc, name, 321);
1187
1188#define DO_TESTCASE_6x2B(desc, name) \
1189 DO_TESTCASE_2IB(desc, name, 123); \
1190 DO_TESTCASE_2IB(desc, name, 132); \
1191 DO_TESTCASE_2IB(desc, name, 213); \
1192 DO_TESTCASE_2IB(desc, name, 231); \
1193 DO_TESTCASE_2IB(desc, name, 312); \
1194 DO_TESTCASE_2IB(desc, name, 321);
1195
1196#define DO_TESTCASE_6x6(desc, name) \
1197 DO_TESTCASE_6I(desc, name, 123); \
1198 DO_TESTCASE_6I(desc, name, 132); \
1199 DO_TESTCASE_6I(desc, name, 213); \
1200 DO_TESTCASE_6I(desc, name, 231); \
1201 DO_TESTCASE_6I(desc, name, 312); \
1202 DO_TESTCASE_6I(desc, name, 321);
1203
1204#define DO_TESTCASE_6x6RW(desc, name) \
1205 DO_TESTCASE_6IRW(desc, name, 123); \
1206 DO_TESTCASE_6IRW(desc, name, 132); \
1207 DO_TESTCASE_6IRW(desc, name, 213); \
1208 DO_TESTCASE_6IRW(desc, name, 231); \
1209 DO_TESTCASE_6IRW(desc, name, 312); \
1210 DO_TESTCASE_6IRW(desc, name, 321);
1211
1de99445
ML		 1212static void ww_test_fail_acquire(void)
1213{
1214 int ret;
1215
1216 WWAI(&t);
1217 t.stamp++;
1218
1219 ret = WWL(&o, &t);
1220
1221 if (WARN_ON(!o.ctx) ||
1222 WARN_ON(ret))
1223 return;
1224
1225 /* No lockdep test, pure API */
1226 ret = WWL(&o, &t);
1227 WARN_ON(ret != -EALREADY);
1228
1229 ret = WWT(&o);
1230 WARN_ON(ret);
1231
1232 t2 = t;
1233 t2.stamp++;
1234 ret = WWL(&o, &t2);
1235 WARN_ON(ret != -EDEADLK);
1236 WWU(&o);
1237
1238 if (WWT(&o))
1239 WWU(&o);
1240#ifdef CONFIG_DEBUG_LOCK_ALLOC
1241 else
1242 DEBUG_LOCKS_WARN_ON(1);
1243#endif
1244}
1245
2fe3d4b1
ML		 1246static void ww_test_normal(void)
1247{
1248 int ret;
1249
1250 WWAI(&t);
1251
1252 /*
1253 * None of the ww_mutex codepaths should be taken in the 'normal'
1254 * mutex calls. The easiest way to verify this is by using the
1255 * normal mutex calls, and making sure o.ctx is unmodified.
1256 */
1257
1258 /* mutex_lock (and indirectly, mutex_lock_nested) */
1259 o.ctx = (void *)~0UL;
1260 mutex_lock(&o.base);
1261 mutex_unlock(&o.base);
1262 WARN_ON(o.ctx != (void *)~0UL);
1263
1264 /* mutex_lock_interruptible (and *_nested) */
1265 o.ctx = (void *)~0UL;
1266 ret = mutex_lock_interruptible(&o.base);
1267 if (!ret)
1268 mutex_unlock(&o.base);
1269 else
1270 WARN_ON(1);
1271 WARN_ON(o.ctx != (void *)~0UL);
1272
1273 /* mutex_lock_killable (and *_nested) */
1274 o.ctx = (void *)~0UL;
1275 ret = mutex_lock_killable(&o.base);
1276 if (!ret)
1277 mutex_unlock(&o.base);
1278 else
1279 WARN_ON(1);
1280 WARN_ON(o.ctx != (void *)~0UL);
1281
1282 /* trylock, succeeding */
1283 o.ctx = (void *)~0UL;
1284 ret = mutex_trylock(&o.base);
1285 WARN_ON(!ret);
1286 if (ret)
1287 mutex_unlock(&o.base);
1288 else
1289 WARN_ON(1);
1290 WARN_ON(o.ctx != (void *)~0UL);
1291
1292 /* trylock, failing */
1293 o.ctx = (void *)~0UL;
1294 mutex_lock(&o.base);
1295 ret = mutex_trylock(&o.base);
1296 WARN_ON(ret);
1297 mutex_unlock(&o.base);
1298 WARN_ON(o.ctx != (void *)~0UL);
1299
1300 /* nest_lock */
1301 o.ctx = (void *)~0UL;
1302 mutex_lock_nest_lock(&o.base, &t);
1303 mutex_unlock(&o.base);
1304 WARN_ON(o.ctx != (void *)~0UL);
1305}
1306
1de99445
ML		 1307static void ww_test_two_contexts(void)
1308{
1309 WWAI(&t);
1310 WWAI(&t2);
1311}
1312
1313static void ww_test_diff_class(void)
1314{
1315 WWAI(&t);
1316#ifdef CONFIG_DEBUG_MUTEXES
1317 t.ww_class = NULL;
1318#endif
1319 WWL(&o, &t);
1320}
1321
1322static void ww_test_context_done_twice(void)
1323{
1324 WWAI(&t);
1325 WWAD(&t);
1326 WWAD(&t);
1327 WWAF(&t);
1328}
1329
1330static void ww_test_context_unlock_twice(void)
1331{
1332 WWAI(&t);
1333 WWAD(&t);
1334 WWAF(&t);
1335 WWAF(&t);
1336}
1337
1338static void ww_test_context_fini_early(void)
1339{
1340 WWAI(&t);
1341 WWL(&o, &t);
1342 WWAD(&t);
1343 WWAF(&t);
1344}
1345
1346static void ww_test_context_lock_after_done(void)
1347{
1348 WWAI(&t);
1349 WWAD(&t);
1350 WWL(&o, &t);
1351}
1352
1353static void ww_test_object_unlock_twice(void)
1354{
1355 WWL1(&o);
1356 WWU(&o);
1357 WWU(&o);
1358}
1359
1360static void ww_test_object_lock_unbalanced(void)
1361{
1362 WWAI(&t);
1363 WWL(&o, &t);
1364 t.acquired = 0;
1365 WWU(&o);
1366 WWAF(&t);
1367}
1368
1369static void ww_test_object_lock_stale_context(void)
1370{
1371 WWAI(&t);
1372 o.ctx = &t2;
1373 WWL(&o, &t);
1374}
1375
f3cf139e
ML		 1376static void ww_test_edeadlk_normal(void)
1377{
1378 int ret;
1379
1380 mutex_lock(&o2.base);
1381 o2.ctx = &t2;
1382 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1383
1384 WWAI(&t);
1385 t2 = t;
1386 t2.stamp--;
1387
1388 ret = WWL(&o, &t);
1389 WARN_ON(ret);
1390
1391 ret = WWL(&o2, &t);
1392 WARN_ON(ret != -EDEADLK);
1393
1394 o2.ctx = NULL;
1395 mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1396 mutex_unlock(&o2.base);
1397 WWU(&o);
1398
1399 WWL(&o2, &t);
1400}
1401
1402static void ww_test_edeadlk_normal_slow(void)
1403{
1404 int ret;
1405
1406 mutex_lock(&o2.base);
1407 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1408 o2.ctx = &t2;
1409
1410 WWAI(&t);
1411 t2 = t;
1412 t2.stamp--;
1413
1414 ret = WWL(&o, &t);
1415 WARN_ON(ret);
1416
1417 ret = WWL(&o2, &t);
1418 WARN_ON(ret != -EDEADLK);
1419
1420 o2.ctx = NULL;
1421 mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1422 mutex_unlock(&o2.base);
1423 WWU(&o);
1424
1425 ww_mutex_lock_slow(&o2, &t);
1426}
1427
1428static void ww_test_edeadlk_no_unlock(void)
1429{
1430 int ret;
1431
1432 mutex_lock(&o2.base);
1433 o2.ctx = &t2;
1434 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1435
1436 WWAI(&t);
1437 t2 = t;
1438 t2.stamp--;
1439
1440 ret = WWL(&o, &t);
1441 WARN_ON(ret);
1442
1443 ret = WWL(&o2, &t);
1444 WARN_ON(ret != -EDEADLK);
1445
1446 o2.ctx = NULL;
1447 mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1448 mutex_unlock(&o2.base);
1449
1450 WWL(&o2, &t);
1451}
1452
1453static void ww_test_edeadlk_no_unlock_slow(void)
1454{
1455 int ret;
1456
1457 mutex_lock(&o2.base);
1458 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1459 o2.ctx = &t2;
1460
1461 WWAI(&t);
1462 t2 = t;
1463 t2.stamp--;
1464
1465 ret = WWL(&o, &t);
1466 WARN_ON(ret);
1467
1468 ret = WWL(&o2, &t);
1469 WARN_ON(ret != -EDEADLK);
1470
1471 o2.ctx = NULL;
1472 mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
1473 mutex_unlock(&o2.base);
1474
1475 ww_mutex_lock_slow(&o2, &t);
1476}
1477
1478static void ww_test_edeadlk_acquire_more(void)
1479{
1480 int ret;
1481
1482 mutex_lock(&o2.base);
1483 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1484 o2.ctx = &t2;
1485
1486 WWAI(&t);
1487 t2 = t;
1488 t2.stamp--;
1489
1490 ret = WWL(&o, &t);
1491 WARN_ON(ret);
1492
1493 ret = WWL(&o2, &t);
1494 WARN_ON(ret != -EDEADLK);
1495
1496 ret = WWL(&o3, &t);
1497}
1498
1499static void ww_test_edeadlk_acquire_more_slow(void)
1500{
1501 int ret;
1502
1503 mutex_lock(&o2.base);
1504 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1505 o2.ctx = &t2;
1506
1507 WWAI(&t);
1508 t2 = t;
1509 t2.stamp--;
1510
1511 ret = WWL(&o, &t);
1512 WARN_ON(ret);
1513
1514 ret = WWL(&o2, &t);
1515 WARN_ON(ret != -EDEADLK);
1516
1517 ww_mutex_lock_slow(&o3, &t);
1518}
1519
1520static void ww_test_edeadlk_acquire_more_edeadlk(void)
1521{
1522 int ret;
1523
1524 mutex_lock(&o2.base);
1525 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1526 o2.ctx = &t2;
1527
1528 mutex_lock(&o3.base);
1529 mutex_release(&o3.base.dep_map, 1, _THIS_IP_);
1530 o3.ctx = &t2;
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 ret = WWL(&o3, &t);
1543 WARN_ON(ret != -EDEADLK);
1544}
1545
1546static void ww_test_edeadlk_acquire_more_edeadlk_slow(void)
1547{
1548 int ret;
1549
1550 mutex_lock(&o2.base);
1551 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1552 o2.ctx = &t2;
1553
1554 mutex_lock(&o3.base);
1555 mutex_release(&o3.base.dep_map, 1, _THIS_IP_);
1556 o3.ctx = &t2;
1557
1558 WWAI(&t);
1559 t2 = t;
1560 t2.stamp--;
1561
1562 ret = WWL(&o, &t);
1563 WARN_ON(ret);
1564
1565 ret = WWL(&o2, &t);
1566 WARN_ON(ret != -EDEADLK);
1567
1568 ww_mutex_lock_slow(&o3, &t);
1569}
1570
1571static void ww_test_edeadlk_acquire_wrong(void)
1572{
1573 int ret;
1574
1575 mutex_lock(&o2.base);
1576 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1577 o2.ctx = &t2;
1578
1579 WWAI(&t);
1580 t2 = t;
1581 t2.stamp--;
1582
1583 ret = WWL(&o, &t);
1584 WARN_ON(ret);
1585
1586 ret = WWL(&o2, &t);
1587 WARN_ON(ret != -EDEADLK);
1588 if (!ret)
1589 WWU(&o2);
1590
1591 WWU(&o);
1592
1593 ret = WWL(&o3, &t);
1594}
1595
1596static void ww_test_edeadlk_acquire_wrong_slow(void)
1597{
1598 int ret;
1599
1600 mutex_lock(&o2.base);
1601 mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
1602 o2.ctx = &t2;
1603
1604 WWAI(&t);
1605 t2 = t;
1606 t2.stamp--;
1607
1608 ret = WWL(&o, &t);
1609 WARN_ON(ret);
1610
1611 ret = WWL(&o2, &t);
1612 WARN_ON(ret != -EDEADLK);
1613 if (!ret)
1614 WWU(&o2);
1615
1616 WWU(&o);
1617
1618 ww_mutex_lock_slow(&o3, &t);
1619}
1620
1de99445
ML		 1621static void ww_test_spin_nest_unlocked(void)
1622{
1623 raw_spin_lock_nest_lock(&lock_A, &o.base);
1624 U(A);
1625}
1626
1627static void ww_test_unneeded_slow(void)
1628{
1629 WWAI(&t);
1630
1631 ww_mutex_lock_slow(&o, &t);
1632}
1633
1634static void ww_test_context_block(void)
1635{
1636 int ret;
1637
1638 WWAI(&t);
1639
1640 ret = WWL(&o, &t);
1641 WARN_ON(ret);
1642 WWL1(&o2);
1643}
1644
1645static void ww_test_context_try(void)
1646{
1647 int ret;
1648
1649 WWAI(&t);
1650
1651 ret = WWL(&o, &t);
1652 WARN_ON(ret);
1653
1654 ret = WWT(&o2);
1655 WARN_ON(!ret);
1656 WWU(&o2);
1657 WWU(&o);
1658}
1659
1660static void ww_test_context_context(void)
1661{
1662 int ret;
1663
1664 WWAI(&t);
1665
1666 ret = WWL(&o, &t);
1667 WARN_ON(ret);
1668
1669 ret = WWL(&o2, &t);
1670 WARN_ON(ret);
1671
1672 WWU(&o2);
1673 WWU(&o);
1674}
1675
1676static void ww_test_try_block(void)
1677{
1678 bool ret;
1679
1680 ret = WWT(&o);
1681 WARN_ON(!ret);
1682
1683 WWL1(&o2);
1684 WWU(&o2);
1685 WWU(&o);
1686}
1687
1688static void ww_test_try_try(void)
1689{
1690 bool ret;
1691
1692 ret = WWT(&o);
1693 WARN_ON(!ret);
1694 ret = WWT(&o2);
1695 WARN_ON(!ret);
1696 WWU(&o2);
1697 WWU(&o);
1698}
1699
1700static void ww_test_try_context(void)
1701{
1702 int ret;
1703
1704 ret = WWT(&o);
1705 WARN_ON(!ret);
1706
1707 WWAI(&t);
1708
1709 ret = WWL(&o2, &t);
1710 WARN_ON(ret);
1711}
1712
1713static void ww_test_block_block(void)
1714{
1715 WWL1(&o);
1716 WWL1(&o2);
1717}
1718
1719static void ww_test_block_try(void)
1720{
1721 bool ret;
1722
1723 WWL1(&o);
1724 ret = WWT(&o2);
1725 WARN_ON(!ret);
1726}
1727
1728static void ww_test_block_context(void)
1729{
1730 int ret;
1731
1732 WWL1(&o);
1733 WWAI(&t);
1734
1735 ret = WWL(&o2, &t);
1736 WARN_ON(ret);
1737}
1738
1739static void ww_test_spin_block(void)
1740{
1741 L(A);
1742 U(A);
1743
1744 WWL1(&o);
1745 L(A);
1746 U(A);
1747 WWU(&o);
1748
1749 L(A);
1750 WWL1(&o);
1751 WWU(&o);
1752 U(A);
1753}
1754
1755static void ww_test_spin_try(void)
1756{
1757 bool ret;
1758
1759 L(A);
1760 U(A);
1761
1762 ret = WWT(&o);
1763 WARN_ON(!ret);
1764 L(A);
1765 U(A);
1766 WWU(&o);
1767
1768 L(A);
1769 ret = WWT(&o);
1770 WARN_ON(!ret);
1771 WWU(&o);
1772 U(A);
1773}
1774
1775static void ww_test_spin_context(void)
1776{
1777 int ret;
1778
1779 L(A);
1780 U(A);
1781
1782 WWAI(&t);
1783
1784 ret = WWL(&o, &t);
1785 WARN_ON(ret);
1786 L(A);
1787 U(A);
1788 WWU(&o);
1789
1790 L(A);
1791 ret = WWL(&o, &t);
1792 WARN_ON(ret);
1793 WWU(&o);
1794 U(A);
1795}
1796
1797static void ww_tests(void)
1798{
1799 printk(" --------------------------------------------------------------------------\n");
1800 printk(" | Wound/wait tests |\n");
1801 printk(" ---------------------\n");
1802
1803 print_testname("ww api failures");
1804 dotest(ww_test_fail_acquire, SUCCESS, LOCKTYPE_WW);
2fe3d4b1 1805 dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW);
1de99445 1806 dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW);
25139409 1807 pr_cont("\n");
1de99445
ML		 1808
1809 print_testname("ww contexts mixing");
1810 dotest(ww_test_two_contexts, FAILURE, LOCKTYPE_WW);
1811 dotest(ww_test_diff_class, FAILURE, LOCKTYPE_WW);
25139409 1812 pr_cont("\n");
1de99445
ML		 1813
1814 print_testname("finishing ww context");
1815 dotest(ww_test_context_done_twice, FAILURE, LOCKTYPE_WW);
1816 dotest(ww_test_context_unlock_twice, FAILURE, LOCKTYPE_WW);
1817 dotest(ww_test_context_fini_early, FAILURE, LOCKTYPE_WW);
1818 dotest(ww_test_context_lock_after_done, FAILURE, LOCKTYPE_WW);
25139409 1819 pr_cont("\n");
1de99445
ML		 1820
1821 print_testname("locking mismatches");
1822 dotest(ww_test_object_unlock_twice, FAILURE, LOCKTYPE_WW);
1823 dotest(ww_test_object_lock_unbalanced, FAILURE, LOCKTYPE_WW);
1824 dotest(ww_test_object_lock_stale_context, FAILURE, LOCKTYPE_WW);
25139409 1825 pr_cont("\n");
1de99445 1826
f3cf139e
ML		 1827 print_testname("EDEADLK handling");
1828 dotest(ww_test_edeadlk_normal, SUCCESS, LOCKTYPE_WW);
1829 dotest(ww_test_edeadlk_normal_slow, SUCCESS, LOCKTYPE_WW);
1830 dotest(ww_test_edeadlk_no_unlock, FAILURE, LOCKTYPE_WW);
1831 dotest(ww_test_edeadlk_no_unlock_slow, FAILURE, LOCKTYPE_WW);
1832 dotest(ww_test_edeadlk_acquire_more, FAILURE, LOCKTYPE_WW);
1833 dotest(ww_test_edeadlk_acquire_more_slow, FAILURE, LOCKTYPE_WW);
1834 dotest(ww_test_edeadlk_acquire_more_edeadlk, FAILURE, LOCKTYPE_WW);
1835 dotest(ww_test_edeadlk_acquire_more_edeadlk_slow, FAILURE, LOCKTYPE_WW);
1836 dotest(ww_test_edeadlk_acquire_wrong, FAILURE, LOCKTYPE_WW);
1837 dotest(ww_test_edeadlk_acquire_wrong_slow, FAILURE, LOCKTYPE_WW);
25139409 1838 pr_cont("\n");
f3cf139e 1839
1de99445
ML		 1840 print_testname("spinlock nest unlocked");
1841 dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);
25139409 1842 pr_cont("\n");
1de99445
ML		 1843
1844 printk(" -----------------------------------------------------\n");
1845 printk(" |block | try |context|\n");
1846 printk(" -----------------------------------------------------\n");
1847
1848 print_testname("context");
1849 dotest(ww_test_context_block, FAILURE, LOCKTYPE_WW);
1850 dotest(ww_test_context_try, SUCCESS, LOCKTYPE_WW);
1851 dotest(ww_test_context_context, SUCCESS, LOCKTYPE_WW);
25139409 1852 pr_cont("\n");
1de99445
ML		 1853
1854 print_testname("try");
1855 dotest(ww_test_try_block, FAILURE, LOCKTYPE_WW);
1856 dotest(ww_test_try_try, SUCCESS, LOCKTYPE_WW);
1857 dotest(ww_test_try_context, FAILURE, LOCKTYPE_WW);
25139409 1858 pr_cont("\n");
1de99445
ML		 1859
1860 print_testname("block");
1861 dotest(ww_test_block_block, FAILURE, LOCKTYPE_WW);
1862 dotest(ww_test_block_try, SUCCESS, LOCKTYPE_WW);
1863 dotest(ww_test_block_context, FAILURE, LOCKTYPE_WW);
25139409 1864 pr_cont("\n");
1de99445
ML		 1865
1866 print_testname("spinlock");
1867 dotest(ww_test_spin_block, FAILURE, LOCKTYPE_WW);
1868 dotest(ww_test_spin_try, SUCCESS, LOCKTYPE_WW);
1869 dotest(ww_test_spin_context, FAILURE, LOCKTYPE_WW);
25139409 1870 pr_cont("\n");
1de99445 1871}
cae2ed9a
IM		 1872
1873void locking_selftest(void)
1874{
1875 /*
1876 * Got a locking failure before the selftest ran?
1877 */
1878 if (!debug_locks) {
1879 printk("----------------------------------\n");
1880 printk("| Locking API testsuite disabled |\n");
1881 printk("----------------------------------\n");
1882 return;
1883 }
1884
1885 /*
1886 * Run the testsuite:
1887 */
1888 printk("------------------------\n");
1889 printk("| Locking API testsuite:\n");
1890 printk("----------------------------------------------------------------------------\n");
1891 printk(" | spin |wlock |rlock |mutex | wsem | rsem |\n");
1892 printk(" --------------------------------------------------------------------------\n");
1893
1894 init_shared_classes();
1895 debug_locks_silent = !debug_locks_verbose;
1896
6c9076ec 1897 DO_TESTCASE_6R("A-A deadlock", AA);
cae2ed9a
IM		 1898 DO_TESTCASE_6R("A-B-B-A deadlock", ABBA);
1899 DO_TESTCASE_6R("A-B-B-C-C-A deadlock", ABBCCA);
1900 DO_TESTCASE_6R("A-B-C-A-B-C deadlock", ABCABC);
1901 DO_TESTCASE_6R("A-B-B-C-C-D-D-A deadlock", ABBCCDDA);
1902 DO_TESTCASE_6R("A-B-C-D-B-D-D-A deadlock", ABCDBDDA);
1903 DO_TESTCASE_6R("A-B-C-D-B-C-D-A deadlock", ABCDBCDA);
1904 DO_TESTCASE_6("double unlock", double_unlock);
1905 DO_TESTCASE_6("initialize held", init_held);
cae2ed9a
IM		 1906
1907 printk(" --------------------------------------------------------------------------\n");
1908 print_testname("recursive read-lock");
25139409 1909 pr_cont(" |");
cae2ed9a 1910 dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
25139409 1911 pr_cont(" |");
cae2ed9a 1912 dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
25139409 1913 pr_cont("\n");
cae2ed9a
IM		 1914
1915 print_testname("recursive read-lock #2");
25139409 1916 pr_cont(" |");
6c9076ec 1917 dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
25139409 1918 pr_cont(" |");
cae2ed9a 1919 dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
25139409 1920 pr_cont("\n");
cae2ed9a
IM		 1921
1922 print_testname("mixed read-write-lock");
25139409 1923 pr_cont(" |");
cae2ed9a 1924 dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
25139409 1925 pr_cont(" |");
cae2ed9a 1926 dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
25139409 1927 pr_cont("\n");
cae2ed9a
IM		 1928
1929 print_testname("mixed write-read-lock");
25139409 1930 pr_cont(" |");
cae2ed9a 1931 dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
25139409 1932 pr_cont(" |");
cae2ed9a 1933 dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
25139409 1934 pr_cont("\n");
cae2ed9a
IM		 1935
1936 printk(" --------------------------------------------------------------------------\n");
1937
1938 /*
1939 * irq-context testcases:
1940 */
1941 DO_TESTCASE_2x6("irqs-on + irq-safe-A", irqsafe1);
1942 DO_TESTCASE_2x3("sirq-safe-A => hirqs-on", irqsafe2A);
1943 DO_TESTCASE_2x6("safe-A + irqs-on", irqsafe2B);
1944 DO_TESTCASE_6x6("safe-A + unsafe-B #1", irqsafe3);
1945 DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4);
1946 DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion);
1947
1948 DO_TESTCASE_6x2("irq read-recursion", irq_read_recursion);
1949// DO_TESTCASE_6x2B("irq read-recursion #2", irq_read_recursion2);
1950
1de99445
ML		 1951 ww_tests();
1952
cae2ed9a
IM		 1953 if (unexpected_testcase_failures) {
1954 printk("-----------------------------------------------------------------\n");
1955 debug_locks = 0;
1956 printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
1957 unexpected_testcase_failures, testcase_total);
1958 printk("-----------------------------------------------------------------\n");
1959 } else if (expected_testcase_failures && testcase_successes) {
1960 printk("--------------------------------------------------------\n");
1961 printk("%3d out of %3d testcases failed, as expected. |\n",
1962 expected_testcase_failures, testcase_total);
1963 printk("----------------------------------------------------\n");
1964 debug_locks = 1;
1965 } else if (expected_testcase_failures && !testcase_successes) {
1966 printk("--------------------------------------------------------\n");
1967 printk("All %3d testcases failed, as expected. |\n",
1968 expected_testcase_failures);
1969 printk("----------------------------------------\n");
1970 debug_locks = 1;
1971 } else {
1972 printk("-------------------------------------------------------\n");
1973 printk("Good, all %3d testcases passed! |\n",
1974 testcase_successes);
1975 printk("---------------------------------\n");
1976 debug_locks = 1;
1977 }
1978 debug_locks_silent = 0;
1979}
Ubuntu Artful kernel mirror