chore: update rustix to 1.0

Author: colinmarc

mm-server/Cargo.lock

@@ -25,7 +25,12 @@ crossbeam-channel = "0.5"
 cstr = "0.2"
 ctrlc = "3"
 cursor-icon = "1"
-dasp = { version = "0.11", features = ["signal", "interpolate", "interpolate-sinc", "ring_buffer"] }
+dasp = { version = "0.11", features = [
+    "signal",
+    "interpolate",
+    "interpolate-sinc",
+    "ring_buffer",
+] }
 drm = "0.14"
 drm-fourcc = "2"
 either = "1"
@@ -73,7 +78,11 @@ tracing-tracy = { version = "0.11", default-features = false }
 tracy-client = { version = "0.17", default-features = false }
 uds = "0.4"
 uuid = "1"
-wayland-protocols = { version = "0.32", features = ["server", "staging", "unstable"] }
+wayland-protocols = { version = "0.32", features = [
+    "server",
+    "staging",
+    "unstable",
+] }
 wayland-scanner = "0.31"
 wayland-server = { version = "0.31", features = ["log"] }
 x11rb = { version = "0.13", features = ["composite"] }
@@ -92,9 +101,21 @@ git = "https://github.com/colinmarc/pulseaudio-rs"
 rev = "70ddb748f20ceecc20e963e571188124aeb30186"
 
 [dependencies.rustix]
-version = "0.38"
-default-features = false
-features = ["mm", "mount", "pipe", "time", "thread", "stdio"]
+version = "1.0"
+features = [
+    "core",
+    "event",
+    "fs",
+    "mm",
+    "mount",
+    "net",
+    "pipe",
+    "time",
+    "thread",
+    "stdio",
+    "system",
+    "process",
+]
 
 [dependencies.southpaw]
 git = "https://github.com/colinmarc/southpaw"

mm-server/Cargo.toml

