Re: [PATCH v2 3/4] rust: sync: atomic: Add i8/i16 load and store support

["Alexandre Courbot" <acourbot@nvidia.com>]

On Mon Nov 17, 2025 at 9:10 AM JST, FUJITA Tomonori wrote:
> Add atomic operation support for i8 and i16 types using volatile
> read/write and smp_load_acquire/smp_store_release helpers.
>
> Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
> ---
>  rust/kernel/sync/atomic/internal.rs  | 48 ++++++++++++++++++++++++++++
>  rust/kernel/sync/atomic/predefine.rs | 14 +++++++-
>  2 files changed, 61 insertions(+), 1 deletion(-)
>
> diff --git a/rust/kernel/sync/atomic/internal.rs b/rust/kernel/sync/atomic/internal.rs
> index 6fdd8e59f45b..4c9f4f76dbdf 100644
> --- a/rust/kernel/sync/atomic/internal.rs
> +++ b/rust/kernel/sync/atomic/internal.rs
> @@ -263,3 +263,51 @@ fn fetch_add[acquire, release, relaxed](a: &AtomicRepr<Self>, v: Self::Delta) ->
>          }
>      }
>  );
> +
> +impl private::Sealed for i8 {}
> +impl private::Sealed for i16 {}
> +
> +impl AtomicImpl for i8 {
> +    type Delta = Self;
> +}
> +
> +impl AtomicImpl for i16 {
> +    type Delta = Self;
> +}

I'd suggest putting these next to the impls for `i32` and `i64`, for clarity.

> +
> +macro_rules! impl_atomic_only_load_and_store_ops {
> +    ($($ty:ty),* $(,)?) => {
> +        $(
> +            impl AtomicBasicOps for $ty {
> +                paste! {
> +                    #[inline(always)]
> +                    fn atomic_read(a: &AtomicRepr<Self>) -> Self {
> +                        // SAFETY: `a.as_ptr()` is valid and properly aligned.
> +                        unsafe { bindings::[< atomic_ $ty _load >](a.as_ptr().cast()) }
> +                    }
> +
> +                    #[inline(always)]
> +                    fn atomic_read_acquire(a: &AtomicRepr<Self>) -> Self {
> +                        // SAFETY: `a.as_ptr()` is valid and properly aligned.
> +                        unsafe { bindings::[< atomic_ $ty _load_acquire >](a.as_ptr().cast()) }
> +                    }
> +
> +                    // Generate atomic_set and atomic_set_release
> +                    #[inline(always)]
> +                    fn atomic_set(a: &AtomicRepr<Self>, v: Self) {
> +                        // SAFETY: `a.as_ptr()` is valid and properly aligned.
> +                        unsafe { bindings::[< atomic_ $ty _store >](a.as_ptr().cast(), v) }
> +                    }
> +
> +                    #[inline(always)]
> +                    fn atomic_set_release(a: &AtomicRepr<Self>, v: Self) {
> +                        // SAFETY: `a.as_ptr()` is valid and properly aligned.
> +                        unsafe { bindings::[< atomic_ $ty _store_release >](a.as_ptr().cast(), v) }
> +                    }
> +                }
> +            }
> +        )*
> +    };
> +}

Can you document this macro a bit, in particular the motivations for not
leveraging the existing ones (I guess this has to be with the new
helpers, but following the code through is a bit difficult without
comments).