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(+)
@@ -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>
@@ -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
@@ -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()) };
+ }
+}