[DRAFT 2/2] locking/selftest: Add AA deadlock selftest for Mutex and SpinLock

[Boqun Feng <boqun.feng@gmail.com>]

Signed-off-by: Boqun Feng <boqun.feng@gmail.com>
---
 lib/locking-selftest.c       |  3 +-
 lib/rust_locking_selftest.rs | 99 ++++++++++++++++++++++++++++++++++++
 2 files changed, 101 insertions(+), 1 deletion(-)

diff --git a/lib/locking-selftest.c b/lib/locking-selftest.c
index 9ef3ad92bc47..a4830e3cc998 100644
--- a/lib/locking-selftest.c
+++ b/lib/locking-selftest.c
@@ -60,6 +60,7 @@ __setup("debug_locks_verbose=", setup_debug_locks_verbose);
 #define LOCKTYPE_RTMUTEX 0x20
 #define LOCKTYPE_LL	0x40
 #define LOCKTYPE_SPECIAL 0x80
+#define LOCKTYPE_RUST	0x100
 
 static struct ww_acquire_ctx t, t2;
 static struct ww_mutex o, o2, o3;
@@ -1427,7 +1428,7 @@ static int testcase_successes;
 static int expected_testcase_failures;
 static int unexpected_testcase_failures;
 
-static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
+void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
 {
 	int saved_preempt_count = preempt_count();
 #ifdef CONFIG_PREEMPT_RT
diff --git a/lib/rust_locking_selftest.rs b/lib/rust_locking_selftest.rs
index 61560a2f3c6b..c050edf2ac9a 100644
--- a/lib/rust_locking_selftest.rs
+++ b/lib/rust_locking_selftest.rs
@@ -2,11 +2,110 @@
 
 //! Selftests for Rust locking APIs.
 
+use kernel::pr_cont;
 use kernel::prelude::*;
 const __LOG_PREFIX: &[u8] = b"locking selftest\0";
 
+extern "C" {
+    fn dotest(
+        testcase_fn: extern "C" fn(),
+        expected: core::ffi::c_int,
+        lockclass_mask: core::ffi::c_int,
+    );
+}
+
+/// Same as the definition in lib/locking-selftest.c
+#[allow(dead_code)]
+enum Expectation {
+    Failure = 0,
+    Success = 1,
+    Timeout = 2,
+}
+
+trait LockTest {
+    const EXPECTED: Expectation;
+    const MASK: i32;
+
+    fn test();
+}
+
+extern "C" fn bridge<T: LockTest>() {
+    T::test();
+}
+
+fn test<T: LockTest>() {
+    pr_cont!("\n");
+    pr_cont!("{}: ", core::any::type_name::<T>());
+    unsafe {
+        dotest(bridge::<T>, T::EXPECTED as core::ffi::c_int, T::MASK);
+    }
+    pr_cont!("\n");
+}
+
+struct SpinLockAATest;
+
+impl LockTest for SpinLockAATest {
+    const EXPECTED: Expectation = Expectation::Failure;
+    const MASK: i32 = 0x100; // TODO
+
+    fn test() {
+        use kernel::static_lock_class;
+        use kernel::sync::SpinLock;
+        use kernel::{c_str, stack_pin_init};
+
+        let key = static_lock_class!();
+        let name = c_str!("A1");
+
+        stack_pin_init!(
+            let a1 = SpinLock::new(0, name, key)
+        );
+
+        stack_pin_init!(
+            let a2 = SpinLock::new(0, name, key)
+        );
+
+        let a1 = a1.unwrap();
+        let a2 = a2.unwrap();
+
+        let _x = a1.lock();
+        let _y = a2.lock();
+    }
+}
+
+struct MutexAATest;
+
+impl LockTest for MutexAATest {
+    const EXPECTED: Expectation = Expectation::Failure;
+    const MASK: i32 = 0x100; // TODO
+
+    fn test() {
+        use kernel::static_lock_class;
+        use kernel::sync::Mutex;
+        use kernel::{c_str, stack_pin_init};
+
+        let key = static_lock_class!();
+        let name = c_str!("A1");
+
+        stack_pin_init!(
+            let a1 = Mutex::new(0, name, key)
+        );
+
+        stack_pin_init!(
+            let a2 = Mutex::new(0, name, key)
+        );
+
+        let a1 = a1.unwrap();
+        let a2 = a2.unwrap();
+
+        let _x = a1.lock();
+        let _y = a2.lock();
+    }
+}
+
 /// Entry point for tests.
 #[no_mangle]
 pub extern "C" fn rust_locking_test() {
     pr_info!("Selftests for Rust locking APIs");
+    test::<SpinLockAATest>();
+    test::<MutexAATest>();
 }
-- 
2.39.2