Re: [PATCH v1] rust: sync: atomic: Add i32-backed Flag for atomic booleans

[Gary Guo <gary@garyguo.net>]

On Thu,  1 Jan 2026 19:27:18 +0900
FUJITA Tomonori <fujita.tomonori@gmail.com> wrote:

> Add a new Flag enum (Clear/Set) with #[repr(i32)] and implement
> AtomicType for it, so users can use Atomic<Flag> for boolean flags.
> 
> Document when Atomic<Flag> is generally preferable to Atomic<bool>: in
> particular, when RMW operations such as xchg()/cmpxchg() may be used
> and minimizing memory usage is not the top priority. On some
> architectures without byte-sized RMW instructions, Atomic<bool> can be
> slower for RMW operations.
> 
> Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
> ---
>  rust/kernel/sync/atomic.rs | 35 +++++++++++++++++++++++++++++++++++
>  1 file changed, 35 insertions(+)
> 
> diff --git a/rust/kernel/sync/atomic.rs b/rust/kernel/sync/atomic.rs
> index 4aebeacb961a..d98ab51ae4fc 100644
> --- a/rust/kernel/sync/atomic.rs
> +++ b/rust/kernel/sync/atomic.rs
> @@ -560,3 +560,38 @@ pub fn fetch_add<Rhs, Ordering: ordering::Ordering>(&self, v: Rhs, _: Ordering)
>          unsafe { from_repr(ret) }
>      }
>  }
> +
> +/// An atomic flag type backed by `i32`.

I would recommend that we document that the backing type is the
(perf-)optimal type on the target architecure, so arch can decide to use
i8 as backing type if they prefer.

> +///
> +/// `Atomic<Flag>` is generally preferable when you need an atomic boolean and you may use
> +/// read-modify-write operations (e.g. `xchg()`/`cmpxchg()`), and when minimizing memory usage is
> +/// not the top priority.
> +///
> +/// `Atomic<bool>` is backed by `u8`. On some architectures that do not support byte-sized RMW
> +/// instructions, this can make RMW operations slower.
> +///
> +/// If you only use `load()`/`store()`, either `Atomic<bool>` or `Atomic<Flag>` is fine.
> +///
> +/// ## Examples
> +///
> +/// ```
> +/// use kernel::sync::atomic::{Atomic, Flag, Relaxed};
> +/// let flag = Atomic::new(Flag::Clear);
> +/// assert_eq!(Flag::Clear, flag.load(Relaxed));
> +/// flag.store(Flag::Set, Relaxed);
> +/// assert_eq!(Flag::Set, flag.load(Relaxed));
> +/// ```
> +#[derive(Clone, Copy, PartialEq, Eq)]
> +#[repr(i32)]
> +pub enum Flag {
> +    /// The flag is clear.
> +    Clear = 0,
> +    /// The flag is set.
> +    Set = 1,
> +}

Maybe add `From` impls that convert this type to boolean?

Best,
Gary

> +
> +// SAFETY: `Flag` and `i32` has the same size and alignment, and it's round-trip
> +// transmutable to `i32`.
> +unsafe impl AtomicType for Flag {
> +    type Repr = i32;
> +}
> 
> base-commit: dafb6d4cabd044ccd7e49cea29363e8526edc071