Merge tag 'trace-v5.11' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt...

[linux-2.6-microblaze.git] / lib / locking-selftest.c

diff --git a/lib/locking-selftest.c b/lib/locking-selftest.c
index a899b3f..9959ea2 100644 (file)
--- a/lib/locking-selftest.c
+++ b/lib/locking-selftest.c
@@ -15,6 +15,7 @@
 #include <linux/mutex.h>
 #include <linux/ww_mutex.h>
 #include <linux/sched.h>
+#include <linux/sched/mm.h>
 #include <linux/delay.h>
 #include <linux/lockdep.h>
 #include <linux/spinlock.h>
@@ -58,10 +59,10 @@ static struct ww_mutex o, o2, o3;
  * Normal standalone locks, for the circular and irq-context
  * dependency tests:
  */
-static DEFINE_RAW_SPINLOCK(lock_A);
-static DEFINE_RAW_SPINLOCK(lock_B);
-static DEFINE_RAW_SPINLOCK(lock_C);
-static DEFINE_RAW_SPINLOCK(lock_D);
+static DEFINE_SPINLOCK(lock_A);
+static DEFINE_SPINLOCK(lock_B);
+static DEFINE_SPINLOCK(lock_C);
+static DEFINE_SPINLOCK(lock_D);
 
 static DEFINE_RWLOCK(rwlock_A);
 static DEFINE_RWLOCK(rwlock_B);
@@ -93,12 +94,12 @@ static DEFINE_RT_MUTEX(rtmutex_D);
  * but X* and Y* are different classes. We do this so that
  * we do not trigger a real lockup:
  */
-static DEFINE_RAW_SPINLOCK(lock_X1);
-static DEFINE_RAW_SPINLOCK(lock_X2);
-static DEFINE_RAW_SPINLOCK(lock_Y1);
-static DEFINE_RAW_SPINLOCK(lock_Y2);
-static DEFINE_RAW_SPINLOCK(lock_Z1);
-static DEFINE_RAW_SPINLOCK(lock_Z2);
+static DEFINE_SPINLOCK(lock_X1);
+static DEFINE_SPINLOCK(lock_X2);
+static DEFINE_SPINLOCK(lock_Y1);
+static DEFINE_SPINLOCK(lock_Y2);
+static DEFINE_SPINLOCK(lock_Z1);
+static DEFINE_SPINLOCK(lock_Z2);
 
 static DEFINE_RWLOCK(rwlock_X1);
 static DEFINE_RWLOCK(rwlock_X2);
@@ -138,10 +139,10 @@ static DEFINE_RT_MUTEX(rtmutex_Z2);
  */
 #define INIT_CLASS_FUNC(class)                                 \
 static noinline void                                   \
-init_class_##class(raw_spinlock_t *lock, rwlock_t *rwlock, \
+init_class_##class(spinlock_t *lock, rwlock_t *rwlock, \
        struct mutex *mutex, struct rw_semaphore *rwsem)\
 {                                                      \
-       raw_spin_lock_init(lock);                       \
+       spin_lock_init(lock);                   \
        rwlock_init(rwlock);                            \
        mutex_init(mutex);                              \
        init_rwsem(rwsem);                              \
@@ -210,10 +211,10 @@ static void init_shared_classes(void)
  * Shortcuts for lock/unlock API variants, to keep
  * the testcases compact:
  */
-#define L(x)                   raw_spin_lock(&lock_##x)
-#define U(x)                   raw_spin_unlock(&lock_##x)
+#define L(x)                   spin_lock(&lock_##x)
+#define U(x)                   spin_unlock(&lock_##x)
 #define LU(x)                  L(x); U(x)
-#define SI(x)                  raw_spin_lock_init(&lock_##x)
+#define SI(x)                  spin_lock_init(&lock_##x)
 
 #define WL(x)                  write_lock(&rwlock_##x)
 #define WU(x)                  write_unlock(&rwlock_##x)
@@ -1341,7 +1342,7 @@ GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_wlock)
 
 #define I2(x)                                  \
        do {                                    \
-               raw_spin_lock_init(&lock_##x);  \
+               spin_lock_init(&lock_##x);      \
                rwlock_init(&rwlock_##x);       \
                mutex_init(&mutex_##x);         \
                init_rwsem(&rwsem_##x);         \
@@ -2005,10 +2006,23 @@ static void ww_test_edeadlk_acquire_wrong_slow(void)
 
 static void ww_test_spin_nest_unlocked(void)
 {
-       raw_spin_lock_nest_lock(&lock_A, &o.base);
+       spin_lock_nest_lock(&lock_A, &o.base);
        U(A);
 }
 
+/* This is not a deadlock, because we have X1 to serialize Y1 and Y2 */
+static void ww_test_spin_nest_lock(void)
+{
+       spin_lock(&lock_X1);
+       spin_lock_nest_lock(&lock_Y1, &lock_X1);
+       spin_lock(&lock_A);
+       spin_lock_nest_lock(&lock_Y2, &lock_X1);
+       spin_unlock(&lock_A);
+       spin_unlock(&lock_Y2);
+       spin_unlock(&lock_Y1);
+       spin_unlock(&lock_X1);
+}
+
 static void ww_test_unneeded_slow(void)
 {
        WWAI(&t);
@@ -2226,6 +2240,10 @@ static void ww_tests(void)
        dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);
        pr_cont("\n");
 
+       print_testname("spinlock nest test");
+       dotest(ww_test_spin_nest_lock, SUCCESS, LOCKTYPE_WW);
+       pr_cont("\n");
+
        printk("  -----------------------------------------------------\n");
        printk("                                 |block | try  |context|\n");
        printk("  -----------------------------------------------------\n");
@@ -2357,6 +2375,50 @@ static void queued_read_lock_tests(void)
        pr_cont("\n");
 }
 
+static void fs_reclaim_correct_nesting(void)
+{
+       fs_reclaim_acquire(GFP_KERNEL);
+       might_alloc(GFP_NOFS);
+       fs_reclaim_release(GFP_KERNEL);
+}
+
+static void fs_reclaim_wrong_nesting(void)
+{
+       fs_reclaim_acquire(GFP_KERNEL);
+       might_alloc(GFP_KERNEL);
+       fs_reclaim_release(GFP_KERNEL);
+}
+
+static void fs_reclaim_protected_nesting(void)
+{
+       unsigned int flags;
+
+       fs_reclaim_acquire(GFP_KERNEL);
+       flags = memalloc_nofs_save();
+       might_alloc(GFP_KERNEL);
+       memalloc_nofs_restore(flags);
+       fs_reclaim_release(GFP_KERNEL);
+}
+
+static void fs_reclaim_tests(void)
+{
+       printk("  --------------------\n");
+       printk("  | fs_reclaim tests |\n");
+       printk("  --------------------\n");
+
+       print_testname("correct nesting");
+       dotest(fs_reclaim_correct_nesting, SUCCESS, 0);
+       pr_cont("\n");
+
+       print_testname("wrong nesting");
+       dotest(fs_reclaim_wrong_nesting, FAILURE, 0);
+       pr_cont("\n");
+
+       print_testname("protected nesting");
+       dotest(fs_reclaim_protected_nesting, SUCCESS, 0);
+       pr_cont("\n");
+}
+
 void locking_selftest(void)
 {
        /*
@@ -2478,6 +2540,8 @@ void locking_selftest(void)
        if (IS_ENABLED(CONFIG_QUEUED_RWLOCKS))
                queued_read_lock_tests();
 
+       fs_reclaim_tests();
+
        if (unexpected_testcase_failures) {
                printk("-----------------------------------------------------------------\n");
                debug_locks = 0;