Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336// SPDX-License-Identifier: GPL-2.0
//! Pre-defined atomic types
use crate::prelude::*;
// Ensure size and alignment requirements are checked.static_assert!(size_of::<bool>() == size_of::<i8>());static_assert!(align_of::<bool>() == align_of::<i8>());
// SAFETY: `bool` has the same size and alignment as `i8`, and Rust guarantees that `bool` has// only two valid bit patterns: 0 (false) and 1 (true). Those are valid `i8` values, so `bool` is// round-trip transmutable to `i8`.unsafe impl super::AtomicType for bool { type Repr = i8;}
// SAFETY: `i8` has the same size and alignment with itself, and is round-trip transmutable to// itself.unsafe impl super::AtomicType for i8 { type Repr = i8;}
// SAFETY: `i16` has the same size and alignment with itself, and is round-trip transmutable to// itself.unsafe impl super::AtomicType for i16 { type Repr = i16;}
// SAFETY://// - `*mut T` has the same size and alignment with `*const c_void`, and is round-trip// transmutable to `*const c_void`.// - `*mut T` is safe to transfer between execution contexts. See the safety requirement of// [`AtomicType`].unsafe impl<T: Sized> super::AtomicType for *mut T { type Repr = *const c_void;}
// SAFETY://// - `*const T` has the same size and alignment with `*const c_void`, and is round-trip// transmutable to `*const c_void`.// - `*const T` is safe to transfer between execution contexts. See the safety requirement of// [`AtomicType`].unsafe impl<T: Sized> super::AtomicType for *const T { type Repr = *const c_void;}
// SAFETY: `i32` has the same size and alignment with itself, and is round-trip transmutable to// itself.unsafe impl super::AtomicType for i32 { type Repr = i32;}
// SAFETY: The wrapping add result of two `i32`s is a valid `i32`.unsafe impl super::AtomicAdd<i32> for i32 { fn rhs_into_delta(rhs: i32) -> i32 { rhs }}
// SAFETY: `i64` has the same size and alignment with itself, and is round-trip transmutable to// itself.unsafe impl super::AtomicType for i64 { type Repr = i64;}
// SAFETY: The wrapping add result of two `i64`s is a valid `i64`.unsafe impl super::AtomicAdd<i64> for i64 { fn rhs_into_delta(rhs: i64) -> i64 { rhs }}
// Defines an internal type that always maps to the integer type which has the same size alignment// as `isize` and `usize`, and `isize` and `usize` are always bi-directional transmutable to// `isize_atomic_repr`, which also always implements `AtomicImpl`.#[allow(non_camel_case_types)]#[cfg(not(testlib))]#[cfg(not(CONFIG_64BIT))]type isize_atomic_repr = i32;#[allow(non_camel_case_types)]#[cfg(not(testlib))]#[cfg(CONFIG_64BIT)]type isize_atomic_repr = i64;
#[allow(non_camel_case_types)]#[cfg(testlib)]#[cfg(target_pointer_width = "32")]type isize_atomic_repr = i32;#[allow(non_camel_case_types)]#[cfg(testlib)]#[cfg(target_pointer_width = "64")]type isize_atomic_repr = i64;
// Ensure size and alignment requirements are checked.static_assert!(size_of::<isize>() == size_of::<isize_atomic_repr>());static_assert!(align_of::<isize>() == align_of::<isize_atomic_repr>());static_assert!(size_of::<usize>() == size_of::<isize_atomic_repr>());static_assert!(align_of::<usize>() == align_of::<isize_atomic_repr>());
// SAFETY: `isize` has the same size and alignment with `isize_atomic_repr`, and is round-trip// transmutable to `isize_atomic_repr`.unsafe impl super::AtomicType for isize { type Repr = isize_atomic_repr;}
// SAFETY: The wrapping add result of two `isize_atomic_repr`s is a valid `usize`.unsafe impl super::AtomicAdd<isize> for isize { fn rhs_into_delta(rhs: isize) -> isize_atomic_repr { rhs as isize_atomic_repr }}
// SAFETY: `u32` and `i32` has the same size and alignment, and `u32` is round-trip transmutable to// `i32`.unsafe impl super::AtomicType for u32 { type Repr = i32;}
// SAFETY: The wrapping add result of two `i32`s is a valid `u32`.unsafe impl super::AtomicAdd<u32> for u32 { fn rhs_into_delta(rhs: u32) -> i32 { rhs as i32 }}
// SAFETY: `u64` and `i64` has the same size and alignment, and `u64` is round-trip transmutable to// `i64`.unsafe impl super::AtomicType for u64 { type Repr = i64;}
// SAFETY: The wrapping add result of two `i64`s is a valid `u64`.unsafe impl super::AtomicAdd<u64> for u64 { fn rhs_into_delta(rhs: u64) -> i64 { rhs as i64 }}
// SAFETY: `usize` has the same size and alignment with `isize_atomic_repr`, and is round-trip// transmutable to `isize_atomic_repr`.unsafe impl super::AtomicType for usize { type Repr = isize_atomic_repr;}
// SAFETY: The wrapping add result of two `isize_atomic_repr`s is a valid `usize`.unsafe impl super::AtomicAdd<usize> for usize { fn rhs_into_delta(rhs: usize) -> isize_atomic_repr { rhs as isize_atomic_repr }}
#[cfg(CONFIG_RUST_ATOMICS_KUNIT_TEST)]#[macros::kunit_tests(rust_atomics)]mod tests { use super::super::*;
// Call $fn($val) with each $type of $val. macro_rules! for_each_type { ($val:literal in [$($type:ty),*] $fn:expr) => { $({ let v: $type = $val;
$fn(v); })* } }
#[test] fn atomic_basic_tests() { for_each_type!(42 in [i8, i16, i32, i64, u32, u64, isize, usize] |v| { let x = Atomic::new(v);
assert_eq!(v, x.load(Relaxed)); });
for_each_type!(42 in [i8, i16, i32, i64, u32, u64, isize, usize] |v| { let x = Atomic::new(v); let ptr = x.as_ptr();
// SAFETY: `ptr` is a valid pointer and no concurrent access. assert_eq!(v, unsafe { atomic_load(ptr, Relaxed) }); }); }
#[test] fn atomic_acquire_release_tests() { for_each_type!(42 in [i8, i16, i32, i64, u32, u64, isize, usize] |v| { let x = Atomic::new(0);
x.store(v, Release); assert_eq!(v, x.load(Acquire)); });
for_each_type!(42 in [i8, i16, i32, i64, u32, u64, isize, usize] |v| { let x = Atomic::new(0); let ptr = x.as_ptr();
// SAFETY: `ptr` is a valid pointer and no concurrent access. unsafe { atomic_store(ptr, v, Release) };
// SAFETY: `ptr` is a valid pointer and no concurrent access. assert_eq!(v, unsafe { atomic_load(ptr, Acquire) }); }); }
#[test] fn atomic_xchg_tests() { for_each_type!(42 in [i8, i16, i32, i64, u32, u64, isize, usize] |v| { let x = Atomic::new(v);
let old = v; let new = v + 1;
assert_eq!(old, x.xchg(new, Full)); assert_eq!(new, x.load(Relaxed)); });
for_each_type!(42 in [i8, i16, i32, i64, u32, u64, isize, usize] |v| { let x = Atomic::new(v); let ptr = x.as_ptr();
let old = v; let new = v + 1;
// SAFETY: `ptr` is a valid pointer and no concurrent access. assert_eq!(old, unsafe { xchg(ptr, new, Full) }); assert_eq!(new, x.load(Relaxed)); }); }
#[test] fn atomic_cmpxchg_tests() { for_each_type!(42 in [i8, i16, i32, i64, u32, u64, isize, usize] |v| { let x = Atomic::new(v);
let old = v; let new = v + 1;
assert_eq!(Err(old), x.cmpxchg(new, new, Full)); assert_eq!(old, x.load(Relaxed)); assert_eq!(Ok(old), x.cmpxchg(old, new, Relaxed)); assert_eq!(new, x.load(Relaxed)); });
for_each_type!(42 in [i8, i16, i32, i64, u32, u64, isize, usize] |v| { let x = Atomic::new(v); let ptr = x.as_ptr();
let old = v; let new = v + 1;
// SAFETY: `ptr` is a valid pointer and no concurrent access. assert_eq!(Err(old), unsafe { cmpxchg(ptr, new, new, Full) }); assert_eq!(old, x.load(Relaxed)); // SAFETY: `ptr` is a valid pointer and no concurrent access. assert_eq!(Ok(old), unsafe { cmpxchg(ptr, old, new, Relaxed) }); assert_eq!(new, x.load(Relaxed)); }); }
#[test] fn atomic_arithmetic_tests() { for_each_type!(42 in [i32, i64, u32, u64, isize, usize] |v| { let x = Atomic::new(v);
assert_eq!(v, x.fetch_add(12, Full)); assert_eq!(v + 12, x.load(Relaxed));
x.add(13, Relaxed);
assert_eq!(v + 25, x.load(Relaxed)); }); }
#[test] fn atomic_bool_tests() { let x = Atomic::new(false);
assert_eq!(false, x.load(Relaxed)); x.store(true, Relaxed); assert_eq!(true, x.load(Relaxed));
assert_eq!(true, x.xchg(false, Relaxed)); assert_eq!(false, x.load(Relaxed));
assert_eq!(Err(false), x.cmpxchg(true, true, Relaxed)); assert_eq!(false, x.load(Relaxed)); assert_eq!(Ok(false), x.cmpxchg(false, true, Full)); }
#[test] fn atomic_ptr_tests() { let mut v = 42; let mut u = 43; let x = Atomic::new(&raw mut v);
assert_eq!(x.load(Acquire), &raw mut v); assert_eq!(x.cmpxchg(&raw mut u, &raw mut u, Relaxed), Err(&raw mut v)); assert_eq!(x.cmpxchg(&raw mut v, &raw mut u, Relaxed), Ok(&raw mut v)); assert_eq!(x.load(Relaxed), &raw mut u);
let x = Atomic::new(&raw const v);
assert_eq!(x.load(Acquire), &raw const v); assert_eq!( x.cmpxchg(&raw const u, &raw const u, Relaxed), Err(&raw const v) ); assert_eq!( x.cmpxchg(&raw const v, &raw const u, Relaxed), Ok(&raw const v) ); assert_eq!(x.load(Relaxed), &raw const u); }
#[test] fn atomic_flag_tests() { let mut flag = AtomicFlag::new(false);
assert_eq!(false, flag.load(Relaxed));
*flag.get_mut() = true; assert_eq!(true, flag.load(Relaxed));
assert_eq!(true, flag.xchg(false, Relaxed)); assert_eq!(false, flag.load(Relaxed));
*flag.get_mut() = true; assert_eq!(Ok(true), flag.cmpxchg(true, false, Full)); assert_eq!(false, flag.load(Relaxed)); }}