| 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: <20250527222254.565881-11-lyude@redhat.com>
Date: Tue, 27 May 2025 18:21:51 -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: [RFC RESEND v10 10/14] rust: sync: lock/global: Rename B to G in trait bounds
Due to the introduction of Backend::BackendInContext, if we want to be able
support Lock types with a Context we need to be able to handle the fact
that the Backend for a returned Guard may not exactly match the Backend for
the lock. Before we add this though, rename B to G in all of our trait
bounds to make sure things don't become more difficult to understand once
we add a Backend bound.
There should be no functional changes in this patch.
Signed-off-by: Lyude Paul <lyude@...hat.com>
---
rust/kernel/sync/lock/global.rs | 56 ++++++++++++++++-----------------
1 file changed, 28 insertions(+), 28 deletions(-)
diff --git a/rust/kernel/sync/lock/global.rs b/rust/kernel/sync/lock/global.rs
index 45400824b0940..37209882e006b 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<'a, B: GlobalLockBackend> GlobalLock<B> {
+impl<'a, 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<'static, 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<'static, 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<'static, B>> {
/// A guard for a [`GlobalLock`].
///
/// See [`global_lock!`] for examples.
-pub struct GlobalGuard<'a, B: GlobalLockBackend> {
- inner: Guard<'a, B::Item, B::Backend>,
+pub struct GlobalGuard<'a, G: GlobalLockBackend> {
+ inner: Guard<'a, G::Item, G::Backend>,
}
-impl<'a, B: GlobalLockBackend> core::ops::Deref for GlobalGuard<'a, 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<'a, B: GlobalLockBackend> core::ops::DerefMut for GlobalGuard<'a, 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() }
}
--
2.49.0
Powered by blists - more mailing lists