(This is more an RFC)
Add arithmetic operations support for `Atomic<*mut T>`. Currently the
semantics of arithmetic atomic operation is the same as pointer
arithmetic, that is, e.g. `Atomic<*mut u64>::add(1)` is adding 8
(`size_of::<u64>`) to the pointer value.
In Rust std library, there are two sets of pointer arithmetic for
`AtomicPtr`:
* ptr_add() and ptr_sub(), which is the same as Atomic<*mut T>::add(),
pointer arithmetic.
* byte_add() and byte_sub(), which use the input as byte offset to
change the pointer value, e.g. byte_add(1) means adding 1 to the
pointer value.
We can either take the approach in the current patch and add byte_add()
later on if needed, or start with ptr_add() and byte_add() naming.
Signed-off-by: Boqun Feng <boqun.feng@xxxxxxxxx>
---
rust/kernel/sync/atomic.rs | 29 +++++++++++++++++++++++++++++
1 file changed, 29 insertions(+)
diff --git a/rust/kernel/sync/atomic.rs b/rust/kernel/sync/atomic.rs
index e62c3cd1d3ca..cbe5d40d9e36 100644
--- a/rust/kernel/sync/atomic.rs
+++ b/rust/kernel/sync/atomic.rs
@@ -197,3 +197,32 @@ fn from_repr(repr: Self::Repr) -> Self {
repr as _
}
}
+
+/// ```rust
+/// use kernel::sync::atomic::{Atomic, Relaxed};
+///
+/// let s: &mut [i32] = &mut [1, 3, 2, 4];
+///
+/// let x = Atomic::new(s.as_mut_ptr());
+///
+/// x.add(1, Relaxed);
+///
+/// let ptr = x.fetch_add(1, Relaxed); // points to the 2nd element.
+/// let ptr2 = x.load(Relaxed); // points to the 3rd element.
+///
+/// // SAFETY: `ptr` and `ptr2` are valid pointers to the 2nd and 3rd elements of `s` with writing
+/// // provenance, and no other thread is accessing these elements.
+/// unsafe { core::ptr::swap(ptr, ptr2); }
+///
+/// assert_eq!(s, &mut [1, 2, 3, 4]);
+/// ```
+impl<T> generic::AllowAtomicArithmetic for *mut T {
+ type Delta = isize;
+
+ /// The behavior of arithmetic operations
+ fn delta_into_repr(d: Self::Delta) -> Self::Repr {
+ // Since atomic arithmetic operations are wrapping, so a wrapping_mul() here suffices even
+ // if overflow may happen.
+ d.wrapping_mul(core::mem::size_of::<T>() as _) as _
+ }
+}
--
2.45.2
