refactor!: use rustix

Author: George-Miao

Cargo.toml

@@ -79,6 +79,7 @@ synchrony = "0.1.7"
 thin-cell = "0.2.1"
 slotmap = "1.1.1"
 crossfire = "3.1.5"
+rustix = { version = "1.1.4", default-features = false }
 
 [profile.bench]
 debug = true

compio-driver/Cargo.toml

@@ -30,6 +30,7 @@ synchrony = { workspace = true, features = ["waker_slot"] }
 bitflags = { version = "2.11.0" }
 paste = { workspace = true }
 mod_use = "0.2.3"
+rustix = { workspace = true, features = ["net"] }
 
 # Windows specific dependencies
 [target.'cfg(windows)'.dependencies]
@@ -53,16 +54,17 @@ compile_warning = { version = "0.1.0", optional = true }
 io-uring = { version = "0.7.0", optional = true }
 once_cell = { workspace = true, optional = true }
 polling = { version = "3.3.0", optional = true }
+rustix = { workspace = true, features = ["linux_5_11"] }
 
 # Other platform dependencies
-[target.'cfg(all(not(target_os = "linux"), unix))'.dependencies]
+[target.'cfg(all(unix, not(target_os = "linux")))'.dependencies]
 polling = "3.3.0"
 
 [target.'cfg(unix)'.dependencies]
 smallvec = { workspace = true, features = ["union"] }
 crossbeam-queue = { workspace = true }
 libc = { workspace = true }
-nix = { workspace = true, features = ["fs"] }
+rustix = { workspace = true, features = ["fs", "pipe"] }
 
 [dev-dependencies]
 nix = { workspace = true, features = ["mman"] }
@@ -73,7 +75,8 @@ cfg_aliases = { workspace = true }
 [features]
 default = ["io-uring"]
 io-uring = [
-    "nix/mman",
+    "rustix/mm",
+    "rustix/event",
     "dep:io-uring",
     "dep:once_cell",
 ]

compio-driver/build.rs

@@ -4,16 +4,10 @@ fn main() {
     cfg_aliases! {
         // Feature
         aio: { any(freebsd, solarish) },
-        datasync: { any(
-            target_os = "android",
-            target_os = "freebsd",
-            target_os = "fuchsia",
-            target_os = "illumos",
-            target_os = "linux",
-            target_os = "netbsd"
-        ) },
+        datasync: { all(unix, not(apple)) },
 
         // Platform
+        apple : { target_os = "macos" },
         linux_all: { any(target_os = "linux", target_os = "android") },
         gnulinux: { all(target_os = "linux", target_env = "gnu") },
         freebsd: { target_os = "freebsd" },

compio-driver/src/macros.rs

@@ -51,7 +51,7 @@ macro_rules! syscall {
         if res == -1 {
             Err(::std::io::Error::last_os_error())
         } else {
-            Ok(res)
+            Ok(res as usize)
         }
     }};
 }

compio-driver/src/sys/buffer_pool/iour.rs

@@ -1,13 +1,13 @@
 use std::{
     io,
-    num::{NonZeroU16, NonZeroUsize},
-    ptr::NonNull,
+    num::NonZeroU16,
+    ptr::{NonNull, null_mut},
     slice,
     sync::atomic::Ordering,
 };
 
 use io_uring::types::BufRingEntry;
