mirror of
https://github.com/torvalds/linux.git
synced 2025-11-03 01:59:51 +02:00
8eea62ff94
Add support for creating global variables that are wrapped in a mutex or spinlock. The implementation here is intended to replace the global mutex workaround found in the Rust Binder RFC [1]. In both cases, the global lock must be initialized before first use. The macro is unsafe to use for the same reason. The separate initialization step is required because it is tricky to access the value of __ARCH_SPIN_LOCK_UNLOCKED from Rust. Doing so will require changes to the C side. That change will happen as a follow-up to this patch. Link: https://lore.kernel.org/rust-for-linux/20231101-rust-binder-v1-2-08ba9197f637@google.com/#Z31drivers:android:context.rs [1] Signed-off-by: Alice Ryhl <aliceryhl@google.com> Reviewed-by: Boqun Feng <boqun.feng@gmail.com> Link: https://lore.kernel.org/r/20241023-static-mutex-v6-1-d7efdadcc84f@google.com [ Simplified a few intra-doc links. Formatted a few comments. Reworded title. - Miguel ] Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
68 lines
1.8 KiB
Rust
68 lines
1.8 KiB
Rust
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
//! Synchronisation primitives.
|
|
//!
|
|
//! 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::types::Opaque;
|
|
|
|
mod arc;
|
|
mod condvar;
|
|
pub mod lock;
|
|
mod locked_by;
|
|
|
|
pub use arc::{Arc, ArcBorrow, UniqueArc};
|
|
pub use condvar::{new_condvar, CondVar, CondVarTimeoutResult};
|
|
pub use lock::global::{global_lock, GlobalGuard, GlobalLock, GlobalLockBackend, GlobalLockedBy};
|
|
pub use lock::mutex::{new_mutex, Mutex};
|
|
pub use lock::spinlock::{new_spinlock, SpinLock};
|
|
pub use locked_by::LockedBy;
|
|
|
|
/// Represents a lockdep class. It's a wrapper around C's `lock_class_key`.
|
|
#[repr(transparent)]
|
|
pub struct LockClassKey(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 {
|
|
/// Creates a new lock class key.
|
|
pub const fn new() -> Self {
|
|
Self(Opaque::uninit())
|
|
}
|
|
|
|
pub(crate) fn as_ptr(&self) -> *mut bindings::lock_class_key {
|
|
self.0.get()
|
|
}
|
|
}
|
|
|
|
impl Default for LockClassKey {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
/// Defines a new static lock class and returns a pointer to it.
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! static_lock_class {
|
|
() => {{
|
|
static CLASS: $crate::sync::LockClassKey = $crate::sync::LockClassKey::new();
|
|
&CLASS
|
|
}};
|
|
}
|
|
|
|
/// Returns the given string, if one is provided, otherwise generates one based on the source code
|
|
/// location.
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! optional_name {
|
|
() => {
|
|
$crate::c_str!(::core::concat!(::core::file!(), ":", ::core::line!()))
|
|
};
|
|
($name:literal) => {
|
|
$crate::c_str!($name)
|
|
};
|
|
}
|