@@ -11,7 +11,7 @@ use std::{
 use anyhow::{bail, Context as _};
 use rustix::{
     mount::MountAttrFlags,
-    process::{Pid, Signal, WaitId, WaitidOptions},
+    process::{Pid, Signal, WaitId, WaitIdOptions},
 };
 use tracing::{debug, info};
 
@@ -51,7 +51,7 @@ impl ContainerHandle {
 
     pub fn wait(&mut self) -> anyhow::Result<()> {
         let exit_status =
-            rustix::process::waitid(WaitId::PidFd(self.as_fd()), WaitidOptions::EXITED)
+            rustix::process::waitid(WaitId::PidFd(self.as_fd()), WaitIdOptions::EXITED)
                 .context("waitid")?
                 .and_then(|x| x.exit_status())
                 .unwrap_or_default();

mm-server/src/container.rs

@@ -100,8 +100,9 @@ fn signal_eventfd(fd: impl AsFd) -> rustix::io::Result<()> {
 fn wait_eventfd(fd: impl AsFd, timeout: time::Duration) -> rustix::io::Result<()> {
     let mut pollfd = [PollFd::new(&fd, PollFlags::IN)];
     let mut buf = [0; 8];
+    let timespec = timeout.try_into().expect("invalid duration");
     loop {
-        match poll(&mut pollfd, timeout.as_millis() as _) {
+        match poll(&mut pollfd, Some(&timespec)) {
             Ok(0) => return Err(Errno::TIMEDOUT),
             Ok(_) => return read(fd, &mut buf).map(|_| ()),
             Err(Errno::INTR) => continue,

mm-server/src/container/ipc.rs

@@ -423,8 +423,7 @@ impl Container {
     }
 
     // Signal safety dictates what we can do here, and it's not a lot. The main
-    // thing we avoid is allocations. Note that rustix is added as a dependency
-    // without the 'alloc' feature.
+    // thing we avoid is allocations.
     unsafe fn child_after_fork<FD>(
         mut self,
         stderr: Option<FD>,
@@ -444,7 +443,7 @@ impl Container {
         // is particularly important because we're PID 1, so the kernel won't
         // kill on SIGINT/SIGQUIT/etc if the child process doesn't have a signal
         // handler set up for them.
-        must!(set_parent_process_death_signal(Some(Signal::Kill)));
+        must!(set_parent_process_death_signal(Some(Signal::KILL)));
 
         preexec_debug!("starting container setup");
 
@@ -694,7 +693,7 @@ where
                 let _ = rustix::stdio::dup2_stderr(fd.as_fd()); // Replace stderr.
             }
 
-            must!(set_parent_process_death_signal(Some(Signal::Kill)));
+            must!(set_parent_process_death_signal(Some(Signal::KILL)));
 
             must!(move_into_link_name_space(
                 ns_pidfd.as_fd(),
@@ -721,7 +720,7 @@ where
             WaitOptions::empty(),
         ) {
             Ok(st) => match st {
-                Some(st) if st.as_raw() == 0 => return Ok(()),
+                Some((_, st)) if st.as_raw() == 0 => return Ok(()),
                 _ => return Err(io::Error::other("forked process exited with error")),
             },
             Err(Errno::INTR) => continue,

mm-server/src/container/runtime.rs

@@ -11,7 +11,7 @@ use std::{
     sync::{Arc, RwLock},
 };
 
-use anyhow::bail;
+use anyhow::{bail, Context as _};
 use ash::vk;
 use drm_fourcc::DrmModifier;
 pub use modifiers::*;
@@ -365,7 +365,10 @@ pub fn validate_buffer_parameters(
 mod ioctl {
     use std::{ffi::c_void, os::fd::RawFd};
 
-    use rustix::{io::Errno, ioctl::Opcode};
+    use rustix::{
+        io::Errno,
+        ioctl::{opcode, Opcode},
+    };
 
     pub(super) const DMA_BUF_SYNC_READ: u32 = 1 << 0;
     pub(super) const DMA_BUF_SYNC_WRITE: u32 = 1 << 1;
@@ -403,9 +406,12 @@ mod ioctl {
     unsafe impl rustix::ioctl::Ioctl for ExportSyncFile {
         type Output = RawFd;
 
-        const OPCODE: Opcode = Opcode::read_write::<dma_buf_export_sync_file>(b'b', 2);
         const IS_MUTATING: bool = true;
 
+        fn opcode(&self) -> Opcode {
+            opcode::read_write::<dma_buf_export_sync_file>(b'b', 2)
+        }
+
         fn as_ptr(&mut self) -> *mut c_void {
             &mut self.0 as *mut dma_buf_export_sync_file as _
         }
@@ -428,9 +434,12 @@ mod ioctl {
     unsafe impl rustix::ioctl::Ioctl for ImportSyncFile {
         type Output = ();
 
-        const OPCODE: Opcode = Opcode::write::<dma_buf_import_sync_file>(b'b', 3);
         const IS_MUTATING: bool = true;
 
+        fn opcode(&self) -> Opcode {
+            opcode::write::<dma_buf_import_sync_file>(b'b', 3)
+        }
+
         fn as_ptr(&mut self) -> *mut c_void {
             &mut self.0 as *mut dma_buf_import_sync_file as _
         }
@@ -483,7 +492,8 @@ pub unsafe fn import_sync_file_as_semaphore(
 
 /// Retrieves the fd of a sync file for a dmabuf.
 pub unsafe fn export_sync_file(dmabuf: impl AsFd, flags: u32) -> anyhow::Result<OwnedFd> {
-    let raw_fd = rustix::ioctl::ioctl(dmabuf, ioctl::ExportSyncFile::new(flags))?;
+    let raw_fd = rustix::ioctl::ioctl(dmabuf, ioctl::ExportSyncFile::new(flags))
+        .context("DMA_BUF_IOCTL_EXPORT_SYNC_FILE")?;
     Ok(OwnedFd::from_raw_fd(raw_fd))
 }
 
@@ -502,7 +512,8 @@ pub unsafe fn attach_sync_file(
     rustix::ioctl::ioctl(
         dmabuf,
         ioctl::ImportSyncFile::new(sync_file.as_raw_fd(), flags),
-    )?;
+    )
+    .context("DMA_BUF_IOCTL_IMPORT_SYNC_FILE")?;
 
     Ok(())
 }

mm-server/src/session/compositor/buffers.rs

@@ -50,7 +50,7 @@ impl DisplaySocket {
         loop {
             let dp = DisplaySocket(display);
 
-            match rustix::net::bind_unix(
+            match rustix::net::bind(
                 &sock,
                 // By convention, the name is the same as the path.
                 &SocketAddrUnix::new_abstract_name(dp.inner_path().as_os_str().as_encoded_bytes())?,
@@ -188,5 +188,5 @@ impl XWayland {
 }
 
 fn unset_cloexec(socket_fd: impl AsFd) -> Result<(), rustix::io::Errno> {
-    rustix::fs::fcntl_setfd(socket_fd, rustix::fs::FdFlags::empty())
+    rustix::io::fcntl_setfd(socket_fd, rustix::io::FdFlags::empty())
 }

mm-server/src/session/compositor/xwayland.rs

@@ -374,7 +374,7 @@ impl Reactor {
 
                                 // Usually, TERM doesn't work, because the
                                 // process is PID 1 in the container.
-                                self.child.signal(rustix::process::Signal::Kill)?;
+                                self.child.signal(rustix::process::Signal::KILL)?;
                             }
                             Ok(msg) => self.handle_control_message(msg)?,
                             Err(crossbeam::TryRecvError::Empty) => break,
@@ -448,7 +448,7 @@ impl Reactor {
             if self.ready_once.is_some() && self.compositor.surfaces_ready() {
                 self.ready_once.take().unwrap().send(control_send.clone())?;
             } else if self.ready_once.is_some() && start.elapsed() > READY_TIMEOUT {
-                self.child.signal(rustix::process::Signal::Kill)?;
+                self.child.signal(rustix::process::Signal::KILL)?;
                 bail!("timed out waiting for client");
             }