Port to rustix from nix (#131)

* Begin porting to rustix

* Cut down nix features

Signed-off-by: John Nunley <dev@notgull.net>

* Make signals an optional feature

Signed-off-by: John Nunley <dev@notgull.net>

* Alphabetize dependencies

Signed-off-by: John Nunley <dev@notgull.net>

* Fix some test errors

Signed-off-by: John Nunley <dev@notgull.net>

* Fix some CI errors

Signed-off-by: John Nunley <dev@notgull.net>

* Don't drop sock2 by accident

Signed-off-by: John Nunley <dev@notgull.net>

* Bump MSRV to 1.63

Signed-off-by: John Nunley <dev@notgull.net>

* Change CI to use 1.63

Signed-off-by: John Nunley <dev@notgull.net>

* Fix macos

Signed-off-by: John Nunley <dev@notgull.net>

---------

Signed-off-by: John Nunley <dev@notgull.net>

Author: notgull

.github/workflows/ci.yml

@@ -86,7 +86,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        rust: ['1.56.0', 'stable', 'beta']
+        rust: ['1.63.0', 'stable', 'beta']
 
     runs-on: 'ubuntu-latest'
 
@@ -126,7 +126,7 @@ jobs:
 
       - name: Downgrade log
         uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust == '1.56.0' }}
+        if: ${{ matrix.rust == '1.63.0' }}
         with:
           command: update
           args: --package log --precise 0.4.16
@@ -137,6 +137,12 @@ jobs:
           command: test
           args: --features "block_on executor"
 
+      - name: Run tests with signals
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --features "block_on executor signals"
+
       - name: Run book tests
         uses: actions-rs/cargo@v1
         if: ${{ matrix.rust == 'stable' || matrix.rust == 'beta' }}

CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+#### Breaking changes
+
+- Bump MSRV to 1.63
+- Make signals an optional feature under the `signals` features.
+- Replace the `nix` crate with standard library I/O errors and the `rustix` 
+crate.
+
 ## 0.11.0 -- 2023-06-05
 
 #### Bugfixes

Cargo.toml

@@ -10,7 +10,7 @@ keywords = [ "events", "loop", "callback", "eventloop", "unix" ]
 autotests = false
 edition = "2018"
 readme = "README.md"
-rust-version = "1.56.0"
+rust-version = "1.63.0"
 
 [workspace]
 members = [ "doc" ]
@@ -19,24 +19,27 @@ members = [ "doc" ]
 codecov = { repository = "Smithay/calloop" }
 
 [dependencies]
+async-task = { version = "4.4.0", optional = true }
 bitflags = "1.2"
+futures-io = { version = "0.3.5", optional = true }
 io-lifetimes = "1.0.3"
 log = "0.4"
-nix = { version = "0.26", default-features = false, features = ["event", "fs", "signal", "socket", "time"] }
-async-task = { version = "4.4.0", optional = true }
-futures-io = { version = "0.3.5", optional = true }
-thiserror = "1.0"
+nix = { version = "0.26", default-features = false, features = ["signal"], optional = true }
 pin-utils = { version = "0.1.0", optional = true }
-slab = "0.4.8"
 polling = "2.6.0"
+rustix = { version = "0.38", default-features = false, features = ["event", "fs", "pipe", "std"] }
+slab = "0.4.8"
+thiserror = "1.0"
 
 [dev-dependencies]
 futures = "0.3.5"
+rustix = { version = "0.38", default-features = false, features = ["net"] }
 
 [features]
 block_on = ["pin-utils"]
 executor = ["async-task"]
 nightly_coverage = []
+signals = ["nix"]
 
 [package.metadata.docs.rs]
 features = ["block_on", "executor"]

src/error.rs

