Use utils::{as_ptr, as_ptr_mut} to reduce as casts. (#654)

This reduces `as` casts, and is generally more concise.

Author: sunfishcode

src/backend/libc/io/syscalls.rs

@@ -34,7 +34,7 @@ use libc_errno::errno;
 use {
     super::super::conv::syscall_ret_owned_fd,
     crate::io::{IoSliceRaw, ReadWriteFlags, SpliceFlags},
-    core::ptr,
+    crate::utils::optional_as_mut_ptr,
 };
 #[cfg(bsd)]
 use {crate::io::kqueue::Event, crate::utils::as_ptr, core::ptr::null};
@@ -586,13 +586,8 @@ pub fn splice(
     len: usize,
     flags: SpliceFlags,
 ) -> io::Result<usize> {
-    let off_in = off_in
-        .map(|off| (off as *mut u64).cast())
-        .unwrap_or(ptr::null_mut());
-
-    let off_out = off_out
-        .map(|off| (off as *mut u64).cast())
-        .unwrap_or(ptr::null_mut());
+    let off_in = optional_as_mut_ptr(off_in).cast();
+    let off_out = optional_as_mut_ptr(off_out).cast();
 
     unsafe {
         ret_usize(c::splice(

src/backend/linux_raw/io/syscalls.rs

@@ -366,7 +366,7 @@ pub(crate) fn ext4_ioc_resize_fs(fd: BorrowedFd<'_>, blocks: u64) -> io::Result<
             __NR_ioctl,
             fd,
             c_uint(EXT4_IOC_RESIZE_FS),
-            &blocks as *const u64
+            by_ref(&blocks)
         ))
     }
 }

src/backend/linux_raw/process/syscalls.rs

@@ -22,6 +22,7 @@ use crate::process::{
     Resource, Rlimit, Signal, Sysinfo, Uid, WaitId, WaitOptions, WaitStatus, WaitidOptions,
     WaitidStatus,
 };
+use crate::utils::as_mut_ptr;
 use core::convert::TryInto;
 use core::mem::MaybeUninit;
 use core::num::NonZeroU32;
@@ -224,7 +225,7 @@ pub(crate) fn sched_getaffinity(pid: Option<Pid>, cpuset: &mut RawCpuSet) -> io:
             size_of::<RawCpuSet, _>(),
             by_mut(&mut cpuset.bits)
         ))?;
-        let bytes = (cpuset as *mut RawCpuSet).cast::<u8>();
+        let bytes = as_mut_ptr(cpuset).cast::<u8>();
         let rest = bytes.wrapping_add(size);
         // Zero every byte in the cpuset not set by the kernel.
         rest.write_bytes(0, core::mem::size_of::<RawCpuSet>() - size);

src/process/prctl.rs

@@ -18,6 +18,7 @@ use crate::fd::{AsRawFd, BorrowedFd};
 use crate::ffi::CStr;
 use crate::io;
 use crate::process::{Pid, RawPid};
+use crate::utils::{as_mut_ptr, as_ptr};
 
 //
 // Helper functions.
@@ -58,7 +59,7 @@ where
     T: TryFrom<P, Error = io::Errno>,
 {
     let mut value: P = Default::default();
-    prctl_2args(option, ((&mut value) as *mut P).cast())?;
+    prctl_2args(option, as_mut_ptr(&mut value).cast())?;
     TryFrom::try_from(value)
 }
 
@@ -702,7 +703,7 @@ pub unsafe fn set_auxiliary_vector(auxv: &[*const c_void]) -> io::Result<()> {
 #[inline]
 pub fn virtual_memory_map_config_struct_size() -> io::Result<usize> {
     let mut value: c_uint = 0;
-    let value_ptr = (&mut value) as *mut c_uint;
+    let value_ptr = as_mut_ptr(&mut value);
     unsafe { prctl_3args(PR_SET_MM, PR_SET_MM_MAP_SIZE as *mut _, value_ptr.cast())? };
     Ok(value as usize)
 }
@@ -761,7 +762,7 @@ pub unsafe fn configure_virtual_memory_map(config: &PrctlMmMap) -> io::Result<()
     syscalls::prctl(
         PR_SET_MM,
         PR_SET_MM_MAP as *mut _,
-        config as *const PrctlMmMap as *mut _,
+        as_ptr(config) as *mut _,
         size_of::<PrctlMmMap>() as *mut _,
         null_mut(),
     )

src/process/procctl.rs

@@ -17,6 +17,7 @@ use crate::backend::process::syscalls;
 use crate::backend::process::types::{RawId, Signal};
 use crate::io;
 use crate::process::{Pid, RawPid};
+use crate::utils::{as_mut_ptr, as_ptr};
 
 //
 // Helper functions.
@@ -61,7 +62,7 @@ pub(crate) unsafe fn procctl_set<P>(
     process: ProcSelector,
     data: &P,
 ) -> io::Result<()> {
-    procctl(option, process, (data as *const P as *mut P).cast())
+    procctl(option, process, (as_ptr(data) as *mut P).cast())
 }
 
 #[inline]
@@ -338,13 +339,7 @@ pub fn get_reaper_pids(process: ProcSelector) -> io::Result<Vec<PidInfo>> {
         rp_pad0: [0; 15],
         rp_pids: pids.as_mut_slice().as_mut_ptr(),
     };
-    unsafe {
-        procctl(
-            PROC_REAP_GETPIDS,
-            process,
-            (&mut pinfo as *mut procctl_reaper_pids).cast(),
-        )?
-    };
+    unsafe { procctl(PROC_REAP_GETPIDS, process, as_mut_ptr(&mut pinfo).cast())? };
     let mut result = Vec::new();
     for raw in pids.into_iter() {
         let flags = PidInfoFlags::from_bits_truncate(raw.pi_flags);
@@ -412,13 +407,7 @@ pub fn reaper_kill(
         rk_fpid: 0,
         rk_pad0: [0; 15],
     };
-    unsafe {
-        procctl(
-            PROC_REAP_KILL,
-            process,
-            (&mut req as *mut procctl_reaper_kill).cast(),
-        )?
-    };
+    unsafe { procctl(PROC_REAP_KILL, process, as_mut_ptr(&mut req).cast())? };
     Ok(KillResult {
         killed: req.rk_killed as _,
         first_failed: if req.rk_fpid == -1 {

src/thread/prctl.rs

@@ -26,6 +26,7 @@ use crate::process::{
     prctl_1arg, prctl_2args, prctl_3args, prctl_get_at_arg2_optional, Pid,
     PointerAuthenticationKeys,
 };
+use crate::utils::as_ptr;
 
 //
 // PR_GET_KEEPCAPS/PR_SET_KEEPCAPS
@@ -854,7 +855,7 @@ pub unsafe fn enable_syscall_user_dispatch(
         PR_SYS_DISPATCH_ON as *mut _,
         always_allowed_region.as_ptr() as *mut _,
         always_allowed_region.len() as *mut _,
-        fast_switch_flag as *const AtomicU8 as *mut _,
+        as_ptr(fast_switch_flag) as *mut _,
     )
     .map(|_r| ())
 }