Experiment with changing Buffer::parts_mut to Buffer::as_mut_ptr.

Based on an idea suggested [here], experiment with changing from a
`parts_mut` that returns `(*mut T, usize)` to a `as_mut_ptr` which
returns a `*mut [MaybeUninit<T>]`.

[here]: https://hachyderm.io/deck/@wffl@im-in.space/114145162248844972

Author: sunfishcode

src/backend/libc/event/syscalls.rs

@@ -4,8 +4,6 @@ use crate::backend::c;
 #[cfg(any(linux_kernel, solarish, target_os = "redox"))]
 use crate::backend::conv::ret;
 use crate::backend::conv::ret_c_int;
-#[cfg(any(linux_kernel, target_os = "illumos", target_os = "redox"))]
-use crate::backend::conv::ret_u32;
 #[cfg(solarish)]
 use crate::event::port::Event;
 #[cfg(any(
@@ -21,7 +19,13 @@ use crate::event::{PollFd, Timespec};
 use crate::io;
 #[cfg(any(linux_kernel, target_os = "illumos", target_os = "redox"))]
 use crate::utils::as_ptr;
-#[cfg(solarish)]
+#[cfg(any(
+    bsd,
+    linux_kernel,
+    solarish,
+    target_os = "illumos",
+    target_os = "redox"
+))]
 use core::mem::MaybeUninit;
 #[cfg(any(
     bsd,
@@ -47,6 +51,8 @@ use {crate::backend::conv::borrowed_fd, crate::fd::BorrowedFd};
     target_os = "redox"
 ))]
 use {crate::backend::conv::ret_owned_fd, crate::fd::OwnedFd};
+#[cfg(any(linux_kernel, target_os = "illumos", target_os = "redox"))]
+use {crate::backend::conv::ret_u32, crate::event::epoll::Event};
 #[cfg(bsd)]
 use {crate::event::kqueue::Event, crate::utils::as_ptr};
 