-use nix::sys::mman::{MapFlags, ProtFlags, mmap_anonymous, munmap};
+use rustix::mm::{MapFlags, ProtFlags, mmap_anonymous, munmap};
 use synchrony::unsync::atomic::AtomicU16;
 
 use crate::{
@@ -22,7 +22,7 @@ pub(in crate::sys) struct BufControl {
     /// Number of entries
     len: NonZeroU16,
     /// Total size of the mmap
-    size: NonZeroUsize,
+    size: usize,
 }
 
 assert_not_impl!(BufControl, Send);
@@ -49,12 +49,13 @@ impl BufControl {
         let driver = driver.as_iour_mut().expect("Should be iour");
 
         let len = NonZeroU16::new(bufs.len() as u16).expect("Empty buffers");
-        let size = NonZeroUsize::new(len.get() as usize * size_of::<BufRingEntry>())
-            .expect("Shouldn't overflow");
+        let size = len.get() as usize * size_of::<BufRingEntry>();
 
-        let prot = ProtFlags::PROT_READ | ProtFlags::PROT_WRITE;
-        let mflags = MapFlags::MAP_PRIVATE;
-        let ptr = unsafe { mmap_anonymous(None, size, prot, mflags) }?.cast::<BufRingEntry>();
+        let prot = ProtFlags::READ | ProtFlags::WRITE;
+        let mflags = MapFlags::PRIVATE;
+        let ptr = NonNull::new(unsafe { mmap_anonymous(null_mut(), size, prot, mflags) }?)
+            .expect("mmap failed")
+            .cast::<BufRingEntry>();
 
         let mut this = Self { ptr, len, size };
 
@@ -113,7 +114,7 @@ impl BufControl {
             .inner()
             .submitter()
             .unregister_buf_ring(Self::BUF_GROUP)?;
-        unsafe { munmap(self.ptr.cast(), self.size.get()) }?;
+        unsafe { munmap(self.ptr.cast().as_ptr(), self.size) }?;
 
         Ok(())
     }

compio-driver/src/sys/driver/iocp/op.rs

@@ -16,7 +16,7 @@ pub unsafe trait OpCode {
     ///
     /// Caller must guarantee that during the lifetime of `ctrl`, `Self` is
     /// unmoved and valid.
-    unsafe fn init(&mut self, ctrl: &mut Self::Control);
+    unsafe fn init(&mut self, _: &mut Self::Control) {}
 
     /// Determines that the operation is really overlapped defined by
     /// Windows API. If not, the driver will try to operate it in

compio-driver/src/sys/driver/iour/mod.rs

@@ -34,7 +34,6 @@ use crate::{
     AsyncifyPool, DriverType, Entry, ProactorBuilder,
     key::{BorrowedKey, ErasedKey},
     panic::catch_unwind_io,
-    syscall,
 };
 
 /// Low-level driver of io-uring.

compio-driver/src/sys/driver/iour/notify.rs

@@ -1,3 +1,5 @@
+use rustix::event::{EventfdFlags, eventfd};
+
 use super::*;
 
 #[derive(Debug)]
@@ -8,40 +10,36 @@ pub(super) struct Notifier {
 impl Notifier {
     /// Create a new notifier.
     pub fn new() -> io::Result<Self> {
-        let fd = syscall!(libc::eventfd(0, libc::EFD_CLOEXEC | libc::EFD_NONBLOCK))?;
-        let fd = unsafe { OwnedFd::from_raw_fd(fd) };
+        let fd = eventfd(0, EventfdFlags::CLOEXEC | EventfdFlags::NONBLOCK)?;
+
         Ok(Self {
             notify: Arc::new(Notify::new(fd)),
         })
     }
 
     pub fn clear(&self) -> io::Result<()> {
-        loop {
-            let mut buffer = [0u64];
-            let res = syscall!(libc::read(
-                self.as_raw_fd(),
-                buffer.as_mut_ptr().cast(),
-                std::mem::size_of::<u64>()
-            ));
-            match res {
-                Ok(len) => {
-                    debug_assert_eq!(len, std::mem::size_of::<u64>() as _);
-                    break Ok(());
-                }
-                // Clear the next time:)
-                Err(e) if e.kind() == io::ErrorKind::WouldBlock => break Ok(()),
-                // Just like read_exact
-                Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
-                Err(e) => break Err(e),
-            }
-        }
+        const LEN: usize = std::mem::size_of::<u64>();
+
+        let mut buffer = [0u8; LEN];
+
+        let res = poll_io(|| rustix::io::read(self, &mut buffer))?;
+
+        debug_assert!(matches!(res, Poll::Pending | Poll::Ready(LEN)));
+
+        Ok(())
     }
 
     pub fn waker(&self) -> Waker {
         Waker::from(self.notify.clone())
     }
 }
 
+impl AsFd for Notifier {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.notify.fd.as_fd()
+    }
+}
+
 impl AsRawFd for Notifier {
     fn as_raw_fd(&self) -> RawFd {
         self.notify.fd.as_raw_fd()
@@ -61,12 +59,8 @@ impl Notify {
 
     /// Notify the inner driver.
     pub fn notify(&self) -> io::Result<()> {
-        let data = 1u64;
-        syscall!(libc::write(
-            self.fd.as_raw_fd(),
-            &data as *const _ as *const _,
-            std::mem::size_of::<u64>(),
-        ))?;
+        rustix::io::write(&self.fd, &u64::to_be_bytes(1))?;
+
         Ok(())
     }
 }

compio-driver/src/sys/driver/iour/op.rs

@@ -33,7 +33,7 @@ pub unsafe trait OpCode {
     ///
     /// Caller must guarantee that during the lifetime of `ctrl`, `Self` is
     /// unmoved and valid.
-    unsafe fn init(&mut self, ctrl: &mut Self::Control);
+    unsafe fn init(&mut self, _: &mut Self::Control) {}
 
     /// Create submission entry.
     fn create_entry(&mut self, _: &mut Self::Control) -> OpEntry;

compio-driver/src/sys/driver/poll/mod.rs

@@ -18,17 +18,6 @@ use crate::{
     sys::{extra::PollExtra, prelude::*},
 };
 
-/// Meta of AIO operations.
-#[cfg(aio)]
-#[derive(Debug, Clone, Copy)]
-#[doc(hidden)]
-pub struct AioControl {
-    /// Pointer of the control block.
-    pub aiocbp: NonNull<libc::aiocb>,
-    /// The aio_* submit function.
-    pub submit: unsafe extern "C" fn(*mut libc::aiocb) -> i32,
-}
-
 #[derive(Debug, Default)]
 struct FdQueue {
     read_queue: VecDeque<ErasedKey>,
@@ -330,7 +319,7 @@ impl Driver {
                 Poll::Pending
             }
             #[cfg(aio)]
-            Decision::Aio(AioControl { mut aiocbp, submit }) => {
+            Decision::Aio(AioArg { mut aiocbp, submit }) => {
                 let aiocb = unsafe { aiocbp.as_mut() };
                 let user_data = key.as_raw();
                 #[cfg(freebsd)]
@@ -491,9 +480,7 @@ impl Driver {
                                 trace!("op {} is not completed", key.as_raw());
                                 continue;
                             }
-                            _ => {
-                                syscall!(libc::aio_return(aiocbp.as_ptr())).map(|res| res as usize)
-                            }
+                            _ => syscall!(libc::aio_return(aiocbp.as_ptr())),
                         };
                         let key = unsafe { ErasedKey::from_raw(event.key) };
                         Entry::new(key, res).notify()