rust: lockdep: Use Pin for all LockClassKey usages (f73ca66f) · Commits · git / linux-net

rust/helpers/helpers.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@
		#include "signal.c"
		#include "slab.c"
		#include "spinlock.c"
		#include "sync.c"
		#include "task.c"
		#include "uaccess.c"
		#include "vmalloc.c"

rust/helpers/sync.c

0 → 100644

+13 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0

		#include <linux/lockdep.h>

		void rust_helper_lockdep_register_key(struct lock_class_key *k)
		{
		lockdep_register_key(k);
		}

		void rust_helper_lockdep_unregister_key(struct lock_class_key *k)
		{
		lockdep_unregister_key(k);
		}

rust/kernel/sync.rs

+54 −3

Original line number	Diff line number	Diff line
		@@ -5,6 +5,8 @@
		//! This module contains the kernel APIs related to synchronisation that have been ported or
		//! wrapped for usage by Rust code in the kernel.

		use crate::pin_init;
		use crate::prelude::*;
		use crate::types::Opaque;

		mod arc;
		@@ -23,15 +25,64 @@

		/// Represents a lockdep class. It's a wrapper around C's `lock_class_key`.
		#[repr(transparent)]
		pub struct LockClassKey(Opaque<bindings::lock_class_key>);
		#[pin_data(PinnedDrop)]
		pub struct LockClassKey {
		#[pin]
		inner: Opaque<bindings::lock_class_key>,
		}

		// SAFETY: `bindings::lock_class_key` is designed to be used concurrently from multiple threads and
		// provides its own synchronization.
		unsafe impl Sync for LockClassKey {}

		impl LockClassKey {
		/// Initializes a dynamically allocated lock class key. In the common case of using a
		/// statically allocated lock class key, the static_lock_class! macro should be used instead.
		///
		/// # Example
		/// ```
		/// # use kernel::{c_str, stack_pin_init};
		/// # use kernel::alloc::KBox;
		/// # use kernel::types::ForeignOwnable;
		/// # use kernel::sync::{LockClassKey, SpinLock};
		///
		/// let key = KBox::pin_init(LockClassKey::new_dynamic(), GFP_KERNEL)?;
		/// let key_ptr = key.into_foreign();
		///
		/// {
		/// stack_pin_init!(let num: SpinLock<u32> = SpinLock::new(
		/// 0,
		/// c_str!("my_spinlock"),
		/// // SAFETY: `key_ptr` is returned by the above `into_foreign()`, whose
		/// // `from_foreign()` has not yet been called.
		/// unsafe { <Pin<KBox<LockClassKey>> as ForeignOwnable>::borrow(key_ptr) }
		/// ));
		/// }
		///
		/// // SAFETY: We dropped `num`, the only use of the key, so the result of the previous
		/// // `borrow` has also been dropped. Thus, it's safe to use from_foreign.
		/// unsafe { drop(<Pin<KBox<LockClassKey>> as ForeignOwnable>::from_foreign(key_ptr)) };
		///
		/// # Ok::<(), Error>(())
		/// ```
		pub fn new_dynamic() -> impl PinInit<Self> {
		pin_init!(Self {
		// SAFETY: lockdep_register_key expects an uninitialized block of memory
		inner <- Opaque::ffi_init(\|slot\| unsafe { bindings::lockdep_register_key(slot) })
		})
		}

		pub(crate) fn as_ptr(&self) -> *mut bindings::lock_class_key {
		self.0.get()
		self.inner.get()
		}
		}

		#[pinned_drop]
		impl PinnedDrop for LockClassKey {
		fn drop(self: Pin<&mut Self>) {
		// SAFETY: self.as_ptr was registered with lockdep and self is pinned, so the address
		// hasn't changed. Thus, it's safe to pass to unregister.
		unsafe { bindings::lockdep_unregister_key(self.as_ptr()) }
		}
		}

		@@ -44,7 +95,7 @@ macro_rules! static_lock_class {
		// SAFETY: lockdep expects uninitialized memory when it's handed a statically allocated
		// lock_class_key
		unsafe { ::core::mem::MaybeUninit::uninit().assume_init() };
		&CLASS
		$crate::prelude::Pin::static_ref(&CLASS)
		}};
		}

rust/kernel/sync/condvar.rs

+2 −3

Original line number	Diff line number	Diff line
		@@ -17,8 +17,7 @@
		time::Jiffies,
		types::Opaque,
		};
		use core::marker::PhantomPinned;
		use core::ptr;
		use core::{marker::PhantomPinned, pin::Pin, ptr};
		use macros::pin_data;

		/// Creates a [`CondVar`] initialiser with the given name and a newly-created lock class.
		@@ -103,7 +102,7 @@ unsafe impl Sync for CondVar {}

		impl CondVar {
		/// Constructs a new condvar initialiser.
		pub fn new(name: &'static CStr, key: &'static LockClassKey) -> impl PinInit<Self> {
		pub fn new(name: &'static CStr, key: Pin<&'static LockClassKey>) -> impl PinInit<Self> {
		pin_init!(Self {
		_pin: PhantomPinned,
		// SAFETY: `slot` is valid while the closure is called and both `name` and `key` have

rust/kernel/sync/lock.rs

+2 −2

Original line number	Diff line number	Diff line
		@@ -12,7 +12,7 @@
		str::CStr,
		types::{NotThreadSafe, Opaque, ScopeGuard},
		};
		use core::{cell::UnsafeCell, marker::PhantomPinned};
		use core::{cell::UnsafeCell, marker::PhantomPinned, pin::Pin};
		use macros::pin_data;

		pub mod mutex;
		@@ -129,7 +129,7 @@ unsafe impl<T: ?Sized + Send, B: Backend> Sync for Lock<T, B> {}

		impl<T, B: Backend> Lock<T, B> {
		/// Constructs a new lock initialiser.
		pub fn new(t: T, name: &'static CStr, key: &'static LockClassKey) -> impl PinInit<Self> {
		pub fn new(t: T, name: &'static CStr, key: Pin<&'static LockClassKey>) -> impl PinInit<Self> {
		pin_init!(Self {
		data: UnsafeCell::new(t),
		_pin: PhantomPinned,