@@ -41,15 +41,6 @@ pub enum Error {
     OtherError(#[from] Box<dyn std::error::Error + Sync + Send>),
 }
 
-impl From<nix::errno::Errno> for Error {
-    /// Converts a [`nix::Error`] into a wrapped version of the equivalent
-    /// [`std::io::Error`].
-    #[cfg_attr(feature = "nightly_coverage", no_coverage)]
-    fn from(err: nix::errno::Errno) -> Self {
-        Into::<std::io::Error>::into(err).into()
-    }
-}
-
 impl From<Error> for std::io::Error {
     /// Converts Calloop's error type into a [`std::io::Error`].
     fn from(err: Error) -> Self {

src/io.rs

@@ -13,7 +13,7 @@ use std::rc::Rc;
 use std::task::{Context, Poll as TaskPoll, Waker};
 
 use io_lifetimes::{AsFd, BorrowedFd};
-use nix::fcntl::{fcntl, FcntlArg, OFlag};
+use rustix::fs::{fcntl_getfl, fcntl_setfl, OFlags};
 
 #[cfg(feature = "futures-io")]
 use futures_io::{AsyncRead, AsyncWrite, IoSlice, IoSliceMut};
@@ -37,7 +37,7 @@ pub struct Async<'l, F: AsFd> {
     fd: Option<F>,
     dispatcher: Rc<RefCell<IoDispatcher>>,
     inner: Rc<dyn IoLoopInner + 'l>,
-    old_flags: OFlag,
+    old_flags: OFlags,
 }
 
 impl<'l, F: AsFd + std::fmt::Debug> std::fmt::Debug for Async<'l, F> {
@@ -49,11 +49,9 @@ impl<'l, F: AsFd + std::fmt::Debug> std::fmt::Debug for Async<'l, F> {
 
 impl<'l, F: AsFd> Async<'l, F> {
     pub(crate) fn new<Data>(inner: Rc<LoopInner<'l, Data>>, fd: F) -> crate::Result<Async<'l, F>> {
-        let rawfd = fd.as_fd().as_raw_fd();
         // set non-blocking
-        let old_flags = fcntl(rawfd, FcntlArg::F_GETFL)?;
-        let old_flags = unsafe { OFlag::from_bits_unchecked(old_flags) };
-        fcntl(rawfd, FcntlArg::F_SETFL(old_flags | OFlag::O_NONBLOCK))?;
+        let old_flags = fcntl_getfl(&fd).map_err(std::io::Error::from)?;
+        fcntl_setfl(&fd, old_flags | OFlags::NONBLOCK).map_err(std::io::Error::from)?;
         // register in the loop
         let dispatcher = Rc::new(RefCell::new(IoDispatcher {
             fd: fd.as_fd().as_raw_fd(),
@@ -158,9 +156,9 @@ impl<'l, F: AsFd> Drop for Async<'l, F> {
     fn drop(&mut self) {
         self.inner.kill(&self.dispatcher);
         // restore flags
-        let _ = fcntl(
-            self.dispatcher.borrow().fd,
-            FcntlArg::F_SETFL(self.old_flags),
+        let _ = fcntl_setfl(
+            unsafe { BorrowedFd::borrow_raw(self.dispatcher.borrow().fd) },
+            self.old_flags,
         );
     }
 }

src/loop_logic.rs

@@ -695,14 +695,10 @@ mod tests {
 
     #[test]
     fn insert_source_no_interest() {
-        use nix::unistd::{close, pipe};
-        use std::os::unix::io::FromRawFd;
+        use rustix::pipe::pipe;
 
         // Create a pipe to get an arbitrary fd.
-        let (read, write) = pipe().unwrap();
-        let read = unsafe { io_lifetimes::OwnedFd::from_raw_fd(read) };
-        // We don't need the write end.
-        close(write).unwrap();
+        let (read, _write) = pipe().unwrap();
 
         let source = crate::sources::generic::Generic::new(read, Interest::EMPTY, Mode::Level);
         let dispatcher = Dispatcher::new(source, |_, _, _| Ok(PostAction::Continue));
@@ -856,27 +852,25 @@ mod tests {
 
     #[test]
     fn change_interests() {
-        use nix::sys::socket::{recv, socketpair, AddressFamily, MsgFlags, SockFlag, SockType};
-        use nix::unistd::write;
-        use std::os::unix::io::{AsRawFd, FromRawFd};
+        use rustix::io::write;
+        use rustix::net::{recv, socketpair, AddressFamily, RecvFlags, SocketFlags, SocketType};
         let mut event_loop = EventLoop::<bool>::try_new().unwrap();
 
         let (sock1, sock2) = socketpair(
-            AddressFamily::Unix,
-            SockType::Stream,
-            None,
-            SockFlag::empty(), // recv with DONTWAIT will suffice for platforms without SockFlag::SOCK_NONBLOCKING such as macOS
+            AddressFamily::UNIX,
+            SocketType::STREAM,
+            SocketFlags::empty(),
+            None, // recv with DONTWAIT will suffice for platforms without SockFlag::SOCK_NONBLOCKING such as macOS
         )
         .unwrap();
-        let sock1 = unsafe { io_lifetimes::OwnedFd::from_raw_fd(sock1) };
 
         let source = Generic::new(sock1, Interest::READ, Mode::Level);
         let dispatcher = Dispatcher::new(source, |_, fd, dispatched| {
             *dispatched = true;
             // read all contents available to drain the socket
             let mut buf = [0u8; 32];
             loop {
-                match recv(fd.as_raw_fd(), &mut buf, MsgFlags::MSG_DONTWAIT) {
+                match recv(&*fd, &mut buf, RecvFlags::DONTWAIT) {
                     Ok(0) => break, // closed pipe, we are now inert
                     Ok(_) => {}
                     Err(e) => {
@@ -907,7 +901,7 @@ mod tests {
         assert!(!dispatched);
 
         // write something, the socket becomes readable
-        write(sock2, &[1, 2, 3]).unwrap();
+        write(&sock2, &[1, 2, 3]).unwrap();
         dispatched = false;
         event_loop
             .dispatch(Duration::ZERO, &mut dispatched)

src/sources/mod.rs

@@ -12,7 +12,7 @@ pub mod channel;
 pub mod futures;
 pub mod generic;
 pub mod ping;
-#[cfg(target_os = "linux")]
+#[cfg(all(target_os = "linux", feature = "signals"))]
 #[cfg_attr(docsrs, doc(cfg(target_os = "linux")))]
 pub mod signals;
 pub mod timer;

src/sources/ping/eventfd.rs

@@ -18,14 +18,11 @@
 //! can then check the LSB and if it's set, we know it was a close event. This
 //! only works if a close event never fires more than once.
 
-use std::{
-    os::unix::io::{AsRawFd, FromRawFd},
-    sync::Arc,
-};
+use std::sync::Arc;
 
 use io_lifetimes::{AsFd, BorrowedFd, OwnedFd};
-use nix::sys::eventfd::{eventfd, EfdFlags};
-use nix::unistd::{read, write};
+use rustix::event::{eventfd, EventfdFlags};
+use rustix::io::{read, write, Errno};
 
 use super::PingError;
 use crate::{
@@ -40,14 +37,14 @@ const INCREMENT_CLOSE: u64 = 0x1;
 
 #[inline]
 pub fn make_ping() -> std::io::Result<(Ping, PingSource)> {
-    let read = eventfd(0, EfdFlags::EFD_CLOEXEC | EfdFlags::EFD_NONBLOCK)?;
+    let read = eventfd(0, EventfdFlags::CLOEXEC | EventfdFlags::NONBLOCK)?;
 
     // We only have one fd for the eventfd. If the sending end closes it when
     // all copies are dropped, the receiving end will be closed as well. We need
     // to make sure the fd is not closed until all holders of it have dropped
     // it.
 
-    let fd = Arc::new(unsafe { OwnedFd::from_raw_fd(read) });
+    let fd = Arc::new(read);
 
     let ping = Ping {
         event: Arc::new(FlagOnDrop(Arc::clone(&fd))),
@@ -65,13 +62,13 @@ pub fn make_ping() -> std::io::Result<(Ping, PingSource)> {
 #[inline]
 fn send_ping(fd: BorrowedFd<'_>, count: u64) -> std::io::Result<()> {
     assert!(count > 0);
-    match write(fd.as_raw_fd(), &count.to_ne_bytes()) {
+    match write(fd, &count.to_ne_bytes()) {
         // The write succeeded, the ping will wake up the loop.
         Ok(_) => Ok(()),
 
         // The counter hit its cap, which means previous calls to write() will
         // wake up the loop.
-        Err(nix::errno::Errno::EAGAIN) => Ok(()),
+        Err(Errno::AGAIN) => Ok(()),
 
         // Anything else is a real error.
         Err(e) => Err(e.into()),
@@ -84,7 +81,7 @@ fn drain_ping(fd: BorrowedFd<'_>) -> std::io::Result<u64> {
     const NBYTES: usize = 8;
     let mut buf = [0u8; NBYTES];
 
-    match read(fd.as_raw_fd(), &mut buf) {
+    match read(fd, &mut buf) {
         // Reading from an eventfd should only ever produce 8 bytes. No looping
         // is required.
         Ok(NBYTES) => Ok(u64::from_ne_bytes(buf)),

src/sources/ping/pipe.rs

@@ -2,14 +2,10 @@
 //! syscall. Sending a ping involves writing to one end of a pipe, and the other
 //! end becoming readable is what wakes up the event loop.
 
-use std::{
-    os::unix::io::{AsRawFd, FromRawFd, RawFd},
-    sync::Arc,
-};
+use std::sync::Arc;
 
-use io_lifetimes::OwnedFd;
-use nix::fcntl::OFlag;
-use nix::unistd::{read, write};
+use io_lifetimes::{AsFd, BorrowedFd, OwnedFd};
+use rustix::io::{read, write, Errno};
 
 use super::PingError;
 use crate::{
@@ -18,42 +14,31 @@ use crate::{
 
 #[cfg(target_os = "macos")]
 #[inline]
-fn make_ends() -> std::io::Result<(RawFd, RawFd)> {
-    // macOS does not have pipe2, but we can emulate the behavior of pipe2 by
-    // setting the flags after calling pipe.
-    use nix::{
-        fcntl::{fcntl, FcntlArg},
-        unistd::pipe,
-    };
+fn make_ends() -> std::io::Result<(OwnedFd, OwnedFd)> {
+    use rustix::fs::{fcntl_getfl, fcntl_setfl, OFlags};
+    use rustix::pipe::pipe;
 
     let (read, write) = pipe()?;
 
-    let read_flags = OFlag::from_bits_truncate(fcntl(read, FcntlArg::F_GETFD)?)
-        | OFlag::O_CLOEXEC
-        | OFlag::O_NONBLOCK;
-    let write_flags = OFlag::from_bits_truncate(fcntl(write, FcntlArg::F_GETFD)?)
-        | OFlag::O_CLOEXEC
-        | OFlag::O_NONBLOCK;
+    let set_flags = |fd| fcntl_setfl(fd, fcntl_getfl(fd)? | OFlags::CLOEXEC | OFlags::NONBLOCK);
 
-    fcntl(read, FcntlArg::F_SETFL(read_flags))?;
-    fcntl(write, FcntlArg::F_SETFL(write_flags))?;
+    set_flags(&read)?;
+    set_flags(&write)?;
 
     Ok((read, write))
 }
 
 #[cfg(not(target_os = "macos"))]
 #[inline]
-fn make_ends() -> std::io::Result<(RawFd, RawFd)> {
-    Ok(nix::unistd::pipe2(OFlag::O_CLOEXEC | OFlag::O_NONBLOCK)?)
+fn make_ends() -> std::io::Result<(OwnedFd, OwnedFd)> {
+    use rustix::pipe::{pipe_with, PipeFlags};
+    Ok(pipe_with(PipeFlags::CLOEXEC | PipeFlags::NONBLOCK)?)
 }
 
 #[inline]
 pub fn make_ping() -> std::io::Result<(Ping, PingSource)> {
     let (read, write) = make_ends()?;
 
-    let read = unsafe { OwnedFd::from_raw_fd(read) };
-    let write = unsafe { OwnedFd::from_raw_fd(write) };
-
     let source = PingSource {
         pipe: Generic::new(read, Interest::READ, Mode::Level),
     };
@@ -66,7 +51,7 @@ pub fn make_ping() -> std::io::Result<(Ping, PingSource)> {
 // Helper functions for the event source IO.
 
 #[inline]
-fn send_ping(fd: RawFd) -> std::io::Result<()> {
+fn send_ping(fd: BorrowedFd<'_>) -> std::io::Result<()> {
     write(fd, &[0u8])?;
     Ok(())
 }
@@ -100,7 +85,7 @@ impl EventSource for PingSource {
                 let mut action = PostAction::Continue;
 
                 loop {
-                    match read(fd.as_raw_fd(), &mut buf) {
+                    match read(&fd, &mut buf) {
                         Ok(0) => {
                             // The other end of the pipe was closed, mark ourselves
                             // for removal.
@@ -112,7 +97,7 @@ impl EventSource for PingSource {
                         Ok(_) => read_something = true,
 
                         // Nothing more to read.
-                        Err(nix::errno::Errno::EAGAIN) => break,
+                        Err(Errno::AGAIN) => break,
 
                         // Propagate error.
                         Err(e) => return Err(e.into()),
@@ -154,7 +139,7 @@ pub struct Ping {
 impl Ping {
     /// Send a ping to the `PingSource`
     pub fn ping(&self) {
-        if let Err(e) = send_ping(self.pipe.as_raw_fd()) {
+        if let Err(e) = send_ping(self.pipe.as_fd()) {
             log::warn!("[calloop] Failed to write a ping: {:?}", e);
         }
     }