Commit c49cf341 authored by Andreas Hindborg's avatar Andreas Hindborg Committed by Peter Zijlstra
Browse files

rust: sync: atomic: Add fetch_sub() 



Add `Atomic::fetch_sub()` with implementation and documentation in line
with existing `Atomic::fetch_add()` implementation.

Signed-off-by: default avatarAndreas Hindborg <a.hindborg@kernel.org>
Signed-off-by: default avatarBoqun Feng <boqun@kernel.org>
Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Reviewed-by: default avatarAlice Ryhl <aliceryhl@google.com>
Link: https://patch.msgid.link/20260220-atomic-sub-v3-1-e63cbed1d2aa@kernel.org
Link: https://patch.msgid.link/20260303201701.12204-12-boqun@kernel.org
parent e2f9c86f

rust/kernel/sync/atomic.rs

+43 −0
Original line number Diff line number Diff line
@@ -577,6 +577,49 @@ pub fn fetch_add<Rhs, Ordering: ordering::Ordering>(&self, v: Rhs, _: Ordering) 
        // SAFETY: `ret` comes from reading `self.0`, which is a valid `T` per type invariants.

        unsafe { from_repr(ret) }

    }



    /// Atomic fetch and subtract.

    ///

    /// Atomically updates `*self` to `(*self).wrapping_sub(v)`, and returns the value of `*self`

    /// before the update.

    ///

    /// # Examples

    ///

    /// ```

    /// use kernel::sync::atomic::{Atomic, Acquire, Full, Relaxed};

    ///

    /// let x = Atomic::new(42);

    /// assert_eq!(42, x.load(Relaxed));

    /// assert_eq!(42, x.fetch_sub(12, Acquire));

    /// assert_eq!(30, x.load(Relaxed));

    ///

    /// let x = Atomic::new(42);

    /// assert_eq!(42, x.load(Relaxed));

    /// assert_eq!(42, x.fetch_sub(12, Full));

    /// assert_eq!(30, x.load(Relaxed));

    /// ```

    #[inline(always)]

    pub fn fetch_sub<Rhs, Ordering: ordering::Ordering>(&self, v: Rhs, _: Ordering) -> T

    where

        // Types that support addition also support subtraction.

        T: AtomicAdd<Rhs>,

    {

        let v = T::rhs_into_delta(v);



        // INVARIANT: `self.0` is a valid `T` after `atomic_fetch_sub*()` due to safety requirement

        // of `AtomicAdd`.

        let ret = {

            match Ordering::TYPE {

                OrderingType::Full => T::Repr::atomic_fetch_sub(&self.0, v),

                OrderingType::Acquire => T::Repr::atomic_fetch_sub_acquire(&self.0, v),

                OrderingType::Release => T::Repr::atomic_fetch_sub_release(&self.0, v),

                OrderingType::Relaxed => T::Repr::atomic_fetch_sub_relaxed(&self.0, v),

            }

        };



        // SAFETY: `ret` comes from reading `self.0`, which is a valid `T` per type invariants.

        unsafe { from_repr(ret) }

    }

}



#[cfg(any(CONFIG_X86_64, CONFIG_UML, CONFIG_ARM, CONFIG_ARM64))]

rust/kernel/sync/atomic/internal.rs

+5 −0
Original line number Diff line number Diff line
@@ -340,5 +340,10 @@ fn fetch_add[acquire, release, relaxed](a: &AtomicRepr<Self>, v: Self::Delta) -> 
            // SAFETY: `a.as_ptr()` is valid and properly aligned.

            unsafe { bindings::#call(v, a.as_ptr().cast()) }

        }



        fn fetch_sub[acquire, release, relaxed](a: &AtomicRepr<Self>, v: Self::Delta) -> Self {

            // SAFETY: `a.as_ptr()` guarantees the returned pointer is valid and properly aligned.

            unsafe { bindings::#call(v, a.as_ptr().cast()) }

        }

    }

);