[PATCH RFC 10/11] rust: sync: Add LockdepMap abstraction

Asahi Lina
2023-07-14T09:31:43Z

Add a simple abstraction for creating new lockdep maps. This allows
Rust code to explicitly integrate types with lockdep.

There's some voodoo compiler intrinsic magic to get the caller return
address on the C side. I have no idea how to plumb that through in Rust
if that's even possible, so let's just wrap it in a C helper for now.
That gives us the callsite from the Rust abstraction instead of its
user, but that's probably okay for now.

Signed-off-by: Asahi Lina <lina@asahilina.net>
---
rust/bindings/bindings_helper.h | 1 +
rust/helpers.c | 16 ++++++++++++++++
rust/kernel/sync/lockdep.rs | 40 ++++++++++++++++++++++++++++++++++++++++
3 files changed, 57 insertions(+)

diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index 52f32e423b04..5c28de44e528 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -8,6 +8,7 @@

#include <linux/errname.h>
#include <linux/slab.h>
+#include <linux/lockdep.h>
#include <linux/refcount.h>
#include <linux/wait.h>
#include <linux/siphash.h>
diff --git a/rust/helpers.c b/rust/helpers.c
index 1ed71315d1eb..392f5359677a 100644
--- a/rust/helpers.c
+++ b/rust/helpers.c
@@ -22,6 +22,8 @@
#include <linux/build_bug.h>
#include <linux/err.h>
#include <linux/errname.h>
+#include <linux/instruction_pointer.h>
+#include <linux/lockdep.h>
#include <linux/refcount.h>
#include <linux/mutex.h>
#include <linux/siphash.h>
@@ -143,6 +145,20 @@ u64 rust_helper_siphash(const void *data, size_t len,
}
EXPORT_SYMBOL_GPL(rust_helper_siphash);

+void rust_helper_lock_acquire_ret(struct lockdep_map *lock, unsigned int subclass,
+ int trylock, int read, int check,
+ struct lockdep_map *nest_lock)
+{
+ lock_acquire(lock, subclass, trylock, read, check, nest_lock, _RET_IP_);
+}
+EXPORT_SYMBOL_GPL(rust_helper_lock_acquire_ret);
+
+void rust_helper_lock_release_ret(struct lockdep_map *lock)
+{
+ lock_release(lock, _RET_IP_);
+}
+EXPORT_SYMBOL_GPL(rust_helper_lock_release_ret);
+
/*
* We use `bindgen`'s `--size_t-is-usize` option to bind the C `size_t` type
* as the Rust `usize` type, so we can use it in contexts where Rust
diff --git a/rust/kernel/sync/lockdep.rs b/rust/kernel/sync/lockdep.rs
index fbf9f6ed403d..ca32aa833e10 100644
--- a/rust/kernel/sync/lockdep.rs
+++ b/rust/kernel/sync/lockdep.rs
@@ -187,3 +187,43 @@ pub(crate) fn caller_lock_class() -> (LockClassKey, &'static CStr) {
}
}
}
+
+pub(crate) struct LockdepMap(Opaque<bindings::lockdep_map>);
+pub(crate) struct LockdepGuard<'a>(&'a LockdepMap);
+
+#[allow(dead_code)]
+impl LockdepMap {
+ #[track_caller]
+ pub(crate) fn new() -> Self {
+ let map = Opaque::uninit();
+ let (key, name) = caller_lock_class();
+
+ unsafe {
+ bindings::lockdep_init_map_type(
+ map.get(),
+ name.as_char_ptr(),
+ key.as_ptr(),
+ 0,
+ bindings::lockdep_wait_type_LD_WAIT_INV as _,
+ bindings::lockdep_wait_type_LD_WAIT_INV as _,
+ bindings::lockdep_lock_type_LD_LOCK_NORMAL as _,
+ )
+ };
+
+ LockdepMap(map)
+ }
+
+ #[inline(always)]
+ pub(crate) fn lock(&self) -> LockdepGuard<'_> {
+ unsafe { bindings::lock_acquire_ret(self.0.get(), 0, 0, 1, 1, core::ptr::null_mut()) };
+
+ LockdepGuard(self)
+ }
+}
+
+impl<'a> Drop for LockdepGuard<'a> {
+ #[inline(always)]
+ fn drop(&mut self) {
+ unsafe { bindings::lock_release_ret(self.0 .0.get()) };
+ }
+}

--
2.40.1