@@ -95,7 +101,7 @@ pub(crate) fn kqueue() -> io::Result<OwnedFd> {
 pub(crate) unsafe fn kevent(
     kq: BorrowedFd<'_>,
     changelist: &[Event],
-    eventlist: (*mut Event, usize),
+    eventlist: *mut [MaybeUninit<Event>],
     timeout: Option<&c::timespec>,
 ) -> io::Result<c::c_int> {
     ret_c_int(c::kevent(
@@ -105,8 +111,11 @@ pub(crate) unsafe fn kevent(
             .len()
             .try_into()
             .map_err(|_| io::Errno::OVERFLOW)?,
-        eventlist.0.cast(),
-        eventlist.1.try_into().map_err(|_| io::Errno::OVERFLOW)?,
+        eventlist.cast::<c::kevent>(),
+        eventlist
+            .len()
+            .try_into()
+            .map_err(|_| io::Errno::OVERFLOW)?,
         timeout.map_or(null(), as_ptr),
     ))
 }
@@ -395,7 +404,7 @@ pub(crate) fn port_get(port: BorrowedFd<'_>, timeout: Option<&Timespec>) -> io::
 #[cfg(solarish)]
 pub(crate) unsafe fn port_getn(
     port: BorrowedFd<'_>,
-    events: (*mut Event, usize),
+    events: *mut [MaybeUninit<Eventt>],
     mut nget: u32,
     timeout: Option<&Timespec>,
 ) -> io::Result<usize> {
@@ -422,15 +431,15 @@ pub(crate) unsafe fn port_getn(
 
     // `port_getn` special-cases a max value of 0 to be a query that returns
     // the number of events, so bail out early if needed.
-    if events.1 == 0 {
+    if events.is_empty() {
         return Ok(0);
     }
 
     // In Rust ≥ 1.65, the `as _` can be `.cast_mut()`.
     ret(c::port_getn(
         borrowed_fd(port),
-        events.0.cast(),
-        events.1.try_into().unwrap_or(u32::MAX),
+        events.cast::<c::port_event_t>(),
+        events.len().try_into().unwrap_or(u32::MAX),
         &mut nget,
         timeout as _,
     ))?;
@@ -484,7 +493,7 @@ pub(crate) fn epoll_create(flags: super::epoll::CreateFlags) -> io::Result<Owned
 pub(crate) fn epoll_add(
     epoll: BorrowedFd<'_>,
     source: BorrowedFd<'_>,
-    event: &crate::event::epoll::Event,
+    event: &Event,
 ) -> io::Result<()> {
     // We use our own `Event` struct instead of libc's because
     // ours preserves pointer provenance instead of just using a `u64`,
@@ -505,7 +514,7 @@ pub(crate) fn epoll_add(
 pub(crate) fn epoll_mod(
     epoll: BorrowedFd<'_>,
     source: BorrowedFd<'_>,
-    event: &crate::event::epoll::Event,
+    event: &Event,
 ) -> io::Result<()> {
     unsafe {
         ret(c::epoll_ctl(
@@ -535,7 +544,7 @@ pub(crate) fn epoll_del(epoll: BorrowedFd<'_>, source: BorrowedFd<'_>) -> io::Re
 #[cfg(any(linux_kernel, target_os = "illumos", target_os = "redox"))]
 pub(crate) unsafe fn epoll_wait(
     epoll: BorrowedFd<'_>,
-    events: (*mut crate::event::epoll::Event, usize),
+    events: *mut [MaybeUninit<Event>],
     timeout: Option<&Timespec>,
 ) -> io::Result<usize> {
     // If we're on Linux ≥ 5.11 and a libc that has an `epoll_pwait2`
@@ -560,8 +569,8 @@ pub(crate) unsafe fn epoll_wait(
         if let Some(epoll_pwait2_func) = epoll_pwait2.get() {
             return ret_u32(epoll_pwait2_func(
                 borrowed_fd(epoll),
-                events.0.cast::<c::epoll_event>(),
-                events.1.try_into().unwrap_or(i32::MAX),
+                events.cast::<c::epoll_event>(),
+                events.len().try_into().unwrap_or(i32::MAX),
                 crate::utils::option_as_ptr(timeout).cast(),
                 null(),
             ))
@@ -584,8 +593,8 @@ pub(crate) unsafe fn epoll_wait(
 
         ret_u32(epoll_pwait2(
             borrowed_fd(epoll),
-            events.0.cast::<c::epoll_event>(),
-            events.1.try_into().unwrap_or(i32::MAX),
+            events.cast::<c::epoll_event>(),
+            events.len().try_into().unwrap_or(i32::MAX),
             crate::utils::option_as_ptr(timeout).cast(),
             null(),
         ))
@@ -602,8 +611,8 @@ pub(crate) unsafe fn epoll_wait(
 
         ret_u32(c::epoll_wait(
             borrowed_fd(epoll),
-            events.0.cast::<c::epoll_event>(),
-            events.1.try_into().unwrap_or(i32::MAX),
+            events.cast::<c::epoll_event>(),
+            events.len().try_into().unwrap_or(i32::MAX),
             timeout,
         ))
         .map(|i| i as usize)

src/backend/libc/fs/syscalls.rs

@@ -292,9 +292,14 @@ pub(crate) fn readlink(path: &CStr, buf: &mut [u8]) -> io::Result<usize> {
 pub(crate) unsafe fn readlinkat(
     dirfd: BorrowedFd<'_>,
     path: &CStr,
-    buf: (*mut u8, usize),
+    buf: *mut [MaybeUninit<u8>],
 ) -> io::Result<usize> {
-    ret_usize(c::readlinkat(borrowed_fd(dirfd), c_str(path), buf.0.cast(), buf.1) as isize)
+    ret_usize(c::readlinkat(
+        borrowed_fd(dirfd),
+        c_str(path),
+        buf.cast::<ffi::c_char>(),
+        buf.len(),
+    ) as isize)
 }
 
 pub(crate) fn mkdir(path: &CStr, mode: Mode) -> io::Result<()> {
@@ -2349,32 +2354,32 @@ struct Attrlist {
 pub(crate) unsafe fn getxattr(
     path: &CStr,
     name: &CStr,
-    value: (*mut u8, usize),
+    value: *mut [MaybeUninit<u8>],
 ) -> io::Result<usize> {
     #[cfg(not(apple))]
     {
         ret_usize(c::getxattr(
             path.as_ptr(),
             name.as_ptr(),
-            value.0.cast::<c::c_void>(),
-            value.1,
+            value.cast::<c::c_void>(),
+            value.len(),
         ))
     }
 
     #[cfg(apple)]
     {
         // Passing an empty to slice to `getxattr` leads to `ERANGE` on macOS.
         // Pass null instead.
-        let ptr = if value.1 == 0 {
+        let ptr = if value.len() == 0 {
             core::ptr::null_mut()
         } else {
-            value.0.cast::<c::c_void>()
+            value.cast::<c::c_void>()
         };
         ret_usize(c::getxattr(
             path.as_ptr(),
             name.as_ptr(),
             ptr,
-            value.1,
+            value.len(),
             0,
             0,
         ))
@@ -2385,33 +2390,33 @@ pub(crate) unsafe fn getxattr(
 pub(crate) unsafe fn lgetxattr(
     path: &CStr,
     name: &CStr,
-    value: (*mut u8, usize),
+    value: *mut [MaybeUninit<u8>],
 ) -> io::Result<usize> {
     #[cfg(not(apple))]
     {
         ret_usize(c::lgetxattr(
             path.as_ptr(),
             name.as_ptr(),
-            value.0.cast::<c::c_void>(),
-            value.1,
+            value.cast::<c::c_void>(),
+            value.len(),
         ))
     }
 
     #[cfg(apple)]
     {
         // Passing an empty to slice to `getxattr` leads to `ERANGE` on macOS.
         // Pass null instead.
-        let ptr = if value.1 == 0 {
+        let ptr = if value.len() == 0 {
             core::ptr::null_mut()
         } else {
-            value.0.cast::<c::c_void>()
+            value.cast::<c::c_void>()
         };
 
         ret_usize(c::getxattr(
             path.as_ptr(),
             name.as_ptr(),
             ptr,
-            value.1,
+            value.len(),
             0,
             c::XATTR_NOFOLLOW,
         ))
@@ -2422,32 +2427,32 @@ pub(crate) unsafe fn lgetxattr(
 pub(crate) unsafe fn fgetxattr(
     fd: BorrowedFd<'_>,
     name: &CStr,
-    value: (*mut u8, usize),
+    value: *mut [MaybeUninit<u8>],
 ) -> io::Result<usize> {
     #[cfg(not(apple))]
     {
         ret_usize(c::fgetxattr(
             borrowed_fd(fd),
             name.as_ptr(),
-            value.0.cast::<c::c_void>(),
-            value.1,
+            value.cast::<c::c_void>(),
+            value.len(),
         ))
     }
 
     #[cfg(apple)]
     {
         // Passing an empty to slice to `getxattr` leads to `ERANGE` on macOS.
         // Pass null instead.
-        let ptr = if value.1 == 0 {
+        let ptr = if value.len() == 0 {
             core::ptr::null_mut()
         } else {
-            value.0.cast::<c::c_void>()
+            value.cast::<c::c_void>()
         };
         ret_usize(c::fgetxattr(
             borrowed_fd(fd),
             name.as_ptr(),
             ptr,
-            value.1,
+            value.len(),
             0,
             0,
         ))
@@ -2548,61 +2553,64 @@ pub(crate) fn fsetxattr(
 }
 
 #[cfg(any(apple, linux_kernel, target_os = "hurd"))]
-pub(crate) unsafe fn listxattr(path: &CStr, list: (*mut u8, usize)) -> io::Result<usize> {
+pub(crate) unsafe fn listxattr(path: &CStr, list: *mut [MaybeUninit<u8>]) -> io::Result<usize> {
     #[cfg(not(apple))]
     {
         ret_usize(c::listxattr(
             path.as_ptr(),
-            list.0.cast::<ffi::c_char>(),
-            list.1,
+            list.cast::<ffi::c_char>(),
+            list.len(),
         ))
     }
 
     #[cfg(apple)]
     {
         ret_usize(c::listxattr(
             path.as_ptr(),
-            list.0.cast::<ffi::c_char>(),
-            list.1,
+            list.cast::<ffi::c_char>(),
+            list.len(),
             0,
         ))
     }
 }
 
 #[cfg(any(apple, linux_kernel, target_os = "hurd"))]
-pub(crate) unsafe fn llistxattr(path: &CStr, list: (*mut u8, usize)) -> io::Result<usize> {
+pub(crate) unsafe fn llistxattr(path: &CStr, list: *mut [MaybeUninit<u8>]) -> io::Result<usize> {
     #[cfg(not(apple))]
     {
         ret_usize(c::llistxattr(
             path.as_ptr(),
-            list.0.cast::<ffi::c_char>(),
-            list.1,
+            list.cast::<ffi::c_char>(),
+            list.len(),
         ))
     }
 
     #[cfg(apple)]
     {
         ret_usize(c::listxattr(
             path.as_ptr(),
-            list.0.cast::<ffi::c_char>(),
-            list.1,
+            list.cast::<ffi::c_char>(),
+            list.len(),
             c::XATTR_NOFOLLOW,
         ))
     }
 }
 
 #[cfg(any(apple, linux_kernel, target_os = "hurd"))]
-pub(crate) unsafe fn flistxattr(fd: BorrowedFd<'_>, list: (*mut u8, usize)) -> io::Result<usize> {
+pub(crate) unsafe fn flistxattr(
+    fd: BorrowedFd<'_>,
+    list: *mut [MaybeUninit<u8>],
+) -> io::Result<usize> {
     let fd = borrowed_fd(fd);
 
     #[cfg(not(apple))]
     {
-        ret_usize(c::flistxattr(fd, list.0.cast::<ffi::c_char>(), list.1))
+        ret_usize(c::flistxattr(fd, list.cast::<ffi::c_char>(), list.len()))
     }
 
     #[cfg(apple)]
     {
-        ret_usize(c::flistxattr(fd, list.0.cast::<ffi::c_char>(), list.1, 0))
+        ret_usize(c::flistxattr(fd, list.cast::<ffi::c_char>(), list.len(), 0))
     }
 }