Uses ptr::from_ref in futex.rs

Author: ruihe774

library/std/src/sys/pal/unix/futex.rs

@@ -8,6 +8,7 @@
     target_os = "fuchsia",
 ))]
 
+use crate::ptr;
 use crate::sync::atomic::AtomicU32;
 use crate::time::Duration;
 
@@ -24,7 +25,6 @@ pub type SmallPrimitive = u32;
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
 pub fn futex_wait(futex: &AtomicU32, expected: u32, timeout: Option<Duration>) -> bool {
     use super::time::Timespec;
-    use crate::ptr::null;
     use crate::sync::atomic::Ordering::Relaxed;
 
     // Calculate the timeout as an absolute timespec.
@@ -52,10 +52,10 @@ pub fn futex_wait(futex: &AtomicU32, expected: u32, timeout: Option<Duration>) -
                         _flags: libc::UMTX_ABSTIME,
                         _clockid: libc::CLOCK_MONOTONIC as u32,
                     });
-                    let umtx_timeout_ptr = umtx_timeout.as_ref().map_or(null(), |t| t as *const _);
+                    let umtx_timeout_ptr = umtx_timeout.as_ref().map_or(ptr::null(), ptr::from_ref);
                     let umtx_timeout_size = umtx_timeout.as_ref().map_or(0, |t| crate::mem::size_of_val(t));
                     libc::_umtx_op(
-                        futex as *const AtomicU32 as *mut _,
+                        ptr::from_ref(futex) as *mut _,
                         libc::UMTX_OP_WAIT_UINT_PRIVATE,
                         expected as libc::c_ulong,
                         crate::ptr::without_provenance_mut(umtx_timeout_size),
@@ -66,11 +66,11 @@ pub fn futex_wait(futex: &AtomicU32, expected: u32, timeout: Option<Duration>) -
                     // absolute time rather than a relative time.
                     libc::syscall(
                         libc::SYS_futex,
-                        futex as *const AtomicU32,
+                        ptr::from_ref(futex),
                         libc::FUTEX_WAIT_BITSET | libc::FUTEX_PRIVATE_FLAG,
                         expected,
-                        timespec.as_ref().map_or(null(), |t| t as *const libc::timespec),
-                        null::<u32>(), // This argument is unused for FUTEX_WAIT_BITSET.
+                        timespec.as_ref().map_or(ptr::null(), ptr::from_ref),
+                        ptr::null::<u32>(), // This argument is unused for FUTEX_WAIT_BITSET.
                         !0u32,         // A full bitmask, to make it behave like a regular FUTEX_WAIT.
                     )
                 } else {
@@ -95,55 +95,52 @@ pub fn futex_wait(futex: &AtomicU32, expected: u32, timeout: Option<Duration>) -
 /// On some platforms, this always returns false.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub fn futex_wake(futex: &AtomicU32) -> bool {
-    let ptr = futex as *const AtomicU32;
+    let p = ptr::from_ref(futex);
     let op = libc::FUTEX_WAKE | libc::FUTEX_PRIVATE_FLAG;
-    unsafe { libc::syscall(libc::SYS_futex, ptr, op, 1) > 0 }
+    unsafe { libc::syscall(libc::SYS_futex, p, op, 1) > 0 }
 }
 
 /// Wakes up all threads that are waiting on `futex_wait` on this futex.
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub fn futex_wake_all(futex: &AtomicU32) {
-    let ptr = futex as *const AtomicU32;
+    let p = ptr::from_ref(futex);
     let op = libc::FUTEX_WAKE | libc::FUTEX_PRIVATE_FLAG;
     unsafe {
-        libc::syscall(libc::SYS_futex, ptr, op, i32::MAX);
+        libc::syscall(libc::SYS_futex, p, op, i32::MAX);
     }
 }
 
 // FreeBSD doesn't tell us how many threads are woken up, so this always returns false.
 #[cfg(target_os = "freebsd")]
 pub fn futex_wake(futex: &AtomicU32) -> bool {
-    use crate::ptr::null_mut;
     unsafe {
         libc::_umtx_op(
-            futex as *const AtomicU32 as *mut _,
+            ptr::from_ref(futex) as *mut _,
             libc::UMTX_OP_WAKE_PRIVATE,
             1,
-            null_mut(),
-            null_mut(),
+            ptr::null_mut(),
+            ptr::null_mut(),
         )
     };
     false
 }
 
 #[cfg(target_os = "freebsd")]
 pub fn futex_wake_all(futex: &AtomicU32) {
-    use crate::ptr::null_mut;
     unsafe {
         libc::_umtx_op(
-            futex as *const AtomicU32 as *mut _,
+            ptr::from_ref(futex) as *mut _,
             libc::UMTX_OP_WAKE_PRIVATE,
             i32::MAX as libc::c_ulong,
-            null_mut(),
-            null_mut(),
+            ptr::null_mut(),
+            ptr::null_mut(),
         )
     };
 }
 
 #[cfg(target_os = "openbsd")]
 pub fn futex_wait(futex: &AtomicU32, expected: u32, timeout: Option<Duration>) -> bool {
     use super::time::Timespec;
-    use crate::ptr::{null, null_mut};
 
     // Overflows are rounded up to an infinite timeout (None).
     let timespec = timeout
@@ -152,11 +149,11 @@ pub fn futex_wait(futex: &AtomicU32, expected: u32, timeout: Option<Duration>) -
 
     let r = unsafe {
         libc::futex(
-            futex as *const AtomicU32 as *mut u32,
+            ptr::from_ref(futex) as *mut u32,
             libc::FUTEX_WAIT,
             expected as i32,
-            timespec.as_ref().map_or(null(), |t| t as *const libc::timespec),
-            null_mut(),
+            timespec.as_ref().map_or(ptr::null(), ptr::from),
+            ptr::null_mut(),
         )
     };
 
@@ -165,23 +162,26 @@ pub fn futex_wait(futex: &AtomicU32, expected: u32, timeout: Option<Duration>) -
 
 #[cfg(target_os = "openbsd")]
 pub fn futex_wake(futex: &AtomicU32) -> bool {
-    use crate::ptr::{null, null_mut};
     unsafe {
-        libc::futex(futex as *const AtomicU32 as *mut u32, libc::FUTEX_WAKE, 1, null(), null_mut())
-            > 0
+        libc::futex(
+            ptr::from_ref(futex) as *mut u32,
+            libc::FUTEX_WAKE,
+            1,
+            ptr::null(),
+            ptr::null_mut(),
+        ) > 0
     }
 }
 
 #[cfg(target_os = "openbsd")]
 pub fn futex_wake_all(futex: &AtomicU32) {
-    use crate::ptr::{null, null_mut};
     unsafe {
         libc::futex(
-            futex as *const AtomicU32 as *mut u32,
+            ptr::from_ref(futex) as *mut u32,
             libc::FUTEX_WAKE,
             i32::MAX,
-            null(),
-            null_mut(),
+            ptr::null(),
+            ptr::null_mut(),
         );
     }
 }
@@ -195,7 +195,7 @@ pub fn futex_wait(futex: &AtomicU32, expected: u32, timeout: Option<Duration>) -
         timeout.and_then(|d| Some(i32::try_from(d.as_millis()).ok()?.max(1))).unwrap_or(0);
 
     let r = unsafe {
-        libc::umtx_sleep(futex as *const AtomicU32 as *const i32, expected as i32, timeout_ms)
+        libc::umtx_sleep(ptr::from_ref(futex) as *const i32, expected as i32, timeout_ms)
     };
 
     r == 0 || super::os::errno() != libc::ETIMEDOUT
@@ -204,13 +204,13 @@ pub fn futex_wait(futex: &AtomicU32, expected: u32, timeout: Option<Duration>) -
 // DragonflyBSD doesn't tell us how many threads are woken up, so this always returns false.
 #[cfg(target_os = "dragonfly")]
 pub fn futex_wake(futex: &AtomicU32) -> bool {
-    unsafe { libc::umtx_wakeup(futex as *const AtomicU32 as *const i32, 1) };
+    unsafe { libc::umtx_wakeup(ptr::from_ref(futex) as *const i32, 1) };
     false
 }
 
 #[cfg(target_os = "dragonfly")]
 pub fn futex_wake_all(futex: &AtomicU32) {
-    unsafe { libc::umtx_wakeup(futex as *const AtomicU32 as *const i32, i32::MAX) };
+    unsafe { libc::umtx_wakeup(ptr::from_ref(futex) as *const i32, i32::MAX) };
 }
 
 #[cfg(target_os = "emscripten")]