| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20250717184055.2071216-11-lyude@redhat.com>
Date: Thu, 17 Jul 2025 14:38:02 -0400
From: Lyude Paul <lyude@...hat.com>
To: rust-for-linux@...r.kernel.org,
Thomas Gleixner <tglx@...utronix.de>,
Boqun Feng <boqun.feng@...il.com>,
linux-kernel@...r.kernel.org,
Daniel Almeida <daniel.almeida@...labora.com>
Cc: Peter Zijlstra <peterz@...radead.org>,
Ingo Molnar <mingo@...hat.com>,
Will Deacon <will@...nel.org>,
Waiman Long <longman@...hat.com>,
Miguel Ojeda <ojeda@...nel.org>,
Alex Gaynor <alex.gaynor@...il.com>,
Gary Guo <gary@...yguo.net>,
Björn Roy Baron <bjorn3_gh@...tonmail.com>,
Benno Lossin <lossin@...nel.org>,
Andreas Hindborg <a.hindborg@...nel.org>,
Alice Ryhl <aliceryhl@...gle.com>,
Trevor Gross <tmgross@...ch.edu>,
Danilo Krummrich <dakr@...nel.org>
Subject: [PATCH v11 10/14] rust: sync: Add a lifetime parameter to lock::global::GlobalGuard
While a GlobalLock is always going to be static, in the case of locks with
explicit backend contexts the GlobalGuard will not be 'static and will
instead share the lifetime of the context. So, add a lifetime parameter to
GlobalGuard to allow for this so we can implement GlobalGuard support for
SpinlockIrq.
Signed-off-by: Lyude Paul <lyude@...hat.com>
---
rust/kernel/sync/lock/global.rs | 58 ++++++++++++++++-----------------
1 file changed, 29 insertions(+), 29 deletions(-)
diff --git a/rust/kernel/sync/lock/global.rs b/rust/kernel/sync/lock/global.rs
index 47e200b750c1d..f846ecf9168e7 100644
--- a/rust/kernel/sync/lock/global.rs
+++ b/rust/kernel/sync/lock/global.rs
@@ -33,18 +33,18 @@ pub trait GlobalLockBackend {
/// Type used for global locks.
///
/// See [`global_lock!`] for examples.
-pub struct GlobalLock<B: GlobalLockBackend> {
- inner: Lock<B::Item, B::Backend>,
+pub struct GlobalLock<G: GlobalLockBackend> {
+ inner: Lock<G::Item, G::Backend>,
}
-impl<B: GlobalLockBackend> GlobalLock<B> {
+impl<G: GlobalLockBackend> GlobalLock<G> {
/// Creates a global lock.
///
/// # Safety
///
/// * Before any other method on this lock is called, [`Self::init`] must be called.
- /// * The type `B` must not be used with any other lock.
- pub const unsafe fn new(data: B::Item) -> Self {
+ /// * The type `G` must not be used with any other lock.
+ pub const unsafe fn new(data: G::Item) -> Self {
Self {
inner: Lock {
state: Opaque::uninit(),
@@ -68,23 +68,23 @@ pub unsafe fn init(&'static self) {
// `init` before using any other methods. As `init` can only be called once, all other
// uses of this lock must happen after this call.
unsafe {
- B::Backend::init(
+ G::Backend::init(
self.inner.state.get(),
- B::NAME.as_char_ptr(),
- B::get_lock_class().as_ptr(),
+ G::NAME.as_char_ptr(),
+ G::get_lock_class().as_ptr(),
)
}
}
/// Lock this global lock.
- pub fn lock(&'static self) -> GlobalGuard<B> {
+ pub fn lock(&'static self) -> GlobalGuard<'static, G> {
GlobalGuard {
inner: self.inner.lock(),
}
}
/// Try to lock this global lock.
- pub fn try_lock(&'static self) -> Option<GlobalGuard<B>> {
+ pub fn try_lock(&'static self) -> Option<GlobalGuard<'static, G>> {
Some(GlobalGuard {
inner: self.inner.try_lock()?,
})
@@ -94,19 +94,19 @@ pub fn try_lock(&'static self) -> Option<GlobalGuard<B>> {
/// A guard for a [`GlobalLock`].
///
/// See [`global_lock!`] for examples.
-pub struct GlobalGuard<B: GlobalLockBackend> {
- inner: Guard<'static, B::Item, B::Backend>,
+pub struct GlobalGuard<'a, G: GlobalLockBackend> {
+ inner: Guard<'a, G::Item, G::Backend>,
}
-impl<B: GlobalLockBackend> core::ops::Deref for GlobalGuard<B> {
- type Target = B::Item;
+impl<'a, G: GlobalLockBackend> core::ops::Deref for GlobalGuard<'a, G> {
+ type Target = G::Item;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
-impl<B: GlobalLockBackend> core::ops::DerefMut for GlobalGuard<B> {
+impl<'a, G: GlobalLockBackend> core::ops::DerefMut for GlobalGuard<'a, G> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
@@ -115,33 +115,33 @@ fn deref_mut(&mut self) -> &mut Self::Target {
/// A version of [`LockedBy`] for a [`GlobalLock`].
///
/// See [`global_lock!`] for examples.
-pub struct GlobalLockedBy<T: ?Sized, B: GlobalLockBackend> {
- _backend: PhantomData<B>,
+pub struct GlobalLockedBy<T: ?Sized, G: GlobalLockBackend> {
+ _backend: PhantomData<G>,
value: UnsafeCell<T>,
}
// SAFETY: The same thread-safety rules as `LockedBy` apply to `GlobalLockedBy`.
-unsafe impl<T, B> Send for GlobalLockedBy<T, B>
+unsafe impl<T, G> Send for GlobalLockedBy<T, G>
where
T: ?Sized,
- B: GlobalLockBackend,
- LockedBy<T, B::Item>: Send,
+ G: GlobalLockBackend,
+ LockedBy<T, G::Item>: Send,
{
}
// SAFETY: The same thread-safety rules as `LockedBy` apply to `GlobalLockedBy`.
-unsafe impl<T, B> Sync for GlobalLockedBy<T, B>
+unsafe impl<T, G> Sync for GlobalLockedBy<T, G>
where
T: ?Sized,
- B: GlobalLockBackend,
- LockedBy<T, B::Item>: Sync,
+ G: GlobalLockBackend,
+ LockedBy<T, G::Item>: Sync,
{
}
-impl<T, B: GlobalLockBackend> GlobalLockedBy<T, B> {
+impl<T, G: GlobalLockBackend> GlobalLockedBy<T, G> {
/// Create a new [`GlobalLockedBy`].
///
- /// The provided value will be protected by the global lock indicated by `B`.
+ /// The provided value will be protected by the global lock indicated by `G`.
pub fn new(val: T) -> Self {
Self {
value: UnsafeCell::new(val),
@@ -150,11 +150,11 @@ pub fn new(val: T) -> Self {
}
}
-impl<T: ?Sized, B: GlobalLockBackend> GlobalLockedBy<T, B> {
+impl<T: ?Sized, G: GlobalLockBackend> GlobalLockedBy<T, G> {
/// Access the value immutably.
///
/// The caller must prove shared access to the lock.
- pub fn as_ref<'a>(&'a self, _guard: &'a GlobalGuard<B>) -> &'a T {
+ pub fn as_ref<'a>(&'a self, _guard: &'a GlobalGuard<'_, G>) -> &'a T {
// SAFETY: The lock is globally unique, so there can only be one guard.
unsafe { &*self.value.get() }
}
@@ -162,7 +162,7 @@ pub fn as_ref<'a>(&'a self, _guard: &'a GlobalGuard<B>) -> &'a T {
/// Access the value mutably.
///
/// The caller must prove shared exclusive to the lock.
- pub fn as_mut<'a>(&'a self, _guard: &'a mut GlobalGuard<B>) -> &'a mut T {
+ pub fn as_mut<'a>(&'a self, _guard: &'a mut GlobalGuard<'_, G>) -> &'a mut T {
// SAFETY: The lock is globally unique, so there can only be one guard.
unsafe { &mut *self.value.get() }
}
@@ -232,7 +232,7 @@ pub fn get_mut(&mut self) -> &mut T {
/// /// Increment the counter in this instance.
/// ///
/// /// The caller must hold the `MY_MUTEX` mutex.
-/// fn increment(&self, guard: &mut GlobalGuard<MY_MUTEX>) -> u32 {
+/// fn increment(&self, guard: &mut GlobalGuard<'_, MY_MUTEX>) -> u32 {
/// let my_counter = self.my_counter.as_mut(guard);
/// *my_counter += 1;
/// *my_counter
--
2.50.0
Powered by blists - more mailing lists