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