rust: lock: introduce `SpinLock` (c6d917a4) · Commits · EulixOS / Software / Kernel

rust/helpers.c

+24 −0

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include <linux/err.h>
		#include <linux/refcount.h>
		#include <linux/mutex.h>
		#include <linux/spinlock.h>

		__noreturn void rust_helper_BUG(void)
		{
		@@ -36,6 +37,29 @@ void rust_helper_mutex_lock(struct mutex *lock)
		}
		EXPORT_SYMBOL_GPL(rust_helper_mutex_lock);

		void rust_helper___spin_lock_init(spinlock_t lock, const char name,
		struct lock_class_key *key)
		{
		#ifdef CONFIG_DEBUG_SPINLOCK
		__raw_spin_lock_init(spinlock_check(lock), name, key, LD_WAIT_CONFIG);
		#else
		spin_lock_init(lock);
		#endif
		}
		EXPORT_SYMBOL_GPL(rust_helper___spin_lock_init);

		void rust_helper_spin_lock(spinlock_t *lock)
		{
		spin_lock(lock);
		}
		EXPORT_SYMBOL_GPL(rust_helper_spin_lock);

		void rust_helper_spin_unlock(spinlock_t *lock)
		{
		spin_unlock(lock);
		}
		EXPORT_SYMBOL_GPL(rust_helper_spin_unlock);

		refcount_t rust_helper_REFCOUNT_INIT(int n)
		{
		return (refcount_t)REFCOUNT_INIT(n);

rust/kernel/sync.rs

+1 −1

Original line number	Diff line number	Diff line
		@@ -11,7 +11,7 @@ mod arc;
		pub mod lock;

		pub use arc::{Arc, ArcBorrow, UniqueArc};
		pub use lock::mutex::Mutex;
		pub use lock::{mutex::Mutex, spinlock::SpinLock};

		/// Represents a lockdep class. It's a wrapper around C's `lock_class_key`.
		#[repr(transparent)]

rust/kernel/sync/lock.rs

+1 −0

Original line number	Diff line number	Diff line
		@@ -11,6 +11,7 @@ use core::{cell::UnsafeCell, marker::PhantomData, marker::PhantomPinned};
		use macros::pin_data;

		pub mod mutex;
		pub mod spinlock;

		/// The "backend" of a lock.
		///

rust/kernel/sync/lock/spinlock.rs

0 → 100644

+116 −0

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

		//! A kernel spinlock.
		//!
		//! This module allows Rust code to use the kernel's `spinlock_t`.

		use crate::bindings;

		/// Creates a [`SpinLock`] initialiser with the given name and a newly-created lock class.
		///
		/// It uses the name if one is given, otherwise it generates one based on the file name and line
		/// number.
		#[macro_export]
		macro_rules! new_spinlock {
		($inner:expr $(, $name:literal)? $(,)?) => {
		$crate::sync::SpinLock::new(
		$inner, $crate::optional_name!($($name)?), $crate::static_lock_class!())
		};
		}

		/// A spinlock.
		///
		/// Exposes the kernel's [`spinlock_t`]. When multiple CPUs attempt to lock the same spinlock, only
		/// one at a time is allowed to progress, the others will block (spinning) until the spinlock is
		/// unlocked, at which point another CPU will be allowed to make progress.
		///
		/// Instances of [`SpinLock`] need a lock class and to be pinned. The recommended way to create such
		/// instances is with the [`pin_init`](crate::pin_init) and [`new_spinlock`] macros.
		///
		/// # Examples
		///
		/// The following example shows how to declare, allocate and initialise a struct (`Example`) that
		/// contains an inner struct (`Inner`) that is protected by a spinlock.
		///
		/// ```
		/// use kernel::{init::InPlaceInit, init::PinInit, new_spinlock, pin_init, sync::SpinLock};
		///
		/// struct Inner {
		/// a: u32,
		/// b: u32,
		/// }
		///
		/// #[pin_data]
		/// struct Example {
		/// c: u32,
		/// #[pin]
		/// d: SpinLock<Inner>,
		/// }
		///
		/// impl Example {
		/// fn new() -> impl PinInit<Self> {
		/// pin_init!(Self {
		/// c: 10,
		/// d <- new_spinlock!(Inner { a: 20, b: 30 }),
		/// })
		/// }
		/// }
		///
		/// // Allocate a boxed `Example`.
		/// let e = Box::pin_init(Example::new())?;
		/// assert_eq!(e.c, 10);
		/// assert_eq!(e.d.lock().a, 20);
		/// assert_eq!(e.d.lock().b, 30);
		/// ```
		///
		/// The following example shows how to use interior mutability to modify the contents of a struct
		/// protected by a spinlock despite only having a shared reference:
		///
		/// ```
		/// use kernel::sync::SpinLock;
		///
		/// struct Example {
		/// a: u32,
		/// b: u32,
		/// }
		///
		/// fn example(m: &SpinLock<Example>) {
		/// let mut guard = m.lock();
		/// guard.a += 10;
		/// guard.b += 20;
		/// }
		/// ```
		///
		/// [`spinlock_t`]: ../../../../include/linux/spinlock.h
		pub type SpinLock<T> = super::Lock<T, SpinLockBackend>;

		/// A kernel `spinlock_t` lock backend.
		pub struct SpinLockBackend;

		// SAFETY: The underlying kernel `spinlock_t` object ensures mutual exclusion.
		unsafe impl super::Backend for SpinLockBackend {
		type State = bindings::spinlock_t;
		type GuardState = ();

		unsafe fn init(
		ptr: *mut Self::State,
		name: *const core::ffi::c_char,
		key: *mut bindings::lock_class_key,
		) {
		// SAFETY: The safety requirements ensure that `ptr` is valid for writes, and `name` and
		// `key` are valid for read indefinitely.
		unsafe { bindings::__spin_lock_init(ptr, name, key) }
		}

		unsafe fn lock(ptr: *mut Self::State) -> Self::GuardState {
		// SAFETY: The safety requirements of this function ensure that `ptr` points to valid
		// memory, and that it has been initialised before.
		unsafe { bindings::spin_lock(ptr) }
		}

		unsafe fn unlock(ptr: *mut Self::State, _guard_state: &Self::GuardState) {
		// SAFETY: The safety requirements of this function ensure that `ptr` is valid and that the
		// caller is the owner of the mutex.
		unsafe { bindings::spin_unlock(ptr) }
		}
		}