Lines Matching +full:fail +full:- +full:safe
1 // SPDX-License-Identifier: GPL-2.0
3 * lib/locking-selftest.c
6 * mutexes and rw-semaphores.
68 * Normal standalone locks, for the circular and irq-context
151 * non-inlined runtime initializers, to let separate locks share
152 * the same lock-class:
193 * For spinlocks and rwlocks we also do hardirq-safe / softirq-safe tests.
195 * context, causing the locks to be marked as hardirq-safe/softirq-safe:
261 #define WWAI(x) do { ww_acquire_init(x, &ww_lockdep); (x)->deadlock_inject_countdown = ~0U; } whi…
276 * the same basic lock-dependency/state events:
304 LOCK(X2); /* this one should fail */
309 #include "locking-selftest-spin.h"
311 #include "locking-selftest-wlock.h"
313 #include "locking-selftest-rlock.h"
315 #include "locking-selftest-mutex.h"
317 #include "locking-selftest-wsem.h"
319 #include "locking-selftest-rsem.h"
323 #include "locking-selftest-rtmutex.h"
330 * Special-case for read-locking, they are
336 RL(X1); // this one should NOT fail in rlock_AA1()
342 RL(X2); // this one should NOT fail in rlock_AA1B()
348 RSL(X1); // this one should fail in rsem_AA1()
354 RSL(X2); // this one should fail in rsem_AA1B()
362 WL(X2); // this one should fail in rlock_AA2()
368 WSL(X2); // this one should fail in rsem_AA2()
374 RL(X2); // this one should fail in rlock_AA3()
380 RSL(X2); // this one should fail in rsem_AA3()
399 U(Y1); // should fail in rlock_ABBA1()
412 MU(Y1); // should fail in rwsem_ABBA1()
422 * detecting a read-lock/lock-write deadlock: if the chain cache doesn't differ
425 * { read_lock(A)->lock(B) dependency exists }
431 * { Not a deadlock, B -> A is added in the chain cache }
437 * { B->A found in chain cache, not reported as a deadlock }
455 U(Y1); // should fail in rlock_chaincache_ABBA1()
474 U(Y1); // should NOT fail in rlock_ABBA2()
487 MU(Y1); // should fail in rwsem_ABBA2()
507 U(Y1); // should fail in rlock_ABBA3()
520 MU(Y1); // should fail in rwsem_ABBA3()
530 LOCK_UNLOCK_2(B, A); /* fail */
535 #include "locking-selftest-spin.h"
537 #include "locking-selftest-wlock.h"
539 #include "locking-selftest-rlock.h"
541 #include "locking-selftest-mutex.h"
543 #include "locking-selftest-wsem.h"
545 #include "locking-selftest-rsem.h"
549 #include "locking-selftest-rtmutex.h"
563 LOCK_UNLOCK_2(C, A); /* fail */
568 #include "locking-selftest-spin.h"
570 #include "locking-selftest-wlock.h"
572 #include "locking-selftest-rlock.h"
574 #include "locking-selftest-mutex.h"
576 #include "locking-selftest-wsem.h"
578 #include "locking-selftest-rsem.h"
582 #include "locking-selftest-rtmutex.h"
596 LOCK_UNLOCK_2(B, C); /* fail */
601 #include "locking-selftest-spin.h"
603 #include "locking-selftest-wlock.h"
605 #include "locking-selftest-rlock.h"
607 #include "locking-selftest-mutex.h"
609 #include "locking-selftest-wsem.h"
611 #include "locking-selftest-rsem.h"
615 #include "locking-selftest-rtmutex.h"
630 LOCK_UNLOCK_2(D, A); /* fail */
635 #include "locking-selftest-spin.h"
637 #include "locking-selftest-wlock.h"
639 #include "locking-selftest-rlock.h"
641 #include "locking-selftest-mutex.h"
643 #include "locking-selftest-wsem.h"
645 #include "locking-selftest-rsem.h"
649 #include "locking-selftest-rtmutex.h"
663 LOCK_UNLOCK_2(D, A); /* fail */
668 #include "locking-selftest-spin.h"
670 #include "locking-selftest-wlock.h"
672 #include "locking-selftest-rlock.h"
674 #include "locking-selftest-mutex.h"
676 #include "locking-selftest-wsem.h"
678 #include "locking-selftest-rsem.h"
682 #include "locking-selftest-rtmutex.h"
696 LOCK_UNLOCK_2(D, A); /* fail */
701 #include "locking-selftest-spin.h"
703 #include "locking-selftest-wlock.h"
705 #include "locking-selftest-rlock.h"
707 #include "locking-selftest-mutex.h"
709 #include "locking-selftest-wsem.h"
711 #include "locking-selftest-rsem.h"
715 #include "locking-selftest-rtmutex.h"
734 UNLOCK(A); /* fail */
739 #include "locking-selftest-spin.h"
741 #include "locking-selftest-wlock.h"
743 #include "locking-selftest-rlock.h"
745 #include "locking-selftest-mutex.h"
747 #include "locking-selftest-wsem.h"
749 #include "locking-selftest-rsem.h"
753 #include "locking-selftest-rtmutex.h"
765 INIT(A); /* fail */
770 #include "locking-selftest-spin.h"
772 #include "locking-selftest-wlock.h"
774 #include "locking-selftest-rlock.h"
776 #include "locking-selftest-mutex.h"
778 #include "locking-selftest-wsem.h"
780 #include "locking-selftest-rsem.h"
784 #include "locking-selftest-rtmutex.h"
791 * locking an irq-safe lock with irqs enabled:
808 #include "locking-selftest-spin-hardirq.h"
811 #include "locking-selftest-rlock-hardirq.h"
814 #include "locking-selftest-wlock-hardirq.h" in GENERATE_PERMUTATIONS_2_EVENTS()
818 #include "locking-selftest-spin-softirq.h" in GENERATE_PERMUTATIONS_2_EVENTS()
821 #include "locking-selftest-rlock-softirq.h" in GENERATE_PERMUTATIONS_2_EVENTS()
824 #include "locking-selftest-wlock-softirq.h" in GENERATE_PERMUTATIONS_2_EVENTS()
833 * Enabling hardirqs with a softirq-safe lock held: in GENERATE_PERMUTATIONS_2_EVENTS()
852 #include "locking-selftest-spin.h"
855 #include "locking-selftest-wlock.h"
858 #include "locking-selftest-rlock.h"
867 * Enabling irqs with an irq-safe lock held:
886 #include "locking-selftest-spin-hardirq.h"
889 #include "locking-selftest-rlock-hardirq.h"
892 #include "locking-selftest-wlock-hardirq.h"
896 #include "locking-selftest-spin-softirq.h"
899 #include "locking-selftest-rlock-softirq.h"
902 #include "locking-selftest-wlock-softirq.h"
910 * Acquiring a irq-unsafe lock while holding an irq-safe-lock:
934 #include "locking-selftest-spin-hardirq.h"
937 #include "locking-selftest-rlock-hardirq.h"
940 #include "locking-selftest-wlock-hardirq.h"
944 #include "locking-selftest-spin-softirq.h"
947 #include "locking-selftest-rlock-softirq.h"
950 #include "locking-selftest-wlock-softirq.h"
959 * If a lock turns into softirq-safe, but earlier it took
960 * a softirq-unsafe lock:
984 #include "locking-selftest-spin-hardirq.h"
987 #include "locking-selftest-rlock-hardirq.h"
990 #include "locking-selftest-wlock-hardirq.h"
994 #include "locking-selftest-spin-softirq.h"
997 #include "locking-selftest-rlock-softirq.h"
1000 #include "locking-selftest-wlock-softirq.h"
1009 * read-lock / write-lock irq inversion.
1013 * CPU#1 is at #1, i.e. it has write-locked A, but has not
1018 * Hardirq hits CPU#2 at point #2 and is trying to read-lock A.
1048 #include "locking-selftest-spin-hardirq.h"
1051 #include "locking-selftest-rlock-hardirq.h"
1054 #include "locking-selftest-wlock-hardirq.h"
1058 #include "locking-selftest-spin-softirq.h"
1061 #include "locking-selftest-rlock-softirq.h"
1064 #include "locking-selftest-wlock-softirq.h"
1073 * write-read / write-read / write-read deadlock even if read is recursive
1097 #include "locking-selftest-rlock.h"
1105 * write-write / read-read / write-read deadlock even if read is recursive
1129 #include "locking-selftest-rlock.h"
1137 * write-write / read-read / read-write is not deadlock when read is recursive
1161 #include "locking-selftest-rlock.h"
1169 * write-read / read-read / write-write is not deadlock when read is recursive
1193 #include "locking-selftest-rlock.h"
1200 * read-lock / write-lock recursion that is actually safe.
1227 #include "locking-selftest-hardirq.h"
1228 #include "locking-selftest-rlock.h"
1231 #include "locking-selftest-wlock.h"
1235 #include "locking-selftest-softirq.h"
1236 #include "locking-selftest-rlock.h"
1239 #include "locking-selftest-wlock.h"
1248 * read-lock / write-lock recursion that is unsafe.
1275 #include "locking-selftest-hardirq.h"
1276 #include "locking-selftest-rlock.h"
1279 #include "locking-selftest-wlock.h"
1283 #include "locking-selftest-softirq.h"
1284 #include "locking-selftest-rlock.h"
1287 #include "locking-selftest-wlock.h"
1295 * read-lock / write-lock recursion that is unsafe.
1331 #include "locking-selftest-hardirq.h"
1332 #include "locking-selftest-rlock.h"
1335 #include "locking-selftest-wlock.h"
1339 #include "locking-selftest-softirq.h"
1340 #include "locking-selftest-rlock.h"
1343 #include "locking-selftest-wlock.h"
1435 int saved_mgd_count = current->migration_disabled; in dotest()
1437 int saved_rcu_count = current->rcu_read_lock_nesting; in dotest()
1468 * Some tests (e.g. double-unlock) might corrupt the preemption in dotest()
1475 while (current->migration_disabled > saved_mgd_count) in dotest()
1479 while (current->rcu_read_lock_nesting > saved_rcu_count) in dotest()
1481 WARN_ON_ONCE(current->rcu_read_lock_nesting < saved_rcu_count); in dotest()
1486 current->softirqs_enabled = 0; in dotest()
1488 current->softirqs_enabled = 1; in dotest()
1550 DO_TESTCASE_2RW("hard-"desc, name##_hard, nr) \
1551 NON_RT(DO_TESTCASE_2RW("soft-"desc, name##_soft, nr)) \
1598 DO_TESTCASE_1("hard-"desc, name##_hard, nr); \
1599 NON_RT(DO_TESTCASE_1("soft-"desc, name##_soft, nr));
1602 DO_TESTCASE_1B("hard-"desc, name##_hard, nr); \
1603 NON_RT(DO_TESTCASE_1B("soft-"desc, name##_soft, nr));
1606 DO_TESTCASE_3("hard-"desc, name##_hard, nr); \
1607 NON_RT(DO_TESTCASE_3("soft-"desc, name##_soft, nr));
1610 DO_TESTCASE_3RW("hard-"desc, name##_hard, nr); \
1611 NON_RT(DO_TESTCASE_3RW("soft-"desc, name##_soft, nr));
1684 WARN_ON(ret != -EALREADY); in ww_test_fail_acquire()
1692 WARN_ON(ret != -EDEADLK); in ww_test_fail_acquire()
1859 t2.stamp--; in ww_test_edeadlk_normal()
1865 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_normal()
1885 t2.stamp--; in ww_test_edeadlk_normal_slow()
1891 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_normal_slow()
1911 t2.stamp--; in ww_test_edeadlk_no_unlock()
1917 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_no_unlock()
1936 t2.stamp--; in ww_test_edeadlk_no_unlock_slow()
1942 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_no_unlock_slow()
1961 t2.stamp--; in ww_test_edeadlk_acquire_more()
1967 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_acquire_more()
1982 t2.stamp--; in ww_test_edeadlk_acquire_more_slow()
1988 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_acquire_more_slow()
2007 t2.stamp--; in ww_test_edeadlk_acquire_more_edeadlk()
2013 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_acquire_more_edeadlk()
2016 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_acquire_more_edeadlk()
2033 t2.stamp--; in ww_test_edeadlk_acquire_more_edeadlk_slow()
2039 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_acquire_more_edeadlk_slow()
2054 t2.stamp--; in ww_test_edeadlk_acquire_wrong()
2060 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_acquire_wrong()
2079 t2.stamp--; in ww_test_edeadlk_acquire_wrong_slow()
2085 WARN_ON(ret != -EDEADLK); in ww_test_edeadlk_acquire_wrong_slow()
2285 printk(" --------------------------------------------------------------------------\n"); in ww_tests()
2287 printk(" ---------------------\n"); in ww_tests()
2334 printk(" -----------------------------------------------------\n"); in ww_tests()
2336 printk(" -----------------------------------------------------\n"); in ww_tests()
2426 * is a deadlock. Because the two read_lock()s are both non-recursive readers.
2449 printk(" --------------------------------------------------------------------------\n"); in queued_read_lock_tests()
2451 printk(" ---------------------------\n"); in queued_read_lock_tests()
2452 print_testname("hardirq read-lock/lock-read"); in queued_read_lock_tests()
2456 print_testname("hardirq lock-read/read-lock"); in queued_read_lock_tests()
2492 printk(" --------------------\n"); in fs_reclaim_tests()
2494 printk(" --------------------\n"); in fs_reclaim_tests()
2529 /* Relies the reversed clean-up ordering: inner first */ \
2542 * ---------------+-------+----------+------+-------
2544 * ---------------+-------+----------+------+-------
2546 * ---------------+-------+----------+------+-------
2548 * ---------------+-------+----------+------+-------
2550 * ---------------+-------+----------+------+-------
2552 * ---------------+-------+----------+------+-------
2554 * ---------------+-------+----------+------+-------
2556 * ---------------+-------+----------+------+-------
2558 * ---------------+-------+----------+------+-------
2560 * ---------------+-------+----------+------+-------
2605 printk(" --------------------------------------------------------------------------\n");
2607 printk(" --------------------------------------------------------------------------\n");
2609 printk(" --------------------------------------------------------------------------\n");
2626 print_testname("in RCU-bh context");
2630 print_testname("in RCU-sched context");
2649 local_lock(&local_A); /* IRQ-ON */ in local_lock_2()
2653 spin_lock(&lock_A); /* IN-IRQ */ in local_lock_2()
2659 local_lock(&local_A); /* IN-IRQ <-> IRQ-ON cycle, false */ in local_lock_2()
2667 local_lock(&local_A); /* IRQ-ON */ in local_lock_3A()
2668 spin_lock(&lock_B); /* IRQ-ON */ in local_lock_3A()
2673 spin_lock(&lock_A); /* IN-IRQ */ in local_lock_3A()
2679 local_lock(&local_A); /* IN-IRQ <-> IRQ-ON cycle only if we count local_lock(), false */ in local_lock_3A()
2687 local_lock(&local_A); /* IRQ-ON */ in local_lock_3B()
2688 spin_lock(&lock_B); /* IRQ-ON */ in local_lock_3B()
2693 spin_lock(&lock_A); /* IN-IRQ */ in local_lock_3B()
2699 local_lock(&local_A); /* IN-IRQ <-> IRQ-ON cycle only if we count local_lock(), false */ in local_lock_3B()
2706 spin_lock(&lock_B); /* IN-IRQ <-> IRQ-ON cycle, true */ in local_lock_3B()
2715 printk(" --------------------------------------------------------------------------\n"); in local_lock_tests()
2717 printk(" ---------------------\n"); in local_lock_tests()
2734 /* mutex_A is hardirq-unsafe and softirq-unsafe */ in hardirq_deadlock_softirq_not_deadlock()
2735 /* mutex_A -> lock_C */ in hardirq_deadlock_softirq_not_deadlock()
2743 /* lock_A is hardirq-safe */ in hardirq_deadlock_softirq_not_deadlock()
2749 /* lock_A -> lock_B */ in hardirq_deadlock_softirq_not_deadlock()
2757 /* lock_B -> lock_C */ in hardirq_deadlock_softirq_not_deadlock()
2765 /* lock_D is softirq-safe */ in hardirq_deadlock_softirq_not_deadlock()
2771 /* And lock_D is hardirq-unsafe */ in hardirq_deadlock_softirq_not_deadlock()
2778 * mutex_A -> lock_C -> lock_D is softirq-unsafe -> softirq-safe, not in hardirq_deadlock_softirq_not_deadlock()
2781 * lock_A -> lock_B -> lock_C -> lock_D is hardirq-safe -> in hardirq_deadlock_softirq_not_deadlock()
2782 * hardirq-unsafe, deadlock. in hardirq_deadlock_softirq_not_deadlock()
2798 printk("----------------------------------\n"); in locking_selftest()
2800 printk("----------------------------------\n"); in locking_selftest()
2812 printk("------------------------\n"); in locking_selftest()
2814 printk("----------------------------------------------------------------------------\n"); in locking_selftest()
2816 printk(" --------------------------------------------------------------------------\n"); in locking_selftest()
2821 DO_TESTCASE_6R("A-A deadlock", AA); in locking_selftest()
2822 DO_TESTCASE_6R("A-B-B-A deadlock", ABBA); in locking_selftest()
2823 DO_TESTCASE_6R("A-B-B-C-C-A deadlock", ABBCCA); in locking_selftest()
2824 DO_TESTCASE_6R("A-B-C-A-B-C deadlock", ABCABC); in locking_selftest()
2825 DO_TESTCASE_6R("A-B-B-C-C-D-D-A deadlock", ABBCCDDA); in locking_selftest()
2826 DO_TESTCASE_6R("A-B-C-D-B-D-D-A deadlock", ABCDBDDA); in locking_selftest()
2827 DO_TESTCASE_6R("A-B-C-D-B-C-D-A deadlock", ABCDBCDA); in locking_selftest()
2831 printk(" --------------------------------------------------------------------------\n"); in locking_selftest()
2832 print_testname("recursive read-lock"); in locking_selftest()
2839 print_testname("recursive read-lock #2"); in locking_selftest()
2846 print_testname("mixed read-write-lock"); in locking_selftest()
2853 print_testname("mixed write-read-lock"); in locking_selftest()
2860 print_testname("mixed read-lock/lock-write ABBA"); in locking_selftest()
2866 print_testname("mixed read-lock/lock-read ABBA"); in locking_selftest()
2872 print_testname("mixed write-lock/lock-write ABBA"); in locking_selftest()
2878 print_testname("chain cached mixed R-L/L-W ABBA"); in locking_selftest()
2887 printk(" --------------------------------------------------------------------------\n"); in locking_selftest()
2889 * irq-context testcases: in locking_selftest()
2891 DO_TESTCASE_2x6("irqs-on + irq-safe-A", irqsafe1); in locking_selftest()
2892 NON_RT(DO_TESTCASE_2x3("sirq-safe-A => hirqs-on", irqsafe2A)); in locking_selftest()
2893 DO_TESTCASE_2x6("safe-A + irqs-on", irqsafe2B); in locking_selftest()
2894 DO_TESTCASE_6x6("safe-A + unsafe-B #1", irqsafe3); in locking_selftest()
2895 DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4); in locking_selftest()
2896 DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion); in locking_selftest()
2898 DO_TESTCASE_6x2x2RW("irq read-recursion", irq_read_recursion); in locking_selftest()
2899 DO_TESTCASE_6x2x2RW("irq read-recursion #2", irq_read_recursion2); in locking_selftest()
2900 DO_TESTCASE_6x2x2RW("irq read-recursion #3", irq_read_recursion3); in locking_selftest()
2924 printk("-----------------------------------------------------------------\n"); in locking_selftest()
2926 printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n", in locking_selftest()
2928 printk("-----------------------------------------------------------------\n"); in locking_selftest()
2930 printk("--------------------------------------------------------\n"); in locking_selftest()
2933 printk("----------------------------------------------------\n"); in locking_selftest()
2936 printk("--------------------------------------------------------\n"); in locking_selftest()
2939 printk("----------------------------------------\n"); in locking_selftest()
2942 printk("-------------------------------------------------------\n"); in locking_selftest()
2945 printk("---------------------------------\n"); in locking_selftest()