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@redhat.com>
---
rust/kernel/sync/atomic.rs | 2 +-
rust/kernel/sync/lock/global.rs | 58 ++++++++++++++++-----------------
2 files changed, 30 insertions(+), 30 deletions(-)
diff --git a/rust/kernel/sync/atomic.rs b/rust/kernel/sync/atomic.rs
index 3afc376be42d9..c07a53f8360b4 100644
--- a/rust/kernel/sync/atomic.rs
+++ b/rust/kernel/sync/atomic.rs
@@ -21,8 +21,8 @@
mod predefine;
pub use internal::AtomicImpl;
-pub use ordering::{Acquire, Full, Relaxed, Release};
pub(crate) use internal::{AtomicArithmeticOps, AtomicBasicOps, AtomicExchangeOps};
+pub use ordering::{Acquire, Full, Relaxed, Release};
use crate::build_error;
use internal::AtomicRepr;
diff --git a/rust/kernel/sync/lock/global.rs b/rust/kernel/sync/lock/global.rs
index 7030a47bc0ad1..06d62ad02f90d 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<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<G>> {
Some(GlobalGuard {
inner: self.inner.try_lock()?,
})
@@ -94,21 +94,21 @@ 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<G: GlobalLockBackend> {
+ inner: Guard<'static, G::Item, G::Backend>,
}
-impl<B: GlobalLockBackend> core::ops::Deref for GlobalGuard<B> {
- type Target = B::Item;
+impl<G: GlobalLockBackend> core::ops::Deref for GlobalGuard<G> {
+ type Target = G::Item;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
-impl<B: GlobalLockBackend> core::ops::DerefMut for GlobalGuard<B>
+impl<G: GlobalLockBackend> core::ops::DerefMut for GlobalGuard<G>
where
- B::Item: Unpin,
+ G::Item: Unpin,
{
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
@@ -118,33 +118,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),
@@ -153,11 +153,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() }
}
@@ -165,7 +165,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.52.0