Re: [PATCH v6 4/9] rust: sync: atomic: Add generic atomics

Boqun Feng
2025-07-11T13:58:46Z

On Fri, Jul 11, 2025 at 10:03:07AM +0200, Benno Lossin wrote:
> On Thu Jul 10, 2025 at 8:00 AM CEST, Boqun Feng wrote:
> > diff --git a/rust/kernel/sync/atomic/generic.rs b/rust/kernel/sync/atomic/generic.rs
> > new file mode 100644
> > index 000000000000..e044fe21b128
> > --- /dev/null
> > +++ b/rust/kernel/sync/atomic/generic.rs
> > @@ -0,0 +1,289 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +
> > +//! Generic atomic primitives.
> > +
> > +use super::ops::*;
> > +use super::ordering::*;
> > +use crate::build_error;
> > +use core::cell::UnsafeCell;
> > +
> > +/// A generic atomic variable.
[...]
>
> > +///
> > +/// # Guarantees
> > +///
> > +/// Doing an atomic operation while holding a reference of [`Self`] won't cause a data race,
> > +/// this is guaranteed by the safety requirement of [`Self::from_ptr()`] and the extra safety
> > +/// requirement of the usage on pointers returned by [`Self::as_ptr()`].
>
> I'd rather think we turn this into an invariant that says any operations
> on `self.0` through a shared reference is atomic.
>
[...]
> > +/// unit-only enums:
>
> What are "unit-only" enums? Do you mean enums that don't have associated
> data?
>

Yes, I used the term mentioned at:

https://doc.rust-lang.org/reference/items/enumerations.html#r-items.enum.unit-only

> > +///
> > +/// ```
> > +/// #[repr(i32)]
> > +/// enum State { Init = 0, Working = 1, Done = 2, }
> > +/// ```
> > +///
> > +/// # Safety
> > +///
> > +/// - [`Self`] must have the same size and alignment as [`Self::Repr`].
> > +/// - [`Self`] and [`Self::Repr`] must have the [round-trip transmutability].
[...]
> > + let a = self.as_ptr().cast::<T::Repr>();
> > +
> > + // SAFETY:
> > + // - For calling the atomic_read*() function:
> > + // - `a` is a valid pointer for the function per the CAST justification above.
> > + // - Per the type guarantees, the following atomic operation won't cause data races.
>
> Which type guarantees? `Self`?
>

The above "# Guarantees" of `Atomic<T>`, but yeah I think it should be
"# Invariants".

> > + // - For extra safety requirement of usage on pointers returned by `self.as_ptr()`:
> > + // - Atomic operations are used here.
> > + let v = unsafe {
> > + match Ordering::TYPE {
> > + OrderingType::Relaxed => T::Repr::atomic_read(a),
> > + OrderingType::Acquire => T::Repr::atomic_read_acquire(a),
> > + _ => build_error!("Wrong ordering"),
> > + }
> > + };
> > +
> > + // SAFETY: The atomic variable holds a valid `T`, so `v` is a valid bit pattern of `T`,
> > + // therefore it's safe to call `from_repr()`. …