Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

136 files changed, 6049 insertions, 7275 deletions

diff --git a/vendor/rustix/src/backend/libc/c.rs b/vendor/rustix/src/backend/libc/c.rs
index 35d24d893..90d3c26f3 100644
--- a/vendor/rustix/src/backend/libc/c.rs
+++ b/vendor/rustix/src/backend/libc/c.rs
@@ -1,9 +1,504 @@
+#![allow(unused_imports)]
+
+// Import everything from libc, but we'll add some stuff and override some
+// things below.
 pub(crate) use libc::*;
 
 /// `PROC_SUPER_MAGIC`—The magic number for the procfs filesystem.
-#[cfg(all(any(target_os = "android", target_os = "linux"), target_env = "musl"))]
+#[cfg(all(linux_kernel, target_env = "musl"))]
 pub(crate) const PROC_SUPER_MAGIC: u32 = 0x0000_9fa0;
 
 /// `NFS_SUPER_MAGIC`—The magic number for the NFS filesystem.
-#[cfg(all(any(target_os = "android", target_os = "linux"), target_env = "musl"))]
+#[cfg(all(linux_kernel, target_env = "musl"))]
 pub(crate) const NFS_SUPER_MAGIC: u32 = 0x0000_6969;
+
+// Submitted upstream in <https://github.com/rust-lang/libc/pull/3272>.
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const IPPROTO_ETHERNET: c_int = linux_raw_sys::net::IPPROTO_ETHERNET as _;
+
+// TODO: Upstream these.
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_TSN: c_int = linux_raw_sys::if_ether::ETH_P_TSN as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_ERSPAN2: c_int = linux_raw_sys::if_ether::ETH_P_ERSPAN2 as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_ERSPAN: c_int = linux_raw_sys::if_ether::ETH_P_ERSPAN as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_PROFINET: c_int = linux_raw_sys::if_ether::ETH_P_PROFINET as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_REALTEK: c_int = linux_raw_sys::if_ether::ETH_P_REALTEK as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_ETHERCAT: c_int = linux_raw_sys::if_ether::ETH_P_ETHERCAT as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_PREAUTH: c_int = linux_raw_sys::if_ether::ETH_P_PREAUTH as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_LLDP: c_int = linux_raw_sys::if_ether::ETH_P_LLDP as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_MRP: c_int = linux_raw_sys::if_ether::ETH_P_MRP as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_NCSI: c_int = linux_raw_sys::if_ether::ETH_P_NCSI as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_CFM: c_int = linux_raw_sys::if_ether::ETH_P_CFM as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_IBOE: c_int = linux_raw_sys::if_ether::ETH_P_IBOE as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_HSR: c_int = linux_raw_sys::if_ether::ETH_P_HSR as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_NSH: c_int = linux_raw_sys::if_ether::ETH_P_NSH as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_DSA_8021Q: c_int = linux_raw_sys::if_ether::ETH_P_DSA_8021Q as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_DSA_A5PSW: c_int = linux_raw_sys::if_ether::ETH_P_DSA_A5PSW as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_IFE: c_int = linux_raw_sys::if_ether::ETH_P_IFE as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_CAN: c_int = linux_raw_sys::if_ether::ETH_P_CAN as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_CANXL: c_int = linux_raw_sys::if_ether::ETH_P_CANXL as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_XDSA: c_int = linux_raw_sys::if_ether::ETH_P_XDSA as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_MAP: c_int = linux_raw_sys::if_ether::ETH_P_MAP as _;
+#[cfg(all(linux_kernel, feature = "net"))]
+pub(crate) const ETH_P_MCTP: c_int = linux_raw_sys::if_ether::ETH_P_MCTP as _;
+
+#[cfg(all(
+    linux_kernel,
+    any(
+        target_arch = "mips",
+        target_arch = "mips64",
+        target_arch = "sparc",
+        target_arch = "sparc64"
+    )
+))]
+pub(crate) const SIGEMT: c_int = linux_raw_sys::general::SIGEMT as _;
+
+// TODO: Upstream these.
+#[cfg(all(linux_kernel, feature = "termios"))]
+pub(crate) const IUCLC: tcflag_t = linux_raw_sys::general::IUCLC as _;
+#[cfg(all(linux_kernel, feature = "termios"))]
+pub(crate) const XCASE: tcflag_t = linux_raw_sys::general::XCASE as _;
+
+// On PowerPC, the regular `termios` has the `termios2` fields and there is no
+// `termios2`. linux-raw-sys has aliases `termios2` to `termios` to cover this
+// difference, but we still need to manually import it since `libc` doesn't
+// have this.
+#[cfg(all(
+    linux_kernel,
+    feature = "termios",
+    any(target_arch = "powerpc", target_arch = "powerpc64")
+))]
+pub(crate) use {
+    linux_raw_sys::general::{termios2, CIBAUD},
+    linux_raw_sys::ioctl::{TCGETS2, TCSETS2, TCSETSF2, TCSETSW2},
+};
+
+// Automatically enable “large file” support (LFS) features.
+
+#[cfg(target_os = "vxworks")]
+pub(super) use libc::_Vx_ticks64_t as _Vx_ticks_t;
+#[cfg(target_os = "aix")]
+pub(super) use libc::blksize64_t as blksize_t;
+#[cfg(linux_kernel)]
+pub(super) use libc::fallocate64 as fallocate;
+#[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
+#[cfg(any(linux_like, target_os = "aix"))]
+pub(super) use libc::open64 as open;
+#[cfg(any(linux_kernel, target_os = "aix", target_os = "l4re"))]
+pub(super) use libc::posix_fallocate64 as posix_fallocate;
+#[cfg(any(all(linux_like, not(target_os = "android")), target_os = "aix"))]
+pub(super) use libc::{blkcnt64_t as blkcnt_t, rlim64_t as rlim_t};
+#[cfg(any(linux_like, target_os = "aix"))]
+pub(super) use libc::{
+    fstat64 as fstat, fstatat64 as fstatat, fstatfs64 as fstatfs, fstatvfs64 as fstatvfs,
+    ftruncate64 as ftruncate, getrlimit64 as getrlimit, ino64_t as ino_t, lseek64 as lseek,
+    mmap64 as mmap, off64_t as off_t, openat64 as openat, posix_fadvise64 as posix_fadvise,
+    rlimit64 as rlimit, setrlimit64 as setrlimit, statfs64 as statfs, statvfs64 as statvfs,
+    RLIM64_INFINITY as RLIM_INFINITY,
+};
+#[cfg(apple)]
+pub(super) use libc::{
+    host_info64_t as host_info_t, host_statistics64 as host_statistics,
+    vm_statistics64_t as vm_statistics_t,
+};
+#[cfg(not(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64"))))]
+#[cfg(any(linux_like, target_os = "aix"))]
+pub(super) use libc::{lstat64 as lstat, stat64 as stat};
+#[cfg(any(linux_kernel, target_os = "aix", target_os = "emscripten"))]
+pub(super) use libc::{pread64 as pread, pwrite64 as pwrite};
+#[cfg(any(target_os = "aix", target_os = "linux", target_os = "emscripten"))]
+pub(super) use libc::{preadv64 as preadv, pwritev64 as pwritev};
+
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+pub(super) unsafe fn prlimit(
+    pid: libc::pid_t,
+    resource: libc::__rlimit_resource_t,
+    new_limit: *const libc::rlimit64,
+    old_limit: *mut libc::rlimit64,
+) -> libc::c_int {
+    // `prlimit64` wasn't supported in glibc until 2.13.
+    weak_or_syscall! {
+        fn prlimit64(
+            pid: libc::pid_t,
+            resource: libc::__rlimit_resource_t,
+            new_limit: *const libc::rlimit64,
+            old_limit: *mut libc::rlimit64
+        ) via SYS_prlimit64 -> libc::c_int
+    }
+
+    prlimit64(pid, resource, new_limit, old_limit)
+}
+
+#[cfg(all(target_os = "linux", target_env = "musl"))]
+pub(super) unsafe fn prlimit(
+    pid: libc::pid_t,
+    resource: libc::c_int,
+    new_limit: *const libc::rlimit64,
+    old_limit: *mut libc::rlimit64,
+) -> libc::c_int {
+    weak_or_syscall! {
+        fn prlimit64(
+            pid: libc::pid_t,
+            resource: libc::c_int,
+            new_limit: *const libc::rlimit64,
+            old_limit: *mut libc::rlimit64
+        ) via SYS_prlimit64 -> libc::c_int
+    }
+
+    prlimit64(pid, resource, new_limit, old_limit)
+}
+
+#[cfg(target_os = "android")]
+pub(super) unsafe fn prlimit(
+    pid: libc::pid_t,
+    resource: libc::c_int,
+    new_limit: *const libc::rlimit64,
+    old_limit: *mut libc::rlimit64,
+) -> libc::c_int {
+    weak_or_syscall! {
+        fn prlimit64(
+            pid: libc::pid_t,
+            resource: libc::c_int,
+            new_limit: *const libc::rlimit64,
+            old_limit: *mut libc::rlimit64
+        ) via SYS_prlimit64 -> libc::c_int
+    }
+
+    prlimit64(pid, resource, new_limit, old_limit)
+}
+
+// 64-bit offsets on 32-bit platforms are passed in endianness-specific
+// lo/hi pairs. See src/backend/linux_raw/conv.rs for details.
+#[cfg(all(linux_kernel, target_endian = "little", target_pointer_width = "32"))]
+fn lo(x: i64) -> usize {
+    (x >> 32) as usize
+}
+#[cfg(all(linux_kernel, target_endian = "little", target_pointer_width = "32"))]
+fn hi(x: i64) -> usize {
+    x as usize
+}
+#[cfg(all(linux_kernel, target_endian = "big", target_pointer_width = "32"))]
+fn lo(x: i64) -> usize {
+    x as usize
+}
+#[cfg(all(linux_kernel, target_endian = "big", target_pointer_width = "32"))]
+fn hi(x: i64) -> usize {
+    (x >> 32) as usize
+}
+
+#[cfg(target_os = "android")]
+mod readwrite_pv64 {
+    use super::*;
+
+    pub(in super::super) unsafe fn preadv64(
+        fd: libc::c_int,
+        iov: *const libc::iovec,
+        iovcnt: libc::c_int,
+        offset: libc::off64_t,
+    ) -> libc::ssize_t {
+        // Older Android libc lacks `preadv64`, so use the `weak!` mechanism to
+        // test for it, and call back to `libc::syscall`. We don't use
+        // `weak_or_syscall` here because we need to pass the 64-bit offset
+        // specially.
+        weak! {
+            fn preadv64(libc::c_int, *const libc::iovec, libc::c_int, libc::off64_t) -> libc::ssize_t
+        }
+        if let Some(fun) = preadv64.get() {
+            fun(fd, iov, iovcnt, offset)
+        } else {
+            #[cfg(target_pointer_width = "32")]
+            {
+                syscall! {
+                    fn preadv(
+                        fd: libc::c_int,
+                        iov: *const libc::iovec,
+                        iovcnt: libc::c_int,
+                        offset_hi: usize,
+                        offset_lo: usize
+                    ) via SYS_preadv -> libc::ssize_t
+                }
+                preadv(fd, iov, iovcnt, hi(offset), lo(offset))
+            }
+            #[cfg(target_pointer_width = "64")]
+            {
+                syscall! {
+                    fn preadv(
+                        fd: libc::c_int,
+                        iov: *const libc::iovec,
+                        iovcnt: libc::c_int,
+                        offset: libc::off_t
+                    ) via SYS_preadv -> libc::ssize_t
+                }
+                preadv(fd, iov, iovcnt, offset)
+            }
+        }
+    }
+    pub(in super::super) unsafe fn pwritev64(
+        fd: libc::c_int,
+        iov: *const libc::iovec,
+        iovcnt: libc::c_int,
+        offset: libc::off64_t,
+    ) -> libc::ssize_t {
+        // See the comments in `preadv64`.
+        weak! {
+            fn pwritev64(libc::c_int, *const libc::iovec, libc::c_int, libc::off64_t) -> libc::ssize_t
+        }
+        if let Some(fun) = pwritev64.get() {
+            fun(fd, iov, iovcnt, offset)
+        } else {
+            #[cfg(target_pointer_width = "32")]
+            {
+                syscall! {
+                    fn pwritev(
+                        fd: libc::c_int,
+                        iov: *const libc::iovec,
+                        iovcnt: libc::c_int,
+                        offset_hi: usize,
+                        offset_lo: usize
+                    ) via SYS_pwritev -> libc::ssize_t
+                }
+                pwritev(fd, iov, iovcnt, hi(offset), lo(offset))
+            }
+            #[cfg(target_pointer_width = "64")]
+            {
+                syscall! {
+                    fn pwritev(
+                        fd: libc::c_int,
+                        iov: *const libc::iovec,
+                        iovcnt: libc::c_int,
+                        offset: libc::off_t
+                    ) via SYS_pwritev -> libc::ssize_t
+                }
+                pwritev(fd, iov, iovcnt, offset)
+            }
+        }
+    }
+}
+#[cfg(target_os = "android")]
+pub(super) use readwrite_pv64::{preadv64 as preadv, pwritev64 as pwritev};
+
+// macOS added preadv and pwritev in version 11.0
+#[cfg(apple)]
+mod readwrite_pv {
+    weakcall! {
+        pub(in super::super) fn preadv(
+            fd: libc::c_int,
+            iov: *const libc::iovec,
+            iovcnt: libc::c_int,
+            offset: libc::off_t
+        ) -> libc::ssize_t
+    }
+    weakcall! {
+        pub(in super::super) fn pwritev(
+            fd: libc::c_int,
+            iov: *const libc::iovec,
+            iovcnt: libc::c_int, offset: libc::off_t
+        ) -> libc::ssize_t
+    }
+}
+#[cfg(apple)]
+pub(super) use readwrite_pv::{preadv, pwritev};
+
+// glibc added `preadv64v2` and `pwritev64v2` in version 2.26.
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+mod readwrite_pv64v2 {
+    use super::*;
+
+    pub(in super::super) unsafe fn preadv64v2(
+        fd: libc::c_int,
+        iov: *const libc::iovec,
+        iovcnt: libc::c_int,
+        offset: libc::off64_t,
+        flags: libc::c_int,
+    ) -> libc::ssize_t {
+        // Older glibc lacks `preadv64v2`, so use the `weak!` mechanism to
+        // test for it, and call back to `libc::syscall`. We don't use
+        // `weak_or_syscall` here because we need to pass the 64-bit offset
+        // specially.
+        weak! {
+            fn preadv64v2(libc::c_int, *const libc::iovec, libc::c_int, libc::off64_t, libc::c_int) -> libc::ssize_t
+        }
+        if let Some(fun) = preadv64v2.get() {
+            fun(fd, iov, iovcnt, offset, flags)
+        } else {
+            #[cfg(target_pointer_width = "32")]
+            {
+                syscall! {
+                    fn preadv2(
+                        fd: libc::c_int,
+                        iov: *const libc::iovec,
+                        iovcnt: libc::c_int,
+                        offset_hi: usize,
+                        offset_lo: usize,
+                        flags: libc::c_int
+                    ) via SYS_preadv2 -> libc::ssize_t
+                }
+                preadv2(fd, iov, iovcnt, hi(offset), lo(offset), flags)
+            }
+            #[cfg(target_pointer_width = "64")]
+            {
+                syscall! {
+                    fn preadv2(
+                        fd: libc::c_int,
+                        iov: *const libc::iovec,
+                        iovcnt: libc::c_int,
+                        offset: libc::off_t,
+                        flags: libc::c_int
+                    ) via SYS_preadv2 -> libc::ssize_t
+                }
+                preadv2(fd, iov, iovcnt, offset, flags)
+            }
+        }
+    }
+    pub(in super::super) unsafe fn pwritev64v2(
+        fd: libc::c_int,
+        iov: *const libc::iovec,
+        iovcnt: libc::c_int,
+        offset: libc::off64_t,
+        flags: libc::c_int,
+    ) -> libc::ssize_t {
+        // See the comments in `preadv64v2`.
+        weak! {
+            fn pwritev64v2(libc::c_int, *const libc::iovec, libc::c_int, libc::off64_t, libc::c_int) -> libc::ssize_t
+        }
+        if let Some(fun) = pwritev64v2.get() {
+            fun(fd, iov, iovcnt, offset, flags)
+        } else {
+            #[cfg(target_pointer_width = "32")]
+            {
+                syscall! {
+                    fn pwritev2(
+                        fd: libc::c_int,
+                        iov: *const libc::iovec,
+                        iovec: libc::c_int,
+                        offset_hi: usize,
+                        offset_lo: usize,
+                        flags: libc::c_int
+                    ) via SYS_pwritev2 -> libc::ssize_t
+                }
+                pwritev2(fd, iov, iovcnt, hi(offset), lo(offset), flags)
+            }
+            #[cfg(target_pointer_width = "64")]
+            {
+                syscall! {
+                    fn pwritev2(
+                        fd: libc::c_int,
+                        iov:*const libc::iovec,
+                        iovcnt: libc::c_int,
+                        offset: libc::off_t,
+                        flags: libc::c_int
+                    ) via SYS_pwritev2 -> libc::ssize_t
+                }
+                pwritev2(fd, iov, iovcnt, offset, flags)
+            }
+        }
+    }
+}
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+pub(super) use readwrite_pv64v2::{preadv64v2 as preadv2, pwritev64v2 as pwritev2};
+
+// On non-glibc, assume we don't have `pwritev2`/`preadv2` in libc and use
+// `c::syscall` instead.
+#[cfg(any(
+    target_os = "android",
+    all(target_os = "linux", not(target_env = "gnu")),
+))]
+mod readwrite_pv64v2 {
+    use super::*;
+
+    pub(in super::super) unsafe fn preadv64v2(
+        fd: libc::c_int,
+        iov: *const libc::iovec,
+        iovcnt: libc::c_int,
+        offset: libc::off64_t,
+        flags: libc::c_int,
+    ) -> libc::ssize_t {
+        #[cfg(target_pointer_width = "32")]
+        {
+            syscall! {
+                fn preadv2(
+                    fd: libc::c_int,
+                    iov: *const libc::iovec,
+                    iovcnt: libc::c_int,
+                    offset_hi: usize,
+                    offset_lo: usize,
+                    flags: libc::c_int
+                ) via SYS_preadv2 -> libc::ssize_t
+            }
+            preadv2(fd, iov, iovcnt, hi(offset), lo(offset), flags)
+        }
+        #[cfg(target_pointer_width = "64")]
+        {
+            syscall! {
+                fn preadv2(
+                    fd: libc::c_int,
+                    iov: *const libc::iovec,
+                    iovcnt: libc::c_int,
+                    offset: libc::off_t,
+                    flags: libc::c_int
+                ) via SYS_preadv2 -> libc::ssize_t
+            }
+            preadv2(fd, iov, iovcnt, offset, flags)
+        }
+    }
+    pub(in super::super) unsafe fn pwritev64v2(
+        fd: libc::c_int,
+        iov: *const libc::iovec,
+        iovcnt: libc::c_int,
+        offset: libc::off64_t,
+        flags: libc::c_int,
+    ) -> libc::ssize_t {
+        #[cfg(target_pointer_width = "32")]
+        {
+            syscall! {
+                fn pwritev2(
+                    fd: libc::c_int,
+                    iov: *const libc::iovec,
+                    iovcnt: libc::c_int,
+                    offset_hi: usize,
+                    offset_lo: usize,
+                    flags: libc::c_int
+                ) via SYS_pwritev2 -> libc::ssize_t
+            }
+            pwritev2(fd, iov, iovcnt, hi(offset), lo(offset), flags)
+        }
+        #[cfg(target_pointer_width = "64")]
+        {
+            syscall! {
+                fn pwritev2(
+                    fd: libc::c_int,
+                    iov:*const libc::iovec,
+                    iovcnt: libc::c_int,
+                    offset: libc::off_t,
+                    flags: libc::c_int
+                ) via SYS_pwritev2 -> libc::ssize_t
+            }
+            pwritev2(fd, iov, iovcnt, offset, flags)
+        }
+    }
+}
+#[cfg(any(
+    target_os = "android",
+    all(target_os = "linux", not(target_env = "gnu")),
+))]
+pub(super) use readwrite_pv64v2::{preadv64v2 as preadv2, pwritev64v2 as pwritev2};
diff --git a/vendor/rustix/src/backend/libc/conv.rs b/vendor/rustix/src/backend/libc/conv.rs
index b827d0bbc..d6bcc16ee 100644
--- a/vendor/rustix/src/backend/libc/conv.rs
+++ b/vendor/rustix/src/backend/libc/conv.rs
@@ -7,13 +7,8 @@
 use super::c;
 use super::fd::{AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, LibcFd, OwnedFd, RawFd};
 #[cfg(not(windows))]
-#[cfg(feature = "fs")]
-use super::offset::libc_off_t;
-#[cfg(not(windows))]
 use crate::ffi::CStr;
 use crate::io;
-#[cfg(windows)]
-use core::convert::TryInto;
 
 #[cfg(not(windows))]
 #[inline]
@@ -47,15 +42,6 @@ pub(super) fn ret(raw: c::c_int) -> io::Result<()> {
 }
 
 #[inline]
-pub(super) fn syscall_ret(raw: c::c_long) -> io::Result<()> {
-    if raw == 0 {
-        Ok(())
-    } else {
-        Err(io::Errno::last_os_error())
-    }
-}
-
-#[inline]
 pub(super) fn nonnegative_ret(raw: c::c_int) -> io::Result<()> {
     if raw >= 0 {
         Ok(())
@@ -97,35 +83,10 @@ pub(super) fn ret_usize(raw: c::ssize_t) -> io::Result<usize> {
     }
 }
 
-#[inline]
-pub(super) fn syscall_ret_usize(raw: c::c_long) -> io::Result<usize> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        debug_assert!(raw >= 0);
-        Ok(raw as c::ssize_t as usize)
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(super) fn syscall_ret_u32(raw: c::c_long) -> io::Result<u32> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        let r32 = raw as u32;
-
-        // Converting `raw` to `u32` should be lossless.
-        debug_assert_eq!(r32 as c::c_long, raw);
-
-        Ok(r32)
-    }
-}
-
 #[cfg(not(windows))]
 #[cfg(feature = "fs")]
 #[inline]
-pub(super) fn ret_off_t(raw: libc_off_t) -> io::Result<libc_off_t> {
+pub(super) fn ret_off_t(raw: c::off_t) -> io::Result<c::off_t> {
     if raw == -1 {
         Err(io::Errno::last_os_error())
     } else {
@@ -176,22 +137,6 @@ pub(super) fn ret_discarded_char_ptr(raw: *mut c::c_char) -> io::Result<()> {
     }
 }
 
-/// Convert a `c_long` returned from `syscall` to an `OwnedFd`, if valid.
-///
-/// # Safety
-///
-/// The caller must ensure that this is the return value of a `syscall` call
-/// which returns an owned file descriptor.
-#[cfg(not(windows))]
-#[inline]
-pub(super) unsafe fn syscall_ret_owned_fd(raw: c::c_long) -> io::Result<OwnedFd> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(OwnedFd::from_raw_fd(raw as RawFd))
-    }
-}
-
 /// Convert the buffer-length argument value of a `send` or `recv` call.
 #[cfg(not(windows))]
 #[inline]
@@ -222,3 +167,59 @@ pub(super) fn ret_send_recv(len: isize) -> io::Result<usize> {
 pub(super) fn ret_send_recv(len: i32) -> io::Result<usize> {
     ret_usize(len as isize)
 }
+
+/// Convert the value to the `msg_iovlen` field of a `msghdr` struct.
+#[cfg(all(
+    not(any(windows, target_os = "wasi")),
+    any(
+        target_os = "android",
+        all(target_os = "linux", not(target_env = "musl"))
+    )
+))]
+#[inline]
+pub(super) fn msg_iov_len(len: usize) -> c::size_t {
+    len
+}
+
+/// Convert the value to the `msg_iovlen` field of a `msghdr` struct.
+#[cfg(all(
+    not(any(windows, target_os = "wasi")),
+    not(any(
+        target_os = "android",
+        all(target_os = "linux", not(target_env = "musl"))
+    ))
+))]
+#[inline]
+pub(crate) fn msg_iov_len(len: usize) -> c::c_int {
+    len.try_into().unwrap_or(c::c_int::MAX)
+}
+
+/// Convert the value to a `socklen_t`.
+#[cfg(any(
+    bsd,
+    solarish,
+    target_env = "musl",
+    target_os = "emscripten",
+    target_os = "haiku",
+    target_os = "fuchsia"
+))]
+#[inline]
+pub(crate) fn msg_control_len(len: usize) -> c::socklen_t {
+    len.try_into().unwrap_or(c::socklen_t::MAX)
+}
+
+/// Convert the value to a `size_t`.
+#[cfg(not(any(
+    bsd,
+    solarish,
+    target_env = "musl",
+    target_os = "emscripten",
+    target_os = "haiku",
+    target_os = "fuchsia",
+    windows,
+    target_os = "wasi"
+)))]
+#[inline]
+pub(crate) fn msg_control_len(len: usize) -> c::size_t {
+    len
+}
diff --git a/vendor/rustix/src/backend/libc/io/epoll.rs b/vendor/rustix/src/backend/libc/event/epoll.rs
index 62a3c742b..c59a38cd4 100644
--- a/vendor/rustix/src/backend/libc/io/epoll.rs
+++ b/vendor/rustix/src/backend/libc/event/epoll.rs
@@ -7,45 +7,50 @@
 //! # Examples
 //!
 //! ```no_run
-//! # #![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
 //! # #[cfg(feature = "net")]
 //! # fn main() -> std::io::Result<()> {
-//! use io_lifetimes::AsFd;
-//! use rustix::io::{epoll, ioctl_fionbio, read, write};
+//! use rustix::event::epoll;
+//! use rustix::fd::AsFd;
+//! use rustix::io::{ioctl_fionbio, read, write};
 //! use rustix::net::{
-//!     accept, bind_v4, listen, socket, AddressFamily, Ipv4Addr, Protocol, SocketAddrV4,
-//!     SocketType,
+//!     accept, bind_v4, listen, socket, AddressFamily, Ipv4Addr, SocketAddrV4, SocketType,
 //! };
 //! use std::collections::HashMap;
 //! use std::os::unix::io::AsRawFd;
 //!
 //! // Create a socket and listen on it.
-//! let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+//! let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, None)?;
 //! bind_v4(&listen_sock, &SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0))?;
 //! listen(&listen_sock, 1)?;
 //!
 //! // Create an epoll object. Using `Owning` here means the epoll object will
 //! // take ownership of the file descriptors registered with it.
-//! let epoll = epoll::epoll_create(epoll::CreateFlags::CLOEXEC)?;
+//! let epoll = epoll::create(epoll::CreateFlags::CLOEXEC)?;
 //!
 //! // Register the socket with the epoll object.
-//! epoll::epoll_add(&epoll, &listen_sock, 1, epoll::EventFlags::IN)?;
+//! epoll::add(
+//!     &epoll,
+//!     &listen_sock,
+//!     epoll::EventData::new_u64(1),
+//!     epoll::EventFlags::IN,
+//! )?;
 //!
 //! // Keep track of the sockets we've opened.
-//! let mut next_id = 2;
+//! let mut next_id = epoll::EventData::new_u64(2);
 //! let mut sockets = HashMap::new();
 //!
 //! // Process events.
 //! let mut event_list = epoll::EventVec::with_capacity(4);
 //! loop {
-//!     epoll::epoll_wait(&epoll, &mut event_list, -1)?;
-//!     for (_event_flags, target) in &event_list {
-//!         if target == 1 {
+//!     epoll::wait(&epoll, &mut event_list, -1)?;
+//!     for event in &event_list {
+//!         let target = event.data;
+//!         if target.u64() == 1 {
 //!             // Accept a new connection, set it to non-blocking, and
 //!             // register to be notified when it's ready to write to.
 //!             let conn_sock = accept(&listen_sock)?;
 //!             ioctl_fionbio(&conn_sock, true)?;
-//!             epoll::epoll_add(
+//!             epoll::add(
 //!                 &epoll,
 //!                 &conn_sock,
 //!                 next_id,
@@ -54,12 +59,12 @@
 //!
 //!             // Keep track of the socket.
 //!             sockets.insert(next_id, conn_sock);
-//!             next_id += 1;
+//!             next_id = epoll::EventData::new_u64(next_id.u64() + 1);
 //!         } else {
 //!             // Write a message to the stream and then unregister it.
 //!             let target = sockets.remove(&target).unwrap();
 //!             write(&target, b"hello\n")?;
-//!             let _ = epoll::epoll_del(&epoll, &target)?;
+//!             let _ = epoll::delete(&epoll, &target)?;
 //!         }
 //!     }
 //! }
@@ -68,151 +73,166 @@
 //! # fn main() {}
 //! ```
 
-use super::super::c;
-use super::super::conv::{ret, ret_owned_fd, ret_u32};
+use crate::backend::c;
+use crate::backend::conv::{ret, ret_owned_fd, ret_u32};
 use crate::fd::{AsFd, AsRawFd, OwnedFd};
 use crate::io;
+use crate::utils::as_mut_ptr;
 use alloc::vec::Vec;
 use bitflags::bitflags;
-use core::convert::TryInto;
+use core::ffi::c_void;
+use core::hash::{Hash, Hasher};
 use core::ptr::null_mut;
+use core::slice;
 
 bitflags! {
-    /// `EPOLL_*` for use with [`Epoll::new`].
-    pub struct CreateFlags: c::c_int {
+    /// `EPOLL_*` for use with [`new`].
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct CreateFlags: u32 {
         /// `EPOLL_CLOEXEC`
-        const CLOEXEC = c::EPOLL_CLOEXEC;
+        const CLOEXEC = bitcast!(c::EPOLL_CLOEXEC);
     }
 }
 
 bitflags! {
-    /// `EPOLL*` for use with [`Epoll::add`].
-    #[derive(Default)]
+    /// `EPOLL*` for use with [`add`].
+    #[repr(transparent)]
+    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct EventFlags: u32 {
         /// `EPOLLIN`
-        const IN = c::EPOLLIN as u32;
+        const IN = bitcast!(c::EPOLLIN);
 
         /// `EPOLLOUT`
-        const OUT = c::EPOLLOUT as u32;
+        const OUT = bitcast!(c::EPOLLOUT);
 
         /// `EPOLLPRI`
-        const PRI = c::EPOLLPRI as u32;
+        const PRI = bitcast!(c::EPOLLPRI);
 
         /// `EPOLLERR`
-        const ERR = c::EPOLLERR as u32;
+        const ERR = bitcast!(c::EPOLLERR);
 
         /// `EPOLLHUP`
-        const HUP = c::EPOLLHUP as u32;
+        const HUP = bitcast!(c::EPOLLHUP);
 
         /// `EPOLLRDNORM`
-        const RDNORM = c::EPOLLRDNORM as u32;
+        const RDNORM = bitcast!(c::EPOLLRDNORM);
 
         /// `EPOLLRDBAND`
-        const RDBAND = c::EPOLLRDBAND as u32;
+        const RDBAND = bitcast!(c::EPOLLRDBAND);
 
         /// `EPOLLWRNORM`
-        const WRNORM = c::EPOLLWRNORM as u32;
+        const WRNORM = bitcast!(c::EPOLLWRNORM);
 
         /// `EPOLLWRBAND`
-        const WRBAND = c::EPOLLWRBAND as u32;
+        const WRBAND = bitcast!(c::EPOLLWRBAND);
 
         /// `EPOLLMSG`
-        const MSG = c::EPOLLMSG as u32;
+        const MSG = bitcast!(c::EPOLLMSG);
 
         /// `EPOLLRDHUP`
-        const RDHUP = c::EPOLLRDHUP as u32;
+        const RDHUP = bitcast!(c::EPOLLRDHUP);
 
         /// `EPOLLET`
-        const ET = c::EPOLLET as u32;
+        const ET = bitcast!(c::EPOLLET);
 
         /// `EPOLLONESHOT`
-        const ONESHOT = c::EPOLLONESHOT as u32;
+        const ONESHOT = bitcast!(c::EPOLLONESHOT);
 
         /// `EPOLLWAKEUP`
-        const WAKEUP = c::EPOLLWAKEUP as u32;
+        const WAKEUP = bitcast!(c::EPOLLWAKEUP);
 
         /// `EPOLLEXCLUSIVE`
         #[cfg(not(target_os = "android"))]
-        const EXCLUSIVE = c::EPOLLEXCLUSIVE as u32;
+        const EXCLUSIVE = bitcast!(c::EPOLLEXCLUSIVE);
     }
 }
 
-/// `epoll_create1(flags)`—Creates a new `Epoll`.
+/// `epoll_create1(flags)`—Creates a new epoll object.
 ///
 /// Use the [`CreateFlags::CLOEXEC`] flag to prevent the resulting file
 /// descriptor from being implicitly passed across `exec` boundaries.
 #[inline]
 #[doc(alias = "epoll_create1")]
-pub fn epoll_create(flags: CreateFlags) -> io::Result<OwnedFd> {
+pub fn create(flags: CreateFlags) -> io::Result<OwnedFd> {
     // SAFETY: We're calling `epoll_create1` via FFI and we know how it
     // behaves.
-    unsafe { ret_owned_fd(c::epoll_create1(flags.bits())) }
+    unsafe { ret_owned_fd(c::epoll_create1(bitflags_bits!(flags))) }
 }
 
 /// `epoll_ctl(self, EPOLL_CTL_ADD, data, event)`—Adds an element to an
-/// `Epoll`.
+/// epoll object.
 ///
-/// Note that if `epoll_del` is not called on the I/O source passed into
-/// this function before the I/O source is `close`d, then the `epoll` will
-/// act as if the I/O source is still registered with it. This can lead to
-/// spurious events being returned from `epoll_wait`. If a file descriptor
-/// is an `Arc<dyn SystemResource>`, then `epoll` can be thought to maintain
-/// a `Weak<dyn SystemResource>` to the file descriptor.
+/// This registers interest in any of the events set in `events` occurring
+/// on the file descriptor associated with `data`.
+///
+/// If [`delete`] is not called on the I/O source passed into this function
+/// before the I/O source is `close`d, then the `epoll` will act as if the I/O
+/// source is still registered with it. This can lead to spurious events being
+/// returned from [`wait`]. If a file descriptor is an
+/// `Arc<dyn SystemResource>`, then `epoll` can be thought to maintain a
+/// `Weak<dyn SystemResource>` to the file descriptor.
 #[doc(alias = "epoll_ctl")]
-pub fn epoll_add(
+pub fn add(
     epoll: impl AsFd,
     source: impl AsFd,
-    data: u64,
+    data: EventData,
     event_flags: EventFlags,
 ) -> io::Result<()> {
     // SAFETY: We're calling `epoll_ctl` via FFI and we know how it
-    // behaves.
+    // behaves. We use our own `Event` struct instead of libc's because
+    // ours preserves pointer provenance instead of just using a `u64`,
+    // and we have tests elsehwere for layout equivalence.
     unsafe {
         let raw_fd = source.as_fd().as_raw_fd();
         ret(c::epoll_ctl(
             epoll.as_fd().as_raw_fd(),
             c::EPOLL_CTL_ADD,
             raw_fd,
-            &mut c::epoll_event {
-                events: event_flags.bits(),
-                r#u64: data,
-            },
+            as_mut_ptr(&mut Event {
+                flags: event_flags,
+                data,
+            })
+            .cast(),
         ))
     }
 }
 
 /// `epoll_ctl(self, EPOLL_CTL_MOD, target, event)`—Modifies an element in
-/// this `Epoll`.
+/// a given epoll object.
 ///
 /// This sets the events of interest with `target` to `events`.
 #[doc(alias = "epoll_ctl")]
-pub fn epoll_mod(
+pub fn modify(
     epoll: impl AsFd,
     source: impl AsFd,
-    data: u64,
+    data: EventData,
     event_flags: EventFlags,
 ) -> io::Result<()> {
     let raw_fd = source.as_fd().as_raw_fd();
 
     // SAFETY: We're calling `epoll_ctl` via FFI and we know how it
-    // behaves.
+    // behaves. We use our own `Event` struct instead of libc's because
+    // ours preserves pointer provenance instead of just using a `u64`,
+    // and we have tests elsehwere for layout equivalence.
     unsafe {
         ret(c::epoll_ctl(
             epoll.as_fd().as_raw_fd(),
             c::EPOLL_CTL_MOD,
             raw_fd,
-            &mut c::epoll_event {
-                events: event_flags.bits(),
-                r#u64: data,
-            },
+            as_mut_ptr(&mut Event {
+                flags: event_flags,
+                data,
+            })
+            .cast(),
         ))
     }
 }
 
 /// `epoll_ctl(self, EPOLL_CTL_DEL, target, NULL)`—Removes an element in
-/// this `Epoll`.
+/// a given epoll object.
 #[doc(alias = "epoll_ctl")]
-pub fn epoll_del(epoll: impl AsFd, source: impl AsFd) -> io::Result<()> {
+pub fn delete(epoll: impl AsFd, source: impl AsFd) -> io::Result<()> {
     // SAFETY: We're calling `epoll_ctl` via FFI and we know how it
     // behaves.
     unsafe {
@@ -231,11 +251,7 @@ pub fn epoll_del(epoll: impl AsFd, source: impl AsFd) -> io::Result<()> {
 ///
 /// For each event of interest, an element is written to `events`. On
 /// success, this returns the number of written elements.
-pub fn epoll_wait(
-    epoll: impl AsFd,
-    event_list: &mut EventVec,
-    timeout: c::c_int,
-) -> io::Result<()> {
+pub fn wait(epoll: impl AsFd, event_list: &mut EventVec, timeout: c::c_int) -> io::Result<()> {
     // SAFETY: We're calling `epoll_wait` via FFI and we know how it
     // behaves.
     unsafe {
@@ -254,19 +270,18 @@ pub fn epoll_wait(
 
 /// An iterator over the `Event`s in an `EventVec`.
 pub struct Iter<'a> {
-    iter: core::slice::Iter<'a, Event>,
+    /// Use `Copied` to copy the struct, since `Event` is `packed` on some
+    /// platforms, and it's common for users to directly destructure it,
+    /// which would lead to errors about forming references to packed fields.
+    iter: core::iter::Copied<slice::Iter<'a, Event>>,
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = (EventFlags, u64);
+    type Item = Event;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        // SAFETY: `self.context` is guaranteed to be valid because we hold
-        // `'context` for it. And we know this event is associated with this
-        // context because `wait` sets both.
-        self.iter
-            .next()
-            .map(|event| (event.event_flags, event.data))
+        self.iter.next()
     }
 }
 
@@ -283,11 +298,94 @@ impl<'a> Iterator for Iter<'a> {
     ),
     repr(packed)
 )]
-struct Event {
-    // Match the layout of `c::epoll_event`. We just use a `u64` instead of
-    // the full union.
-    event_flags: EventFlags,
-    data: u64,
+#[derive(Copy, Clone, Eq, PartialEq, Hash)]
+pub struct Event {
+    /// Which specific event(s) occurred.
+    pub flags: EventFlags,
+    /// User data.
+    pub data: EventData,
+}
+
+/// Data assocated with an [`Event`]. This can either be a 64-bit integer value
+/// or a pointer which preserves pointer provenance.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union EventData {
+    /// A 64-bit integer value.
+    as_u64: u64,
+
+    /// A `*mut c_void` which preserves pointer provenance, extended to be
+    /// 64-bit so that if we read the value as a `u64` union field, we don't
+    /// get uninitialized memory.
+    sixty_four_bit_pointer: SixtyFourBitPointer,
+}
+
+impl EventData {
+    /// Construct a new value containing a `u64`.
+    #[inline]
+    pub const fn new_u64(value: u64) -> Self {
+        Self { as_u64: value }
+    }
+
+    /// Construct a new value containing a `*mut c_void`.
+    #[inline]
+    pub const fn new_ptr(value: *mut c_void) -> Self {
+        Self {
+            sixty_four_bit_pointer: SixtyFourBitPointer {
+                pointer: value,
+                #[cfg(target_pointer_width = "32")]
+                _padding: 0,
+            },
+        }
+    }
+
+    /// Return the value as a `u64`.
+    ///
+    /// If the stored value was a pointer, the pointer is zero-extended to
+    /// a `u64`.
+    #[inline]
+    pub fn u64(self) -> u64 {
+        unsafe { self.as_u64 }
+    }
+
+    /// Return the value as a `*mut c_void`.
+    ///
+    /// If the stored value was a `u64`, the least-significant bits of the
+    /// `u64` are returned as a pointer value.
+    #[inline]
+    pub fn ptr(self) -> *mut c_void {
+        unsafe { self.sixty_four_bit_pointer.pointer }
+    }
+}
+
+impl PartialEq for EventData {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.u64() == other.u64()
+    }
+}
+
+impl Eq for EventData {}
+
+impl Hash for EventData {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.u64().hash(state)
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct SixtyFourBitPointer {
+    #[cfg(target_endian = "big")]
+    #[cfg(target_pointer_width = "32")]
+    _padding: u32,
+
+    pointer: *mut c_void,
+
+    #[cfg(target_endian = "little")]
+    #[cfg(target_pointer_width = "32")]
+    _padding: u32,
 }
 
 /// A vector of `Event`s, plus context for interpreting them.
@@ -296,6 +394,20 @@ pub struct EventVec {
 }
 
 impl EventVec {
+    /// Constructs an `EventVec` from raw pointer, length, and capacity.
+    ///
+    /// # Safety
+    ///
+    /// This function calls [`Vec::from_raw_parts`] with its arguments.
+    ///
+    /// [`Vec::from_raw_parts`]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.from_raw_parts
+    #[inline]
+    pub unsafe fn from_raw_parts(ptr: *mut Event, len: usize, capacity: usize) -> Self {
+        Self {
+            events: Vec::from_raw_parts(ptr, len, capacity),
+        }
+    }
+
     /// Constructs an `EventVec` with memory for `capacity` `Event`s.
     #[inline]
     pub fn with_capacity(capacity: usize) -> Self {
@@ -338,7 +450,7 @@ impl EventVec {
     #[inline]
     pub fn iter(&self) -> Iter<'_> {
         Iter {
-            iter: self.events.iter(),
+            iter: self.events.iter().copied(),
         }
     }
 
@@ -357,10 +469,18 @@ impl EventVec {
 
 impl<'a> IntoIterator for &'a EventVec {
     type IntoIter = Iter<'a>;
-    type Item = (EventFlags, u64);
+    type Item = Event;
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
+
+#[test]
+fn test_epoll_layouts() {
+    check_renamed_type!(Event, epoll_event);
+    check_renamed_type!(Event, epoll_event);
+    check_renamed_struct_renamed_field!(Event, epoll_event, flags, events);
+    check_renamed_struct_renamed_field!(Event, epoll_event, data, u64);
+}
diff --git a/vendor/rustix/src/backend/libc/event/mod.rs b/vendor/rustix/src/backend/libc/event/mod.rs
new file mode 100644
index 000000000..6aed4612a
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/event/mod.rs
@@ -0,0 +1,9 @@
+pub(crate) mod poll_fd;
+#[cfg(not(windows))]
+pub(crate) mod types;
+
+#[cfg_attr(windows, path = "windows_syscalls.rs")]
+pub(crate) mod syscalls;
+
+#[cfg(linux_kernel)]
+pub mod epoll;
diff --git a/vendor/rustix/src/backend/libc/io/poll_fd.rs b/vendor/rustix/src/backend/libc/event/poll_fd.rs
index a0568c60a..49a6d1126 100644
--- a/vendor/rustix/src/backend/libc/io/poll_fd.rs
+++ b/vendor/rustix/src/backend/libc/event/poll_fd.rs
@@ -1,17 +1,20 @@
-use super::super::c;
-use super::super::conv::borrowed_fd;
-#[cfg(windows)]
-use super::super::fd::RawFd;
-use super::super::fd::{AsFd, AsRawFd, BorrowedFd, LibcFd};
+use crate::backend::c;
+use crate::backend::conv::borrowed_fd;
+use crate::backend::fd::{AsFd, AsRawFd, BorrowedFd, LibcFd};
 use bitflags::bitflags;
 use core::marker::PhantomData;
 #[cfg(windows)]
-use std::fmt;
+use {
+    crate::backend::fd::{AsSocket, RawFd},
+    core::fmt,
+};
 
 bitflags! {
     /// `POLL*` flags for use with [`poll`].
     ///
     /// [`poll`]: crate::io::poll
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct PollFlags: c::c_short {
         /// `POLLIN`
         const IN = c::POLLIN;
@@ -21,16 +24,14 @@ bitflags! {
         /// `POLLOUT`
         const OUT = c::POLLOUT;
         /// `POLLRDNORM`
-        #[cfg(not(target_os = "redox"))]
         const RDNORM = c::POLLRDNORM;
         /// `POLLWRNORM`
-        #[cfg(not(target_os = "redox"))]
         const WRNORM = c::POLLWRNORM;
         /// `POLLRDBAND`
-        #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+        #[cfg(not(target_os = "wasi"))]
         const RDBAND = c::POLLRDBAND;
         /// `POLLWRBAND`
-        #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+        #[cfg(not(target_os = "wasi"))]
         const WRBAND = c::POLLWRBAND;
         /// `POLLERR`
         const ERR = c::POLLERR;
@@ -40,7 +41,7 @@ bitflags! {
         const NVAL = c::POLLNVAL;
         /// `POLLRDHUP`
         #[cfg(all(
-            any(target_os = "android", target_os = "linux"),
+            linux_kernel,
             not(any(target_arch = "sparc", target_arch = "sparc64"))),
         )]
         const RDHUP = c::POLLRDHUP;
@@ -49,7 +50,7 @@ bitflags! {
 
 /// `struct pollfd`—File descriptor and flags for use with [`poll`].
 ///
-/// [`poll`]: crate::io::poll
+/// [`poll`]: crate::event::poll
 #[doc(alias = "pollfd")]
 #[derive(Clone)]
 #[cfg_attr(not(windows), derive(Debug))]
@@ -126,7 +127,7 @@ impl<'fd> AsFd for PollFd<'fd> {
 }
 
 #[cfg(windows)]
-impl<'fd> io_lifetimes::AsSocket for PollFd<'fd> {
+impl<'fd> AsSocket for PollFd<'fd> {
     #[inline]
     fn as_socket(&self) -> BorrowedFd<'_> {
         // SAFETY: Our constructors and `set_fd` require `pollfd.fd` to be
diff --git a/vendor/rustix/src/backend/libc/event/syscalls.rs b/vendor/rustix/src/backend/libc/event/syscalls.rs
new file mode 100644
index 000000000..11f6af83e
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/event/syscalls.rs
@@ -0,0 +1,161 @@
+//! libc syscalls supporting `rustix::event`.
+
+use crate::backend::c;
+use crate::backend::conv::ret_c_int;
+#[cfg(any(apple, netbsdlike, target_os = "dragonfly", target_os = "solaris"))]
+use crate::backend::conv::ret_owned_fd;
+use crate::event::PollFd;
+#[cfg(any(linux_kernel, bsd, solarish))]
+use crate::fd::OwnedFd;
+use crate::io;
+#[cfg(any(bsd, solarish))]
+use {crate::backend::conv::borrowed_fd, crate::fd::BorrowedFd, core::mem::MaybeUninit};
+#[cfg(solarish)]
+use {
+    crate::backend::conv::ret, crate::event::port::Event, crate::utils::as_mut_ptr,
+    core::ptr::null_mut,
+};
+#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "illumos"))]
+use {crate::backend::conv::ret_owned_fd, crate::event::EventfdFlags};
+#[cfg(bsd)]
+use {crate::event::kqueue::Event, crate::utils::as_ptr, core::ptr::null};
+
+#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "illumos"))]
+pub(crate) fn eventfd(initval: u32, flags: EventfdFlags) -> io::Result<OwnedFd> {
+    #[cfg(linux_kernel)]
+    unsafe {
+        syscall! {
+            fn eventfd2(
+                initval: c::c_uint,
+                flags: c::c_int
+            ) via SYS_eventfd2 -> c::c_int
+        }
+        ret_owned_fd(eventfd2(initval, bitflags_bits!(flags)))
+    }
+
+    #[cfg(any(target_os = "freebsd", target_os = "illumos"))]
+    unsafe {
+        ret_owned_fd(c::eventfd(initval, bitflags_bits!(flags)))
+    }
+}
+
+#[cfg(bsd)]
+pub(crate) fn kqueue() -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(c::kqueue()) }
+}
+
+#[cfg(bsd)]
+pub(crate) unsafe fn kevent(
+    kq: BorrowedFd<'_>,
+    changelist: &[Event],
+    eventlist: &mut [MaybeUninit<Event>],
+    timeout: Option<&c::timespec>,
+) -> io::Result<c::c_int> {
+    ret_c_int(c::kevent(
+        borrowed_fd(kq),
+        changelist.as_ptr().cast(),
+        changelist
+            .len()
+            .try_into()
+            .map_err(|_| io::Errno::OVERFLOW)?,
+        eventlist.as_mut_ptr().cast(),
+        eventlist
+            .len()
+            .try_into()
+            .map_err(|_| io::Errno::OVERFLOW)?,
+        timeout.map_or(null(), as_ptr),
+    ))
+}
+
+#[inline]
+pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> {
+    let nfds = fds
+        .len()
+        .try_into()
+        .map_err(|_convert_err| io::Errno::INVAL)?;
+
+    ret_c_int(unsafe { c::poll(fds.as_mut_ptr().cast(), nfds, timeout) })
+        .map(|nready| nready as usize)
+}
+
+#[cfg(solarish)]
+pub(crate) fn port_create() -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(c::port_create()) }
+}
+
+#[cfg(solarish)]
+pub(crate) unsafe fn port_associate(
+    port: BorrowedFd<'_>,
+    source: c::c_int,
+    object: c::uintptr_t,
+    events: c::c_int,
+    user: *mut c::c_void,
+) -> io::Result<()> {
+    ret(c::port_associate(
+        borrowed_fd(port),
+        source,
+        object,
+        events,
+        user,
+    ))
+}
+
+#[cfg(solarish)]
+pub(crate) unsafe fn port_dissociate(
+    port: BorrowedFd<'_>,
+    source: c::c_int,
+    object: c::uintptr_t,
+) -> io::Result<()> {
+    ret(c::port_dissociate(borrowed_fd(port), source, object))
+}
+
+#[cfg(solarish)]
+pub(crate) fn port_get(
+    port: BorrowedFd<'_>,
+    timeout: Option<&mut c::timespec>,
+) -> io::Result<Event> {
+    let mut event = MaybeUninit::<c::port_event>::uninit();
+    let timeout = timeout.map_or(null_mut(), as_mut_ptr);
+
+    unsafe {
+        ret(c::port_get(borrowed_fd(port), event.as_mut_ptr(), timeout))?;
+    }
+
+    // If we're done, initialize the event and return it.
+    Ok(Event(unsafe { event.assume_init() }))
+}
+
+#[cfg(solarish)]
+pub(crate) fn port_getn(
+    port: BorrowedFd<'_>,
+    timeout: Option<&mut c::timespec>,
+    events: &mut Vec<Event>,
+    mut nget: u32,
+) -> io::Result<()> {
+    let timeout = timeout.map_or(null_mut(), as_mut_ptr);
+    unsafe {
+        ret(c::port_getn(
+            borrowed_fd(port),
+            events.as_mut_ptr().cast(),
+            events.len().try_into().unwrap(),
+            &mut nget,
+            timeout,
+        ))?;
+    }
+
+    // Update the vector length.
+    unsafe {
+        events.set_len(nget.try_into().unwrap());
+    }
+
+    Ok(())
+}
+
+#[cfg(solarish)]
+pub(crate) fn port_send(
+    port: BorrowedFd<'_>,
+    events: c::c_int,
+    userdata: *mut c::c_void,
+) -> io::Result<()> {
+    unsafe { ret(c::port_send(borrowed_fd(port), events, userdata)) }
+}
diff --git a/vendor/rustix/src/backend/libc/event/types.rs b/vendor/rustix/src/backend/libc/event/types.rs
new file mode 100644
index 000000000..632b1be63
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/event/types.rs
@@ -0,0 +1,19 @@
+#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "illumos"))]
+use {crate::backend::c, bitflags::bitflags};
+
+#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "illumos"))]
+bitflags! {
+    /// `EFD_*` flags for use with [`eventfd`].
+    ///
+    /// [`eventfd`]: crate::io::eventfd
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct EventfdFlags: u32 {
+        /// `EFD_CLOEXEC`
+        const CLOEXEC = bitcast!(c::EFD_CLOEXEC);
+        /// `EFD_NONBLOCK`
+        const NONBLOCK = bitcast!(c::EFD_NONBLOCK);
+        /// `EFD_SEMAPHORE`
+        const SEMAPHORE = bitcast!(c::EFD_SEMAPHORE);
+    }
+}
diff --git a/vendor/rustix/src/backend/libc/event/windows_syscalls.rs b/vendor/rustix/src/backend/libc/event/windows_syscalls.rs
new file mode 100644
index 000000000..8ccad4794
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/event/windows_syscalls.rs
@@ -0,0 +1,16 @@
+//! Windows system calls in the `event` module.
+
+use crate::backend::c;
+use crate::backend::conv::ret_c_int;
+use crate::event::PollFd;
+use crate::io;
+
+pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> {
+    let nfds = fds
+        .len()
+        .try_into()
+        .map_err(|_convert_err| io::Errno::INVAL)?;
+
+    ret_c_int(unsafe { c::poll(fds.as_mut_ptr().cast(), nfds, timeout) })
+        .map(|nready| nready as usize)
+}
diff --git a/vendor/rustix/src/backend/libc/fs/dir.rs b/vendor/rustix/src/backend/libc/fs/dir.rs
index b6eb32580..c8a4d77c9 100644
--- a/vendor/rustix/src/backend/libc/fs/dir.rs
+++ b/vendor/rustix/src/backend/libc/fs/dir.rs
@@ -1,8 +1,7 @@
-use super::super::c;
-use super::super::conv::owned_fd;
-use super::super::offset::libc_ino_t;
 #[cfg(not(any(solarish, target_os = "haiku")))]
 use super::types::FileType;
+use crate::backend::c;
+use crate::backend::conv::owned_fd;
 use crate::fd::{AsFd, BorrowedFd};
 use crate::ffi::{CStr, CString};
 use crate::fs::{fcntl_getfl, fstat, openat, Mode, OFlags, Stat};
@@ -18,8 +17,8 @@ use crate::fs::{fstatfs, StatFs};
 use crate::fs::{fstatvfs, StatVfs};
 use crate::io;
 #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
+#[cfg(feature = "process")]
 use crate::process::fchdir;
-#[cfg(target_os = "wasi")]
 use alloc::borrow::ToOwned;
 #[cfg(not(linux_like))]
 use c::readdir as libc_readdir;
@@ -139,7 +138,9 @@ impl Dir {
     }
 
     /// `fchdir(self)`
+    #[cfg(feature = "process")]
     #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "process")))]
     #[inline]
     pub fn chdir(&self) -> io::Result<()> {
         fchdir(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.0.as_ptr())) })
@@ -183,10 +184,10 @@ pub struct DirEntry {
     d_type: u8,
 
     #[cfg(not(any(freebsdlike, netbsdlike)))]
-    d_ino: libc_ino_t,
+    d_ino: c::ino_t,
 
     #[cfg(any(freebsdlike, netbsdlike))]
-    d_fileno: libc_ino_t,
+    d_fileno: c::ino_t,
 
     name: CString,
 }
diff --git a/vendor/rustix/src/backend/libc/fs/inotify.rs b/vendor/rustix/src/backend/libc/fs/inotify.rs
index 8a42e0583..05d4d904f 100644
--- a/vendor/rustix/src/backend/libc/fs/inotify.rs
+++ b/vendor/rustix/src/backend/libc/fs/inotify.rs
@@ -1,7 +1,7 @@
 //! inotify support for working with inotifies
 
-use super::super::c;
-use super::super::conv::{borrowed_fd, c_str, ret, ret_c_int, ret_owned_fd};
+use crate::backend::c;
+use crate::backend::conv::{borrowed_fd, c_str, ret, ret_c_int, ret_owned_fd};
 use crate::fd::{BorrowedFd, OwnedFd};
 use crate::io;
 use bitflags::bitflags;
@@ -10,11 +10,13 @@ bitflags! {
     /// `IN_*` for use with [`inotify_init`].
     ///
     /// [`inotify_init`]: crate::fs::inotify::inotify_init
-    pub struct CreateFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct CreateFlags: u32 {
         /// `IN_CLOEXEC`
-        const CLOEXEC = c::IN_CLOEXEC;
+        const CLOEXEC = bitcast!(c::IN_CLOEXEC);
         /// `IN_NONBLOCK`
-        const NONBLOCK = c::IN_NONBLOCK;
+        const NONBLOCK = bitcast!(c::IN_NONBLOCK);
     }
 }
 
@@ -22,7 +24,8 @@ bitflags! {
     /// `IN*` for use with [`inotify_add_watch`].
     ///
     /// [`inotify_add_watch`]: crate::fs::inotify::inotify_add_watch
-    #[derive(Default)]
+    #[repr(transparent)]
+    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct WatchFlags: u32 {
         /// `IN_ACCESS`
         const ACCESS = c::IN_ACCESS;
@@ -78,7 +81,7 @@ bitflags! {
 #[doc(alias = "inotify_init1")]
 pub fn inotify_init(flags: CreateFlags) -> io::Result<OwnedFd> {
     // SAFETY: `inotify_init1` has no safety preconditions.
-    unsafe { ret_owned_fd(c::inotify_init1(flags.bits())) }
+    unsafe { ret_owned_fd(c::inotify_init1(bitflags_bits!(flags))) }
 }
 
 /// `inotify_add_watch(self, path, flags)`—Adds a watch to inotify
@@ -113,7 +116,8 @@ pub fn inotify_add_watch<P: crate::path::Arg>(
 /// by [`inotify_add_watch`] and not previously have been removed.
 #[doc(alias = "inotify_rm_watch")]
 pub fn inotify_remove_watch(inot: BorrowedFd<'_>, wd: i32) -> io::Result<()> {
-    // Android's `inotify_rm_watch` takes u32 despite `inotify_add_watch` is i32.
+    // Android's `inotify_rm_watch` takes `u32` despite that
+    // `inotify_add_watch` expects a `i32`.
     #[cfg(target_os = "android")]
     let wd = wd as u32;
     // SAFETY: The fd is valid and closing an arbitrary wd is valid.
diff --git a/vendor/rustix/src/backend/libc/fs/makedev.rs b/vendor/rustix/src/backend/libc/fs/makedev.rs
index afe942a59..640d5005b 100644
--- a/vendor/rustix/src/backend/libc/fs/makedev.rs
+++ b/vendor/rustix/src/backend/libc/fs/makedev.rs
@@ -1,9 +1,10 @@
 #[cfg(not(all(target_os = "android", target_pointer_width = "32")))]
-use super::super::c;
+use crate::backend::c;
 use crate::fs::Dev;
 
 #[cfg(not(any(
     apple,
+    solarish,
     target_os = "aix",
     target_os = "android",
     target_os = "emscripten",
@@ -13,6 +14,13 @@ pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
     c::makedev(maj, min)
 }
 
+#[cfg(solarish)]
+pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
+    // SAFETY: Solarish's `makedev` is marked unsafe but it isn't doing
+    // anything unsafe.
+    unsafe { c::makedev(maj, min) }
+}
+
 #[cfg(all(target_os = "android", not(target_pointer_width = "32")))]
 #[inline]
 pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
@@ -54,19 +62,24 @@ pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
 #[cfg(not(any(
     apple,
     freebsdlike,
-    netbsdlike,
     target_os = "android",
     target_os = "emscripten",
+    target_os = "netbsd"
 )))]
 #[inline]
 pub(crate) fn major(dev: Dev) -> u32 {
     unsafe { c::major(dev) }
 }
 
-#[cfg(all(target_os = "android", not(target_pointer_width = "32")))]
+#[cfg(any(
+    apple,
+    freebsdlike,
+    target_os = "netbsd",
+    all(target_os = "android", not(target_pointer_width = "32")),
+))]
 #[inline]
 pub(crate) fn major(dev: Dev) -> u32 {
-    // Android's `major` oddly has signed return types.
+    // On some platforms `major` oddly has signed return types.
     (unsafe { c::major(dev) }) as u32
 }
 
@@ -88,19 +101,24 @@ pub(crate) fn major(dev: Dev) -> u32 {
 #[cfg(not(any(
     apple,
     freebsdlike,
-    netbsdlike,
     target_os = "android",
     target_os = "emscripten",
+    target_os = "netbsd"
 )))]
 #[inline]
 pub(crate) fn minor(dev: Dev) -> u32 {
     unsafe { c::minor(dev) }
 }
 
-#[cfg(all(target_os = "android", not(target_pointer_width = "32")))]
+#[cfg(any(
+    apple,
+    freebsdlike,
+    target_os = "netbsd",
+    all(target_os = "android", not(target_pointer_width = "32"))
+))]
 #[inline]
 pub(crate) fn minor(dev: Dev) -> u32 {
-    // Android's `minor` oddly has signed return types.
+    // On some platforms, `minor` oddly has signed return types.
     (unsafe { c::minor(dev) }) as u32
 }
 
diff --git a/vendor/rustix/src/backend/libc/fs/mod.rs b/vendor/rustix/src/backend/libc/fs/mod.rs
index 54a48103c..28579c993 100644
--- a/vendor/rustix/src/backend/libc/fs/mod.rs
+++ b/vendor/rustix/src/backend/libc/fs/mod.rs
@@ -1,8 +1,8 @@
 #[cfg(not(target_os = "redox"))]
 pub(crate) mod dir;
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub mod inotify;
-#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))]
+#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
 pub(crate) mod makedev;
 #[cfg(not(windows))]
 pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/fs/syscalls.rs b/vendor/rustix/src/backend/libc/fs/syscalls.rs
index 40c160182..bdba777e9 100644
--- a/vendor/rustix/src/backend/libc/fs/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/fs/syscalls.rs
@@ -1,48 +1,9 @@
 //! libc syscalls supporting `rustix::fs`.
 
-use super::super::c;
-use super::super::conv::{borrowed_fd, c_str, ret, ret_c_int, ret_off_t, ret_owned_fd, ret_usize};
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::{syscall_ret, syscall_ret_owned_fd, syscall_ret_usize};
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-use super::super::offset::libc_fallocate;
-#[cfg(not(any(
-    apple,
-    netbsdlike,
-    solarish,
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "redox",
-)))]
-use super::super::offset::libc_posix_fadvise;
-#[cfg(not(any(
-    apple,
-    netbsdlike,
-    solarish,
-    target_os = "aix",
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-    target_os = "redox",
-)))]
-use super::super::offset::libc_posix_fallocate;
-use super::super::offset::{libc_fstat, libc_fstatat, libc_ftruncate, libc_lseek, libc_off_t};
-#[cfg(not(any(
-    solarish,
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-use super::super::offset::{libc_fstatfs, libc_statfs};
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-use super::super::offset::{libc_fstatvfs, libc_statvfs};
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-use super::super::time::types::LibcTimespec;
+use crate::backend::c;
+use crate::backend::conv::{
+    borrowed_fd, c_str, ret, ret_c_int, ret_off_t, ret_owned_fd, ret_usize,
+};
 use crate::fd::{BorrowedFd, OwnedFd};
 use crate::ffi::CStr;
 #[cfg(apple)]
@@ -56,6 +17,8 @@ use crate::ffi::CString;
     target_os = "redox",
 )))]
 use crate::fs::Advice;
+#[cfg(not(target_os = "redox"))]
+use crate::fs::AtFlags;
 #[cfg(not(any(
     netbsdlike,
     solarish,
@@ -66,14 +29,9 @@ use crate::fs::Advice;
 use crate::fs::FallocateFlags;
 #[cfg(not(target_os = "wasi"))]
 use crate::fs::FlockOperation;
-#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "freebsd"))]
 use crate::fs::MemfdFlags;
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "fuchsia"))]
 use crate::fs::SealFlags;
 #[cfg(not(any(
     solarish,
@@ -83,38 +41,39 @@ use crate::fs::SealFlags;
     target_os = "wasi",
 )))]
 use crate::fs::StatFs;
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
-use crate::fs::XattrFlags;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::fs::{cwd, RenameFlags, ResolveFlags, Statx, StatxFlags};
-use crate::fs::{Access, Mode, OFlags, Stat, Timestamps};
+use crate::fs::{Access, Mode, OFlags, SeekFrom, Stat, Timestamps};
 #[cfg(not(any(apple, target_os = "redox", target_os = "wasi")))]
 use crate::fs::{Dev, FileType};
 #[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
 use crate::fs::{StatVfs, StatVfsMountFlags};
-use crate::io::{self, SeekFrom};
+use crate::io;
+#[cfg(all(
+    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
+    target_env = "gnu",
+))]
+use crate::timespec::LibcTimespec;
 #[cfg(not(target_os = "wasi"))]
-use crate::process::{Gid, Uid};
+use crate::ugid::{Gid, Uid};
 #[cfg(not(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
 )))]
 use crate::utils::as_ptr;
-use core::convert::TryInto;
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
-use core::mem::size_of;
+#[cfg(apple)]
+use alloc::vec;
 use core::mem::MaybeUninit;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use core::ptr::null;
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
-use core::ptr::null_mut;
 #[cfg(apple)]
 use {
-    super::super::conv::nonnegative_ret,
+    crate::backend::conv::nonnegative_ret,
     crate::fs::{copyfile_state_t, CloneFlags, CopyfileFlags},
 };
-#[cfg(not(target_os = "redox"))]
-use {super::super::offset::libc_openat, crate::fs::AtFlags};
+#[cfg(any(apple, linux_kernel))]
+use {crate::fs::XattrFlags, core::mem::size_of, core::ptr::null_mut};
+#[cfg(linux_kernel)]
+use {
+    crate::fs::{RenameFlags, ResolveFlags, Statx, StatxFlags, CWD},
+    core::ptr::null,
+};
 
 #[cfg(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
@@ -127,6 +86,64 @@ weak!(fn __utimensat64(c::c_int, *const c::c_char, *const LibcTimespec, c::c_int
 ))]
 weak!(fn __futimens64(c::c_int, *const LibcTimespec) -> c::c_int);
 
+/// Use a direct syscall (via libc) for `open`.
+///
+/// This is only currently necessary as a workaround for old glibc; see below.
+#[cfg(all(unix, target_env = "gnu"))]
+fn open_via_syscall(path: &CStr, oflags: OFlags, mode: Mode) -> io::Result<OwnedFd> {
+    // Linux on aarch64 and riscv64 has no `open` syscall so use `openat`.
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
+    {
+        openat_via_syscall(CWD, path, oflags, mode)
+    }
+
+    // Use the `open` syscall.
+    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
+    unsafe {
+        syscall! {
+            fn open(
+                pathname: *const c::c_char,
+                oflags: c::c_int,
+                mode: c::mode_t
+            ) via SYS_open -> c::c_int
+        }
+
+        ret_owned_fd(open(
+            c_str(path),
+            bitflags_bits!(oflags),
+            bitflags_bits!(mode),
+        ))
+    }
+}
+
+pub(crate) fn open(path: &CStr, oflags: OFlags, mode: Mode) -> io::Result<OwnedFd> {
+    // Work around <https://sourceware.org/bugzilla/show_bug.cgi?id=17523>.
+    // glibc versions before 2.25 don't handle `O_TMPFILE` correctly.
+    #[cfg(all(unix, target_env = "gnu"))]
+    if oflags.contains(OFlags::TMPFILE) && crate::backend::if_glibc_is_less_than_2_25() {
+        return open_via_syscall(path, oflags, mode);
+    }
+
+    // On these platforms, `mode_t` is `u16` and can't be passed directly to
+    // a variadic function.
+    #[cfg(any(
+        apple,
+        freebsdlike,
+        all(target_os = "android", target_pointer_width = "32")
+    ))]
+    let mode: c::c_uint = mode.bits().into();
+
+    // Otherwise, cast to `mode_t` as that's what `open` is documented to take.
+    #[cfg(not(any(
+        apple,
+        freebsdlike,
+        all(target_os = "android", target_pointer_width = "32")
+    )))]
+    let mode: c::mode_t = mode.bits() as _;
+
+    unsafe { ret_owned_fd(c::open(c_str(path), bitflags_bits!(oflags), mode)) }
+}
+
 /// Use a direct syscall (via libc) for `openat`.
 ///
 /// This is only currently necessary as a workaround for old glibc; see below.
@@ -137,18 +154,22 @@ fn openat_via_syscall(
     oflags: OFlags,
     mode: Mode,
 ) -> io::Result<OwnedFd> {
+    syscall! {
+        fn openat(
+            base_dirfd: c::c_int,
+            pathname: *const c::c_char,
+            oflags: c::c_int,
+            mode: c::mode_t
+        ) via SYS_openat -> c::c_int
+    }
+
     unsafe {
-        let dirfd = borrowed_fd(dirfd);
-        let path = c_str(path);
-        let oflags = oflags.bits();
-        let mode = c::c_uint::from(mode.bits());
-        ret_owned_fd(c::syscall(
-            c::SYS_openat,
-            c::c_long::from(dirfd),
-            path,
-            c::c_long::from(oflags),
-            mode as c::c_long,
-        ) as c::c_int)
+        ret_owned_fd(openat(
+            borrowed_fd(dirfd),
+            c_str(path),
+            bitflags_bits!(oflags),
+            bitflags_bits!(mode),
+        ))
     }
 }
 
@@ -165,15 +186,30 @@ pub(crate) fn openat(
     if oflags.contains(OFlags::TMPFILE) && crate::backend::if_glibc_is_less_than_2_25() {
         return openat_via_syscall(dirfd, path, oflags, mode);
     }
+
+    // On these platforms, `mode_t` is `u16` and can't be passed directly to
+    // a variadic function.
+    #[cfg(any(
+        apple,
+        freebsdlike,
+        all(target_os = "android", target_pointer_width = "32")
+    ))]
+    let mode: c::c_uint = mode.bits().into();
+
+    // Otherwise, cast to `mode_t` as that's what `open` is documented to take.
+    #[cfg(not(any(
+        apple,
+        freebsdlike,
+        all(target_os = "android", target_pointer_width = "32")
+    )))]
+    let mode: c::mode_t = mode.bits() as _;
+
     unsafe {
-        // Pass `mode` as a `c_uint` even if `mode_t` is narrower, since
-        // `libc_openat` is declared as a variadic function and narrower
-        // arguments are promoted.
-        ret_owned_fd(libc_openat(
+        ret_owned_fd(c::openat(
             borrowed_fd(dirfd),
             c_str(path),
-            oflags.bits(),
-            c::c_uint::from(mode.bits()),
+            bitflags_bits!(oflags),
+            mode,
         ))
     }
 }
@@ -189,7 +225,7 @@ pub(crate) fn openat(
 pub(crate) fn statfs(filename: &CStr) -> io::Result<StatFs> {
     unsafe {
         let mut result = MaybeUninit::<StatFs>::uninit();
-        ret(libc_statfs(c_str(filename), result.as_mut_ptr()))?;
+        ret(c::statfs(c_str(filename), result.as_mut_ptr()))?;
         Ok(result.assume_init())
     }
 }
@@ -198,15 +234,30 @@ pub(crate) fn statfs(filename: &CStr) -> io::Result<StatFs> {
 #[inline]
 pub(crate) fn statvfs(filename: &CStr) -> io::Result<StatVfs> {
     unsafe {
-        let mut result = MaybeUninit::<libc_statvfs>::uninit();
-        ret(libc_statvfs(c_str(filename), result.as_mut_ptr()))?;
+        let mut result = MaybeUninit::<c::statvfs>::uninit();
+        ret(c::statvfs(c_str(filename), result.as_mut_ptr()))?;
         Ok(libc_statvfs_to_statvfs(result.assume_init()))
     }
 }
 
+#[inline]
+pub(crate) fn readlink(path: &CStr, buf: &mut [u8]) -> io::Result<usize> {
+    unsafe {
+        ret_usize(c::readlink(
+            c_str(path),
+            buf.as_mut_ptr().cast::<c::c_char>(),
+            buf.len(),
+        ))
+    }
+}
+
 #[cfg(not(target_os = "redox"))]
 #[inline]
-pub(crate) fn readlinkat(dirfd: BorrowedFd<'_>, path: &CStr, buf: &mut [u8]) -> io::Result<usize> {
+pub(crate) fn readlinkat(
+    dirfd: BorrowedFd<'_>,
+    path: &CStr,
+    buf: &mut [MaybeUninit<u8>],
+) -> io::Result<usize> {
     unsafe {
         ret_usize(c::readlinkat(
             borrowed_fd(dirfd),
@@ -217,6 +268,10 @@ pub(crate) fn readlinkat(dirfd: BorrowedFd<'_>, path: &CStr, buf: &mut [u8]) ->
     }
 }
 
+pub(crate) fn mkdir(path: &CStr, mode: Mode) -> io::Result<()> {
+    unsafe { ret(c::mkdir(c_str(path), mode.bits() as c::mode_t)) }
+}
+
 #[cfg(not(target_os = "redox"))]
 pub(crate) fn mkdirat(dirfd: BorrowedFd<'_>, path: &CStr, mode: Mode) -> io::Result<()> {
     unsafe {
@@ -228,21 +283,31 @@ pub(crate) fn mkdirat(dirfd: BorrowedFd<'_>, path: &CStr, mode: Mode) -> io::Res
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn getdents_uninit(
     fd: BorrowedFd<'_>,
     buf: &mut [MaybeUninit<u8>],
 ) -> io::Result<usize> {
+    syscall! {
+        fn getdents64(
+            fd: c::c_int,
+            dirp: *mut c::c_void,
+            count: usize
+        ) via SYS_getdents64 -> c::ssize_t
+    }
     unsafe {
-        syscall_ret_usize(c::syscall(
-            c::SYS_getdents64,
-            fd,
-            buf.as_mut_ptr().cast::<c::c_char>(),
+        ret_usize(getdents64(
+            borrowed_fd(fd),
+            buf.as_mut_ptr().cast::<c::c_void>(),
             buf.len(),
         ))
     }
 }
 
+pub(crate) fn link(old_path: &CStr, new_path: &CStr) -> io::Result<()> {
+    unsafe { ret(c::link(c_str(old_path), c_str(new_path))) }
+}
+
 #[cfg(not(target_os = "redox"))]
 pub(crate) fn linkat(
     old_dirfd: BorrowedFd<'_>,
@@ -251,20 +316,107 @@ pub(crate) fn linkat(
     new_path: &CStr,
     flags: AtFlags,
 ) -> io::Result<()> {
+    // macOS <= 10.9 lacks `linkat`.
+    #[cfg(target_os = "macos")]
+    unsafe {
+        weak! {
+            fn linkat(
+                c::c_int,
+                *const c::c_char,
+                c::c_int,
+                *const c::c_char,
+                c::c_int
+            ) -> c::c_int
+        }
+        // If we have `linkat`, use it.
+        if let Some(libc_linkat) = linkat.get() {
+            return ret(libc_linkat(
+                borrowed_fd(old_dirfd),
+                c_str(old_path),
+                borrowed_fd(new_dirfd),
+                c_str(new_path),
+                bitflags_bits!(flags),
+            ));
+        }
+        // Otherwise, see if we can emulate the `AT_FDCWD` case.
+        if borrowed_fd(old_dirfd) != c::AT_FDCWD || borrowed_fd(new_dirfd) != c::AT_FDCWD {
+            return Err(io::Errno::NOSYS);
+        }
+        if flags.intersects(!AtFlags::SYMLINK_FOLLOW) {
+            return Err(io::Errno::INVAL);
+        }
+        if !flags.is_empty() {
+            return Err(io::Errno::OPNOTSUPP);
+        }
+        ret(c::link(c_str(old_path), c_str(new_path)))
+    }
+
+    #[cfg(not(target_os = "macos"))]
     unsafe {
         ret(c::linkat(
             borrowed_fd(old_dirfd),
             c_str(old_path),
             borrowed_fd(new_dirfd),
             c_str(new_path),
-            flags.bits(),
+            bitflags_bits!(flags),
         ))
     }
 }
 
+pub(crate) fn rmdir(path: &CStr) -> io::Result<()> {
+    unsafe { ret(c::rmdir(c_str(path))) }
+}
+
+pub(crate) fn unlink(path: &CStr) -> io::Result<()> {
+    unsafe { ret(c::unlink(c_str(path))) }
+}
+
 #[cfg(not(target_os = "redox"))]
 pub(crate) fn unlinkat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<()> {
-    unsafe { ret(c::unlinkat(borrowed_fd(dirfd), c_str(path), flags.bits())) }
+    // macOS <= 10.9 lacks `unlinkat`.
+    #[cfg(target_os = "macos")]
+    unsafe {
+        weak! {
+            fn unlinkat(
+                c::c_int,
+                *const c::c_char,
+                c::c_int
+            ) -> c::c_int
+        }
+        // If we have `unlinkat`, use it.
+        if let Some(libc_unlinkat) = unlinkat.get() {
+            return ret(libc_unlinkat(
+                borrowed_fd(dirfd),
+                c_str(path),
+                bitflags_bits!(flags),
+            ));
+        }
+        // Otherwise, see if we can emulate the `AT_FDCWD` case.
+        if borrowed_fd(dirfd) != c::AT_FDCWD {
+            return Err(io::Errno::NOSYS);
+        }
+        if flags.intersects(!AtFlags::REMOVEDIR) {
+            return Err(io::Errno::INVAL);
+        }
+        if flags.contains(AtFlags::REMOVEDIR) {
+            ret(c::rmdir(c_str(path)))
+        } else {
+            ret(c::unlink(c_str(path)))
+        }
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    unsafe {
+        ret(c::unlinkat(
+            borrowed_fd(dirfd),
+            c_str(path),
+            bitflags_bits!(flags),
+        ))
+    }
+}
+
+pub(crate) fn rename(old_path: &CStr, new_path: &CStr) -> io::Result<()> {
+    unsafe { ret(c::rename(c_str(old_path), c_str(new_path))) }
 }
 
 #[cfg(not(target_os = "redox"))]
@@ -274,6 +426,34 @@ pub(crate) fn renameat(
     new_dirfd: BorrowedFd<'_>,
     new_path: &CStr,
 ) -> io::Result<()> {
+    // macOS <= 10.9 lacks `renameat`.
+    #[cfg(target_os = "macos")]
+    unsafe {
+        weak! {
+            fn renameat(
+                c::c_int,
+                *const c::c_char,
+                c::c_int,
+                *const c::c_char
+            ) -> c::c_int
+        }
+        // If we have `renameat`, use it.
+        if let Some(libc_renameat) = renameat.get() {
+            return ret(libc_renameat(
+                borrowed_fd(old_dirfd),
+                c_str(old_path),
+                borrowed_fd(new_dirfd),
+                c_str(new_path),
+            ));
+        }
+        // Otherwise, see if we can emulate the `AT_FDCWD` case.
+        if borrowed_fd(old_dirfd) != c::AT_FDCWD || borrowed_fd(new_dirfd) != c::AT_FDCWD {
+            return Err(io::Errno::NOSYS);
+        }
+        ret(c::rename(c_str(old_path), c_str(new_path)))
+    }
+
+    #[cfg(not(target_os = "macos"))]
     unsafe {
         ret(c::renameat(
             borrowed_fd(old_dirfd),
@@ -292,7 +472,7 @@ pub(crate) fn renameat2(
     new_path: &CStr,
     flags: RenameFlags,
 ) -> io::Result<()> {
-    // `getrandom` wasn't supported in glibc until 2.28.
+    // `renameat2` wasn't supported in glibc until 2.28.
     weak_or_syscall! {
         fn renameat2(
             olddirfd: c::c_int,
@@ -332,6 +512,10 @@ pub(crate) fn renameat2(
     renameat(old_dirfd, old_path, new_dirfd, new_path)
 }
 
+pub(crate) fn symlink(old_path: &CStr, new_path: &CStr) -> io::Result<()> {
+    unsafe { ret(c::symlink(c_str(old_path), c_str(new_path))) }
+}
+
 #[cfg(not(target_os = "redox"))]
 pub(crate) fn symlinkat(
     old_path: &CStr,
@@ -347,16 +531,64 @@ pub(crate) fn symlinkat(
     }
 }
 
+pub(crate) fn stat(path: &CStr) -> io::Result<Stat> {
+    // See the comments in `fstat` about using `crate::fs::statx` here.
+    #[cfg(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64")))]
+    {
+        match crate::fs::statx(
+            crate::fs::CWD,
+            path,
+            AtFlags::empty(),
+            StatxFlags::BASIC_STATS,
+        ) {
+            Ok(x) => statx_to_stat(x),
+            Err(io::Errno::NOSYS) => statat_old(crate::fs::CWD, path, AtFlags::empty()),
+            Err(err) => Err(err),
+        }
+    }
+
+    // Main version: libc is y2038 safe. Or, the platform is not y2038 safe and
+    // there's nothing practical we can do.
+    #[cfg(not(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64"))))]
+    unsafe {
+        let mut stat = MaybeUninit::<Stat>::uninit();
+        ret(c::stat(c_str(path), stat.as_mut_ptr()))?;
+        Ok(stat.assume_init())
+    }
+}
+
+pub(crate) fn lstat(path: &CStr) -> io::Result<Stat> {
+    // See the comments in `fstat` about using `crate::fs::statx` here.
+    #[cfg(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64")))]
+    {
+        match crate::fs::statx(
+            crate::fs::CWD,
+            path,
+            AtFlags::SYMLINK_NOFOLLOW,
+            StatxFlags::BASIC_STATS,
+        ) {
+            Ok(x) => statx_to_stat(x),
+            Err(io::Errno::NOSYS) => statat_old(crate::fs::CWD, path, AtFlags::empty()),
+            Err(err) => Err(err),
+        }
+    }
+
+    // Main version: libc is y2038 safe. Or, the platform is not y2038 safe and
+    // there's nothing practical we can do.
+    #[cfg(not(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64"))))]
+    unsafe {
+        let mut stat = MaybeUninit::<Stat>::uninit();
+        ret(c::lstat(c_str(path), stat.as_mut_ptr()))?;
+        Ok(stat.assume_init())
+    }
+}
+
 #[cfg(not(target_os = "redox"))]
 pub(crate) fn statat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> {
-    // 32-bit and mips64 Linux: `struct stat64` is not y2038 compatible; use
-    // `statx`.
-    #[cfg(all(
-        any(target_os = "android", target_os = "linux"),
-        any(target_pointer_width = "32", target_arch = "mips64"),
-    ))]
+    // See the comments in `fstat` about using `crate::fs::statx` here.
+    #[cfg(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64")))]
     {
-        match statx(dirfd, path, flags, StatxFlags::BASIC_STATS) {
+        match crate::fs::statx(dirfd, path, flags, StatxFlags::BASIC_STATS) {
             Ok(x) => statx_to_stat(x),
             Err(io::Errno::NOSYS) => statat_old(dirfd, path, flags),
             Err(err) => Err(err),
@@ -365,39 +597,38 @@ pub(crate) fn statat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::
 
     // Main version: libc is y2038 safe. Or, the platform is not y2038 safe and
     // there's nothing practical we can do.
-    #[cfg(not(all(
-        any(target_os = "android", target_os = "linux"),
-        any(target_pointer_width = "32", target_arch = "mips64"),
-    )))]
+    #[cfg(not(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64"))))]
     unsafe {
         let mut stat = MaybeUninit::<Stat>::uninit();
-        ret(libc_fstatat(
+        ret(c::fstatat(
             borrowed_fd(dirfd),
             c_str(path),
             stat.as_mut_ptr(),
-            flags.bits(),
+            bitflags_bits!(flags),
         ))?;
         Ok(stat.assume_init())
     }
 }
 
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    any(target_pointer_width = "32", target_arch = "mips64"),
-))]
+#[cfg(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64")))]
 fn statat_old(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> {
     unsafe {
         let mut result = MaybeUninit::<c::stat64>::uninit();
-        ret(libc_fstatat(
+        ret(c::fstatat(
             borrowed_fd(dirfd),
             c_str(path),
             result.as_mut_ptr(),
-            flags.bits(),
+            bitflags_bits!(flags),
         ))?;
         stat64_to_stat(result.assume_init())
     }
 }
 
+#[cfg(not(target_os = "emscripten"))]
+pub(crate) fn access(path: &CStr, access: Access) -> io::Result<()> {
+    unsafe { ret(c::access(c_str(path), access.bits())) }
+}
+
 #[cfg(not(any(target_os = "emscripten", target_os = "redox")))]
 pub(crate) fn accessat(
     dirfd: BorrowedFd<'_>,
@@ -405,17 +636,56 @@ pub(crate) fn accessat(
     access: Access,
     flags: AtFlags,
 ) -> io::Result<()> {
+    // macOS <= 10.9 lacks `faccessat`.
+    #[cfg(target_os = "macos")]
+    unsafe {
+        weak! {
+            fn faccessat(
+                c::c_int,
+                *const c::c_char,
+                c::c_int,
+                c::c_int
+            ) -> c::c_int
+        }
+        // If we have `faccessat`, use it.
+        if let Some(libc_faccessat) = faccessat.get() {
+            return ret(libc_faccessat(
+                borrowed_fd(dirfd),
+                c_str(path),
+                bitflags_bits!(access),
+                bitflags_bits!(flags),
+            ));
+        }
+        // Otherwise, see if we can emulate the `AT_FDCWD` case.
+        if borrowed_fd(dirfd) != c::AT_FDCWD {
+            return Err(io::Errno::NOSYS);
+        }
+        if flags.intersects(!(AtFlags::EACCESS | AtFlags::SYMLINK_NOFOLLOW)) {
+            return Err(io::Errno::INVAL);
+        }
+        if !flags.is_empty() {
+            return Err(io::Errno::OPNOTSUPP);
+        }
+        ret(c::access(c_str(path), bitflags_bits!(access)))
+    }
+
+    #[cfg(not(target_os = "macos"))]
     unsafe {
         ret(c::faccessat(
             borrowed_fd(dirfd),
             c_str(path),
-            access.bits(),
-            flags.bits(),
+            bitflags_bits!(access),
+            bitflags_bits!(flags),
         ))
     }
 }
 
 #[cfg(target_os = "emscripten")]
+pub(crate) fn access(_path: &CStr, _access: Access) -> io::Result<()> {
+    Ok(())
+}
+
+#[cfg(target_os = "emscripten")]
 pub(crate) fn accessat(
     _dirfd: BorrowedFd<'_>,
     _path: &CStr,
@@ -449,7 +719,7 @@ pub(crate) fn utimensat(
                 borrowed_fd(dirfd),
                 c_str(path),
                 libc_times.as_ptr(),
-                flags.bits(),
+                bitflags_bits!(flags),
             ))
         } else {
             utimensat_old(dirfd, path, times, flags)
@@ -473,7 +743,7 @@ pub(crate) fn utimensat(
             borrowed_fd(dirfd),
             c_str(path),
             as_ptr(times).cast(),
-            flags.bits(),
+            bitflags_bits!(flags),
         ))
     }
 
@@ -509,7 +779,7 @@ pub(crate) fn utimensat(
                 borrowed_fd(dirfd),
                 c_str(path),
                 as_ptr(times).cast(),
-                flags.bits(),
+                bitflags_bits!(flags),
             ));
         }
 
@@ -625,16 +895,16 @@ unsafe fn utimensat_old(
         borrowed_fd(dirfd),
         c_str(path),
         old_times.as_ptr(),
-        flags.bits(),
+        bitflags_bits!(flags),
     ))
 }
 
-#[cfg(not(any(
-    target_os = "android",
-    target_os = "linux",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
+#[cfg(not(target_os = "wasi"))]
+pub(crate) fn chmod(path: &CStr, mode: Mode) -> io::Result<()> {
+    unsafe { ret(c::chmod(c_str(path), mode.bits() as c::mode_t)) }
+}
+
+#[cfg(not(any(linux_kernel, target_os = "redox", target_os = "wasi")))]
 pub(crate) fn chmodat(
     dirfd: BorrowedFd<'_>,
     path: &CStr,
@@ -646,12 +916,12 @@ pub(crate) fn chmodat(
             borrowed_fd(dirfd),
             c_str(path),
             mode.bits() as c::mode_t,
-            flags.bits(),
+            bitflags_bits!(flags),
         ))
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn chmodat(
     dirfd: BorrowedFd<'_>,
     path: &CStr,
@@ -664,6 +934,13 @@ pub(crate) fn chmodat(
     // implementations, such as musl, add extra logic to `fchmod` to emulate
     // support for `AT_SYMLINK_NOFOLLOW`, which uses `/proc` outside our
     // control.
+    syscall! {
+        fn fchmodat(
+            base_dirfd: c::c_int,
+            pathname: *const c::c_char,
+            mode: c::mode_t
+        ) via SYS_fchmodat -> c::c_int
+    }
     if flags == AtFlags::SYMLINK_NOFOLLOW {
         return Err(io::Errno::OPNOTSUPP);
     }
@@ -671,14 +948,10 @@ pub(crate) fn chmodat(
         return Err(io::Errno::INVAL);
     }
     unsafe {
-        // Pass `mode` as a `c_uint` even if `mode_t` is narrower, since
-        // `libc_openat` is declared as a variadic function and narrower
-        // arguments are promoted.
-        syscall_ret(c::syscall(
-            c::SYS_fchmodat,
+        ret(fchmodat(
             borrowed_fd(dirfd),
             c_str(path),
-            c::c_uint::from(mode.bits()),
+            mode.bits() as c::mode_t,
         ))
     }
 }
@@ -699,7 +972,14 @@ pub(crate) fn fclonefileat(
         ) via SYS_fclonefileat -> c::c_int
     }
 
-    unsafe { ret(fclonefileat(srcfd, dst_dirfd, c_str(dst), flags.bits())) }
+    unsafe {
+        ret(fclonefileat(
+            srcfd,
+            dst_dirfd,
+            c_str(dst),
+            bitflags_bits!(flags),
+        ))
+    }
 }
 
 #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
@@ -711,13 +991,13 @@ pub(crate) fn chownat(
     flags: AtFlags,
 ) -> io::Result<()> {
     unsafe {
-        let (ow, gr) = crate::process::translate_fchown_args(owner, group);
+        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
         ret(c::fchownat(
             borrowed_fd(dirfd),
             c_str(path),
             ow,
             gr,
-            flags.bits(),
+            bitflags_bits!(flags),
         ))
     }
 }
@@ -740,7 +1020,7 @@ pub(crate) fn mknodat(
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn copy_file_range(
     fd_in: BorrowedFd<'_>,
     off_in: Option<&mut u64>,
@@ -748,26 +1028,36 @@ pub(crate) fn copy_file_range(
     off_out: Option<&mut u64>,
     len: usize,
 ) -> io::Result<usize> {
+    syscall! {
+        fn copy_file_range(
+            fd_in: c::c_int,
+            off_in: *mut c::loff_t,
+            fd_out: c::c_int,
+            off_out: *mut c::loff_t,
+            len: usize,
+            flags: c::c_uint
+        ) via SYS_copy_file_range -> c::ssize_t
+    }
+
     assert_eq!(size_of::<c::loff_t>(), size_of::<u64>());
 
     let mut off_in_val: c::loff_t = 0;
     let mut off_out_val: c::loff_t = 0;
     // Silently cast; we'll get `EINVAL` if the value is negative.
     let off_in_ptr = if let Some(off_in) = &off_in {
-        off_in_val = (**off_in) as i64;
+        off_in_val = **off_in as i64;
         &mut off_in_val
     } else {
         null_mut()
     };
     let off_out_ptr = if let Some(off_out) = &off_out {
-        off_out_val = (**off_out) as i64;
+        off_out_val = **off_out as i64;
         &mut off_out_val
     } else {
         null_mut()
     };
     let copied = unsafe {
-        syscall_ret_usize(c::syscall(
-            c::SYS_copy_file_range,
+        ret_usize(copy_file_range(
             borrowed_fd(fd_in),
             off_in_ptr,
             borrowed_fd(fd_out),
@@ -813,7 +1103,7 @@ pub(crate) fn fadvise(fd: BorrowedFd<'_>, offset: u64, len: u64, advice: Advice)
         len
     };
 
-    let err = unsafe { libc_posix_fadvise(borrowed_fd(fd), offset, len, advice as c::c_int) };
+    let err = unsafe { c::posix_fadvise(borrowed_fd(fd), offset, len, advice as c::c_int) };
 
     // `posix_fadvise` returns its error status rather than using `errno`.
     if err == 0 {
@@ -824,32 +1114,21 @@ pub(crate) fn fadvise(fd: BorrowedFd<'_>, offset: u64, len: u64, advice: Advice)
 }
 
 pub(crate) fn fcntl_getfl(fd: BorrowedFd<'_>) -> io::Result<OFlags> {
-    unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETFL)).map(OFlags::from_bits_truncate) }
+    let flags = unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETFL))? };
+    Ok(OFlags::from_bits_retain(bitcast!(flags)))
 }
 
 pub(crate) fn fcntl_setfl(fd: BorrowedFd<'_>, flags: OFlags) -> io::Result<()> {
     unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_SETFL, flags.bits())) }
 }
 
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "fuchsia"))]
 pub(crate) fn fcntl_get_seals(fd: BorrowedFd<'_>) -> io::Result<SealFlags> {
-    unsafe {
-        ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GET_SEALS))
-            .map(|flags| SealFlags::from_bits_unchecked(flags))
-    }
+    let flags = unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GET_SEALS))? };
+    Ok(SealFlags::from_bits_retain(bitcast!(flags)))
 }
 
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "fuchsia"))]
 pub(crate) fn fcntl_add_seals(fd: BorrowedFd<'_>, seals: SealFlags) -> io::Result<()> {
     unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_ADD_SEALS, seals.bits())) }
 }
@@ -889,7 +1168,7 @@ pub(crate) fn fcntl_lock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::R
 }
 
 pub(crate) fn seek(fd: BorrowedFd<'_>, pos: SeekFrom) -> io::Result<u64> {
-    let (whence, offset): (c::c_int, libc_off_t) = match pos {
+    let (whence, offset): (c::c_int, c::off_t) = match pos {
         SeekFrom::Start(pos) => {
             let pos: u64 = pos;
             // Silently cast; we'll get `EINVAL` if the value is negative.
@@ -902,51 +1181,58 @@ pub(crate) fn seek(fd: BorrowedFd<'_>, pos: SeekFrom) -> io::Result<u64> {
         #[cfg(any(freebsdlike, target_os = "linux", target_os = "solaris"))]
         SeekFrom::Hole(offset) => (c::SEEK_HOLE, offset),
     };
-    let offset = unsafe { ret_off_t(libc_lseek(borrowed_fd(fd), offset, whence))? };
+    let offset = unsafe { ret_off_t(c::lseek(borrowed_fd(fd), offset, whence))? };
     Ok(offset as u64)
 }
 
 pub(crate) fn tell(fd: BorrowedFd<'_>) -> io::Result<u64> {
-    let offset = unsafe { ret_off_t(libc_lseek(borrowed_fd(fd), 0, c::SEEK_CUR))? };
+    let offset = unsafe { ret_off_t(c::lseek(borrowed_fd(fd), 0, c::SEEK_CUR))? };
     Ok(offset as u64)
 }
 
-#[cfg(not(any(target_os = "android", target_os = "linux", target_os = "wasi")))]
+#[cfg(not(any(linux_kernel, target_os = "wasi")))]
 pub(crate) fn fchmod(fd: BorrowedFd<'_>, mode: Mode) -> io::Result<()> {
-    unsafe { ret(c::fchmod(borrowed_fd(fd), mode.bits())) }
+    unsafe { ret(c::fchmod(borrowed_fd(fd), bitflags_bits!(mode))) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn fchmod(fd: BorrowedFd<'_>, mode: Mode) -> io::Result<()> {
     // Use `c::syscall` rather than `c::fchmod` because some libc
     // implementations, such as musl, add extra logic to `fchmod` to emulate
     // support for `O_PATH`, which uses `/proc` outside our control and
     // interferes with our own use of `O_PATH`.
-    unsafe {
-        syscall_ret(c::syscall(
-            c::SYS_fchmod,
-            borrowed_fd(fd),
-            c::c_uint::from(mode.bits()),
-        ))
+    syscall! {
+        fn fchmod(
+            fd: c::c_int,
+            mode: c::mode_t
+        ) via SYS_fchmod -> c::c_int
     }
+    unsafe { ret(fchmod(borrowed_fd(fd), mode.bits() as c::mode_t)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn fchown(fd: BorrowedFd<'_>, owner: Option<Uid>, group: Option<Gid>) -> io::Result<()> {
     // Use `c::syscall` rather than `c::fchown` because some libc
     // implementations, such as musl, add extra logic to `fchown` to emulate
     // support for `O_PATH`, which uses `/proc` outside our control and
     // interferes with our own use of `O_PATH`.
+    syscall! {
+        fn fchown(
+            fd: c::c_int,
+            owner: c::uid_t,
+            group: c::gid_t
+        ) via SYS_fchown -> c::c_int
+    }
     unsafe {
-        let (ow, gr) = crate::process::translate_fchown_args(owner, group);
-        syscall_ret(c::syscall(c::SYS_fchown, borrowed_fd(fd), ow, gr))
+        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
+        ret(fchown(borrowed_fd(fd), ow, gr))
     }
 }
 
-#[cfg(not(any(target_os = "android", target_os = "linux", target_os = "wasi")))]
+#[cfg(not(any(linux_kernel, target_os = "wasi")))]
 pub(crate) fn fchown(fd: BorrowedFd<'_>, owner: Option<Uid>, group: Option<Gid>) -> io::Result<()> {
     unsafe {
-        let (ow, gr) = crate::process::translate_fchown_args(owner, group);
+        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
         ret(c::fchown(borrowed_fd(fd), ow, gr))
     }
 }
@@ -956,18 +1242,21 @@ pub(crate) fn flock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::Result
     unsafe { ret(c::flock(borrowed_fd(fd), operation as c::c_int)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn syncfs(fd: BorrowedFd<'_>) -> io::Result<()> {
     // Some versions of Android libc lack a `syncfs` function.
     #[cfg(target_os = "android")]
-    unsafe {
-        syscall_ret(c::syscall(c::SYS_syncfs, borrowed_fd(fd)))
+    syscall! {
+        fn syncfs(fd: c::c_int) via SYS_syncfs -> c::c_int
     }
 
+    // `syncfs` was added to glibc in 2.20.
     #[cfg(not(target_os = "android"))]
-    unsafe {
-        ret(c::syncfs(borrowed_fd(fd)))
+    weak_or_syscall! {
+        fn syncfs(fd: c::c_int) via SYS_syncfs -> c::c_int
     }
+
+    unsafe { ret(syncfs(borrowed_fd(fd))) }
 }
 
 #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
@@ -978,12 +1267,13 @@ pub(crate) fn sync() {
 pub(crate) fn fstat(fd: BorrowedFd<'_>) -> io::Result<Stat> {
     // 32-bit and mips64 Linux: `struct stat64` is not y2038 compatible; use
     // `statx`.
-    #[cfg(all(
-        any(target_os = "android", target_os = "linux"),
-        any(target_pointer_width = "32", target_arch = "mips64"),
-    ))]
+    //
+    // And, some old platforms don't support `statx`, and some fail with a
+    // confusing error code, so we call `crate::fs::statx` to handle that. If
+    // `statx` isn't available, fall back to the buggy system call.
+    #[cfg(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64")))]
     {
-        match statx(fd, cstr!(""), AtFlags::EMPTY_PATH, StatxFlags::BASIC_STATS) {
+        match crate::fs::statx(fd, cstr!(""), AtFlags::EMPTY_PATH, StatxFlags::BASIC_STATS) {
             Ok(x) => statx_to_stat(x),
             Err(io::Errno::NOSYS) => fstat_old(fd),
             Err(err) => Err(err),
@@ -992,25 +1282,19 @@ pub(crate) fn fstat(fd: BorrowedFd<'_>) -> io::Result<Stat> {
 
     // Main version: libc is y2038 safe. Or, the platform is not y2038 safe and
     // there's nothing practical we can do.
-    #[cfg(not(all(
-        any(target_os = "android", target_os = "linux"),
-        any(target_pointer_width = "32", target_arch = "mips64"),
-    )))]
+    #[cfg(not(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64"))))]
     unsafe {
         let mut stat = MaybeUninit::<Stat>::uninit();
-        ret(libc_fstat(borrowed_fd(fd), stat.as_mut_ptr()))?;
+        ret(c::fstat(borrowed_fd(fd), stat.as_mut_ptr()))?;
         Ok(stat.assume_init())
     }
 }
 
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    any(target_pointer_width = "32", target_arch = "mips64"),
-))]
+#[cfg(all(linux_kernel, any(target_pointer_width = "32", target_arch = "mips64")))]
 fn fstat_old(fd: BorrowedFd<'_>) -> io::Result<Stat> {
     unsafe {
         let mut result = MaybeUninit::<c::stat64>::uninit();
-        ret(libc_fstat(borrowed_fd(fd), result.as_mut_ptr()))?;
+        ret(c::fstat(borrowed_fd(fd), result.as_mut_ptr()))?;
         stat64_to_stat(result.assume_init())
     }
 }
@@ -1025,22 +1309,22 @@ fn fstat_old(fd: BorrowedFd<'_>) -> io::Result<Stat> {
 pub(crate) fn fstatfs(fd: BorrowedFd<'_>) -> io::Result<StatFs> {
     let mut statfs = MaybeUninit::<StatFs>::uninit();
     unsafe {
-        ret(libc_fstatfs(borrowed_fd(fd), statfs.as_mut_ptr()))?;
+        ret(c::fstatfs(borrowed_fd(fd), statfs.as_mut_ptr()))?;
         Ok(statfs.assume_init())
     }
 }
 
 #[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
 pub(crate) fn fstatvfs(fd: BorrowedFd<'_>) -> io::Result<StatVfs> {
-    let mut statvfs = MaybeUninit::<libc_statvfs>::uninit();
+    let mut statvfs = MaybeUninit::<c::statvfs>::uninit();
     unsafe {
-        ret(libc_fstatvfs(borrowed_fd(fd), statvfs.as_mut_ptr()))?;
+        ret(c::fstatvfs(borrowed_fd(fd), statvfs.as_mut_ptr()))?;
         Ok(libc_statvfs_to_statvfs(statvfs.assume_init()))
     }
 }
 
 #[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-fn libc_statvfs_to_statvfs(from: libc_statvfs) -> StatVfs {
+fn libc_statvfs_to_statvfs(from: c::statvfs) -> StatVfs {
     StatVfs {
         f_bsize: from.f_bsize as u64,
         f_frsize: from.f_frsize as u64,
@@ -1051,7 +1335,7 @@ fn libc_statvfs_to_statvfs(from: libc_statvfs) -> StatVfs {
         f_ffree: from.f_ffree as u64,
         f_favail: from.f_ffree as u64,
         f_fsid: from.f_fsid as u64,
-        f_flag: unsafe { StatVfsMountFlags::from_bits_unchecked(from.f_flag as u64) },
+        f_flag: StatVfsMountFlags::from_bits_retain(from.f_flag as u64),
         f_namemax: from.f_namemax as u64,
     }
 }
@@ -1174,15 +1458,20 @@ pub(crate) fn fallocate(
     let offset = offset as i64;
     let len = len as i64;
 
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[cfg(any(linux_kernel, target_os = "fuchsia"))]
     unsafe {
-        ret(libc_fallocate(borrowed_fd(fd), mode.bits(), offset, len))
+        ret(c::fallocate(
+            borrowed_fd(fd),
+            bitflags_bits!(mode),
+            offset,
+            len,
+        ))
     }
 
-    #[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))]
+    #[cfg(not(any(linux_kernel, target_os = "fuchsia")))]
     {
         assert!(mode.is_empty());
-        let err = unsafe { libc_posix_fallocate(borrowed_fd(fd), offset, len) };
+        let err = unsafe { c::posix_fallocate(borrowed_fd(fd), offset, len) };
 
         // `posix_fallocate` returns its error status rather than using `errno`.
         if err == 0 {
@@ -1240,10 +1529,10 @@ pub(crate) fn fdatasync(fd: BorrowedFd<'_>) -> io::Result<()> {
 
 pub(crate) fn ftruncate(fd: BorrowedFd<'_>, length: u64) -> io::Result<()> {
     let length = length.try_into().map_err(|_overflow_err| io::Errno::FBIG)?;
-    unsafe { ret(libc_ftruncate(borrowed_fd(fd), length)) }
+    unsafe { ret(c::ftruncate(borrowed_fd(fd), length)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "freebsd"))]
 pub(crate) fn memfd_create(path: &CStr, flags: MemfdFlags) -> io::Result<OwnedFd> {
     #[cfg(target_os = "freebsd")]
     weakcall! {
@@ -1253,7 +1542,7 @@ pub(crate) fn memfd_create(path: &CStr, flags: MemfdFlags) -> io::Result<OwnedFd
         ) -> c::c_int
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(linux_kernel)]
     weak_or_syscall! {
         fn memfd_create(
             name: *const c::c_char,
@@ -1261,10 +1550,10 @@ pub(crate) fn memfd_create(path: &CStr, flags: MemfdFlags) -> io::Result<OwnedFd
         ) via SYS_memfd_create -> c::c_int
     }
 
-    unsafe { ret_owned_fd(memfd_create(c_str(path), flags.bits())) }
+    unsafe { ret_owned_fd(memfd_create(c_str(path), bitflags_bits!(flags))) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn openat2(
     dirfd: BorrowedFd<'_>,
     path: &CStr,
@@ -1272,45 +1561,38 @@ pub(crate) fn openat2(
     mode: Mode,
     resolve: ResolveFlags,
 ) -> io::Result<OwnedFd> {
-    let oflags: i32 = oflags.bits();
-    let open_how = OpenHow {
-        oflag: u64::from(oflags as u32),
+    use linux_raw_sys::general::open_how;
+
+    syscall! {
+        fn openat2(
+            base_dirfd: c::c_int,
+            pathname: *const c::c_char,
+            how: *mut open_how,
+            size: usize
+        ) via SYS_OPENAT2 -> c::c_int
+    }
+
+    let oflags = oflags.bits();
+    let mut open_how = open_how {
+        flags: u64::from(oflags),
         mode: u64::from(mode.bits()),
         resolve: resolve.bits(),
     };
 
     unsafe {
-        syscall_ret_owned_fd(c::syscall(
-            SYS_OPENAT2,
+        ret_owned_fd(openat2(
             borrowed_fd(dirfd),
             c_str(path),
-            &open_how,
-            SIZEOF_OPEN_HOW,
+            &mut open_how,
+            size_of::<open_how>(),
         ))
     }
 }
-#[cfg(all(
-    target_pointer_width = "32",
-    any(target_os = "android", target_os = "linux"),
-))]
+#[cfg(all(linux_kernel, target_pointer_width = "32"))]
 const SYS_OPENAT2: i32 = 437;
-#[cfg(all(
-    target_pointer_width = "64",
-    any(target_os = "android", target_os = "linux"),
-))]
+#[cfg(all(linux_kernel, target_pointer_width = "64"))]
 const SYS_OPENAT2: i64 = 437;
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[repr(C)]
-#[derive(Debug)]
-struct OpenHow {
-    oflag: u64,
-    mode: u64,
-    resolve: u64,
-}
-#[cfg(any(target_os = "android", target_os = "linux"))]
-const SIZEOF_OPEN_HOW: usize = size_of::<OpenHow>();
-
 #[cfg(target_os = "linux")]
 pub(crate) fn sendfile(
     out_fd: BorrowedFd<'_>,
@@ -1329,10 +1611,7 @@ pub(crate) fn sendfile(
 }
 
 /// Convert from a Linux `statx` value to rustix's `Stat`.
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    target_pointer_width = "32",
-))]
+#[cfg(all(linux_kernel, target_pointer_width = "32"))]
 fn statx_to_stat(x: crate::fs::Statx) -> io::Result<Stat> {
     Ok(Stat {
         st_dev: crate::fs::makedev(x.stx_dev_major, x.stx_dev_minor).into(),
@@ -1369,10 +1648,7 @@ fn statx_to_stat(x: crate::fs::Statx) -> io::Result<Stat> {
 /// Convert from a Linux `statx` value to rustix's `Stat`.
 ///
 /// mips64' `struct stat64` in libc has private fields, and `stx_blocks`
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    target_arch = "mips64",
-))]
+#[cfg(all(linux_kernel, target_arch = "mips64"))]
 fn statx_to_stat(x: crate::fs::Statx) -> io::Result<Stat> {
     let mut result: Stat = unsafe { core::mem::zeroed() };
 
@@ -1409,10 +1685,7 @@ fn statx_to_stat(x: crate::fs::Statx) -> io::Result<Stat> {
 }
 
 /// Convert from a Linux `stat64` value to rustix's `Stat`.
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    target_pointer_width = "32",
-))]
+#[cfg(all(linux_kernel, target_pointer_width = "32"))]
 fn stat64_to_stat(s64: c::stat64) -> io::Result<Stat> {
     Ok(Stat {
         st_dev: s64.st_dev.try_into().map_err(|_| io::Errno::OVERFLOW)?,
@@ -1447,10 +1720,7 @@ fn stat64_to_stat(s64: c::stat64) -> io::Result<Stat> {
 ///
 /// mips64' `struct stat64` in libc has private fields, and `st_blocks` has
 /// type `i64`.
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    target_arch = "mips64",
-))]
+#[cfg(all(linux_kernel, target_arch = "mips64"))]
 fn stat64_to_stat(s64: c::stat64) -> io::Result<Stat> {
     let mut result: Stat = unsafe { core::mem::zeroed() };
 
@@ -1483,7 +1753,7 @@ fn stat64_to_stat(s64: c::stat64) -> io::Result<Stat> {
     Ok(result)
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[allow(non_upper_case_globals)]
 mod sys {
     use super::{c, BorrowedFd, Statx};
@@ -1499,7 +1769,7 @@ mod sys {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[allow(non_upper_case_globals)]
 pub(crate) fn statx(
     dirfd: BorrowedFd<'_>,
@@ -1534,7 +1804,7 @@ pub(crate) fn statx(
         ret(sys::statx(
             dirfd,
             c_str(path),
-            flags.bits(),
+            bitflags_bits!(flags),
             mask.bits(),
             statx_buf.as_mut_ptr(),
         ))?;
@@ -1542,14 +1812,14 @@ pub(crate) fn statx(
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn is_statx_available() -> bool {
     unsafe {
         // Call `statx` with null pointers so that if it fails for any reason
         // other than `EFAULT`, we know it's not supported.
         matches!(
-            ret(sys::statx(cwd(), null(), 0, 0, null_mut())),
+            ret(sys::statx(CWD, null(), 0, 0, null_mut())),
             Err(io::Errno::FAULT)
         )
     }
@@ -1575,7 +1845,7 @@ pub(crate) unsafe fn fcopyfile(
         borrowed_fd(from),
         borrowed_fd(to),
         state,
-        flags.bits(),
+        bitflags_bits!(flags),
     ))
 }
 
@@ -1632,7 +1902,7 @@ pub(crate) fn getpath(fd: BorrowedFd<'_>) -> io::Result<CString> {
     // `F_GETPATH` in terms of `MAXPATHLEN`, and there are no
     // alternatives. If a better method is invented, it should be used
     // instead.
-    let mut buf = alloc::vec![0; c::PATH_MAX as usize];
+    let mut buf = vec![0; c::PATH_MAX as usize];
 
     // From the [macOS `fcntl` manual page]:
     // `F_GETPATH` - Get the path of the file descriptor `Fildes`. The argument
@@ -1645,9 +1915,6 @@ pub(crate) fn getpath(fd: BorrowedFd<'_>) -> io::Result<CString> {
 
     let l = buf.iter().position(|&c| c == 0).unwrap();
     buf.truncate(l);
-
-    // TODO: On Rust 1.56, we can use `shrink_to` here.
-    //buf.shrink_to(l + 1);
     buf.shrink_to_fit();
 
     Ok(CString::new(buf).unwrap())
@@ -1781,7 +2048,7 @@ struct Attrlist {
     forkattr: Attrgroup,
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn mount(
     source: Option<&CStr>,
     target: &CStr,
@@ -1800,12 +2067,12 @@ pub(crate) fn mount(
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn unmount(target: &CStr, flags: super::types::UnmountFlags) -> io::Result<()> {
-    unsafe { ret(c::umount2(target.as_ptr(), flags.bits())) }
+    unsafe { ret(c::umount2(target.as_ptr(), bitflags_bits!(flags))) }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn getxattr(path: &CStr, name: &CStr, value: &mut [u8]) -> io::Result<usize> {
     let value_ptr = value.as_mut_ptr();
 
@@ -1832,7 +2099,7 @@ pub(crate) fn getxattr(path: &CStr, name: &CStr, value: &mut [u8]) -> io::Result
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn lgetxattr(path: &CStr, name: &CStr, value: &mut [u8]) -> io::Result<usize> {
     let value_ptr = value.as_mut_ptr();
 
@@ -1859,7 +2126,7 @@ pub(crate) fn lgetxattr(path: &CStr, name: &CStr, value: &mut [u8]) -> io::Resul
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn fgetxattr(fd: BorrowedFd<'_>, name: &CStr, value: &mut [u8]) -> io::Result<usize> {
     let value_ptr = value.as_mut_ptr();
 
@@ -1886,7 +2153,7 @@ pub(crate) fn fgetxattr(fd: BorrowedFd<'_>, name: &CStr, value: &mut [u8]) -> io
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn setxattr(
     path: &CStr,
     name: &CStr,
@@ -1917,7 +2184,7 @@ pub(crate) fn setxattr(
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn lsetxattr(
     path: &CStr,
     name: &CStr,
@@ -1948,7 +2215,7 @@ pub(crate) fn lsetxattr(
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn fsetxattr(
     fd: BorrowedFd<'_>,
     name: &CStr,
@@ -1979,7 +2246,7 @@ pub(crate) fn fsetxattr(
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn listxattr(path: &CStr, list: &mut [c::c_char]) -> io::Result<usize> {
     #[cfg(not(apple))]
     unsafe {
@@ -1997,7 +2264,7 @@ pub(crate) fn listxattr(path: &CStr, list: &mut [c::c_char]) -> io::Result<usize
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn llistxattr(path: &CStr, list: &mut [c::c_char]) -> io::Result<usize> {
     #[cfg(not(apple))]
     unsafe {
@@ -2015,7 +2282,7 @@ pub(crate) fn llistxattr(path: &CStr, list: &mut [c::c_char]) -> io::Result<usiz
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn flistxattr(fd: BorrowedFd<'_>, list: &mut [c::c_char]) -> io::Result<usize> {
     let fd = borrowed_fd(fd);
 
@@ -2030,7 +2297,7 @@ pub(crate) fn flistxattr(fd: BorrowedFd<'_>, list: &mut [c::c_char]) -> io::Resu
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn removexattr(path: &CStr, name: &CStr) -> io::Result<()> {
     #[cfg(not(apple))]
     unsafe {
@@ -2043,7 +2310,7 @@ pub(crate) fn removexattr(path: &CStr, name: &CStr) -> io::Result<()> {
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn lremovexattr(path: &CStr, name: &CStr) -> io::Result<()> {
     #[cfg(not(apple))]
     unsafe {
@@ -2060,7 +2327,7 @@ pub(crate) fn lremovexattr(path: &CStr, name: &CStr) -> io::Result<()> {
     }
 }
 
-#[cfg(any(apple, target_os = "android", target_os = "linux"))]
+#[cfg(any(apple, linux_kernel))]
 pub(crate) fn fremovexattr(fd: BorrowedFd<'_>, name: &CStr) -> io::Result<()> {
     let fd = borrowed_fd(fd);
 
@@ -2074,3 +2341,52 @@ pub(crate) fn fremovexattr(fd: BorrowedFd<'_>, name: &CStr) -> io::Result<()> {
         ret(c::fremovexattr(fd, name.as_ptr(), 0))
     }
 }
+
+#[cfg(linux_kernel)]
+#[inline]
+pub(crate) fn ioctl_blksszget(fd: BorrowedFd) -> io::Result<u32> {
+    let mut result = MaybeUninit::<c::c_uint>::uninit();
+    unsafe {
+        ret(c::ioctl(borrowed_fd(fd), c::BLKSSZGET, result.as_mut_ptr()))?;
+        Ok(result.assume_init() as u32)
+    }
+}
+
+#[cfg(linux_kernel)]
+#[inline]
+pub(crate) fn ioctl_blkpbszget(fd: BorrowedFd) -> io::Result<u32> {
+    let mut result = MaybeUninit::<c::c_uint>::uninit();
+    unsafe {
+        ret(c::ioctl(
+            borrowed_fd(fd),
+            c::BLKPBSZGET,
+            result.as_mut_ptr(),
+        ))?;
+        Ok(result.assume_init() as u32)
+    }
+}
+
+// Sparc lacks `FICLONE`.
+#[cfg(all(linux_kernel, not(any(target_arch = "sparc", target_arch = "sparc64"))))]
+pub(crate) fn ioctl_ficlone(fd: BorrowedFd<'_>, src_fd: BorrowedFd<'_>) -> io::Result<()> {
+    unsafe {
+        ret(c::ioctl(
+            borrowed_fd(fd),
+            c::FICLONE as _,
+            borrowed_fd(src_fd),
+        ))
+    }
+}
+
+#[cfg(linux_kernel)]
+#[inline]
+pub(crate) fn ext4_ioc_resize_fs(fd: BorrowedFd<'_>, blocks: u64) -> io::Result<()> {
+    // TODO: Fix linux-raw-sys to define ioctl codes for sparc.
+    #[cfg(any(target_arch = "sparc", target_arch = "sparc64"))]
+    const EXT4_IOC_RESIZE_FS: u32 = 0x8008_6610;
+
+    #[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))]
+    use linux_raw_sys::ioctl::EXT4_IOC_RESIZE_FS;
+
+    unsafe { ret(c::ioctl(borrowed_fd(fd), EXT4_IOC_RESIZE_FS as _, &blocks)) }
+}
diff --git a/vendor/rustix/src/backend/libc/fs/types.rs b/vendor/rustix/src/backend/libc/fs/types.rs
index 0cf7fe8ff..b52f0e210 100644
--- a/vendor/rustix/src/backend/libc/fs/types.rs
+++ b/vendor/rustix/src/backend/libc/fs/types.rs
@@ -1,10 +1,12 @@
-use super::super::c;
+use crate::backend::c;
 use bitflags::bitflags;
 
 bitflags! {
     /// `*_OK` constants for use with [`accessat`].
     ///
     /// [`accessat`]: fn.accessat.html
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct Access: c::c_int {
         /// `R_OK`
         const READ_OK = c::R_OK;
@@ -27,44 +29,49 @@ bitflags! {
     ///
     /// [`openat`]: crate::fs::openat
     /// [`statat`]: crate::fs::statat
-    pub struct AtFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct AtFlags: u32 {
+        /// `AT_SYMLINK_NOFOLLOW`
+        const SYMLINK_NOFOLLOW = bitcast!(c::AT_SYMLINK_NOFOLLOW);
+
+        /// `AT_EACCESS`
+        #[cfg(not(any(target_os = "emscripten", target_os = "android")))]
+        const EACCESS = bitcast!(c::AT_EACCESS);
+
         /// `AT_REMOVEDIR`
-        const REMOVEDIR = c::AT_REMOVEDIR;
+        const REMOVEDIR = bitcast!(c::AT_REMOVEDIR);
 
         /// `AT_SYMLINK_FOLLOW`
-        const SYMLINK_FOLLOW = c::AT_SYMLINK_FOLLOW;
+        const SYMLINK_FOLLOW = bitcast!(c::AT_SYMLINK_FOLLOW);
 
-        /// `AT_SYMLINK_NOFOLLOW`
-        const SYMLINK_NOFOLLOW = c::AT_SYMLINK_NOFOLLOW;
+        /// `AT_NO_AUTOMOUNT`
+        #[cfg(any(linux_like, target_os = "fuchsia"))]
+        const NO_AUTOMOUNT = bitcast!(c::AT_NO_AUTOMOUNT);
 
         /// `AT_EMPTY_PATH`
         #[cfg(any(
-            target_os = "android",
+            linux_kernel,
             target_os = "freebsd",
             target_os = "fuchsia",
-            target_os = "linux",
         ))]
-        const EMPTY_PATH = c::AT_EMPTY_PATH;
+        const EMPTY_PATH = bitcast!(c::AT_EMPTY_PATH);
 
         /// `AT_RESOLVE_BENEATH`
         #[cfg(target_os = "freebsd")]
-        const RESOLVE_BENEATH = c::AT_RESOLVE_BENEATH;
-
-        /// `AT_EACCESS`
-        #[cfg(not(any(target_os = "emscripten", target_os = "android")))]
-        const EACCESS = c::AT_EACCESS;
+        const RESOLVE_BENEATH = bitcast!(c::AT_RESOLVE_BENEATH);
 
         /// `AT_STATX_SYNC_AS_STAT`
         #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const STATX_SYNC_AS_STAT = c::AT_STATX_SYNC_AS_STAT;
+        const STATX_SYNC_AS_STAT = bitcast!(c::AT_STATX_SYNC_AS_STAT);
 
         /// `AT_STATX_FORCE_SYNC`
         #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const STATX_FORCE_SYNC = c::AT_STATX_FORCE_SYNC;
+        const STATX_FORCE_SYNC = bitcast!(c::AT_STATX_FORCE_SYNC);
 
         /// `AT_STATX_DONT_SYNC`
         #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const STATX_DONT_SYNC = c::AT_STATX_DONT_SYNC;
+        const STATX_DONT_SYNC = bitcast!(c::AT_STATX_DONT_SYNC);
     }
 }
 
@@ -74,6 +81,8 @@ bitflags! {
     /// [`openat`]: crate::fs::openat
     /// [`chmodat`]: crate::fs::chmodat
     /// [`fchmod`]: crate::fs::fchmod
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct Mode: RawMode {
         /// `S_IRWXU`
         #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
@@ -166,7 +175,7 @@ impl From<RawMode> for Mode {
 }
 
 impl From<Mode> for RawMode {
-    /// Support conversions from `Mode to raw mode values.
+    /// Support conversions from `Mode` to raw mode values.
     ///
     /// ```
     /// use rustix::fs::{Mode, RawMode};
@@ -182,9 +191,11 @@ bitflags! {
     /// `O_*` constants for use with [`openat`].
     ///
     /// [`openat`]: crate::fs::openat
-    pub struct OFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct OFlags: u32 {
         /// `O_ACCMODE`
-        const ACCMODE = c::O_ACCMODE;
+        const ACCMODE = bitcast!(c::O_ACCMODE);
 
         /// Similar to `ACCMODE`, but just includes the read/write flags, and
         /// no other flags.
@@ -193,117 +204,112 @@ bitflags! {
         /// sometimes we really just want the read/write bits. Caution is
         /// indicated, as the presence of `O_PATH` may mean that the read/write
         /// bits don't have their usual meaning.
-        const RWMODE = c::O_RDONLY | c::O_WRONLY | c::O_RDWR;
+        const RWMODE = bitcast!(c::O_RDONLY | c::O_WRONLY | c::O_RDWR);
 
         /// `O_APPEND`
-        const APPEND = c::O_APPEND;
+        const APPEND = bitcast!(c::O_APPEND);
 
         /// `O_CREAT`
         #[doc(alias = "CREAT")]
-        const CREATE = c::O_CREAT;
+        const CREATE = bitcast!(c::O_CREAT);
 
         /// `O_DIRECTORY`
-        const DIRECTORY = c::O_DIRECTORY;
+        const DIRECTORY = bitcast!(c::O_DIRECTORY);
 
         /// `O_DSYNC`
         #[cfg(not(any(target_os = "dragonfly", target_os = "redox")))]
-        const DSYNC = c::O_DSYNC;
+        const DSYNC = bitcast!(c::O_DSYNC);
 
         /// `O_EXCL`
-        const EXCL = c::O_EXCL;
+        const EXCL = bitcast!(c::O_EXCL);
 
         /// `O_FSYNC`
         #[cfg(any(
             bsd,
             all(target_os = "linux", not(target_env = "musl")),
         ))]
-        const FSYNC = c::O_FSYNC;
+        const FSYNC = bitcast!(c::O_FSYNC);
 
         /// `O_NOFOLLOW`
-        const NOFOLLOW = c::O_NOFOLLOW;
+        const NOFOLLOW = bitcast!(c::O_NOFOLLOW);
 
         /// `O_NONBLOCK`
-        const NONBLOCK = c::O_NONBLOCK;
+        const NONBLOCK = bitcast!(c::O_NONBLOCK);
 
         /// `O_RDONLY`
-        const RDONLY = c::O_RDONLY;
+        const RDONLY = bitcast!(c::O_RDONLY);
 
         /// `O_WRONLY`
-        const WRONLY = c::O_WRONLY;
+        const WRONLY = bitcast!(c::O_WRONLY);
 
         /// `O_RDWR`
-        const RDWR = c::O_RDWR;
+        const RDWR = bitcast!(c::O_RDWR);
 
         /// `O_NOCTTY`
         #[cfg(not(target_os = "redox"))]
-        const NOCTTY = c::O_NOCTTY;
+        const NOCTTY = bitcast!(c::O_NOCTTY);
 
         /// `O_RSYNC`
         #[cfg(any(
+            linux_kernel,
             netbsdlike,
-            target_os = "android",
             target_os = "emscripten",
-            target_os = "linux",
             target_os = "wasi",
         ))]
-        const RSYNC = c::O_RSYNC;
+        const RSYNC = bitcast!(c::O_RSYNC);
 
         /// `O_SYNC`
         #[cfg(not(target_os = "redox"))]
-        const SYNC = c::O_SYNC;
+        const SYNC = bitcast!(c::O_SYNC);
 
         /// `O_TRUNC`
-        const TRUNC = c::O_TRUNC;
+        const TRUNC = bitcast!(c::O_TRUNC);
 
         /// `O_PATH`
         #[cfg(any(
-            target_os = "android",
+            linux_kernel,
             target_os = "emscripten",
             target_os = "freebsd",
             target_os = "fuchsia",
-            target_os = "linux",
             target_os = "redox",
         ))]
-        const PATH = c::O_PATH;
+        const PATH = bitcast!(c::O_PATH);
 
         /// `O_CLOEXEC`
-        const CLOEXEC = c::O_CLOEXEC;
+        const CLOEXEC = bitcast!(c::O_CLOEXEC);
 
         /// `O_TMPFILE`
         #[cfg(any(
-            target_os = "android",
+            linux_kernel,
             target_os = "emscripten",
             target_os = "fuchsia",
-            target_os = "linux",
         ))]
-        const TMPFILE = c::O_TMPFILE;
+        const TMPFILE = bitcast!(c::O_TMPFILE);
 
         /// `O_NOATIME`
         #[cfg(any(
-            target_os = "android",
+            linux_kernel,
             target_os = "fuchsia",
-            target_os = "linux",
         ))]
-        const NOATIME = c::O_NOATIME;
+        const NOATIME = bitcast!(c::O_NOATIME);
 
         /// `O_DIRECT`
         #[cfg(any(
-            target_os = "android",
+            linux_kernel,
             target_os = "emscripten",
             target_os = "freebsd",
             target_os = "fuchsia",
-            target_os = "linux",
             target_os = "netbsd",
         ))]
-        const DIRECT = c::O_DIRECT;
+        const DIRECT = bitcast!(c::O_DIRECT);
 
         /// `O_RESOLVE_BENEATH`
         #[cfg(target_os = "freebsd")]
-        const RESOLVE_BENEATH = c::O_RESOLVE_BENEATH;
+        const RESOLVE_BENEATH = bitcast!(c::O_RESOLVE_BENEATH);
 
         /// `O_EMPTY_PATH`
         #[cfg(target_os = "freebsd")]
-        const EMPTY_PATH = c::O_EMPTY_PATH;
+        const EMPTY_PATH = bitcast!(c::O_EMPTY_PATH);
     }
 }
 
@@ -312,7 +318,9 @@ bitflags! {
     /// `CLONE_*` constants for use with [`fclonefileat`].
     ///
     /// [`fclonefileat`]: crate::fs::fclonefileat
-    pub struct CloneFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct CloneFlags: u32 {
         /// `CLONE_NOFOLLOW`
         const NOFOLLOW = 1;
 
@@ -337,6 +345,8 @@ bitflags! {
     /// `COPYFILE_*` constants for use with [`fcopyfile`].
     ///
     /// [`fcopyfile`]: crate::fs::fcopyfile
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct CopyfileFlags: c::c_uint {
         /// `COPYFILE_ACL`
         const ACL = copyfile::ACL;
@@ -361,12 +371,13 @@ bitflags! {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
     /// `RESOLVE_*` constants for use with [`openat2`].
     ///
     /// [`openat2`]: crate::fs::openat2
-    #[derive(Default)]
+    #[repr(transparent)]
+    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct ResolveFlags: u64 {
         /// `RESOLVE_NO_XDEV`
         const NO_XDEV = 0x01;
@@ -388,20 +399,22 @@ bitflags! {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
     /// `RENAME_*` constants for use with [`renameat_with`].
     ///
     /// [`renameat_with`]: crate::fs::renameat_with
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct RenameFlags: c::c_uint {
         /// `RENAME_EXCHANGE`
-        const EXCHANGE = c::RENAME_EXCHANGE as _;
+        const EXCHANGE = bitcast!(c::RENAME_EXCHANGE);
 
         /// `RENAME_NOREPLACE`
-        const NOREPLACE = c::RENAME_NOREPLACE as _;
+        const NOREPLACE = bitcast!(c::RENAME_NOREPLACE);
 
         /// `RENAME_WHITEOUT`
-        const WHITEOUT = c::RENAME_WHITEOUT as _;
+        const WHITEOUT = bitcast!(c::RENAME_WHITEOUT);
     }
 }
 
@@ -528,11 +541,13 @@ pub enum Advice {
     DontNeed = c::POSIX_FADV_DONTNEED as c::c_uint,
 }
 
-#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "freebsd"))]
 bitflags! {
     /// `MFD_*` constants for use with [`memfd_create`].
     ///
     /// [`memfd_create`]: crate::fs::memfd_create
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MemfdFlags: c::c_uint {
         /// `MFD_CLOEXEC`
         const CLOEXEC = c::MFD_CLOEXEC;
@@ -570,30 +585,27 @@ bitflags! {
     }
 }
 
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "fuchsia"))]
 bitflags! {
     /// `F_SEAL_*` constants for use with [`fcntl_add_seals`] and
     /// [`fcntl_get_seals`].
     ///
     /// [`fcntl_add_seals`]: crate::fs::fcntl_add_seals
     /// [`fcntl_get_seals`]: crate::fs::fcntl_get_seals
-    pub struct SealFlags: i32 {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct SealFlags: u32 {
        /// `F_SEAL_SEAL`.
-       const SEAL = c::F_SEAL_SEAL;
+       const SEAL = bitcast!(c::F_SEAL_SEAL);
        /// `F_SEAL_SHRINK`.
-       const SHRINK = c::F_SEAL_SHRINK;
+       const SHRINK = bitcast!(c::F_SEAL_SHRINK);
        /// `F_SEAL_GROW`.
-       const GROW = c::F_SEAL_GROW;
+       const GROW = bitcast!(c::F_SEAL_GROW);
        /// `F_SEAL_WRITE`.
-       const WRITE = c::F_SEAL_WRITE;
+       const WRITE = bitcast!(c::F_SEAL_WRITE);
        /// `F_SEAL_FUTURE_WRITE` (since Linux 5.1)
-       #[cfg(any(target_os = "android", target_os = "linux"))]
-       const FUTURE_WRITE = c::F_SEAL_FUTURE_WRITE;
+       #[cfg(linux_kernel)]
+       const FUTURE_WRITE = bitcast!(c::F_SEAL_FUTURE_WRITE);
     }
 }
 
@@ -602,6 +614,8 @@ bitflags! {
     /// `STATX_*` constants for use with [`statx`].
     ///
     /// [`statx`]: crate::fs::statx
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct StatxFlags: u32 {
         /// `STATX_TYPE`
         const TYPE = c::STATX_TYPE;
@@ -645,6 +659,9 @@ bitflags! {
         /// `STATX_MNT_ID` (since Linux 5.8)
         const MNT_ID = c::STATX_MNT_ID;
 
+        /// `STATX_DIOALIGN` (since Linux 6.1)
+        const DIOALIGN = c::STATX_DIOALIGN;
+
         /// `STATX_ALL`
         const ALL = c::STATX_ALL;
     }
@@ -658,6 +675,8 @@ bitflags! {
     /// `STATX_*` constants for use with [`statx`].
     ///
     /// [`statx`]: crate::fs::statx
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct StatxFlags: u32 {
         /// `STATX_TYPE`
         const TYPE = 0x0001;
@@ -711,7 +730,9 @@ bitflags! {
     /// `FALLOC_FL_*` constants for use with [`fallocate`].
     ///
     /// [`fallocate`]: crate::fs::fallocate
-    pub struct FallocateFlags: i32 {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct FallocateFlags: u32 {
         /// `FALLOC_FL_KEEP_SIZE`
         #[cfg(not(any(
             bsd,
@@ -719,7 +740,7 @@ bitflags! {
             target_os = "haiku",
             target_os = "wasi",
         )))]
-        const KEEP_SIZE = c::FALLOC_FL_KEEP_SIZE;
+        const KEEP_SIZE = bitcast!(c::FALLOC_FL_KEEP_SIZE);
         /// `FALLOC_FL_PUNCH_HOLE`
         #[cfg(not(any(
             bsd,
@@ -727,7 +748,7 @@ bitflags! {
             target_os = "haiku",
             target_os = "wasi",
         )))]
-        const PUNCH_HOLE = c::FALLOC_FL_PUNCH_HOLE;
+        const PUNCH_HOLE = bitcast!(c::FALLOC_FL_PUNCH_HOLE);
         /// `FALLOC_FL_NO_HIDE_STALE`
         #[cfg(not(any(
             bsd,
@@ -738,7 +759,7 @@ bitflags! {
             target_os = "fuchsia",
             target_os = "wasi",
         )))]
-        const NO_HIDE_STALE = c::FALLOC_FL_NO_HIDE_STALE;
+        const NO_HIDE_STALE = bitcast!(c::FALLOC_FL_NO_HIDE_STALE);
         /// `FALLOC_FL_COLLAPSE_RANGE`
         #[cfg(not(any(
             bsd,
@@ -747,7 +768,7 @@ bitflags! {
             target_os = "emscripten",
             target_os = "wasi",
         )))]
-        const COLLAPSE_RANGE = c::FALLOC_FL_COLLAPSE_RANGE;
+        const COLLAPSE_RANGE = bitcast!(c::FALLOC_FL_COLLAPSE_RANGE);
         /// `FALLOC_FL_ZERO_RANGE`
         #[cfg(not(any(
             bsd,
@@ -756,7 +777,7 @@ bitflags! {
             target_os = "emscripten",
             target_os = "wasi",
         )))]
-        const ZERO_RANGE = c::FALLOC_FL_ZERO_RANGE;
+        const ZERO_RANGE = bitcast!(c::FALLOC_FL_ZERO_RANGE);
         /// `FALLOC_FL_INSERT_RANGE`
         #[cfg(not(any(
             bsd,
@@ -765,7 +786,7 @@ bitflags! {
             target_os = "emscripten",
             target_os = "wasi",
         )))]
-        const INSERT_RANGE = c::FALLOC_FL_INSERT_RANGE;
+        const INSERT_RANGE = bitcast!(c::FALLOC_FL_INSERT_RANGE);
         /// `FALLOC_FL_UNSHARE_RANGE`
         #[cfg(not(any(
             bsd,
@@ -774,32 +795,39 @@ bitflags! {
             target_os = "emscripten",
             target_os = "wasi",
         )))]
-        const UNSHARE_RANGE = c::FALLOC_FL_UNSHARE_RANGE;
+        const UNSHARE_RANGE = bitcast!(c::FALLOC_FL_UNSHARE_RANGE);
     }
 }
 
 #[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
 bitflags! {
     /// `ST_*` constants for use with [`StatVfs`].
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct StatVfsMountFlags: u64 {
         /// `ST_MANDLOCK`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
         const MANDLOCK = c::ST_MANDLOCK as u64;
 
         /// `ST_NOATIME`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
         const NOATIME = c::ST_NOATIME as u64;
 
         /// `ST_NODEV`
-        #[cfg(any(target_os = "aix", target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg(any(
+            linux_kernel,
+            target_os = "aix",
+            target_os = "emscripten",
+            target_os = "fuchsia"
+        ))]
         const NODEV = c::ST_NODEV as u64;
 
         /// `ST_NODIRATIME`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
         const NODIRATIME = c::ST_NODIRATIME as u64;
 
         /// `ST_NOEXEC`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
         const NOEXEC = c::ST_NOEXEC as u64;
 
         /// `ST_NOSUID`
@@ -813,7 +841,7 @@ bitflags! {
         const RELATIME = c::ST_RELATIME as u64;
 
         /// `ST_SYNCHRONOUS`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
         const SYNCHRONOUS = c::ST_SYNCHRONOUS as u64;
     }
 }
@@ -824,20 +852,20 @@ bitflags! {
 /// [`fcntl_lock`]: crate::fs::fcntl_lock
 #[cfg(not(target_os = "wasi"))]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-#[repr(i32)]
+#[repr(u32)]
 pub enum FlockOperation {
     /// `LOCK_SH`
-    LockShared = c::LOCK_SH,
+    LockShared = bitcast!(c::LOCK_SH),
     /// `LOCK_EX`
-    LockExclusive = c::LOCK_EX,
+    LockExclusive = bitcast!(c::LOCK_EX),
     /// `LOCK_UN`
-    Unlock = c::LOCK_UN,
+    Unlock = bitcast!(c::LOCK_UN),
     /// `LOCK_SH | LOCK_NB`
-    NonBlockingLockShared = c::LOCK_SH | c::LOCK_NB,
+    NonBlockingLockShared = bitcast!(c::LOCK_SH | c::LOCK_NB),
     /// `LOCK_EX | LOCK_NB`
-    NonBlockingLockExclusive = c::LOCK_EX | c::LOCK_NB,
+    NonBlockingLockExclusive = bitcast!(c::LOCK_EX | c::LOCK_NB),
     /// `LOCK_UN | LOCK_NB`
-    NonBlockingUnlock = c::LOCK_UN | c::LOCK_NB,
+    NonBlockingUnlock = bitcast!(c::LOCK_UN | c::LOCK_NB),
 }
 
 /// `struct stat` for use with [`statat`] and [`fstat`].
@@ -852,10 +880,7 @@ pub type Stat = c::stat;
 /// [`statat`]: crate::fs::statat
 /// [`fstat`]: crate::fs::fstat
 #[cfg(any(
-    all(
-        any(target_os = "android", target_os = "linux"),
-        target_pointer_width = "64",
-    ),
+    all(linux_kernel, target_pointer_width = "64"),
     target_os = "emscripten",
     target_os = "l4re",
 ))]
@@ -868,10 +893,7 @@ pub type Stat = c::stat64;
 // On 32-bit, Linux's `struct stat64` has a 32-bit `st_mtime` and friends, so
 // we use our own struct, populated from `statx` where possible, to avoid the
 // y2038 bug.
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    target_pointer_width = "32",
-))]
+#[cfg(all(linux_kernel, target_pointer_width = "32"))]
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 #[allow(missing_docs)]
@@ -1053,11 +1075,13 @@ pub type FsWord = u32;
 #[derive(Copy, Clone)]
 pub struct copyfile_state_t(pub(crate) *mut c::c_void);
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
     /// `MS_*` constants for use with [`mount`].
     ///
     /// [`mount`]: crate::fs::mount
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MountFlags: c::c_ulong {
         /// `MS_BIND`
         const BIND = c::MS_BIND;
@@ -1107,11 +1131,13 @@ bitflags! {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
     /// `MS_*` constants for use with [`change_mount`].
     ///
     /// [`change_mount`]: crate::fs::mount::change_mount
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MountPropagationFlags: c::c_ulong {
         /// `MS_SHARED`
         const SHARED = c::MS_SHARED;
@@ -1126,30 +1152,34 @@ bitflags! {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub(crate) struct InternalMountFlags: c::c_ulong {
         const REMOUNT = c::MS_REMOUNT;
         const MOVE = c::MS_MOVE;
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) struct MountFlagsArg(pub(crate) c::c_ulong);
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
     /// `MNT_*` constants for use with [`unmount`].
     ///
     /// [`unmount`]: crate::fs::mount::unmount
-    pub struct UnmountFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct UnmountFlags: u32 {
         /// `MNT_FORCE`
-        const FORCE = c::MNT_FORCE;
+        const FORCE = bitcast!(c::MNT_FORCE);
         /// `MNT_DETACH`
-        const DETACH = c::MNT_DETACH;
+        const DETACH = bitcast!(c::MNT_DETACH);
         /// `MNT_EXPIRE`
-        const EXPIRE = c::MNT_EXPIRE;
+        const EXPIRE = bitcast!(c::MNT_EXPIRE);
         /// `UMOUNT_NOFOLLOW`
-        const NOFOLLOW = c::UMOUNT_NOFOLLOW;
+        const NOFOLLOW = bitcast!(c::UMOUNT_NOFOLLOW);
     }
 }
diff --git a/vendor/rustix/src/backend/libc/io/errno.rs b/vendor/rustix/src/backend/libc/io/errno.rs
index 9e808c0b4..71fba49e9 100644
--- a/vendor/rustix/src/backend/libc/io/errno.rs
+++ b/vendor/rustix/src/backend/libc/io/errno.rs
@@ -3,7 +3,7 @@
 //! This type holds an OS error code, which conceptually corresponds to an
 //! `errno` value.
 
-use super::super::c;
+use crate::backend::c;
 use libc_errno::errno;
 
 /// The error type for `rustix` APIs.
diff --git a/vendor/rustix/src/backend/libc/io/io_slice.rs b/vendor/rustix/src/backend/libc/io/io_slice.rs
deleted file mode 100644
index de1ef434c..000000000
--- a/vendor/rustix/src/backend/libc/io/io_slice.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/sys/unix/io.rs
-//! dca3f1b786efd27be3b325ed1e01e247aa589c3b.
-
-#![allow(missing_docs)]
-
-use super::super::c;
-use core::marker::PhantomData;
-use core::slice;
-
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct IoSlice<'a> {
-    vec: c::iovec,
-    _p: PhantomData<&'a [u8]>,
-}
-
-impl<'a> IoSlice<'a> {
-    #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
-        IoSlice {
-            vec: c::iovec {
-                iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void,
-                iov_len: buf.len(),
-            },
-            _p: PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n {
-            panic!("advancing IoSlice beyond its length");
-        }
-
-        unsafe {
-            self.vec.iov_len -= n;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }
-    }
-}
-
-#[repr(transparent)]
-pub struct IoSliceMut<'a> {
-    vec: c::iovec,
-    _p: PhantomData<&'a mut [u8]>,
-}
-
-impl<'a> IoSliceMut<'a> {
-    #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
-        IoSliceMut {
-            vec: c::iovec {
-                iov_base: buf.as_mut_ptr() as *mut c::c_void,
-                iov_len: buf.len(),
-            },
-            _p: PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n {
-            panic!("advancing IoSliceMut beyond its length");
-        }
-
-        unsafe {
-            self.vec.iov_len -= n;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }
-    }
-
-    #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
-        unsafe { slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len) }
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/io/mod.rs b/vendor/rustix/src/backend/libc/io/mod.rs
index 1378adf3d..487388576 100644
--- a/vendor/rustix/src/backend/libc/io/mod.rs
+++ b/vendor/rustix/src/backend/libc/io/mod.rs
@@ -1,13 +1,6 @@
 pub(crate) mod errno;
 #[cfg(not(windows))]
-#[cfg(not(feature = "std"))]
-pub(crate) mod io_slice;
-pub(crate) mod poll_fd;
-#[cfg(not(windows))]
 pub(crate) mod types;
 
 #[cfg_attr(windows, path = "windows_syscalls.rs")]
 pub(crate) mod syscalls;
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub mod epoll;
diff --git a/vendor/rustix/src/backend/libc/io/syscalls.rs b/vendor/rustix/src/backend/libc/io/syscalls.rs
index b74a63fa3..6ac1fa593 100644
--- a/vendor/rustix/src/backend/libc/io/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/io/syscalls.rs
@@ -1,43 +1,17 @@
 //! libc syscalls supporting `rustix::io`.
 
-use super::super::c;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::syscall_ret_owned_fd;
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-use super::super::conv::syscall_ret_usize;
-use super::super::conv::{borrowed_fd, ret, ret_c_int, ret_discarded_fd, ret_owned_fd, ret_usize};
-use super::super::offset::{libc_pread, libc_pwrite};
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "solaris")))]
-use super::super::offset::{libc_preadv, libc_pwritev};
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-use super::super::offset::{libc_preadv2, libc_pwritev2};
+use crate::backend::conv::{
+    borrowed_fd, ret, ret_c_int, ret_discarded_fd, ret_owned_fd, ret_usize,
+};
+use crate::backend::{c, MAX_IOV};
 use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
-#[cfg(bsd)]
-use crate::io::kqueue::Event;
-#[cfg(solarish)]
-use crate::io::port::Event;
 #[cfg(not(any(target_os = "aix", target_os = "wasi")))]
 use crate::io::DupFlags;
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "linux"
-))]
-use crate::io::EventfdFlags;
-#[cfg(not(any(apple, target_os = "aix", target_os = "haiku", target_os = "wasi")))]
-use crate::io::PipeFlags;
-use crate::io::{self, FdFlags, IoSlice, IoSliceMut, PollFd};
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::io::{IoSliceRaw, ReadWriteFlags, SpliceFlags};
+#[cfg(linux_kernel)]
+use crate::io::ReadWriteFlags;
+use crate::io::{self, FdFlags, IoSlice, IoSliceMut};
 use core::cmp::min;
-use core::convert::TryInto;
 use core::mem::MaybeUninit;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use core::ptr;
 #[cfg(all(feature = "fs", feature = "net"))]
 use libc_errno::errno;
 
@@ -68,7 +42,7 @@ pub(crate) fn pread(fd: BorrowedFd<'_>, buf: &mut [u8], offset: u64) -> io::Resu
     let offset = offset as i64;
 
     unsafe {
-        ret_usize(libc_pread(
+        ret_usize(c::pread(
             borrowed_fd(fd),
             buf.as_mut_ptr().cast(),
             len,
@@ -83,14 +57,7 @@ pub(crate) fn pwrite(fd: BorrowedFd<'_>, buf: &[u8], offset: u64) -> io::Result<
     // Silently cast; we'll get `EINVAL` if the value is negative.
     let offset = offset as i64;
 
-    unsafe {
-        ret_usize(libc_pwrite(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            len,
-            offset,
-        ))
-    }
+    unsafe { ret_usize(c::pwrite(borrowed_fd(fd), buf.as_ptr().cast(), len, offset)) }
 }
 
 pub(crate) fn readv(fd: BorrowedFd<'_>, bufs: &mut [IoSliceMut]) -> io::Result<usize> {
@@ -98,7 +65,7 @@ pub(crate) fn readv(fd: BorrowedFd<'_>, bufs: &mut [IoSliceMut]) -> io::Result<u
         ret_usize(c::readv(
             borrowed_fd(fd),
             bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
+            min(bufs.len(), MAX_IOV) as c::c_int,
         ))
     }
 }
@@ -108,7 +75,7 @@ pub(crate) fn writev(fd: BorrowedFd<'_>, bufs: &[IoSlice]) -> io::Result<usize>
         ret_usize(c::writev(
             borrowed_fd(fd),
             bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
+            min(bufs.len(), MAX_IOV) as c::c_int,
         ))
     }
 }
@@ -122,10 +89,10 @@ pub(crate) fn preadv(
     // Silently cast; we'll get `EINVAL` if the value is negative.
     let offset = offset as i64;
     unsafe {
-        ret_usize(libc_preadv(
+        ret_usize(c::preadv(
             borrowed_fd(fd),
             bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
+            min(bufs.len(), MAX_IOV) as c::c_int,
             offset,
         ))
     }
@@ -136,42 +103,16 @@ pub(crate) fn pwritev(fd: BorrowedFd<'_>, bufs: &[IoSlice], offset: u64) -> io::
     // Silently cast; we'll get `EINVAL` if the value is negative.
     let offset = offset as i64;
     unsafe {
-        ret_usize(libc_pwritev(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
-            offset,
-        ))
-    }
-}
-
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-pub(crate) fn preadv2(
-    fd: BorrowedFd<'_>,
-    bufs: &mut [IoSliceMut],
-    offset: u64,
-    flags: ReadWriteFlags,
-) -> io::Result<usize> {
-    // Silently cast; we'll get `EINVAL` if the value is negative.
-    let offset = offset as i64;
-    unsafe {
-        ret_usize(libc_preadv2(
+        ret_usize(c::pwritev(
             borrowed_fd(fd),
             bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
+            min(bufs.len(), MAX_IOV) as c::c_int,
             offset,
-            flags.bits(),
         ))
     }
 }
 
-/// At present, `libc` only has `preadv2` defined for glibc. On other
-/// ABIs, use `c::syscall`.
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-#[inline]
+#[cfg(linux_kernel)]
 pub(crate) fn preadv2(
     fd: BorrowedFd<'_>,
     bufs: &mut [IoSliceMut],
@@ -181,18 +122,17 @@ pub(crate) fn preadv2(
     // Silently cast; we'll get `EINVAL` if the value is negative.
     let offset = offset as i64;
     unsafe {
-        syscall_ret_usize(c::syscall(
-            c::SYS_preadv2,
+        ret_usize(c::preadv2(
             borrowed_fd(fd),
             bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
+            min(bufs.len(), MAX_IOV) as c::c_int,
             offset,
-            flags.bits(),
+            bitflags_bits!(flags),
         ))
     }
 }
 
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
+#[cfg(linux_kernel)]
 pub(crate) fn pwritev2(
     fd: BorrowedFd<'_>,
     bufs: &[IoSlice],
@@ -202,39 +142,12 @@ pub(crate) fn pwritev2(
     // Silently cast; we'll get `EINVAL` if the value is negative.
     let offset = offset as i64;
     unsafe {
-        ret_usize(libc_pwritev2(
+        ret_usize(c::pwritev2(
             borrowed_fd(fd),
             bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
+            min(bufs.len(), MAX_IOV) as c::c_int,
             offset,
-            flags.bits(),
-        ))
-    }
-}
-
-/// At present, `libc` only has `pwritev2` defined for glibc. On other
-/// ABIs, use `c::syscall`.
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-#[inline]
-pub(crate) fn pwritev2(
-    fd: BorrowedFd<'_>,
-    bufs: &[IoSlice],
-    offset: u64,
-    flags: ReadWriteFlags,
-) -> io::Result<usize> {
-    // Silently cast; we'll get `EINVAL` if the value is negative.
-    let offset = offset as i64;
-    unsafe {
-        syscall_ret_usize(c::syscall(
-            c::SYS_pwritev2,
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
-            offset,
-            flags.bits(),
+            bitflags_bits!(flags),
         ))
     }
 }
@@ -255,72 +168,10 @@ const READ_LIMIT: usize = c::c_int::MAX as usize - 1;
 #[cfg(not(target_os = "macos"))]
 const READ_LIMIT: usize = c::ssize_t::MAX as usize;
 
-#[cfg(bsd)]
-const fn max_iov() -> usize {
-    c::IOV_MAX as usize
-}
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "linux",
-    target_os = "nto"
-))]
-const fn max_iov() -> usize {
-    c::UIO_MAXIOV as usize
-}
-
-#[cfg(not(any(
-    bsd,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "linux",
-    target_os = "nto",
-    target_os = "horizon",
-)))]
-const fn max_iov() -> usize {
-    16 // The minimum value required by POSIX.
-}
-
 pub(crate) unsafe fn close(raw_fd: RawFd) {
     let _ = c::close(raw_fd as c::c_int);
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn eventfd(initval: u32, flags: EventfdFlags) -> io::Result<OwnedFd> {
-    unsafe { syscall_ret_owned_fd(c::syscall(c::SYS_eventfd2, initval, flags.bits())) }
-}
-
-#[cfg(any(target_os = "freebsd", target_os = "illumos"))]
-pub(crate) fn eventfd(initval: u32, flags: EventfdFlags) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::eventfd(initval, flags.bits())) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) fn ioctl_blksszget(fd: BorrowedFd) -> io::Result<u32> {
-    let mut result = MaybeUninit::<c::c_uint>::uninit();
-    unsafe {
-        ret(c::ioctl(borrowed_fd(fd), c::BLKSSZGET, result.as_mut_ptr()))?;
-        Ok(result.assume_init() as u32)
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) fn ioctl_blkpbszget(fd: BorrowedFd) -> io::Result<u32> {
-    let mut result = MaybeUninit::<c::c_uint>::uninit();
-    unsafe {
-        ret(c::ioctl(
-            borrowed_fd(fd),
-            c::BLKPBSZGET,
-            result.as_mut_ptr(),
-        ))?;
-        Ok(result.assume_init() as u32)
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
 pub(crate) fn ioctl_fionread(fd: BorrowedFd<'_>) -> io::Result<u64> {
     let mut nread = MaybeUninit::<c::c_int>::uninit();
     unsafe {
@@ -339,40 +190,6 @@ pub(crate) fn ioctl_fionbio(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn ioctl_ficlone(fd: BorrowedFd<'_>, src_fd: BorrowedFd<'_>) -> io::Result<()> {
-    // TODO: Enable this on mips and power once libc is updated.
-    #[cfg(not(any(
-        target_arch = "mips",
-        target_arch = "mips64",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "sparc",
-        target_arch = "sparc64"
-    )))]
-    unsafe {
-        ret(c::ioctl(
-            borrowed_fd(fd),
-            c::FICLONE as _,
-            borrowed_fd(src_fd),
-        ))
-    }
-
-    #[cfg(any(
-        target_arch = "mips",
-        target_arch = "mips64",
-        target_arch = "powerpc",
-        target_arch = "powerpc64",
-        target_arch = "sparc",
-        target_arch = "sparc64"
-    ))]
-    {
-        let _ = fd;
-        let _ = src_fd;
-        Err(io::Errno::NOSYS)
-    }
-}
-
 #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
 #[cfg(all(feature = "fs", feature = "net"))]
 pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
@@ -410,8 +227,7 @@ pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
         if unsafe { c::send(borrowed_fd(fd), [].as_ptr(), 0, c::MSG_DONTWAIT) } == -1 {
             #[allow(unreachable_patterns)] // `EAGAIN` may equal `EWOULDBLOCK`
             match errno().0 {
-                c::EAGAIN | c::EWOULDBLOCK => (),
-                c::ENOTSOCK => (),
+                c::EAGAIN | c::EWOULDBLOCK | c::ENOTSOCK => (),
                 c::EPIPE => write = false,
                 err => return Err(io::Errno(err)),
             }
@@ -427,7 +243,8 @@ pub(crate) fn is_read_write(_fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
 }
 
 pub(crate) fn fcntl_getfd(fd: BorrowedFd<'_>) -> io::Result<FdFlags> {
-    unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETFD)).map(FdFlags::from_bits_truncate) }
+    let flags = unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETFD))? };
+    Ok(FdFlags::from_bits_retain(bitcast!(flags)))
 }
 
 pub(crate) fn fcntl_setfd(fd: BorrowedFd<'_>, flags: FdFlags) -> io::Result<()> {
@@ -463,7 +280,7 @@ pub(crate) fn dup3(fd: BorrowedFd<'_>, new: &mut OwnedFd, flags: DupFlags) -> io
         ret_discarded_fd(c::dup3(
             borrowed_fd(fd),
             borrowed_fd(new.as_fd()),
-            flags.bits(),
+            bitflags_bits!(flags),
         ))
     }
 }
@@ -493,199 +310,3 @@ pub(crate) fn ioctl_fioclex(fd: BorrowedFd<'_>) -> io::Result<()> {
         ))
     }
 }
-
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-pub(crate) fn ioctl_tiocexcl(fd: BorrowedFd) -> io::Result<()> {
-    unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCEXCL as _)) }
-}
-
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-pub(crate) fn ioctl_tiocnxcl(fd: BorrowedFd) -> io::Result<()> {
-    unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCNXCL as _)) }
-}
-
-#[cfg(bsd)]
-pub(crate) fn kqueue() -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::kqueue()) }
-}
-
-#[cfg(bsd)]
-pub(crate) unsafe fn kevent(
-    kq: BorrowedFd<'_>,
-    changelist: &[Event],
-    eventlist: &mut [MaybeUninit<Event>],
-    timeout: Option<&c::timespec>,
-) -> io::Result<c::c_int> {
-    ret_c_int(c::kevent(
-        borrowed_fd(kq),
-        changelist.as_ptr() as *const _,
-        changelist
-            .len()
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        eventlist.as_mut_ptr() as *mut _,
-        eventlist
-            .len()
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        timeout.map_or(core::ptr::null(), |t| t as *const _),
-    ))
-}
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn pipe() -> io::Result<(OwnedFd, OwnedFd)> {
-    unsafe {
-        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
-        ret(c::pipe(result.as_mut_ptr().cast::<i32>()))?;
-        let [p0, p1] = result.assume_init();
-        Ok((p0, p1))
-    }
-}
-
-#[cfg(not(any(apple, target_os = "aix", target_os = "haiku", target_os = "wasi")))]
-pub(crate) fn pipe_with(flags: PipeFlags) -> io::Result<(OwnedFd, OwnedFd)> {
-    unsafe {
-        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
-        ret(c::pipe2(result.as_mut_ptr().cast::<i32>(), flags.bits()))?;
-        let [p0, p1] = result.assume_init();
-        Ok((p0, p1))
-    }
-}
-
-#[inline]
-pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> {
-    let nfds = fds
-        .len()
-        .try_into()
-        .map_err(|_convert_err| io::Errno::INVAL)?;
-
-    ret_c_int(unsafe { c::poll(fds.as_mut_ptr().cast(), nfds, timeout) })
-        .map(|nready| nready as usize)
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub fn splice(
-    fd_in: BorrowedFd,
-    off_in: Option<&mut u64>,
-    fd_out: BorrowedFd,
-    off_out: Option<&mut u64>,
-    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());
-
-    unsafe {
-        ret_usize(c::splice(
-            borrowed_fd(fd_in),
-            off_in,
-            borrowed_fd(fd_out),
-            off_out,
-            len,
-            flags.bits(),
-        ))
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub unsafe fn vmsplice(
-    fd: BorrowedFd,
-    bufs: &[IoSliceRaw],
-    flags: SpliceFlags,
-) -> io::Result<usize> {
-    ret_usize(c::vmsplice(
-        borrowed_fd(fd),
-        bufs.as_ptr().cast::<c::iovec>(),
-        min(bufs.len(), max_iov()),
-        flags.bits(),
-    ))
-}
-
-#[cfg(solarish)]
-pub(crate) fn port_create() -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::port_create()) }
-}
-
-#[cfg(solarish)]
-pub(crate) unsafe fn port_associate(
-    port: BorrowedFd<'_>,
-    source: c::c_int,
-    object: c::uintptr_t,
-    events: c::c_int,
-    user: *mut c::c_void,
-) -> io::Result<()> {
-    ret(c::port_associate(
-        borrowed_fd(port),
-        source,
-        object,
-        events,
-        user,
-    ))
-}
-
-#[cfg(solarish)]
-pub(crate) unsafe fn port_dissociate(
-    port: BorrowedFd<'_>,
-    source: c::c_int,
-    object: c::uintptr_t,
-) -> io::Result<()> {
-    ret(c::port_dissociate(borrowed_fd(port), source, object))
-}
-
-#[cfg(solarish)]
-pub(crate) fn port_get(
-    port: BorrowedFd<'_>,
-    timeout: Option<&mut c::timespec>,
-) -> io::Result<Event> {
-    let mut event = MaybeUninit::<c::port_event>::uninit();
-    let timeout = timeout.map_or(core::ptr::null_mut(), |t| t as *mut _);
-
-    unsafe {
-        ret(c::port_get(borrowed_fd(port), event.as_mut_ptr(), timeout))?;
-    }
-
-    // If we're done, initialize the event and return it.
-    Ok(Event(unsafe { event.assume_init() }))
-}
-
-#[cfg(solarish)]
-pub(crate) fn port_getn(
-    port: BorrowedFd<'_>,
-    timeout: Option<&mut c::timespec>,
-    events: &mut Vec<Event>,
-    mut nget: u32,
-) -> io::Result<()> {
-    let timeout = timeout.map_or(core::ptr::null_mut(), |t| t as *mut _);
-    unsafe {
-        ret(c::port_getn(
-            borrowed_fd(port),
-            events.as_mut_ptr().cast(),
-            events.len().try_into().unwrap(),
-            &mut nget,
-            timeout,
-        ))?;
-    }
-
-    // Update the vector length.
-    unsafe {
-        events.set_len(nget.try_into().unwrap());
-    }
-
-    Ok(())
-}
-
-#[cfg(solarish)]
-pub(crate) fn port_send(
-    port: BorrowedFd<'_>,
-    events: c::c_int,
-    userdata: *mut c::c_void,
-) -> io::Result<()> {
-    unsafe { ret(c::port_send(borrowed_fd(port), events, userdata)) }
-}
diff --git a/vendor/rustix/src/backend/libc/io/types.rs b/vendor/rustix/src/backend/libc/io/types.rs
index 90a5e15b5..8743336f2 100644
--- a/vendor/rustix/src/backend/libc/io/types.rs
+++ b/vendor/rustix/src/backend/libc/io/types.rs
@@ -1,51 +1,38 @@
-use super::super::c;
+use crate::backend::c;
 use bitflags::bitflags;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use core::marker::PhantomData;
 
 bitflags! {
     /// `FD_*` constants for use with [`fcntl_getfd`] and [`fcntl_setfd`].
     ///
     /// [`fcntl_getfd`]: crate::io::fcntl_getfd
     /// [`fcntl_setfd`]: crate::io::fcntl_setfd
-    pub struct FdFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct FdFlags: u32 {
         /// `FD_CLOEXEC`
-        const CLOEXEC = c::FD_CLOEXEC;
+        const CLOEXEC = bitcast!(c::FD_CLOEXEC);
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
     /// `RWF_*` constants for use with [`preadv2`] and [`pwritev2`].
     ///
     /// [`preadv2`]: crate::io::preadv2
     /// [`pwritev2`]: crate::io::pwritev
-    pub struct ReadWriteFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct ReadWriteFlags: u32 {
         /// `RWF_DSYNC` (since Linux 4.7)
-        const DSYNC = linux_raw_sys::general::RWF_DSYNC as c::c_int;
+        const DSYNC = linux_raw_sys::general::RWF_DSYNC;
         /// `RWF_HIPRI` (since Linux 4.6)
-        const HIPRI = linux_raw_sys::general::RWF_HIPRI as c::c_int;
+        const HIPRI = linux_raw_sys::general::RWF_HIPRI;
         /// `RWF_SYNC` (since Linux 4.7)
-        const SYNC = linux_raw_sys::general::RWF_SYNC as c::c_int;
+        const SYNC = linux_raw_sys::general::RWF_SYNC;
         /// `RWF_NOWAIT` (since Linux 4.14)
-        const NOWAIT = linux_raw_sys::general::RWF_NOWAIT as c::c_int;
+        const NOWAIT = linux_raw_sys::general::RWF_NOWAIT;
         /// `RWF_APPEND` (since Linux 4.16)
-        const APPEND = linux_raw_sys::general::RWF_APPEND as c::c_int;
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-bitflags! {
-    /// `SPLICE_F_*` constants for use with [`splice`] and [`vmsplice`].
-    pub struct SpliceFlags: c::c_uint {
-        /// `SPLICE_F_MOVE`
-        const MOVE = c::SPLICE_F_MOVE;
-        /// `SPLICE_F_NONBLOCK`
-        const NONBLOCK = c::SPLICE_F_NONBLOCK;
-        /// `SPLICE_F_MORE`
-        const MORE = c::SPLICE_F_MORE;
-        /// `SPLICE_F_GIFT`
-        const GIFT = c::SPLICE_F_GIFT;
+        const APPEND = linux_raw_sys::general::RWF_APPEND;
     }
 }
 
@@ -54,7 +41,9 @@ bitflags! {
     /// `O_*` constants for use with [`dup2`].
     ///
     /// [`dup2`]: crate::io::dup2
-    pub struct DupFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct DupFlags: u32 {
         /// `O_CLOEXEC`
         #[cfg(not(any(
             apple,
@@ -62,97 +51,6 @@ bitflags! {
             target_os = "android",
             target_os = "redox",
         )))] // Android 5.0 has dup3, but libc doesn't have bindings
-        const CLOEXEC = c::O_CLOEXEC;
-    }
-}
-
-#[cfg(not(any(apple, target_os = "wasi")))]
-bitflags! {
-    /// `O_*` constants for use with [`pipe_with`].
-    ///
-    /// [`pipe_with`]: crate::io::pipe_with
-    pub struct PipeFlags: c::c_int {
-        /// `O_CLOEXEC`
-        const CLOEXEC = c::O_CLOEXEC;
-        /// `O_DIRECT`
-        #[cfg(not(any(
-            solarish,
-            target_os = "haiku",
-            target_os = "openbsd",
-            target_os = "redox",
-        )))]
-        const DIRECT = c::O_DIRECT;
-        /// `O_NONBLOCK`
-        const NONBLOCK = c::O_NONBLOCK;
-    }
-}
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "linux"
-))]
-bitflags! {
-    /// `EFD_*` flags for use with [`eventfd`].
-    ///
-    /// [`eventfd`]: crate::io::eventfd
-    pub struct EventfdFlags: c::c_int {
-        /// `EFD_CLOEXEC`
-        const CLOEXEC = c::EFD_CLOEXEC;
-        /// `EFD_NONBLOCK`
-        const NONBLOCK = c::EFD_NONBLOCK;
-        /// `EFD_SEMAPHORE`
-        const SEMAPHORE = c::EFD_SEMAPHORE;
-    }
-}
-
-/// `PIPE_BUF`—The maximum size of a write to a pipe guaranteed to be atomic.
-#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-pub const PIPE_BUF: usize = c::PIPE_BUF;
-
-#[cfg(not(any(windows, target_os = "redox")))]
-pub(crate) const AT_FDCWD: c::c_int = c::AT_FDCWD;
-#[cfg(not(windows))]
-pub(crate) const STDIN_FILENO: c::c_int = c::STDIN_FILENO;
-#[cfg(not(windows))]
-pub(crate) const STDOUT_FILENO: c::c_int = c::STDOUT_FILENO;
-#[cfg(not(windows))]
-pub(crate) const STDERR_FILENO: c::c_int = c::STDERR_FILENO;
-
-/// A buffer type used with `vmsplice`.
-/// It is guaranteed to be ABI compatible with the iovec type on Unix platforms
-/// and `WSABUF` on Windows. Unlike `IoSlice` and `IoSliceMut` it is
-/// semantically like a raw pointer, and therefore can be shared or mutated as
-/// needed.
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[repr(transparent)]
-pub struct IoSliceRaw<'a> {
-    _buf: c::iovec,
-    _lifetime: PhantomData<&'a ()>,
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-impl<'a> IoSliceRaw<'a> {
-    /// Creates a new `IoSlice` wrapping a byte slice.
-    pub fn from_slice(buf: &'a [u8]) -> Self {
-        IoSliceRaw {
-            _buf: c::iovec {
-                iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _lifetime: PhantomData,
-        }
-    }
-
-    /// Creates a new `IoSlice` wrapping a mutable byte slice.
-    pub fn from_slice_mut(buf: &'a mut [u8]) -> Self {
-        IoSliceRaw {
-            _buf: c::iovec {
-                iov_base: buf.as_mut_ptr() as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _lifetime: PhantomData,
-        }
+        const CLOEXEC = bitcast!(c::O_CLOEXEC);
     }
 }
diff --git a/vendor/rustix/src/backend/libc/io/windows_syscalls.rs b/vendor/rustix/src/backend/libc/io/windows_syscalls.rs
index 4c6e86f94..c87a2a247 100644
--- a/vendor/rustix/src/backend/libc/io/windows_syscalls.rs
+++ b/vendor/rustix/src/backend/libc/io/windows_syscalls.rs
@@ -1,12 +1,10 @@
 //! Windows system calls in the `io` module.
 
-use super::super::c;
-use super::super::conv::{borrowed_fd, ret, ret_c_int};
-use super::super::fd::LibcFd;
+use crate::backend::c;
+use crate::backend::conv::{borrowed_fd, ret};
+use crate::backend::fd::LibcFd;
 use crate::fd::{BorrowedFd, RawFd};
 use crate::io;
-use crate::io::PollFd;
-use core::convert::TryInto;
 use core::mem::MaybeUninit;
 
 pub(crate) unsafe fn close(raw_fd: RawFd) {
@@ -27,13 +25,3 @@ pub(crate) fn ioctl_fionbio(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
         ret(c::ioctl(borrowed_fd(fd), c::FIONBIO, &mut data))
     }
 }
-
-pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> {
-    let nfds = fds
-        .len()
-        .try_into()
-        .map_err(|_convert_err| io::Errno::INVAL)?;
-
-    ret_c_int(unsafe { c::poll(fds.as_mut_ptr().cast(), nfds, timeout) })
-        .map(|nready| nready as usize)
-}
diff --git a/vendor/rustix/src/backend/libc/io_lifetimes.rs b/vendor/rustix/src/backend/libc/io_lifetimes.rs
deleted file mode 100644
index 993365c0c..000000000
--- a/vendor/rustix/src/backend/libc/io_lifetimes.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-//! `io_lifetimes` types for Windows assuming that Fd is Socket.
-//!
-//! We can make this assumption since `rustix` supports only `rustix::net` on
-//! Windows.
-
-pub use io_lifetimes::{BorrowedSocket as BorrowedFd, OwnedSocket as OwnedFd};
-#[cfg(feature = "std")]
-pub use std::os::windows::io::RawSocket as RawFd;
-pub(crate) use windows_sys::Win32::Networking::WinSock::SOCKET as LibcFd;
-
-// Re-export the `Socket` traits so that users can implement them.
-pub use io_lifetimes::AsSocket;
-
-/// A version of [`AsRawFd`] for use with Winsock2 API.
-///
-/// [`AsRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsRawFd.html
-pub trait AsRawFd {
-    /// A version of [`as_raw_fd`] for use with Winsock2 API.
-    ///
-    /// [`as_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.as_raw_fd
-    fn as_raw_fd(&self) -> RawFd;
-}
-#[cfg(feature = "std")]
-impl<T: std::os::windows::io::AsRawSocket> AsRawFd for T {
-    #[inline]
-    fn as_raw_fd(&self) -> RawFd {
-        self.as_raw_socket()
-    }
-}
-
-/// A version of [`IntoRawFd`] for use with Winsock2 API.
-///
-/// [`IntoRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.IntoRawFd.html
-pub trait IntoRawFd {
-    /// A version of [`into_raw_fd`] for use with Winsock2 API.
-    ///
-    /// [`into_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.into_raw_fd
-    fn into_raw_fd(self) -> RawFd;
-}
-#[cfg(feature = "std")]
-impl<T: std::os::windows::io::IntoRawSocket> IntoRawFd for T {
-    #[inline]
-    fn into_raw_fd(self) -> RawFd {
-        self.into_raw_socket()
-    }
-}
-
-/// A version of [`FromRawFd`] for use with Winsock2 API.
-///
-/// [`FromRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html
-pub trait FromRawFd {
-    /// A version of [`from_raw_fd`] for use with Winsock2 API.
-    ///
-    /// # Safety
-    ///
-    /// See the [safety requirements] for [`from_raw_fd`].
-    ///
-    /// [`from_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.from_raw_fd
-    /// [safety requirements]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#safety
-    unsafe fn from_raw_fd(raw_fd: RawFd) -> Self;
-}
-#[cfg(feature = "std")]
-impl<T: std::os::windows::io::FromRawSocket> FromRawFd for T {
-    #[inline]
-    unsafe fn from_raw_fd(raw_fd: RawFd) -> Self {
-        Self::from_raw_socket(raw_fd)
-    }
-}
-
-/// A version of [`AsFd`] for use with Winsock2 API.
-///
-/// [`AsFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsFd.html
-pub trait AsFd {
-    /// An `as_fd` function for Winsock2, where a `Fd` is a `Socket`.
-    fn as_fd(&self) -> BorrowedFd;
-}
-impl<T: AsSocket> AsFd for T {
-    #[inline]
-    fn as_fd(&self) -> BorrowedFd {
-        self.as_socket()
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/io_uring/syscalls.rs b/vendor/rustix/src/backend/libc/io_uring/syscalls.rs
index 17d3eb10c..8e8182401 100644
--- a/vendor/rustix/src/backend/libc/io_uring/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/io_uring/syscalls.rs
@@ -1,21 +1,20 @@
 //! libc syscalls supporting `rustix::io_uring`.
 
-use super::super::c;
-use super::super::conv::{borrowed_fd, syscall_ret_owned_fd, syscall_ret_u32};
+use crate::backend::c;
+use crate::backend::conv::{borrowed_fd, ret_owned_fd, ret_u32};
 use crate::fd::{BorrowedFd, OwnedFd};
 use crate::io;
 use crate::io_uring::{io_uring_params, IoringEnterFlags, IoringRegisterOp};
-use linux_raw_sys::general::{__NR_io_uring_enter, __NR_io_uring_register, __NR_io_uring_setup};
 
 #[inline]
 pub(crate) fn io_uring_setup(entries: u32, params: &mut io_uring_params) -> io::Result<OwnedFd> {
-    unsafe {
-        syscall_ret_owned_fd(c::syscall(
-            __NR_io_uring_setup as _,
-            entries as usize,
-            params,
-        ))
+    syscall! {
+        fn io_uring_setup(
+            entries: u32,
+            params: *mut io_uring_params
+        ) via SYS_io_uring_setup -> c::c_int
     }
+    unsafe { ret_owned_fd(io_uring_setup(entries, params)) }
 }
 
 #[inline]
@@ -25,12 +24,19 @@ pub(crate) unsafe fn io_uring_register(
     arg: *const c::c_void,
     nr_args: u32,
 ) -> io::Result<u32> {
-    syscall_ret_u32(c::syscall(
-        __NR_io_uring_register as _,
-        borrowed_fd(fd),
-        opcode as u32 as usize,
+    syscall! {
+        fn io_uring_register(
+            fd: c::c_uint,
+            opcode: c::c_uint,
+            arg: *const c::c_void,
+            nr_args: c::c_uint
+        ) via SYS_io_uring_register -> c::c_int
+    }
+    ret_u32(io_uring_register(
+        borrowed_fd(fd) as _,
+        opcode as u32,
         arg,
-        nr_args as usize,
+        nr_args,
     ))
 }
 
@@ -43,12 +49,21 @@ pub(crate) unsafe fn io_uring_enter(
     arg: *const c::c_void,
     size: usize,
 ) -> io::Result<u32> {
-    syscall_ret_u32(c::syscall(
-        __NR_io_uring_enter as _,
-        borrowed_fd(fd),
-        to_submit as usize,
-        min_complete as usize,
-        flags.bits() as usize,
+    syscall! {
+        fn io_uring_enter2(
+            fd: c::c_uint,
+            to_submit: c::c_uint,
+            min_complete: c::c_uint,
+            flags: c::c_uint,
+            arg: *const c::c_void,
+            size: usize
+        ) via SYS_io_uring_enter -> c::c_int
+    }
+    ret_u32(io_uring_enter2(
+        borrowed_fd(fd) as _,
+        to_submit,
+        min_complete,
+        bitflags_bits!(flags),
         arg,
         size,
     ))
diff --git a/vendor/rustix/src/backend/libc/mm/syscalls.rs b/vendor/rustix/src/backend/libc/mm/syscalls.rs
index 16636f1b9..4b23a58b7 100644
--- a/vendor/rustix/src/backend/libc/mm/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/mm/syscalls.rs
@@ -1,19 +1,18 @@
 //! libc syscalls supporting `rustix::mm`.
 
-use super::super::c;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::syscall_ret_owned_fd;
-use super::super::conv::{borrowed_fd, no_fd, ret};
-use super::super::offset::libc_mmap;
 #[cfg(not(target_os = "redox"))]
 use super::types::Advice;
 #[cfg(any(target_os = "emscripten", target_os = "linux"))]
 use super::types::MremapFlags;
 use super::types::{MapFlags, MprotectFlags, MsyncFlags, ProtFlags};
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 use super::types::{MlockFlags, UserfaultfdFlags};
+use crate::backend::c;
+#[cfg(linux_kernel)]
+use crate::backend::conv::ret_owned_fd;
+use crate::backend::conv::{borrowed_fd, no_fd, ret};
 use crate::fd::BorrowedFd;
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 use crate::fd::OwnedFd;
 use crate::io;
 
@@ -52,7 +51,7 @@ pub(crate) fn madvise(addr: *mut c::c_void, len: usize, advice: Advice) -> io::R
 }
 
 pub(crate) unsafe fn msync(addr: *mut c::c_void, len: usize, flags: MsyncFlags) -> io::Result<()> {
-    let err = c::msync(addr, len, flags.bits());
+    let err = c::msync(addr, len, bitflags_bits!(flags));
 
     // `msync` returns its error status rather than using `errno`.
     if err == 0 {
@@ -74,11 +73,11 @@ pub(crate) unsafe fn mmap(
     fd: BorrowedFd<'_>,
     offset: u64,
 ) -> io::Result<*mut c::c_void> {
-    let res = libc_mmap(
+    let res = c::mmap(
         ptr,
         len,
-        prot.bits(),
-        flags.bits(),
+        bitflags_bits!(prot),
+        bitflags_bits!(flags),
         borrowed_fd(fd),
         offset as i64,
     );
@@ -99,11 +98,11 @@ pub(crate) unsafe fn mmap_anonymous(
     prot: ProtFlags,
     flags: MapFlags,
 ) -> io::Result<*mut c::c_void> {
-    let res = libc_mmap(
+    let res = c::mmap(
         ptr,
         len,
-        prot.bits(),
-        flags.bits() | c::MAP_ANONYMOUS,
+        bitflags_bits!(prot),
+        bitflags_bits!(flags | MapFlags::from_bits_retain(bitcast!(c::MAP_ANONYMOUS))),
         no_fd(),
         0,
     );
@@ -119,7 +118,7 @@ pub(crate) unsafe fn mprotect(
     len: usize,
     flags: MprotectFlags,
 ) -> io::Result<()> {
-    ret(c::mprotect(ptr, len, flags.bits()))
+    ret(c::mprotect(ptr, len, bitflags_bits!(flags)))
 }
 
 pub(crate) unsafe fn munmap(ptr: *mut c::c_void, len: usize) -> io::Result<()> {
@@ -137,7 +136,7 @@ pub(crate) unsafe fn mremap(
     new_size: usize,
     flags: MremapFlags,
 ) -> io::Result<*mut c::c_void> {
-    let res = c::mremap(old_address, old_size, new_size, flags.bits());
+    let res = c::mremap(old_address, old_size, new_size, bitflags_bits!(flags));
     if res == c::MAP_FAILED {
         Err(io::Errno::last_os_error())
     } else {
@@ -162,7 +161,7 @@ pub(crate) unsafe fn mremap_fixed(
         old_address,
         old_size,
         new_size,
-        flags.bits() | c::MAP_FIXED,
+        bitflags_bits!(flags | MremapFlags::from_bits_retain(bitcast!(c::MAP_FIXED))),
         new_address,
     );
     if res == c::MAP_FAILED {
@@ -185,7 +184,7 @@ pub(crate) unsafe fn mlock(addr: *mut c::c_void, length: usize) -> io::Result<()
 ///
 /// `mlock_with` operates on raw pointers and may round out to the nearest page
 /// boundaries.
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) unsafe fn mlock_with(
     addr: *mut c::c_void,
@@ -200,7 +199,7 @@ pub(crate) unsafe fn mlock_with(
         ) via SYS_mlock2 -> c::c_int
     }
 
-    ret(mlock2(addr, length, flags.bits()))
+    ret(mlock2(addr, length, bitflags_bits!(flags)))
 }
 
 /// # Safety
@@ -212,7 +211,12 @@ pub(crate) unsafe fn munlock(addr: *mut c::c_void, length: usize) -> io::Result<
     ret(c::munlock(addr, length))
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) unsafe fn userfaultfd(flags: UserfaultfdFlags) -> io::Result<OwnedFd> {
-    syscall_ret_owned_fd(c::syscall(c::SYS_userfaultfd, flags.bits()))
+    syscall! {
+        fn userfaultfd(
+            flags: c::c_int
+        ) via SYS_userfaultfd -> c::c_int
+    }
+    ret_owned_fd(userfaultfd(bitflags_bits!(flags)))
 }
diff --git a/vendor/rustix/src/backend/libc/mm/types.rs b/vendor/rustix/src/backend/libc/mm/types.rs
index 798fda86b..e4fecfccd 100644
--- a/vendor/rustix/src/backend/libc/mm/types.rs
+++ b/vendor/rustix/src/backend/libc/mm/types.rs
@@ -1,4 +1,4 @@
-use super::super::c;
+use crate::backend::c;
 use bitflags::bitflags;
 
 bitflags! {
@@ -7,13 +7,15 @@ bitflags! {
     /// For `PROT_NONE`, use `ProtFlags::empty()`.
     ///
     /// [`mmap`]: crate::io::mmap
-    pub struct ProtFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct ProtFlags: u32 {
         /// `PROT_READ`
-        const READ = c::PROT_READ;
+        const READ = bitcast!(c::PROT_READ);
         /// `PROT_WRITE`
-        const WRITE = c::PROT_WRITE;
+        const WRITE = bitcast!(c::PROT_WRITE);
         /// `PROT_EXEC`
-        const EXEC = c::PROT_EXEC;
+        const EXEC = bitcast!(c::PROT_EXEC);
     }
 }
 
@@ -23,19 +25,21 @@ bitflags! {
     /// For `PROT_NONE`, use `MprotectFlags::empty()`.
     ///
     /// [`mprotect`]: crate::io::mprotect
-    pub struct MprotectFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct MprotectFlags: u32 {
         /// `PROT_READ`
-        const READ = c::PROT_READ;
+        const READ = bitcast!(c::PROT_READ);
         /// `PROT_WRITE`
-        const WRITE = c::PROT_WRITE;
+        const WRITE = bitcast!(c::PROT_WRITE);
         /// `PROT_EXEC`
-        const EXEC = c::PROT_EXEC;
+        const EXEC = bitcast!(c::PROT_EXEC);
         /// `PROT_GROWSUP`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const GROWSUP = c::PROT_GROWSUP;
+        #[cfg(linux_kernel)]
+        const GROWSUP = bitcast!(c::PROT_GROWSUP);
         /// `PROT_GROWSDOWN`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const GROWSDOWN = c::PROT_GROWSDOWN;
+        #[cfg(linux_kernel)]
+        const GROWSDOWN = bitcast!(c::PROT_GROWSDOWN);
     }
 }
 
@@ -46,9 +50,11 @@ bitflags! {
     ///
     /// [`mmap`]: crate::io::mmap
     /// [`mmap_anonymous`]: crates::io::mmap_anonymous
-    pub struct MapFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct MapFlags: u32 {
         /// `MAP_SHARED`
-        const SHARED = c::MAP_SHARED;
+        const SHARED = bitcast!(c::MAP_SHARED);
         /// `MAP_SHARED_VALIDATE`
         #[cfg(not(any(
             bsd,
@@ -59,9 +65,9 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
         )))]
-        const SHARED_VALIDATE = c::MAP_SHARED_VALIDATE;
+        const SHARED_VALIDATE = bitcast!(c::MAP_SHARED_VALIDATE);
         /// `MAP_PRIVATE`
-        const PRIVATE = c::MAP_PRIVATE;
+        const PRIVATE = bitcast!(c::MAP_PRIVATE);
         /// `MAP_DENYWRITE`
         #[cfg(not(any(
             bsd,
@@ -69,9 +75,9 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
         )))]
-        const DENYWRITE = c::MAP_DENYWRITE;
+        const DENYWRITE = bitcast!(c::MAP_DENYWRITE);
         /// `MAP_FIXED`
-        const FIXED = c::MAP_FIXED;
+        const FIXED = bitcast!(c::MAP_FIXED);
         /// `MAP_FIXED_NOREPLACE`
         #[cfg(not(any(
             bsd,
@@ -82,7 +88,7 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
         )))]
-        const FIXED_NOREPLACE = c::MAP_FIXED_NOREPLACE;
+        const FIXED_NOREPLACE = bitcast!(c::MAP_FIXED_NOREPLACE);
         /// `MAP_GROWSDOWN`
         #[cfg(not(any(
             bsd,
@@ -90,7 +96,7 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
         )))]
-        const GROWSDOWN = c::MAP_GROWSDOWN;
+        const GROWSDOWN = bitcast!(c::MAP_GROWSDOWN);
         /// `MAP_HUGETLB`
         #[cfg(not(any(
             bsd,
@@ -98,7 +104,7 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
         )))]
-        const HUGETLB = c::MAP_HUGETLB;
+        const HUGETLB = bitcast!(c::MAP_HUGETLB);
         /// `MAP_HUGE_2MB`
         #[cfg(not(any(
             bsd,
@@ -109,7 +115,7 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
         )))]
-        const HUGE_2MB = c::MAP_HUGE_2MB;
+        const HUGE_2MB = bitcast!(c::MAP_HUGE_2MB);
         /// `MAP_HUGE_1GB`
         #[cfg(not(any(
             bsd,
@@ -120,7 +126,7 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
         )))]
-        const HUGE_1GB = c::MAP_HUGE_1GB;
+        const HUGE_1GB = bitcast!(c::MAP_HUGE_1GB);
         /// `MAP_LOCKED`
         #[cfg(not(any(
             bsd,
@@ -128,16 +134,16 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
         )))]
-        const LOCKED = c::MAP_LOCKED;
+        const LOCKED = bitcast!(c::MAP_LOCKED);
         /// `MAP_NOCORE`
         #[cfg(freebsdlike)]
-        const NOCORE = c::MAP_NOCORE;
+        const NOCORE = bitcast!(c::MAP_NOCORE);
         /// `MAP_NORESERVE`
         #[cfg(not(any(freebsdlike, target_os = "redox")))]
-        const NORESERVE = c::MAP_NORESERVE;
+        const NORESERVE = bitcast!(c::MAP_NORESERVE);
         /// `MAP_NOSYNC`
         #[cfg(freebsdlike)]
-        const NOSYNC = c::MAP_NOSYNC;
+        const NOSYNC = bitcast!(c::MAP_NOSYNC);
         /// `MAP_POPULATE`
         #[cfg(not(any(
             bsd,
@@ -145,7 +151,7 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
         )))]
-        const POPULATE = c::MAP_POPULATE;
+        const POPULATE = bitcast!(c::MAP_POPULATE);
         /// `MAP_STACK`
         #[cfg(not(any(
             apple,
@@ -155,10 +161,10 @@ bitflags! {
             target_os = "netbsd",
             target_os = "redox",
         )))]
-        const STACK = c::MAP_STACK;
+        const STACK = bitcast!(c::MAP_STACK);
         /// `MAP_PREFAULT_READ`
         #[cfg(target_os = "freebsd")]
-        const PREFAULT_READ = c::MAP_PREFAULT_READ;
+        const PREFAULT_READ = bitcast!(c::MAP_PREFAULT_READ);
         /// `MAP_SYNC`
         #[cfg(not(any(
             bsd,
@@ -169,14 +175,14 @@ bitflags! {
             target_os = "haiku",
             target_os = "redox",
             all(
-                any(target_os = "android", target_os = "linux"),
+                linux_kernel,
                 any(target_arch = "mips", target_arch = "mips64"),
             )
         )))]
-        const SYNC = c::MAP_SYNC;
+        const SYNC = bitcast!(c::MAP_SYNC);
         /// `MAP_UNINITIALIZED`
         #[cfg(any())]
-        const UNINITIALIZED = c::MAP_UNINITIALIZED;
+        const UNINITIALIZED = bitcast!(c::MAP_UNINITIALIZED);
     }
 }
 
@@ -188,9 +194,11 @@ bitflags! {
     ///
     /// [`mremap`]: crate::io::mremap
     /// [`mremap_fixed`]: crate::io::mremap_fixed
-    pub struct MremapFlags: i32 {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct MremapFlags: u32 {
         /// `MREMAP_MAYMOVE`
-        const MAYMOVE = c::MREMAP_MAYMOVE;
+        const MAYMOVE = bitcast!(c::MREMAP_MAYMOVE);
     }
 }
 
@@ -198,27 +206,31 @@ bitflags! {
     /// `MS_*` flags for use with [`msync`].
     ///
     /// [`msync`]: crate::io::msync
-    pub struct MsyncFlags: i32 {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct MsyncFlags: u32 {
         /// `MS_SYNC`—Requests an update and waits for it to complete.
-        const SYNC = c::MS_SYNC;
+        const SYNC = bitcast!(c::MS_SYNC);
         /// `MS_ASYNC`—Specifies that an update be scheduled, but the call
         /// returns immediately.
-        const ASYNC = c::MS_ASYNC;
+        const ASYNC = bitcast!(c::MS_ASYNC);
         /// `MS_INVALIDATE`—Asks to invalidate other mappings of the same
         /// file (so that they can be updated with the fresh values just
         /// written).
-        const INVALIDATE = c::MS_INVALIDATE;
+        const INVALIDATE = bitcast!(c::MS_INVALIDATE);
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
     /// `MLOCK_*` flags for use with [`mlock_with`].
     ///
     /// [`mlock_with`]: crate::io::mlock_with
-    pub struct MlockFlags: i32 {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct MlockFlags: u32 {
         /// `MLOCK_ONFAULT`
-        const ONFAULT = c::MLOCK_ONFAULT as _;
+        const ONFAULT = bitcast!(c::MLOCK_ONFAULT);
     }
 }
 
@@ -227,122 +239,116 @@ bitflags! {
 /// [`madvise`]: crate::mm::madvise
 #[cfg(not(target_os = "redox"))]
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(i32)]
+#[repr(u32)]
 #[non_exhaustive]
 pub enum Advice {
     /// `POSIX_MADV_NORMAL`
     #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    Normal = c::POSIX_MADV_NORMAL,
+    Normal = bitcast!(c::POSIX_MADV_NORMAL),
 
     /// `POSIX_MADV_NORMAL`
     #[cfg(any(target_os = "android", target_os = "haiku"))]
-    Normal = c::MADV_NORMAL,
+    Normal = bitcast!(c::MADV_NORMAL),
 
     /// `POSIX_MADV_SEQUENTIAL`
     #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    Sequential = c::POSIX_MADV_SEQUENTIAL,
+    Sequential = bitcast!(c::POSIX_MADV_SEQUENTIAL),
 
     /// `POSIX_MADV_SEQUENTIAL`
     #[cfg(any(target_os = "android", target_os = "haiku"))]
-    Sequential = c::MADV_SEQUENTIAL,
+    Sequential = bitcast!(c::MADV_SEQUENTIAL),
 
     /// `POSIX_MADV_RANDOM`
     #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    Random = c::POSIX_MADV_RANDOM,
+    Random = bitcast!(c::POSIX_MADV_RANDOM),
 
     /// `POSIX_MADV_RANDOM`
     #[cfg(any(target_os = "android", target_os = "haiku"))]
-    Random = c::MADV_RANDOM,
+    Random = bitcast!(c::MADV_RANDOM),
 
     /// `POSIX_MADV_WILLNEED`
     #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    WillNeed = c::POSIX_MADV_WILLNEED,
+    WillNeed = bitcast!(c::POSIX_MADV_WILLNEED),
 
     /// `POSIX_MADV_WILLNEED`
     #[cfg(any(target_os = "android", target_os = "haiku"))]
-    WillNeed = c::MADV_WILLNEED,
+    WillNeed = bitcast!(c::MADV_WILLNEED),
 
     /// `POSIX_MADV_DONTNEED`
     #[cfg(not(any(target_os = "android", target_os = "emscripten", target_os = "haiku")))]
-    DontNeed = c::POSIX_MADV_DONTNEED,
+    DontNeed = bitcast!(c::POSIX_MADV_DONTNEED),
 
     /// `POSIX_MADV_DONTNEED`
     #[cfg(any(target_os = "android", target_os = "haiku"))]
-    DontNeed = i32::MAX - 1,
+    DontNeed = bitcast!(i32::MAX - 1),
 
     /// `MADV_DONTNEED`
     // `MADV_DONTNEED` has the same value as `POSIX_MADV_DONTNEED`. We don't
     // have a separate `posix_madvise` from `madvise`, so we expose a special
     // value which we special-case.
     #[cfg(target_os = "linux")]
-    LinuxDontNeed = i32::MAX,
+    LinuxDontNeed = bitcast!(i32::MAX),
 
     /// `MADV_DONTNEED`
     #[cfg(target_os = "android")]
-    LinuxDontNeed = c::MADV_DONTNEED,
+    LinuxDontNeed = bitcast!(c::MADV_DONTNEED),
     /// `MADV_FREE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxFree = c::MADV_FREE,
+    #[cfg(linux_kernel)]
+    LinuxFree = bitcast!(c::MADV_FREE),
     /// `MADV_REMOVE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxRemove = c::MADV_REMOVE,
+    #[cfg(linux_kernel)]
+    LinuxRemove = bitcast!(c::MADV_REMOVE),
     /// `MADV_DONTFORK`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxDontFork = c::MADV_DONTFORK,
+    #[cfg(linux_kernel)]
+    LinuxDontFork = bitcast!(c::MADV_DONTFORK),
     /// `MADV_DOFORK`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxDoFork = c::MADV_DOFORK,
+    #[cfg(linux_kernel)]
+    LinuxDoFork = bitcast!(c::MADV_DOFORK),
     /// `MADV_HWPOISON`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxHwPoison = c::MADV_HWPOISON,
+    #[cfg(linux_kernel)]
+    LinuxHwPoison = bitcast!(c::MADV_HWPOISON),
     /// `MADV_SOFT_OFFLINE`
-    #[cfg(all(
-        any(target_os = "android", target_os = "linux"),
-        not(any(target_arch = "mips", target_arch = "mips64")),
-    ))]
-    LinuxSoftOffline = c::MADV_SOFT_OFFLINE,
+    #[cfg(all(linux_kernel, not(any(target_arch = "mips", target_arch = "mips64"))))]
+    LinuxSoftOffline = bitcast!(c::MADV_SOFT_OFFLINE),
     /// `MADV_MERGEABLE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxMergeable = c::MADV_MERGEABLE,
+    #[cfg(linux_kernel)]
+    LinuxMergeable = bitcast!(c::MADV_MERGEABLE),
     /// `MADV_UNMERGEABLE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxUnmergeable = c::MADV_UNMERGEABLE,
+    #[cfg(linux_kernel)]
+    LinuxUnmergeable = bitcast!(c::MADV_UNMERGEABLE),
     /// `MADV_HUGEPAGE` (since Linux 2.6.38)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxHugepage = c::MADV_HUGEPAGE,
+    #[cfg(linux_kernel)]
+    LinuxHugepage = bitcast!(c::MADV_HUGEPAGE),
     /// `MADV_NOHUGEPAGE` (since Linux 2.6.38)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxNoHugepage = c::MADV_NOHUGEPAGE,
+    #[cfg(linux_kernel)]
+    LinuxNoHugepage = bitcast!(c::MADV_NOHUGEPAGE),
     /// `MADV_DONTDUMP` (since Linux 3.4)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxDontDump = c::MADV_DONTDUMP,
+    #[cfg(linux_kernel)]
+    LinuxDontDump = bitcast!(c::MADV_DONTDUMP),
     /// `MADV_DODUMP` (since Linux 3.4)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxDoDump = c::MADV_DODUMP,
+    #[cfg(linux_kernel)]
+    LinuxDoDump = bitcast!(c::MADV_DODUMP),
     /// `MADV_WIPEONFORK` (since Linux 4.14)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxWipeOnFork = linux_raw_sys::general::MADV_WIPEONFORK as i32,
+    #[cfg(linux_kernel)]
+    LinuxWipeOnFork = bitcast!(c::MADV_WIPEONFORK),
     /// `MADV_KEEPONFORK` (since Linux 4.14)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxKeepOnFork = linux_raw_sys::general::MADV_KEEPONFORK as i32,
+    #[cfg(linux_kernel)]
+    LinuxKeepOnFork = bitcast!(c::MADV_KEEPONFORK),
     /// `MADV_COLD` (since Linux 5.4)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxCold = linux_raw_sys::general::MADV_COLD as i32,
+    #[cfg(linux_kernel)]
+    LinuxCold = bitcast!(c::MADV_COLD),
     /// `MADV_PAGEOUT` (since Linux 5.4)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxPageOut = linux_raw_sys::general::MADV_PAGEOUT as i32,
+    #[cfg(linux_kernel)]
+    LinuxPageOut = bitcast!(c::MADV_PAGEOUT),
     /// `MADV_POPULATE_READ` (since Linux 5.14)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxPopulateRead = linux_raw_sys::general::MADV_POPULATE_READ as i32,
+    #[cfg(linux_kernel)]
+    LinuxPopulateRead = bitcast!(c::MADV_POPULATE_READ),
     /// `MADV_POPULATE_WRITE` (since Linux 5.14)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxPopulateWrite = linux_raw_sys::general::MADV_POPULATE_WRITE as i32,
+    #[cfg(linux_kernel)]
+    LinuxPopulateWrite = bitcast!(c::MADV_POPULATE_WRITE),
+    /// `MADV_DONTNEED_LOCKED` (since Linux 5.18)
+    #[cfg(linux_kernel)]
+    LinuxDontneedLocked = bitcast!(c::MADV_DONTNEED_LOCKED),
 }
 
 #[cfg(target_os = "emscripten")]
@@ -352,15 +358,17 @@ impl Advice {
     pub const DontNeed: Self = Self::Normal;
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
     /// `O_*` flags for use with [`userfaultfd`].
     ///
     /// [`userfaultfd`]: crate::io::userfaultfd
-    pub struct UserfaultfdFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct UserfaultfdFlags: u32 {
         /// `O_CLOEXEC`
-        const CLOEXEC = c::O_CLOEXEC;
+        const CLOEXEC = bitcast!(c::O_CLOEXEC);
         /// `O_NONBLOCK`
-        const NONBLOCK = c::O_NONBLOCK;
+        const NONBLOCK = bitcast!(c::O_NONBLOCK);
     }
 }
diff --git a/vendor/rustix/src/backend/libc/mod.rs b/vendor/rustix/src/backend/libc/mod.rs
index f3433903d..357f99484 100644
--- a/vendor/rustix/src/backend/libc/mod.rs
+++ b/vendor/rustix/src/backend/libc/mod.rs
@@ -12,35 +12,89 @@
 #![allow(clippy::useless_conversion)]
 
 mod conv;
-mod offset;
 
 #[cfg(windows)]
-mod io_lifetimes;
-#[cfg(not(windows))]
-#[cfg(not(feature = "std"))]
 pub(crate) mod fd {
-    pub(crate) use super::c::c_int as LibcFd;
-    pub use crate::io::fd::*;
-}
-#[cfg(windows)]
-pub(crate) mod fd {
-    pub use super::io_lifetimes::*;
+    pub use crate::maybe_polyfill::os::windows::io::{
+        AsRawSocket, AsSocket, BorrowedSocket as BorrowedFd, FromRawSocket, IntoRawSocket,
+        OwnedSocket as OwnedFd, RawSocket as RawFd,
+    };
+    pub(crate) use windows_sys::Win32::Networking::WinSock::SOCKET as LibcFd;
+
+    /// A version of [`AsRawFd`] for use with Winsock2 API.
+    ///
+    /// [`AsRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsRawFd.html
+    pub trait AsRawFd {
+        /// A version of [`as_raw_fd`] for use with Winsock2 API.
+        ///
+        /// [`as_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.as_raw_fd
+        fn as_raw_fd(&self) -> RawFd;
+    }
+    impl<T: AsRawSocket> AsRawFd for T {
+        #[inline]
+        fn as_raw_fd(&self) -> RawFd {
+            self.as_raw_socket()
+        }
+    }
+
+    /// A version of [`IntoRawFd`] for use with Winsock2 API.
+    ///
+    /// [`IntoRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.IntoRawFd.html
+    pub trait IntoRawFd {
+        /// A version of [`into_raw_fd`] for use with Winsock2 API.
+        ///
+        /// [`into_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.into_raw_fd
+        fn into_raw_fd(self) -> RawFd;
+    }
+    impl<T: IntoRawSocket> IntoRawFd for T {
+        #[inline]
+        fn into_raw_fd(self) -> RawFd {
+            self.into_raw_socket()
+        }
+    }
+
+    /// A version of [`FromRawFd`] for use with Winsock2 API.
+    ///
+    /// [`FromRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html
+    pub trait FromRawFd {
+        /// A version of [`from_raw_fd`] for use with Winsock2 API.
+        ///
+        /// # Safety
+        ///
+        /// See the [safety requirements] for [`from_raw_fd`].
+        ///
+        /// [`from_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.from_raw_fd
+        /// [safety requirements]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#safety
+        unsafe fn from_raw_fd(raw_fd: RawFd) -> Self;
+    }
+    impl<T: FromRawSocket> FromRawFd for T {
+        #[inline]
+        unsafe fn from_raw_fd(raw_fd: RawFd) -> Self {
+            Self::from_raw_socket(raw_fd)
+        }
+    }
+
+    /// A version of [`AsFd`] for use with Winsock2 API.
+    ///
+    /// [`AsFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsFd.html
+    pub trait AsFd {
+        /// An `as_fd` function for Winsock2, where a `Fd` is a `Socket`.
+        fn as_fd(&self) -> BorrowedFd;
+    }
+    impl<T: AsSocket> AsFd for T {
+        #[inline]
+        fn as_fd(&self) -> BorrowedFd {
+            self.as_socket()
+        }
+    }
 }
 #[cfg(not(windows))]
-#[cfg(feature = "std")]
 pub(crate) mod fd {
-    pub use io_lifetimes::*;
-
-    #[cfg(target_os = "wasi")]
-    #[allow(unused_imports)]
-    pub(crate) use super::c::c_int as LibcFd;
-    #[cfg(unix)]
+    pub use crate::maybe_polyfill::os::fd::{
+        AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd,
+    };
     #[allow(unused_imports)]
-    pub(crate) use std::os::unix::io::RawFd as LibcFd;
-    #[cfg(unix)]
-    pub use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-    #[cfg(target_os = "wasi")]
-    pub use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+    pub(crate) use RawFd as LibcFd;
 }
 
 // On Windows we emulate selected libc-compatible interfaces. On non-Windows,
@@ -48,11 +102,13 @@ pub(crate) mod fd {
 #[cfg_attr(windows, path = "winsock_c.rs")]
 pub(crate) mod c;
 
+#[cfg(feature = "event")]
+pub(crate) mod event;
 #[cfg(not(windows))]
 #[cfg(feature = "fs")]
 pub(crate) mod fs;
 pub(crate) mod io;
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[cfg(feature = "io_uring")]
 pub(crate) mod io_uring;
 #[cfg(not(any(windows, target_os = "wasi")))]
@@ -70,17 +126,30 @@ pub(crate) mod net;
 ))]
 pub(crate) mod param;
 #[cfg(not(windows))]
+#[cfg(feature = "pipe")]
+pub(crate) mod pipe;
+#[cfg(not(windows))]
+#[cfg(feature = "process")]
 pub(crate) mod process;
 #[cfg(not(windows))]
+#[cfg(not(target_os = "wasi"))]
+#[cfg(feature = "pty")]
+pub(crate) mod pty;
+#[cfg(not(windows))]
 #[cfg(feature = "rand")]
 pub(crate) mod rand;
 #[cfg(not(windows))]
+#[cfg(not(target_os = "wasi"))]
+#[cfg(feature = "system")]
+pub(crate) mod system;
+#[cfg(not(windows))]
 #[cfg(feature = "termios")]
 pub(crate) mod termios;
 #[cfg(not(windows))]
 #[cfg(feature = "thread")]
 pub(crate) mod thread;
 #[cfg(not(windows))]
+#[cfg(feature = "time")]
 pub(crate) mod time;
 
 /// If the host libc is glibc, return `true` if it is less than version 2.25.
@@ -93,11 +162,38 @@ pub(crate) mod time;
 #[cfg(all(unix, target_env = "gnu"))]
 pub(crate) fn if_glibc_is_less_than_2_25() -> bool {
     // This is also defined inside `weak_or_syscall!` in
-    // backend/libc/rand/syscalls.rs, but it's not convenient to re-export the weak
-    // symbol from that macro, so we duplicate it at a small cost here.
+    // backend/libc/rand/syscalls.rs, but it's not convenient to re-export the
+    // weak symbol from that macro, so we duplicate it at a small cost here.
     weak! { fn getrandom(*mut c::c_void, c::size_t, c::c_uint) -> c::ssize_t }
 
     // glibc 2.25 has `getrandom`, which is how we satisfy the API contract of
     // this function. But, there are likely other libc versions which have it.
     getrandom.get().is_none()
 }
+
+// Private modules used by multiple public modules.
+#[cfg(any(feature = "procfs", feature = "process", feature = "runtime"))]
+#[cfg(not(any(windows, target_os = "wasi")))]
+pub(crate) mod pid;
+#[cfg(any(feature = "process", feature = "thread"))]
+#[cfg(linux_kernel)]
+pub(crate) mod prctl;
+#[cfg(any(feature = "fs", feature = "thread", feature = "process"))]
+#[cfg(not(any(windows, target_os = "wasi")))]
+pub(crate) mod ugid;
+
+#[cfg(bsd)]
+const MAX_IOV: usize = c::IOV_MAX as usize;
+
+#[cfg(any(linux_kernel, target_os = "emscripten", target_os = "nto"))]
+const MAX_IOV: usize = c::UIO_MAXIOV as usize;
+
+#[cfg(not(any(
+    bsd,
+    linux_kernel,
+    windows,
+    target_os = "emscripten",
+    target_os = "nto",
+    target_os = "horizon",
+)))]
+const MAX_IOV: usize = 16; // The minimum value required by POSIX.
diff --git a/vendor/rustix/src/backend/libc/net/addr.rs b/vendor/rustix/src/backend/libc/net/addr.rs
index d00a48626..bf7d239de 100644
--- a/vendor/rustix/src/backend/libc/net/addr.rs
+++ b/vendor/rustix/src/backend/libc/net/addr.rs
@@ -1,18 +1,16 @@
-//! IPv4, IPv6, and Socket addresses.
+//! Socket address utilities.
 
-use super::super::c;
+use crate::backend::c;
 #[cfg(unix)]
-use crate::ffi::CStr;
-#[cfg(unix)]
-use crate::io;
-#[cfg(unix)]
-use crate::path;
-#[cfg(not(windows))]
-use core::convert::TryInto;
-#[cfg(unix)]
-use core::fmt;
-#[cfg(unix)]
-use core::slice;
+use {
+    crate::ffi::CStr,
+    crate::io,
+    crate::path,
+    core::cmp::Ordering,
+    core::fmt,
+    core::hash::{Hash, Hasher},
+    core::slice,
+};
 
 /// `struct sockaddr_un`
 #[cfg(unix)]
@@ -56,14 +54,14 @@ impl SocketAddrUnix {
     }
 
     /// Construct a new abstract Unix-domain address from a byte slice.
-    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(linux_kernel)]
     #[inline]
     pub fn new_abstract_name(name: &[u8]) -> io::Result<Self> {
         let mut unix = Self::init();
         if 1 + name.len() > unix.sun_path.len() {
             return Err(io::Errno::NAMETOOLONG);
         }
-        unix.sun_path[0] = b'\0' as c::c_char;
+        unix.sun_path[0] = 0;
         for (i, b) in name.iter().enumerate() {
             unix.sun_path[1 + i] = *b as c::c_char;
         }
@@ -94,11 +92,12 @@ impl SocketAddrUnix {
     #[inline]
     pub fn path(&self) -> Option<&CStr> {
         let len = self.len();
-        if len != 0 && self.unix.sun_path[0] != b'\0' as c::c_char {
+        if len != 0 && self.unix.sun_path[0] != 0 {
             let end = len as usize - offsetof_sun_path();
             let bytes = &self.unix.sun_path[..end];
-            // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`. And
-            // `from_bytes_with_nul_unchecked` since the string is NUL-terminated.
+            // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`.
+            // And `from_bytes_with_nul_unchecked` since the string is
+            // NUL-terminated.
             unsafe {
                 Some(CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(
                     bytes.as_ptr().cast(),
@@ -111,11 +110,11 @@ impl SocketAddrUnix {
     }
 
     /// For an abstract address, return the identifier.
-    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(linux_kernel)]
     #[inline]
     pub fn abstract_name(&self) -> Option<&[u8]> {
         let len = self.len();
-        if len != 0 && self.unix.sun_path[0] == b'\0' as c::c_char {
+        if len != 0 && self.unix.sun_path[0] == 0 {
             let end = len as usize - offsetof_sun_path();
             let bytes = &self.unix.sun_path[1..end];
             // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`.
@@ -159,7 +158,7 @@ impl Eq for SocketAddrUnix {}
 #[cfg(unix)]
 impl PartialOrd for SocketAddrUnix {
     #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         let self_len = self.len() - offsetof_sun_path();
         let other_len = other.len() - offsetof_sun_path();
         self.unix.sun_path[..self_len].partial_cmp(&other.unix.sun_path[..other_len])
@@ -169,7 +168,7 @@ impl PartialOrd for SocketAddrUnix {
 #[cfg(unix)]
 impl Ord for SocketAddrUnix {
     #[inline]
-    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> Ordering {
         let self_len = self.len() - offsetof_sun_path();
         let other_len = other.len() - offsetof_sun_path();
         self.unix.sun_path[..self_len].cmp(&other.unix.sun_path[..other_len])
@@ -177,9 +176,9 @@ impl Ord for SocketAddrUnix {
 }
 
 #[cfg(unix)]
-impl core::hash::Hash for SocketAddrUnix {
+impl Hash for SocketAddrUnix {
     #[inline]
-    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: Hasher>(&self, state: &mut H) {
         let self_len = self.len() - offsetof_sun_path();
         self.unix.sun_path[..self_len].hash(state)
     }
@@ -191,7 +190,7 @@ impl fmt::Debug for SocketAddrUnix {
         if let Some(path) = self.path() {
             path.fmt(fmt)
         } else {
-            #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(linux_kernel)]
             if let Some(name) = self.abstract_name() {
                 return name.fmt(fmt);
             }
diff --git a/vendor/rustix/src/backend/libc/net/ext.rs b/vendor/rustix/src/backend/libc/net/ext.rs
index f4ad316dd..4b2d10756 100644
--- a/vendor/rustix/src/backend/libc/net/ext.rs
+++ b/vendor/rustix/src/backend/libc/net/ext.rs
@@ -1,4 +1,4 @@
-use super::super::c;
+use crate::backend::c;
 
 /// The windows `sockaddr_in6` type is a union with accessor functions which
 /// are not `const fn`. Define our own layout-compatible version so that we
@@ -19,7 +19,6 @@ pub(crate) const fn in_addr_s_addr(addr: c::in_addr) -> u32 {
     addr.s_addr
 }
 
-#[cfg(not(feature = "std"))]
 #[cfg(windows)]
 #[inline]
 pub(crate) const fn in_addr_s_addr(addr: c::in_addr) -> u32 {
@@ -27,103 +26,52 @@ pub(crate) const fn in_addr_s_addr(addr: c::in_addr) -> u32 {
     unsafe { core::mem::transmute(addr) }
 }
 
-// TODO: With Rust 1.55, we can use the above `in_addr_s_addr` definition that
-// uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn in_addr_s_addr(addr: c::in_addr) -> u32 {
-    // This should be `*addr.S_un.S_addr()`, except that isn't a `const fn`.
-    unsafe { core::mem::transmute(addr) }
-}
-
 #[cfg(not(windows))]
 #[inline]
 pub(crate) const fn in_addr_new(s_addr: u32) -> c::in_addr {
     c::in_addr { s_addr }
 }
 
-#[cfg(not(feature = "std"))]
 #[cfg(windows)]
 #[inline]
 pub(crate) const fn in_addr_new(s_addr: u32) -> c::in_addr {
     unsafe { core::mem::transmute(s_addr) }
 }
 
-// TODO: With Rust 1.55, we can use the above `in_addr_new` definition that
-// uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn in_addr_new(s_addr: u32) -> c::in_addr {
-    unsafe { core::mem::transmute(s_addr) }
-}
-
 #[cfg(not(windows))]
 #[inline]
 pub(crate) const fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] {
     addr.s6_addr
 }
 
-#[cfg(not(feature = "std"))]
 #[cfg(windows)]
 #[inline]
 pub(crate) const fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] {
     unsafe { core::mem::transmute(addr) }
 }
 
-// TODO: With Rust 1.55, we can use the above `in6_addr_s6_addr` definition
-// that uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] {
-    unsafe { core::mem::transmute(addr) }
-}
-
 #[cfg(not(windows))]
 #[inline]
 pub(crate) const fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr {
     c::in6_addr { s6_addr }
 }
 
-#[cfg(not(feature = "std"))]
 #[cfg(windows)]
 #[inline]
 pub(crate) const fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr {
     unsafe { core::mem::transmute(s6_addr) }
 }
 
-// TODO: With Rust 1.55, we can use the above `in6_addr_new` definition that
-// uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr {
-    unsafe { core::mem::transmute(s6_addr) }
-}
-
 #[cfg(not(windows))]
 #[inline]
-pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 {
-    addr.sin6_scope_id
-}
-
-#[cfg(not(feature = "std"))]
-#[cfg(windows)]
-#[inline]
-pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 {
-    let addr: sockaddr_in6 = unsafe { core::mem::transmute(addr) };
+pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: &c::sockaddr_in6) -> u32 {
     addr.sin6_scope_id
 }
 
-// TODO: With Rust 1.55, we can use the above `sockaddr_in6_sin6_scope_id`
-// definition that uses a const-fn transmute.
-#[cfg(feature = "std")]
 #[cfg(windows)]
 #[inline]
-pub(crate) fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 {
-    let addr: sockaddr_in6 = unsafe { core::mem::transmute(addr) };
+pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: &c::sockaddr_in6) -> u32 {
+    let addr: &sockaddr_in6 = unsafe { core::mem::transmute(addr) };
     addr.sin6_scope_id
 }
 
@@ -150,7 +98,6 @@ pub(crate) const fn sockaddr_in6_new(
     }
 }
 
-#[cfg(not(feature = "std"))]
 #[cfg(windows)]
 #[inline]
 pub(crate) const fn sockaddr_in6_new(
@@ -169,25 +116,3 @@ pub(crate) const fn sockaddr_in6_new(
     };
     unsafe { core::mem::transmute(addr) }
 }
-
-// TODO: With Rust 1.55, we can use the above `sockaddr_in6_new` definition
-// that uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn sockaddr_in6_new(
-    sin6_family: u16,
-    sin6_port: u16,
-    sin6_flowinfo: u32,
-    sin6_addr: c::in6_addr,
-    sin6_scope_id: u32,
-) -> c::sockaddr_in6 {
-    let addr = sockaddr_in6 {
-        sin6_family,
-        sin6_port,
-        sin6_flowinfo,
-        sin6_addr,
-        sin6_scope_id,
-    };
-    unsafe { core::mem::transmute(addr) }
-}
diff --git a/vendor/rustix/src/backend/libc/net/mod.rs b/vendor/rustix/src/backend/libc/net/mod.rs
index f7196ae4f..1b68f1b26 100644
--- a/vendor/rustix/src/backend/libc/net/mod.rs
+++ b/vendor/rustix/src/backend/libc/net/mod.rs
@@ -1,7 +1,8 @@
 pub(crate) mod addr;
 pub(crate) mod ext;
+#[cfg(not(any(target_os = "redox", target_os = "wasi", windows)))]
+pub(crate) mod msghdr;
 pub(crate) mod read_sockaddr;
 pub(crate) mod send_recv;
 pub(crate) mod syscalls;
-pub(crate) mod types;
 pub(crate) mod write_sockaddr;
diff --git a/vendor/rustix/src/backend/libc/net/msghdr.rs b/vendor/rustix/src/backend/libc/net/msghdr.rs
new file mode 100644
index 000000000..e3f873747
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/net/msghdr.rs
@@ -0,0 +1,125 @@
+//! Utilities for dealing with message headers.
+//!
+//! These take closures rather than returning a `c::msghdr` directly because
+//! the message headers may reference stack-local data.
+
+use crate::backend::c;
+use crate::backend::conv::{msg_control_len, msg_iov_len};
+use crate::backend::net::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6};
+
+use crate::io::{self, IoSlice, IoSliceMut};
+use crate::net::{RecvAncillaryBuffer, SendAncillaryBuffer, SocketAddrV4, SocketAddrV6};
+use crate::utils::as_ptr;
+
+use core::mem::{size_of, zeroed, MaybeUninit};
+
+/// Create a message header intended to receive a datagram.
+pub(crate) fn with_recv_msghdr<R>(
+    name: &mut MaybeUninit<c::sockaddr_storage>,
+    iov: &mut [IoSliceMut<'_>],
+    control: &mut RecvAncillaryBuffer<'_>,
+    f: impl FnOnce(&mut c::msghdr) -> io::Result<R>,
+) -> io::Result<R> {
+    control.clear();
+
+    let namelen = size_of::<c::sockaddr_storage>() as c::socklen_t;
+    let mut msghdr = {
+        let mut h: c::msghdr = unsafe { zeroed() };
+        h.msg_name = name.as_mut_ptr().cast();
+        h.msg_namelen = namelen;
+        h.msg_iov = iov.as_mut_ptr().cast();
+        h.msg_iovlen = msg_iov_len(iov.len());
+        h.msg_control = control.as_control_ptr().cast();
+        h.msg_controllen = msg_control_len(control.control_len());
+        h
+    };
+
+    let res = f(&mut msghdr);
+
+    // Reset the control length.
+    if res.is_ok() {
+        unsafe {
+            control.set_control_len(msghdr.msg_controllen.try_into().unwrap_or(usize::MAX));
+        }
+    }
+
+    res
+}
+
+/// Create a message header intended to send without an address.
+pub(crate) fn with_noaddr_msghdr<R>(
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    f: impl FnOnce(c::msghdr) -> R,
+) -> R {
+    f({
+        let mut h: c::msghdr = unsafe { zeroed() };
+        h.msg_iov = iov.as_ptr() as _;
+        h.msg_iovlen = msg_iov_len(iov.len());
+        h.msg_control = control.as_control_ptr().cast();
+        h.msg_controllen = msg_control_len(control.control_len());
+        h
+    })
+}
+
+/// Create a message header intended to send with an IPv4 address.
+pub(crate) fn with_v4_msghdr<R>(
+    addr: &SocketAddrV4,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    f: impl FnOnce(c::msghdr) -> R,
+) -> R {
+    let encoded = unsafe { encode_sockaddr_v4(addr) };
+
+    f({
+        let mut h: c::msghdr = unsafe { zeroed() };
+        h.msg_name = as_ptr(&encoded) as _;
+        h.msg_namelen = size_of::<SocketAddrV4>() as _;
+        h.msg_iov = iov.as_ptr() as _;
+        h.msg_iovlen = msg_iov_len(iov.len());
+        h.msg_control = control.as_control_ptr().cast();
+        h.msg_controllen = msg_control_len(control.control_len());
+        h
+    })
+}
+
+/// Create a message header intended to send with an IPv6 address.
+pub(crate) fn with_v6_msghdr<R>(
+    addr: &SocketAddrV6,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    f: impl FnOnce(c::msghdr) -> R,
+) -> R {
+    let encoded = unsafe { encode_sockaddr_v6(addr) };
+
+    f({
+        let mut h: c::msghdr = unsafe { zeroed() };
+        h.msg_name = as_ptr(&encoded) as _;
+        h.msg_namelen = size_of::<SocketAddrV6>() as _;
+        h.msg_iov = iov.as_ptr() as _;
+        h.msg_iovlen = msg_iov_len(iov.len());
+        h.msg_control = control.as_control_ptr().cast();
+        h.msg_controllen = msg_control_len(control.control_len());
+        h
+    })
+}
+
+/// Create a message header intended to send with a Unix address.
+#[cfg(all(unix, not(target_os = "redox")))]
+pub(crate) fn with_unix_msghdr<R>(
+    addr: &crate::net::SocketAddrUnix,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    f: impl FnOnce(c::msghdr) -> R,
+) -> R {
+    f({
+        let mut h: c::msghdr = unsafe { zeroed() };
+        h.msg_name = as_ptr(addr) as _;
+        h.msg_namelen = addr.addr_len();
+        h.msg_iov = iov.as_ptr() as _;
+        h.msg_iovlen = msg_iov_len(iov.len());
+        h.msg_control = control.as_control_ptr().cast();
+        h.msg_controllen = msg_control_len(control.control_len());
+        h
+    })
+}
diff --git a/vendor/rustix/src/backend/libc/net/read_sockaddr.rs b/vendor/rustix/src/backend/libc/net/read_sockaddr.rs
index 575102c27..c3b23e8c2 100644
--- a/vendor/rustix/src/backend/libc/net/read_sockaddr.rs
+++ b/vendor/rustix/src/backend/libc/net/read_sockaddr.rs
@@ -1,13 +1,14 @@
-use super::super::c;
+//! The BSD sockets API requires us to read the `ss_family` field before
+//! we can interpret the rest of a `sockaddr` produced by the kernel.
+
 #[cfg(unix)]
 use super::addr::SocketAddrUnix;
 use super::ext::{in6_addr_s6_addr, in_addr_s_addr, sockaddr_in6_sin6_scope_id};
+use crate::backend::c;
 #[cfg(not(windows))]
 use crate::ffi::CStr;
 use crate::io;
 use crate::net::{Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrV4, SocketAddrV6};
-#[cfg(not(windows))]
-use alloc::vec::Vec;
 use core::mem::size_of;
 
 // This must match the header of `sockaddr`.
@@ -46,6 +47,11 @@ pub(crate) unsafe fn initialize_family_to_unspec(storage: *mut c::sockaddr_stora
     (*storage.cast::<sockaddr_header>()).ss_family = c::AF_UNSPEC as _;
 }
 
+/// Read a socket address encoded in a platform-specific format.
+///
+/// # Safety
+///
+/// `storage` must point to valid socket address storage.
 pub(crate) unsafe fn read_sockaddr(
     storage: *const c::sockaddr_storage,
     len: usize,
@@ -61,7 +67,7 @@ pub(crate) unsafe fn read_sockaddr(
             if len < size_of::<c::sockaddr_in>() {
                 return Err(io::Errno::INVAL);
             }
-            let decode = *storage.cast::<c::sockaddr_in>();
+            let decode = &*storage.cast::<c::sockaddr_in>();
             Ok(SocketAddrAny::V4(SocketAddrV4::new(
                 Ipv4Addr::from(u32::from_be(in_addr_s_addr(decode.sin_addr))),
                 u16::from_be(decode.sin_port),
@@ -71,7 +77,7 @@ pub(crate) unsafe fn read_sockaddr(
             if len < size_of::<c::sockaddr_in6>() {
                 return Err(io::Errno::INVAL);
             }
-            let decode = *storage.cast::<c::sockaddr_in6>();
+            let decode = &*storage.cast::<c::sockaddr_in6>();
             #[cfg(not(windows))]
             let s6_addr = decode.sin6_addr.s6_addr;
             #[cfg(windows)]
@@ -93,20 +99,40 @@ pub(crate) unsafe fn read_sockaddr(
                 return Err(io::Errno::INVAL);
             }
             if len == offsetof_sun_path {
-                Ok(SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap()))
+                SocketAddrUnix::new(&[][..]).map(SocketAddrAny::Unix)
             } else {
-                let decode = *storage.cast::<c::sockaddr_un>();
+                let decode = &*storage.cast::<c::sockaddr_un>();
+
+                // On Linux check for Linux's [abstract namespace].
+                //
+                // [abstract namespace]: https://man7.org/linux/man-pages/man7/unix.7.html
+                #[cfg(linux_kernel)]
+                if decode.sun_path[0] == 0 {
+                    return SocketAddrUnix::new_abstract_name(core::mem::transmute::<
+                        &[c::c_char],
+                        &[u8],
+                    >(
+                        &decode.sun_path[1..len - offsetof_sun_path],
+                    ))
+                    .map(SocketAddrAny::Unix);
+                }
+
+                // Otherwise we expect a NUL-terminated filesystem path.
 
                 // Trim off unused bytes from the end of `path_bytes`.
                 let path_bytes = if cfg!(target_os = "freebsd") {
                     // FreeBSD sometimes sets the length to longer than the length
                     // of the NUL-terminated string. Find the NUL and truncate the
                     // string accordingly.
-                    &decode.sun_path[..decode.sun_path.iter().position(|b| *b == 0).unwrap()]
+                    &decode.sun_path[..decode
+                        .sun_path
+                        .iter()
+                        .position(|b| *b == 0)
+                        .ok_or(io::Errno::INVAL)?]
                 } else {
                     // Otherwise, use the provided length.
                     let provided_len = len - 1 - offsetof_sun_path;
-                    if decode.sun_path[provided_len] != b'\0' as c::c_char {
+                    if decode.sun_path[provided_len] != 0 {
                         return Err(io::Errno::INVAL);
                     }
                     debug_assert_eq!(
@@ -116,10 +142,8 @@ pub(crate) unsafe fn read_sockaddr(
                     &decode.sun_path[..provided_len]
                 };
 
-                Ok(SocketAddrAny::Unix(
-                    SocketAddrUnix::new(path_bytes.iter().map(|c| *c as u8).collect::<Vec<u8>>())
-                        .unwrap(),
-                ))
+                SocketAddrUnix::new(core::mem::transmute::<&[c::c_char], &[u8]>(path_bytes))
+                    .map(SocketAddrAny::Unix)
             }
         }
         _ => Err(io::Errno::INVAL),
@@ -164,7 +188,7 @@ unsafe fn inner_read_sockaddr_os(
     match family {
         c::AF_INET => {
             assert!(len >= size_of::<c::sockaddr_in>());
-            let decode = *storage.cast::<c::sockaddr_in>();
+            let decode = &*storage.cast::<c::sockaddr_in>();
             SocketAddrAny::V4(SocketAddrV4::new(
                 Ipv4Addr::from(u32::from_be(in_addr_s_addr(decode.sin_addr))),
                 u16::from_be(decode.sin_port),
@@ -172,7 +196,7 @@ unsafe fn inner_read_sockaddr_os(
         }
         c::AF_INET6 => {
             assert!(len >= size_of::<c::sockaddr_in6>());
-            let decode = *storage.cast::<c::sockaddr_in6>();
+            let decode = &*storage.cast::<c::sockaddr_in6>();
             SocketAddrAny::V6(SocketAddrV6::new(
                 Ipv6Addr::from(in6_addr_s6_addr(decode.sin6_addr)),
                 u16::from_be(decode.sin6_port),
@@ -186,11 +210,26 @@ unsafe fn inner_read_sockaddr_os(
             if len == offsetof_sun_path {
                 SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap())
             } else {
-                let decode = *storage.cast::<c::sockaddr_un>();
-                assert_eq!(
-                    decode.sun_path[len - 1 - offsetof_sun_path],
-                    b'\0' as c::c_char
-                );
+                let decode = &*storage.cast::<c::sockaddr_un>();
+
+                // On Linux check for Linux's [abstract namespace].
+                //
+                // [abstract namespace]: https://man7.org/linux/man-pages/man7/unix.7.html
+                #[cfg(linux_kernel)]
+                if decode.sun_path[0] == 0 {
+                    return SocketAddrAny::Unix(
+                        SocketAddrUnix::new_abstract_name(core::mem::transmute::<
+                            &[c::c_char],
+                            &[u8],
+                        >(
+                            &decode.sun_path[1..len - offsetof_sun_path],
+                        ))
+                        .unwrap(),
+                    );
+                }
+
+                // Otherwise we expect a NUL-terminated filesystem path.
+                assert_eq!(decode.sun_path[len - 1 - offsetof_sun_path], 0);
                 let path_bytes = &decode.sun_path[..len - 1 - offsetof_sun_path];
 
                 // FreeBSD sometimes sets the length to longer than the length
@@ -200,7 +239,7 @@ unsafe fn inner_read_sockaddr_os(
                 let path_bytes = &path_bytes[..path_bytes.iter().position(|b| *b == 0).unwrap()];
 
                 SocketAddrAny::Unix(
-                    SocketAddrUnix::new(path_bytes.iter().map(|c| *c as u8).collect::<Vec<u8>>())
+                    SocketAddrUnix::new(core::mem::transmute::<&[c::c_char], &[u8]>(path_bytes))
                         .unwrap(),
                 )
             }
diff --git a/vendor/rustix/src/backend/libc/net/send_recv.rs b/vendor/rustix/src/backend/libc/net/send_recv.rs
index 49c6f2c22..e91017e97 100644
--- a/vendor/rustix/src/backend/libc/net/send_recv.rs
+++ b/vendor/rustix/src/backend/libc/net/send_recv.rs
@@ -1,4 +1,4 @@
-use super::super::c;
+use crate::backend::c;
 use bitflags::bitflags;
 
 bitflags! {
@@ -6,7 +6,9 @@ bitflags! {
     ///
     /// [`send`]: crate::net::send
     /// [`sendto`]: crate::net::sendto
-    pub struct SendFlags: i32 {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct SendFlags: u32 {
         /// `MSG_CONFIRM`
         #[cfg(not(any(
             bsd,
@@ -14,15 +16,15 @@ bitflags! {
             windows,
             target_os = "haiku",
         )))]
-        const CONFIRM = c::MSG_CONFIRM;
+        const CONFIRM = bitcast!(c::MSG_CONFIRM);
         /// `MSG_DONTROUTE`
-        const DONTROUTE = c::MSG_DONTROUTE;
+        const DONTROUTE = bitcast!(c::MSG_DONTROUTE);
         /// `MSG_DONTWAIT`
         #[cfg(not(windows))]
-        const DONTWAIT = c::MSG_DONTWAIT;
+        const DONTWAIT = bitcast!(c::MSG_DONTWAIT);
         /// `MSG_EOR`
         #[cfg(not(windows))]
-        const EOT = c::MSG_EOR;
+        const EOT = bitcast!(c::MSG_EOR);
         /// `MSG_MORE`
         #[cfg(not(any(
             bsd,
@@ -30,12 +32,12 @@ bitflags! {
             windows,
             target_os = "haiku",
         )))]
-        const MORE = c::MSG_MORE;
+        const MORE = bitcast!(c::MSG_MORE);
         #[cfg(not(any(apple, windows)))]
         /// `MSG_NOSIGNAL`
-        const NOSIGNAL = c::MSG_NOSIGNAL;
+        const NOSIGNAL = bitcast!(c::MSG_NOSIGNAL);
         /// `MSG_OOB`
-        const OOB = c::MSG_OOB;
+        const OOB = bitcast!(c::MSG_OOB);
     }
 }
 
@@ -44,13 +46,15 @@ bitflags! {
     ///
     /// [`recv`]: crate::net::recv
     /// [`recvfrom`]: crate::net::recvfrom
-    pub struct RecvFlags: i32 {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct RecvFlags: u32 {
         #[cfg(not(any(apple, solarish, windows, target_os = "haiku")))]
         /// `MSG_CMSG_CLOEXEC`
-        const CMSG_CLOEXEC = c::MSG_CMSG_CLOEXEC;
+        const CMSG_CLOEXEC = bitcast!(c::MSG_CMSG_CLOEXEC);
         /// `MSG_DONTWAIT`
         #[cfg(not(windows))]
-        const DONTWAIT = c::MSG_DONTWAIT;
+        const DONTWAIT = bitcast!(c::MSG_DONTWAIT);
         /// `MSG_ERRQUEUE`
         #[cfg(not(any(
             bsd,
@@ -58,14 +62,14 @@ bitflags! {
             windows,
             target_os = "haiku",
         )))]
-        const ERRQUEUE = c::MSG_ERRQUEUE;
+        const ERRQUEUE = bitcast!(c::MSG_ERRQUEUE);
         /// `MSG_OOB`
-        const OOB = c::MSG_OOB;
+        const OOB = bitcast!(c::MSG_OOB);
         /// `MSG_PEEK`
-        const PEEK = c::MSG_PEEK;
+        const PEEK = bitcast!(c::MSG_PEEK);
         /// `MSG_TRUNC`
-        const TRUNC = c::MSG_TRUNC as c::c_int;
+        const TRUNC = bitcast!(c::MSG_TRUNC);
         /// `MSG_WAITALL`
-        const WAITALL = c::MSG_WAITALL;
+        const WAITALL = bitcast!(c::MSG_WAITALL);
     }
 }
diff --git a/vendor/rustix/src/backend/libc/net/syscalls.rs b/vendor/rustix/src/backend/libc/net/syscalls.rs
index ac260e552..63067ff38 100644
--- a/vendor/rustix/src/backend/libc/net/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/net/syscalls.rs
@@ -1,28 +1,29 @@
 //! libc syscalls supporting `rustix::net`.
 
-use super::super::c;
-use super::super::conv::{borrowed_fd, ret, ret_owned_fd, ret_send_recv, send_recv_len};
 #[cfg(unix)]
 use super::addr::SocketAddrUnix;
 use super::ext::{in6_addr_new, in_addr_new};
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::read_sockaddr::initialize_family_to_unspec;
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::read_sockaddr::{maybe_read_sockaddr_os, read_sockaddr_os};
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::send_recv::{RecvFlags, SendFlags};
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::types::{AddressFamily, Protocol, Shutdown, SocketFlags, SocketType};
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6};
+use crate::backend::c;
+use crate::backend::conv::{borrowed_fd, ret, ret_owned_fd, ret_send_recv, send_recv_len};
 use crate::fd::{BorrowedFd, OwnedFd};
 use crate::io;
 use crate::net::{SocketAddrAny, SocketAddrV4, SocketAddrV6};
 use crate::utils::as_ptr;
-use core::convert::TryInto;
 use core::mem::{size_of, MaybeUninit};
+#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
+use {
+    super::msghdr::{with_noaddr_msghdr, with_recv_msghdr, with_v4_msghdr, with_v6_msghdr},
+    crate::io::{IoSlice, IoSliceMut},
+    crate::net::{RecvAncillaryBuffer, RecvMsgReturn, SendAncillaryBuffer},
+};
 #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use core::ptr::null_mut;
+use {
+    super::read_sockaddr::{initialize_family_to_unspec, maybe_read_sockaddr_os, read_sockaddr_os},
+    super::send_recv::{RecvFlags, SendFlags},
+    super::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6},
+    crate::net::{AddressFamily, Protocol, Shutdown, SocketFlags, SocketType},
+    core::ptr::null_mut,
+};
 
 #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
 pub(crate) fn recv(fd: BorrowedFd<'_>, buf: &mut [u8], flags: RecvFlags) -> io::Result<usize> {
@@ -31,7 +32,7 @@ pub(crate) fn recv(fd: BorrowedFd<'_>, buf: &mut [u8], flags: RecvFlags) -> io::
             borrowed_fd(fd),
             buf.as_mut_ptr().cast(),
             send_recv_len(buf.len()),
-            flags.bits(),
+            bitflags_bits!(flags),
         ))
     }
 }
@@ -43,7 +44,7 @@ pub(crate) fn send(fd: BorrowedFd<'_>, buf: &[u8], flags: SendFlags) -> io::Resu
             borrowed_fd(fd),
             buf.as_ptr().cast(),
             send_recv_len(buf.len()),
-            flags.bits(),
+            bitflags_bits!(flags),
         ))
     }
 }
@@ -67,7 +68,7 @@ pub(crate) fn recvfrom(
             borrowed_fd(fd),
             buf.as_mut_ptr().cast(),
             send_recv_len(buf.len()),
-            flags.bits(),
+            bitflags_bits!(flags),
             storage.as_mut_ptr().cast(),
             &mut len,
         ))
@@ -92,7 +93,7 @@ pub(crate) fn sendto_v4(
             borrowed_fd(fd),
             buf.as_ptr().cast(),
             send_recv_len(buf.len()),
-            flags.bits(),
+            bitflags_bits!(flags),
             as_ptr(&encode_sockaddr_v4(addr)).cast::<c::sockaddr>(),
             size_of::<SocketAddrV4>() as _,
         ))
@@ -111,7 +112,7 @@ pub(crate) fn sendto_v6(
             borrowed_fd(fd),
             buf.as_ptr().cast(),
             send_recv_len(buf.len()),
-            flags.bits(),
+            bitflags_bits!(flags),
             as_ptr(&encode_sockaddr_v6(addr)).cast::<c::sockaddr>(),
             size_of::<SocketAddrV6>() as _,
         ))
@@ -130,7 +131,7 @@ pub(crate) fn sendto_unix(
             borrowed_fd(fd),
             buf.as_ptr().cast(),
             send_recv_len(buf.len()),
-            flags.bits(),
+            bitflags_bits!(flags),
             as_ptr(&addr.unix).cast(),
             addr.addr_len(),
         ))
@@ -141,13 +142,17 @@ pub(crate) fn sendto_unix(
 pub(crate) fn socket(
     domain: AddressFamily,
     type_: SocketType,
-    protocol: Protocol,
+    protocol: Option<Protocol>,
 ) -> io::Result<OwnedFd> {
+    let raw_protocol = match protocol {
+        Some(p) => p.0.get(),
+        None => 0,
+    };
     unsafe {
         ret_owned_fd(c::socket(
             domain.0 as c::c_int,
             type_.0 as c::c_int,
-            protocol.0,
+            raw_protocol as c::c_int,
         ))
     }
 }
@@ -157,13 +162,17 @@ pub(crate) fn socket_with(
     domain: AddressFamily,
     type_: SocketType,
     flags: SocketFlags,
-    protocol: Protocol,
+    protocol: Option<Protocol>,
 ) -> io::Result<OwnedFd> {
+    let raw_protocol = match protocol {
+        Some(p) => p.0.get(),
+        None => 0,
+    };
     unsafe {
         ret_owned_fd(c::socket(
             domain.0 as c::c_int,
-            type_.0 as c::c_int | flags.bits(),
-            protocol.0,
+            (type_.0 | flags.bits()) as c::c_int,
+            raw_protocol as c::c_int,
         ))
     }
 }
@@ -247,6 +256,105 @@ pub(crate) fn accept(sockfd: BorrowedFd<'_>) -> io::Result<OwnedFd> {
     }
 }
 
+#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
+pub(crate) fn recvmsg(
+    sockfd: BorrowedFd<'_>,
+    iov: &mut [IoSliceMut<'_>],
+    control: &mut RecvAncillaryBuffer<'_>,
+    msg_flags: RecvFlags,
+) -> io::Result<RecvMsgReturn> {
+    let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
+
+    with_recv_msghdr(&mut storage, iov, control, |msghdr| {
+        let result = unsafe {
+            ret_send_recv(c::recvmsg(
+                borrowed_fd(sockfd),
+                msghdr,
+                bitflags_bits!(msg_flags),
+            ))
+        };
+
+        result.map(|bytes| {
+            // Get the address of the sender, if any.
+            let addr =
+                unsafe { maybe_read_sockaddr_os(msghdr.msg_name as _, msghdr.msg_namelen as _) };
+
+            RecvMsgReturn {
+                bytes,
+                address: addr,
+                flags: RecvFlags::from_bits_retain(bitcast!(msghdr.msg_flags)),
+            }
+        })
+    })
+}
+
+#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
+pub(crate) fn sendmsg(
+    sockfd: BorrowedFd<'_>,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    msg_flags: SendFlags,
+) -> io::Result<usize> {
+    with_noaddr_msghdr(iov, control, |msghdr| unsafe {
+        ret_send_recv(c::sendmsg(
+            borrowed_fd(sockfd),
+            &msghdr,
+            bitflags_bits!(msg_flags),
+        ))
+    })
+}
+
+#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
+pub(crate) fn sendmsg_v4(
+    sockfd: BorrowedFd<'_>,
+    addr: &SocketAddrV4,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    msg_flags: SendFlags,
+) -> io::Result<usize> {
+    with_v4_msghdr(addr, iov, control, |msghdr| unsafe {
+        ret_send_recv(c::sendmsg(
+            borrowed_fd(sockfd),
+            &msghdr,
+            bitflags_bits!(msg_flags),
+        ))
+    })
+}
+
+#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
+pub(crate) fn sendmsg_v6(
+    sockfd: BorrowedFd<'_>,
+    addr: &SocketAddrV6,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    msg_flags: SendFlags,
+) -> io::Result<usize> {
+    with_v6_msghdr(addr, iov, control, |msghdr| unsafe {
+        ret_send_recv(c::sendmsg(
+            borrowed_fd(sockfd),
+            &msghdr,
+            bitflags_bits!(msg_flags),
+        ))
+    })
+}
+
+#[cfg(all(unix, not(target_os = "redox")))]
+pub(crate) fn sendmsg_unix(
+    sockfd: BorrowedFd<'_>,
+    addr: &SocketAddrUnix,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    msg_flags: SendFlags,
+) -> io::Result<usize> {
+    super::msghdr::with_unix_msghdr(addr, iov, control, |msghdr| unsafe {
+        ret_send_recv(c::sendmsg(
+            borrowed_fd(sockfd),
+            &msghdr,
+            bitflags_bits!(msg_flags),
+        ))
+    })
+}
+
 #[cfg(not(any(
     apple,
     windows,
@@ -260,7 +368,7 @@ pub(crate) fn accept_with(sockfd: BorrowedFd<'_>, flags: SocketFlags) -> io::Res
             borrowed_fd(sockfd),
             null_mut(),
             null_mut(),
-            flags.bits(),
+            flags.bits() as c::c_int,
         ))?;
         Ok(owned_fd)
     }
@@ -301,7 +409,7 @@ pub(crate) fn acceptfrom_with(
             borrowed_fd(sockfd),
             storage.as_mut_ptr().cast(),
             &mut len,
-            flags.bits(),
+            flags.bits() as c::c_int,
         ))?;
         Ok((
             owned_fd,
@@ -368,14 +476,18 @@ pub(crate) fn socketpair(
     domain: AddressFamily,
     type_: SocketType,
     flags: SocketFlags,
-    protocol: Protocol,
+    protocol: Option<Protocol>,
 ) -> io::Result<(OwnedFd, OwnedFd)> {
+    let raw_protocol = match protocol {
+        Some(p) => p.0.get(),
+        None => 0,
+    };
     unsafe {
         let mut fds = MaybeUninit::<[OwnedFd; 2]>::uninit();
         ret(c::socketpair(
             c::c_int::from(domain.0),
-            type_.0 as c::c_int | flags.bits(),
-            protocol.0,
+            (type_.0 | flags.bits()) as c::c_int,
+            raw_protocol as c::c_int,
             fds.as_mut_ptr().cast::<c::c_int>(),
         ))?;
 
@@ -391,14 +503,10 @@ pub(crate) mod sockopt {
     use crate::net::sockopt::Timeout;
     use crate::net::{Ipv4Addr, Ipv6Addr, SocketType};
     use crate::utils::as_mut_ptr;
-    use core::convert::TryInto;
     use core::time::Duration;
     #[cfg(windows)]
     use windows_sys::Win32::Foundation::BOOL;
 
-    // TODO: With Rust 1.53 we can use `Duration::ZERO` instead.
-    const DURATION_ZERO: Duration = Duration::from_secs(0);
-
     #[inline]
     fn getsockopt<T: Copy>(fd: BorrowedFd<'_>, level: i32, optname: i32) -> io::Result<T> {
         use super::*;
@@ -512,21 +620,16 @@ pub(crate) mod sockopt {
     #[inline]
     pub(crate) fn get_socket_linger(fd: BorrowedFd<'_>) -> io::Result<Option<Duration>> {
         let linger: c::linger = getsockopt(fd, c::SOL_SOCKET as _, c::SO_LINGER)?;
-        // TODO: With Rust 1.50, this could use `.then`.
-        Ok(if linger.l_onoff != 0 {
-            Some(Duration::from_secs(linger.l_linger as u64))
-        } else {
-            None
-        })
+        Ok((linger.l_onoff != 0).then(|| Duration::from_secs(linger.l_linger as u64)))
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(linux_kernel)]
     #[inline]
     pub(crate) fn set_socket_passcred(fd: BorrowedFd<'_>, passcred: bool) -> io::Result<()> {
         setsockopt(fd, c::SOL_SOCKET as _, c::SO_PASSCRED, from_bool(passcred))
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(linux_kernel)]
     #[inline]
     pub(crate) fn get_socket_passcred(fd: BorrowedFd<'_>) -> io::Result<bool> {
         getsockopt(fd, c::SOL_SOCKET as _, c::SO_PASSCRED).map(to_bool)
@@ -546,7 +649,7 @@ pub(crate) mod sockopt {
         #[cfg(not(windows))]
         let timeout = match timeout {
             Some(timeout) => {
-                if timeout == DURATION_ZERO {
+                if timeout == Duration::ZERO {
                     return Err(io::Errno::INVAL);
                 }
 
@@ -577,7 +680,7 @@ pub(crate) mod sockopt {
         #[cfg(windows)]
         let timeout: u32 = match timeout {
             Some(timeout) => {
-                if timeout == DURATION_ZERO {
+                if timeout == Duration::ZERO {
                     return Err(io::Errno::INVAL);
                 }
 
@@ -633,13 +736,13 @@ pub(crate) mod sockopt {
 
     #[cfg(any(apple, target_os = "freebsd"))]
     #[inline]
-    pub(crate) fn getsockopt_nosigpipe(fd: BorrowedFd<'_>) -> io::Result<bool> {
+    pub(crate) fn get_socket_nosigpipe(fd: BorrowedFd<'_>) -> io::Result<bool> {
         getsockopt(fd, c::SOL_SOCKET, c::SO_NOSIGPIPE).map(to_bool)
     }
 
     #[cfg(any(apple, target_os = "freebsd"))]
     #[inline]
-    pub(crate) fn setsockopt_nosigpipe(fd: BorrowedFd<'_>, val: bool) -> io::Result<()> {
+    pub(crate) fn set_socket_nosigpipe(fd: BorrowedFd<'_>, val: bool) -> io::Result<()> {
         setsockopt(fd, c::SOL_SOCKET, c::SO_NOSIGPIPE, from_bool(val))
     }
 
@@ -764,14 +867,14 @@ pub(crate) mod sockopt {
         setsockopt(
             fd,
             c::IPPROTO_IP as _,
-            c::IPV6_MULTICAST_LOOP,
+            c::IPV6_MULTICAST_HOPS,
             multicast_hops,
         )
     }
 
     #[inline]
     pub(crate) fn get_ipv6_multicast_hops(fd: BorrowedFd<'_>) -> io::Result<u32> {
-        getsockopt(fd, c::IPPROTO_IP as _, c::IPV6_MULTICAST_LOOP)
+        getsockopt(fd, c::IPPROTO_IP as _, c::IPV6_MULTICAST_HOPS)
     }
 
     #[inline]
diff --git a/vendor/rustix/src/backend/libc/net/types.rs b/vendor/rustix/src/backend/libc/net/types.rs
deleted file mode 100644
index d1d769cb4..000000000
--- a/vendor/rustix/src/backend/libc/net/types.rs
+++ /dev/null
@@ -1,500 +0,0 @@
-use super::super::c;
-use bitflags::bitflags;
-
-/// A type for holding raw integer socket types.
-#[doc(hidden)]
-pub type RawSocketType = u32;
-
-/// `SOCK_*` constants for use with [`socket`].
-///
-/// [`socket`]: crate::net::socket
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct SocketType(pub(crate) RawSocketType);
-
-#[rustfmt::skip]
-impl SocketType {
-    /// `SOCK_STREAM`
-    pub const STREAM: Self = Self(c::SOCK_STREAM as u32);
-
-    /// `SOCK_DGRAM`
-    pub const DGRAM: Self = Self(c::SOCK_DGRAM as u32);
-
-    /// `SOCK_SEQPACKET`
-    pub const SEQPACKET: Self = Self(c::SOCK_SEQPACKET as u32);
-
-    /// `SOCK_RAW`
-    pub const RAW: Self = Self(c::SOCK_RAW as u32);
-
-    /// `SOCK_RDM`
-    #[cfg(not(target_os = "haiku"))]
-    pub const RDM: Self = Self(c::SOCK_RDM as u32);
-
-    /// Constructs a `SocketType` from a raw integer.
-    #[inline]
-    pub const fn from_raw(raw: RawSocketType) -> Self {
-        Self(raw)
-    }
-
-    /// Returns the raw integer for this `SocketType`.
-    #[inline]
-    pub const fn as_raw(self) -> RawSocketType {
-        self.0
-    }
-}
-
-/// A type for holding raw integer address families.
-#[doc(hidden)]
-pub type RawAddressFamily = c::sa_family_t;
-
-/// `AF_*` constants.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct AddressFamily(pub(crate) RawAddressFamily);
-
-#[rustfmt::skip]
-#[allow(non_upper_case_globals)]
-impl AddressFamily {
-    /// `AF_UNSPEC`
-    pub const UNSPEC: Self = Self(c::AF_UNSPEC as _);
-    /// `AF_INET`
-    pub const INET: Self = Self(c::AF_INET as _);
-    /// `AF_INET6`
-    pub const INET6: Self = Self(c::AF_INET6 as _);
-    /// `AF_NETLINK`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const NETLINK: Self = Self(c::AF_NETLINK as _);
-    /// `AF_UNIX`, aka `AF_LOCAL`
-    #[doc(alias = "LOCAL")]
-    pub const UNIX: Self = Self(c::AF_UNIX as _);
-    /// `AF_AX25`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const AX25: Self = Self(c::AF_AX25 as _);
-    /// `AF_IPX`
-    pub const IPX: Self = Self(c::AF_IPX as _);
-    /// `AF_APPLETALK`
-    pub const APPLETALK: Self = Self(c::AF_APPLETALK as _);
-    /// `AF_NETROM`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const NETROM: Self = Self(c::AF_NETROM as _);
-    /// `AF_BRIDGE`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const BRIDGE: Self = Self(c::AF_BRIDGE as _);
-    /// `AF_ATMPVC`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const ATMPVC: Self = Self(c::AF_ATMPVC as _);
-    /// `AF_X25`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const X25: Self = Self(c::AF_X25 as _);
-    /// `AF_ROSE`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const ROSE: Self = Self(c::AF_ROSE as _);
-    /// `AF_DECnet`
-    #[cfg(not(target_os = "haiku"))]
-    pub const DECnet: Self = Self(c::AF_DECnet as _);
-    /// `AF_NETBEUI`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const NETBEUI: Self = Self(c::AF_NETBEUI as _);
-    /// `AF_SECURITY`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const SECURITY: Self = Self(c::AF_SECURITY as _);
-    /// `AF_KEY`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const KEY: Self = Self(c::AF_KEY as _);
-    /// `AF_PACKET`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const PACKET: Self = Self(c::AF_PACKET as _);
-    /// `AF_ASH`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const ASH: Self = Self(c::AF_ASH as _);
-    /// `AF_ECONET`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const ECONET: Self = Self(c::AF_ECONET as _);
-    /// `AF_ATMSVC`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const ATMSVC: Self = Self(c::AF_ATMSVC as _);
-    /// `AF_RDS`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const RDS: Self = Self(c::AF_RDS as _);
-    /// `AF_SNA`
-    #[cfg(not(target_os = "haiku"))]
-    pub const SNA: Self = Self(c::AF_SNA as _);
-    /// `AF_IRDA`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "haiku",
-    )))]
-    pub const IRDA: Self = Self(c::AF_IRDA as _);
-    /// `AF_PPPOX`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const PPPOX: Self = Self(c::AF_PPPOX as _);
-    /// `AF_WANPIPE`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const WANPIPE: Self = Self(c::AF_WANPIPE as _);
-    /// `AF_LLC`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const LLC: Self = Self(c::AF_LLC as _);
-    /// `AF_CAN`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const CAN: Self = Self(c::AF_CAN as _);
-    /// `AF_TIPC`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const TIPC: Self = Self(c::AF_TIPC as _);
-    /// `AF_BLUETOOTH`
-    #[cfg(not(any(apple, solarish, windows)))]
-    pub const BLUETOOTH: Self = Self(c::AF_BLUETOOTH as _);
-    /// `AF_IUCV`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const IUCV: Self = Self(c::AF_IUCV as _);
-    /// `AF_RXRPC`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const RXRPC: Self = Self(c::AF_RXRPC as _);
-    /// `AF_ISDN`
-    #[cfg(not(any(solarish, windows, target_os = "haiku")))]
-    pub const ISDN: Self = Self(c::AF_ISDN as _);
-    /// `AF_PHONET`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const PHONET: Self = Self(c::AF_PHONET as _);
-    /// `AF_IEEE802154`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const IEEE802154: Self = Self(c::AF_IEEE802154 as _);
-
-    /// Constructs a `AddressFamily` from a raw integer.
-    #[inline]
-    pub const fn from_raw(raw: RawAddressFamily) -> Self {
-        Self(raw)
-    }
-
-    /// Returns the raw integer for this `AddressFamily`.
-    #[inline]
-    pub const fn as_raw(self) -> RawAddressFamily {
-        self.0
-    }
-}
-
-/// A type for holding raw integer protocols.
-#[doc(hidden)]
-pub type RawProtocol = i32;
-
-/// `IPPROTO_*` constants for use with [`socket`] and [`socket_with`].
-///
-/// [`socket`]: crate::net::socket
-/// [`socket_with`]: crate::net::socket_with
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct Protocol(pub(crate) RawProtocol);
-
-#[rustfmt::skip]
-impl Protocol {
-    /// `IPPROTO_IP`
-    pub const IP: Self = Self(c::IPPROTO_IP as _);
-    /// `IPPROTO_ICMP`
-    pub const ICMP: Self = Self(c::IPPROTO_ICMP as _);
-    /// `IPPROTO_IGMP`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    pub const IGMP: Self = Self(c::IPPROTO_IGMP as _);
-    /// `IPPROTO_IPIP`
-    #[cfg(not(any(solarish, windows, target_os = "haiku")))]
-    pub const IPIP: Self = Self(c::IPPROTO_IPIP as _);
-    /// `IPPROTO_TCP`
-    pub const TCP: Self = Self(c::IPPROTO_TCP as _);
-    /// `IPPROTO_EGP`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    pub const EGP: Self = Self(c::IPPROTO_EGP as _);
-    /// `IPPROTO_PUP`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    pub const PUP: Self = Self(c::IPPROTO_PUP as _);
-    /// `IPPROTO_UDP`
-    pub const UDP: Self = Self(c::IPPROTO_UDP as _);
-    /// `IPPROTO_IDP`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    pub const IDP: Self = Self(c::IPPROTO_IDP as _);
-    /// `IPPROTO_TP`
-    #[cfg(not(any(solarish, windows, target_os = "haiku")))]
-    pub const TP: Self = Self(c::IPPROTO_TP as _);
-    /// `IPPROTO_DCCP`
-    #[cfg(not(any(
-        apple,
-        solarish,
-        windows,
-        target_os = "dragonfly",
-        target_os = "haiku",
-        target_os = "openbsd",
-    )))]
-    pub const DCCP: Self = Self(c::IPPROTO_DCCP as _);
-    /// `IPPROTO_IPV6`
-    pub const IPV6: Self = Self(c::IPPROTO_IPV6 as _);
-    /// `IPPROTO_RSVP`
-    #[cfg(not(any(solarish, windows, target_os = "haiku")))]
-    pub const RSVP: Self = Self(c::IPPROTO_RSVP as _);
-    /// `IPPROTO_GRE`
-    #[cfg(not(any(solarish, windows, target_os = "haiku")))]
-    pub const GRE: Self = Self(c::IPPROTO_GRE as _);
-    /// `IPPROTO_ESP`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    pub const ESP: Self = Self(c::IPPROTO_ESP as _);
-    /// `IPPROTO_AH`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    pub const AH: Self = Self(c::IPPROTO_AH as _);
-    /// `IPPROTO_MTP`
-    #[cfg(not(any(
-        solarish,
-        netbsdlike,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const MTP: Self = Self(c::IPPROTO_MTP as _);
-    /// `IPPROTO_BEETPH`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const BEETPH: Self = Self(c::IPPROTO_BEETPH as _);
-    /// `IPPROTO_ENCAP`
-    #[cfg(not(any(solarish, windows, target_os = "haiku")))]
-    pub const ENCAP: Self = Self(c::IPPROTO_ENCAP as _);
-    /// `IPPROTO_PIM`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    pub const PIM: Self = Self(c::IPPROTO_PIM as _);
-    /// `IPPROTO_COMP`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "haiku",
-    )))]
-    pub const COMP: Self = Self(c::IPPROTO_COMP as _);
-    /// `IPPROTO_SCTP`
-    #[cfg(not(any(solarish, target_os = "dragonfly", target_os = "haiku", target_os = "openbsd")))]
-    pub const SCTP: Self = Self(c::IPPROTO_SCTP as _);
-    /// `IPPROTO_UDPLITE`
-    #[cfg(not(any(
-        apple,
-        netbsdlike,
-        solarish,
-        windows,
-        target_os = "dragonfly",
-        target_os = "haiku",
-    )))]
-    pub const UDPLITE: Self = Self(c::IPPROTO_UDPLITE as _);
-    /// `IPPROTO_MPLS`
-    #[cfg(not(any(
-        apple,
-        solarish,
-        windows,
-        target_os = "dragonfly",
-        target_os = "haiku",
-        target_os = "netbsd",
-    )))]
-    pub const MPLS: Self = Self(c::IPPROTO_MPLS as _);
-    /// `IPPROTO_RAW`
-    pub const RAW: Self = Self(c::IPPROTO_RAW as _);
-    /// `IPPROTO_MPTCP`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "android",
-        target_os = "emscripten",
-        target_os = "fuchsia",
-        target_os = "haiku",
-    )))]
-    pub const MPTCP: Self = Self(c::IPPROTO_MPTCP as _);
-    /// `IPPROTO_FRAGMENT`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    pub const FRAGMENT: Self = Self(c::IPPROTO_FRAGMENT as _);
-    /// `IPPROTO_ICMPV6`
-    pub const ICMPV6: Self = Self(c::IPPROTO_ICMPV6 as _);
-    /// `IPPROTO_MH`
-    #[cfg(not(any(
-        apple,
-        netbsdlike,
-        solarish,
-        windows,
-        target_os = "dragonfly",
-        target_os = "haiku",
-    )))]
-    pub const MH: Self = Self(c::IPPROTO_MH as _);
-    /// `IPPROTO_ROUTING`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    pub const ROUTING: Self = Self(c::IPPROTO_ROUTING as _);
-
-    /// Constructs a `Protocol` from a raw integer.
-    #[inline]
-    pub const fn from_raw(raw: RawProtocol) -> Self {
-        Self(raw)
-    }
-
-    /// Returns the raw integer for this `Protocol`.
-    #[inline]
-    pub const fn as_raw(self) -> RawProtocol {
-        self.0
-    }
-}
-
-/// `SHUT_*` constants for use with [`shutdown`].
-///
-/// [`shutdown`]: crate::net::shutdown
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum Shutdown {
-    /// `SHUT_RD`—Disable further read operations.
-    Read = c::SHUT_RD,
-    /// `SHUT_WR`—Disable further write operations.
-    Write = c::SHUT_WR,
-    /// `SHUT_RDWR`—Disable further read and write operations.
-    ReadWrite = c::SHUT_RDWR,
-}
-
-bitflags! {
-    /// `SOCK_*` constants for use with [`socket_with`], [`accept_with`] and
-    /// [`acceptfrom_with`].
-    ///
-    /// [`socket_with`]: crate::net::socket_with
-    /// [`accept_with`]: crate::net::accept_with
-    /// [`acceptfrom_with`]: crate::net::acceptfrom_with
-    pub struct SocketFlags: c::c_int {
-        /// `SOCK_NONBLOCK`
-        #[cfg(not(any(apple, windows, target_os = "haiku")))]
-        const NONBLOCK = c::SOCK_NONBLOCK;
-
-        /// `SOCK_CLOEXEC`
-        #[cfg(not(any(apple, windows, target_os = "haiku")))]
-        const CLOEXEC = c::SOCK_CLOEXEC;
-    }
-}
-
-/// Timeout identifier for use with [`set_socket_timeout`] and
-/// [`get_socket_timeout`].
-///
-/// [`set_socket_timeout`]: crate::net::sockopt::set_socket_timeout.
-/// [`get_socket_timeout`]: crate::net::sockopt::get_socket_timeout.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum Timeout {
-    /// `SO_RCVTIMEO`—Timeout for receiving.
-    Recv = c::SO_RCVTIMEO,
-
-    /// `SO_SNDTIMEO`—Timeout for sending.
-    Send = c::SO_SNDTIMEO,
-}
diff --git a/vendor/rustix/src/backend/libc/net/write_sockaddr.rs b/vendor/rustix/src/backend/libc/net/write_sockaddr.rs
index f8ab62966..efb5a4e14 100644
--- a/vendor/rustix/src/backend/libc/net/write_sockaddr.rs
+++ b/vendor/rustix/src/backend/libc/net/write_sockaddr.rs
@@ -1,11 +1,11 @@
 //! The BSD sockets API requires us to read the `ss_family` field before
 //! we can interpret the rest of a `sockaddr` produced by the kernel.
 
-use super::super::c;
 use super::addr::SocketAddrStorage;
 #[cfg(unix)]
 use super::addr::SocketAddrUnix;
 use super::ext::{in6_addr_new, in_addr_new, sockaddr_in6_new};
+use crate::backend::c;
 use crate::net::{SocketAddrAny, SocketAddrV4, SocketAddrV6};
 use core::mem::size_of;
 
diff --git a/vendor/rustix/src/backend/libc/offset.rs b/vendor/rustix/src/backend/libc/offset.rs
deleted file mode 100644
index d7a803415..000000000
--- a/vendor/rustix/src/backend/libc/offset.rs
+++ /dev/null
@@ -1,410 +0,0 @@
-//! Automatically enable “large file” support features.
-
-#[cfg(not(windows))]
-use super::c;
-
-#[cfg(not(any(linux_like, windows)))]
-#[cfg(feature = "fs")]
-pub(super) use c::{
-    fstat as libc_fstat, fstatat as libc_fstatat, ftruncate as libc_ftruncate, ino_t as libc_ino_t,
-    lseek as libc_lseek, off_t as libc_off_t,
-};
-
-#[cfg(linux_like)]
-#[cfg(feature = "fs")]
-pub(super) use c::{
-    fstat64 as libc_fstat, fstatat64 as libc_fstatat, ftruncate64 as libc_ftruncate,
-    ino64_t as libc_ino_t, lseek64 as libc_lseek, off64_t as libc_off_t,
-};
-
-#[cfg(linux_like)]
-pub(super) use c::rlimit64 as libc_rlimit;
-
-#[cfg(not(any(linux_like, windows, target_os = "wasi")))]
-#[cfg(feature = "mm")]
-pub(super) use c::mmap as libc_mmap;
-
-#[cfg(not(any(
-    linux_like,
-    windows,
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-pub(super) use c::{rlimit as libc_rlimit, RLIM_INFINITY as LIBC_RLIM_INFINITY};
-
-#[cfg(not(any(linux_like, windows, target_os = "fuchsia", target_os = "wasi")))]
-pub(super) use c::{getrlimit as libc_getrlimit, setrlimit as libc_setrlimit};
-
-#[cfg(linux_like)]
-pub(super) use c::{
-    getrlimit64 as libc_getrlimit, setrlimit64 as libc_setrlimit,
-    RLIM64_INFINITY as LIBC_RLIM_INFINITY,
-};
-
-#[cfg(linux_like)]
-#[cfg(feature = "mm")]
-pub(super) use c::mmap64 as libc_mmap;
-
-// `prlimit64` wasn't supported in glibc until 2.13.
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-weak_or_syscall! {
-    fn prlimit64(
-        pid: c::pid_t,
-        resource: c::__rlimit_resource_t,
-        new_limit: *const c::rlimit64,
-        old_limit: *mut c::rlimit64
-    ) via SYS_prlimit64 -> c::c_int
-}
-#[cfg(all(target_os = "linux", target_env = "musl"))]
-weak_or_syscall! {
-    fn prlimit64(
-        pid: c::pid_t,
-        resource: c::c_int,
-        new_limit: *const c::rlimit64,
-        old_limit: *mut c::rlimit64
-    ) via SYS_prlimit64 -> c::c_int
-}
-#[cfg(target_os = "android")]
-weak_or_syscall! {
-    fn prlimit64(
-        pid: c::pid_t,
-        resource: c::c_int,
-        new_limit: *const c::rlimit64,
-        old_limit: *mut c::rlimit64
-    ) via SYS_prlimit64 -> c::c_int
-}
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-pub(super) unsafe fn libc_prlimit(
-    pid: c::pid_t,
-    resource: c::__rlimit_resource_t,
-    new_limit: *const c::rlimit64,
-    old_limit: *mut c::rlimit64,
-) -> c::c_int {
-    prlimit64(pid, resource, new_limit, old_limit)
-}
-#[cfg(all(target_os = "linux", target_env = "musl"))]
-pub(super) unsafe fn libc_prlimit(
-    pid: c::pid_t,
-    resource: c::c_int,
-    new_limit: *const c::rlimit64,
-    old_limit: *mut c::rlimit64,
-) -> c::c_int {
-    prlimit64(pid, resource, new_limit, old_limit)
-}
-#[cfg(target_os = "android")]
-pub(super) unsafe fn libc_prlimit(
-    pid: c::pid_t,
-    resource: c::c_int,
-    new_limit: *const c::rlimit64,
-    old_limit: *mut c::rlimit64,
-) -> c::c_int {
-    prlimit64(pid, resource, new_limit, old_limit)
-}
-
-#[cfg(not(any(linux_like, windows, target_os = "redox")))]
-#[cfg(feature = "fs")]
-pub(super) use c::openat as libc_openat;
-#[cfg(linux_like)]
-#[cfg(feature = "fs")]
-pub(super) use c::openat64 as libc_openat;
-
-#[cfg(target_os = "fuchsia")]
-#[cfg(feature = "fs")]
-pub(super) use c::fallocate as libc_fallocate;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[cfg(feature = "fs")]
-pub(super) use c::fallocate64 as libc_fallocate;
-#[cfg(not(any(
-    apple,
-    linux_like,
-    netbsdlike,
-    solarish,
-    windows,
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "redox",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use c::posix_fadvise as libc_posix_fadvise;
-#[cfg(linux_like)]
-#[cfg(feature = "fs")]
-pub(super) use c::posix_fadvise64 as libc_posix_fadvise;
-
-#[cfg(all(not(any(
-    windows,
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-))))]
-pub(super) use c::{pread as libc_pread, pwrite as libc_pwrite};
-#[cfg(any(target_os = "android", target_os = "linux", target_os = "emscripten"))]
-pub(super) use c::{pread64 as libc_pread, pwrite64 as libc_pwrite};
-#[cfg(not(any(
-    apple,
-    windows,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "linux",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub(super) use c::{preadv as libc_preadv, pwritev as libc_pwritev};
-#[cfg(any(target_os = "linux", target_os = "emscripten"))]
-pub(super) use c::{preadv64 as libc_preadv, pwritev64 as libc_pwritev};
-
-#[cfg(target_os = "android")]
-mod readwrite_pv64 {
-    use super::c;
-
-    // 64-bit offsets on 32-bit platforms are passed in endianness-specific
-    // lo/hi pairs. See src/backend/linux_raw/conv.rs for details.
-    #[cfg(all(target_endian = "little", target_pointer_width = "32"))]
-    fn lo(x: u64) -> usize {
-        (x >> 32) as usize
-    }
-    #[cfg(all(target_endian = "little", target_pointer_width = "32"))]
-    fn hi(x: u64) -> usize {
-        (x & 0xffff_ffff) as usize
-    }
-    #[cfg(all(target_endian = "big", target_pointer_width = "32"))]
-    fn lo(x: u64) -> usize {
-        (x & 0xffff_ffff) as usize
-    }
-    #[cfg(all(target_endian = "big", target_pointer_width = "32"))]
-    fn hi(x: u64) -> usize {
-        (x >> 32) as usize
-    }
-
-    pub(in super::super) unsafe fn preadv64(
-        fd: c::c_int,
-        iov: *const c::iovec,
-        iovcnt: c::c_int,
-        offset: c::off64_t,
-    ) -> c::ssize_t {
-        // Older Android libc lacks `preadv64`, so use the `weak!` mechanism to
-        // test for it, and call back to `c::syscall`. We don't use
-        // `weak_or_syscall` here because we need to pass the 64-bit offset
-        // specially.
-        weak! {
-            fn preadv64(c::c_int, *const c::iovec, c::c_int, c::off64_t) -> c::ssize_t
-        }
-        if let Some(fun) = preadv64.get() {
-            fun(fd, iov, iovcnt, offset)
-        } else {
-            #[cfg(target_pointer_width = "32")]
-            {
-                c::syscall(
-                    c::SYS_preadv,
-                    fd,
-                    iov,
-                    iovcnt,
-                    hi(offset as u64),
-                    lo(offset as u64),
-                ) as c::ssize_t
-            }
-            #[cfg(target_pointer_width = "64")]
-            {
-                c::syscall(c::SYS_preadv, fd, iov, iovcnt, offset) as c::ssize_t
-            }
-        }
-    }
-    pub(in super::super) unsafe fn pwritev64(
-        fd: c::c_int,
-        iov: *const c::iovec,
-        iovcnt: c::c_int,
-        offset: c::off64_t,
-    ) -> c::ssize_t {
-        // See the comments in `preadv64`.
-        weak! {
-            fn pwritev64(c::c_int, *const c::iovec, c::c_int, c::off64_t) -> c::ssize_t
-        }
-        if let Some(fun) = pwritev64.get() {
-            fun(fd, iov, iovcnt, offset)
-        } else {
-            #[cfg(target_pointer_width = "32")]
-            {
-                c::syscall(
-                    c::SYS_pwritev,
-                    fd,
-                    iov,
-                    iovcnt,
-                    hi(offset as u64),
-                    lo(offset as u64),
-                ) as c::ssize_t
-            }
-            #[cfg(target_pointer_width = "64")]
-            {
-                c::syscall(c::SYS_pwritev, fd, iov, iovcnt, offset) as c::ssize_t
-            }
-        }
-    }
-}
-#[cfg(target_os = "android")]
-pub(super) use readwrite_pv64::{preadv64 as libc_preadv, pwritev64 as libc_pwritev};
-
-// macOS added preadv and pwritev in version 11.0
-#[cfg(apple)]
-mod readwrite_pv {
-    use super::c;
-
-    weakcall! {
-        pub(in super::super) fn preadv(
-            fd: c::c_int,
-            iov: *const c::iovec,
-            iovcnt: c::c_int,
-            offset: c::off_t
-        ) -> c::ssize_t
-    }
-    weakcall! {
-        pub(in super::super) fn pwritev(
-            fd: c::c_int,
-            iov: *const c::iovec,
-            iovcnt: c::c_int, offset: c::off_t
-        ) -> c::ssize_t
-    }
-}
-#[cfg(apple)]
-pub(super) use readwrite_pv::{preadv as libc_preadv, pwritev as libc_pwritev};
-
-// glibc added `preadv64v2` and `pwritev64v2` in version 2.26.
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-mod readwrite_pv64v2 {
-    use super::c;
-
-    // 64-bit offsets on 32-bit platforms are passed in endianness-specific
-    // lo/hi pairs. See src/backend/linux_raw/conv.rs for details.
-    #[cfg(all(target_endian = "little", target_pointer_width = "32"))]
-    fn lo(x: u64) -> usize {
-        (x >> 32) as usize
-    }
-    #[cfg(all(target_endian = "little", target_pointer_width = "32"))]
-    fn hi(x: u64) -> usize {
-        (x & 0xffff_ffff) as usize
-    }
-    #[cfg(all(target_endian = "big", target_pointer_width = "32"))]
-    fn lo(x: u64) -> usize {
-        (x & 0xffff_ffff) as usize
-    }
-    #[cfg(all(target_endian = "big", target_pointer_width = "32"))]
-    fn hi(x: u64) -> usize {
-        (x >> 32) as usize
-    }
-
-    pub(in super::super) unsafe fn preadv64v2(
-        fd: c::c_int,
-        iov: *const c::iovec,
-        iovcnt: c::c_int,
-        offset: c::off64_t,
-        flags: c::c_int,
-    ) -> c::ssize_t {
-        // Older glibc lacks `preadv64v2`, so use the `weak!` mechanism to
-        // test for it, and call back to `c::syscall`. We don't use
-        // `weak_or_syscall` here because we need to pass the 64-bit offset
-        // specially.
-        weak! {
-            fn preadv64v2(c::c_int, *const c::iovec, c::c_int, c::off64_t, c::c_int) -> c::ssize_t
-        }
-        if let Some(fun) = preadv64v2.get() {
-            fun(fd, iov, iovcnt, offset, flags)
-        } else {
-            #[cfg(target_pointer_width = "32")]
-            {
-                c::syscall(
-                    c::SYS_preadv,
-                    fd,
-                    iov,
-                    iovcnt,
-                    hi(offset as u64),
-                    lo(offset as u64),
-                    flags,
-                ) as c::ssize_t
-            }
-            #[cfg(target_pointer_width = "64")]
-            {
-                c::syscall(c::SYS_preadv2, fd, iov, iovcnt, offset, flags) as c::ssize_t
-            }
-        }
-    }
-    pub(in super::super) unsafe fn pwritev64v2(
-        fd: c::c_int,
-        iov: *const c::iovec,
-        iovcnt: c::c_int,
-        offset: c::off64_t,
-        flags: c::c_int,
-    ) -> c::ssize_t {
-        // See the comments in `preadv64v2`.
-        weak! {
-            fn pwritev64v2(c::c_int, *const c::iovec, c::c_int, c::off64_t, c::c_int) -> c::ssize_t
-        }
-        if let Some(fun) = pwritev64v2.get() {
-            fun(fd, iov, iovcnt, offset, flags)
-        } else {
-            #[cfg(target_pointer_width = "32")]
-            {
-                c::syscall(
-                    c::SYS_pwritev,
-                    fd,
-                    iov,
-                    iovcnt,
-                    hi(offset as u64),
-                    lo(offset as u64),
-                    flags,
-                ) as c::ssize_t
-            }
-            #[cfg(target_pointer_width = "64")]
-            {
-                c::syscall(c::SYS_pwritev2, fd, iov, iovcnt, offset, flags) as c::ssize_t
-            }
-        }
-    }
-}
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-pub(super) use readwrite_pv64v2::{preadv64v2 as libc_preadv2, pwritev64v2 as libc_pwritev2};
-
-#[cfg(not(any(
-    apple,
-    netbsdlike,
-    solarish,
-    windows,
-    target_os = "aix",
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-    target_os = "l4re",
-    target_os = "redox",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use c::posix_fallocate as libc_posix_fallocate;
-#[cfg(target_os = "l4re")]
-#[cfg(feature = "fs")]
-pub(super) use c::posix_fallocate64 as libc_posix_fallocate;
-#[cfg(not(any(
-    linux_like,
-    solarish,
-    windows,
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use {c::fstatfs as libc_fstatfs, c::statfs as libc_statfs};
-#[cfg(not(any(
-    linux_like,
-    windows,
-    target_os = "haiku",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use {c::fstatvfs as libc_fstatvfs, c::statvfs as libc_statvfs};
-
-#[cfg(linux_like)]
-#[cfg(feature = "fs")]
-pub(super) use {
-    c::fstatfs64 as libc_fstatfs, c::fstatvfs64 as libc_fstatvfs, c::statfs64 as libc_statfs,
-    c::statvfs64 as libc_statvfs,
-};
diff --git a/vendor/rustix/src/backend/libc/param/auxv.rs b/vendor/rustix/src/backend/libc/param/auxv.rs
index a770c60d8..0eeb972cc 100644
--- a/vendor/rustix/src/backend/libc/param/auxv.rs
+++ b/vendor/rustix/src/backend/libc/param/auxv.rs
@@ -1,4 +1,4 @@
-use super::super::c;
+use crate::backend::c;
 #[cfg(any(
     all(target_os = "android", target_pointer_width = "64"),
     target_os = "linux",
diff --git a/vendor/rustix/src/backend/libc/pid/mod.rs b/vendor/rustix/src/backend/libc/pid/mod.rs
new file mode 100644
index 000000000..ef944f04d
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/pid/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/pid/syscalls.rs b/vendor/rustix/src/backend/libc/pid/syscalls.rs
new file mode 100644
index 000000000..d0ed4bc9f
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/pid/syscalls.rs
@@ -0,0 +1,14 @@
+//! libc syscalls for PIDs
+
+use crate::backend::c;
+use crate::pid::Pid;
+
+#[cfg(not(target_os = "wasi"))]
+#[inline]
+#[must_use]
+pub(crate) fn getpid() -> Pid {
+    unsafe {
+        let pid = c::getpid();
+        Pid::from_raw_unchecked(pid)
+    }
+}
diff --git a/vendor/rustix/src/backend/libc/pipe/mod.rs b/vendor/rustix/src/backend/libc/pipe/mod.rs
new file mode 100644
index 000000000..1e0181a99
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/pipe/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/libc/pipe/syscalls.rs b/vendor/rustix/src/backend/libc/pipe/syscalls.rs
new file mode 100644
index 000000000..c5ded9174
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/pipe/syscalls.rs
@@ -0,0 +1,111 @@
+use crate::backend::c;
+use crate::backend::conv::ret;
+use crate::fd::OwnedFd;
+use crate::io;
+#[cfg(not(any(apple, target_os = "aix", target_os = "haiku", target_os = "wasi")))]
+use crate::pipe::PipeFlags;
+use core::mem::MaybeUninit;
+#[cfg(linux_kernel)]
+use {
+    crate::backend::conv::{borrowed_fd, ret_c_int, ret_usize},
+    crate::backend::MAX_IOV,
+    crate::fd::BorrowedFd,
+    crate::pipe::{IoSliceRaw, SpliceFlags},
+    crate::utils::optional_as_mut_ptr,
+    core::cmp::min,
+};
+
+#[cfg(not(target_os = "wasi"))]
+pub(crate) fn pipe() -> io::Result<(OwnedFd, OwnedFd)> {
+    unsafe {
+        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
+        ret(c::pipe(result.as_mut_ptr().cast::<i32>()))?;
+        let [p0, p1] = result.assume_init();
+        Ok((p0, p1))
+    }
+}
+
+#[cfg(not(any(apple, target_os = "aix", target_os = "haiku", target_os = "wasi")))]
+pub(crate) fn pipe_with(flags: PipeFlags) -> io::Result<(OwnedFd, OwnedFd)> {
+    unsafe {
+        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
+        ret(c::pipe2(
+            result.as_mut_ptr().cast::<i32>(),
+            bitflags_bits!(flags),
+        ))?;
+        let [p0, p1] = result.assume_init();
+        Ok((p0, p1))
+    }
+}
+
+#[cfg(linux_kernel)]
+#[inline]
+pub fn splice(
+    fd_in: BorrowedFd,
+    off_in: Option<&mut u64>,
+    fd_out: BorrowedFd,
+    off_out: Option<&mut u64>,
+    len: usize,
+    flags: SpliceFlags,
+) -> io::Result<usize> {
+    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(
+            borrowed_fd(fd_in),
+            off_in,
+            borrowed_fd(fd_out),
+            off_out,
+            len,
+            flags.bits(),
+        ))
+    }
+}
+
+#[cfg(linux_kernel)]
+#[inline]
+pub unsafe fn vmsplice(
+    fd: BorrowedFd,
+    bufs: &[IoSliceRaw],
+    flags: SpliceFlags,
+) -> io::Result<usize> {
+    ret_usize(c::vmsplice(
+        borrowed_fd(fd),
+        bufs.as_ptr().cast::<c::iovec>(),
+        min(bufs.len(), MAX_IOV),
+        flags.bits(),
+    ))
+}
+
+#[cfg(linux_kernel)]
+#[inline]
+pub fn tee(
+    fd_in: BorrowedFd,
+    fd_out: BorrowedFd,
+    len: usize,
+    flags: SpliceFlags,
+) -> io::Result<usize> {
+    unsafe {
+        ret_usize(c::tee(
+            borrowed_fd(fd_in),
+            borrowed_fd(fd_out),
+            len,
+            flags.bits(),
+        ))
+    }
+}
+
+#[cfg(linux_kernel)]
+#[inline]
+pub(crate) fn fcntl_getpipe_sz(fd: BorrowedFd<'_>) -> io::Result<usize> {
+    unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETPIPE_SZ)).map(|size| size as usize) }
+}
+
+#[cfg(linux_kernel)]
+#[inline]
+pub(crate) fn fcntl_setpipe_sz(fd: BorrowedFd<'_>, size: usize) -> io::Result<()> {
+    let size: c::c_int = size.try_into().map_err(|_| io::Errno::PERM)?;
+
+    unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_SETPIPE_SZ, size)) }
+}
diff --git a/vendor/rustix/src/backend/libc/pipe/types.rs b/vendor/rustix/src/backend/libc/pipe/types.rs
new file mode 100644
index 000000000..f48d8041b
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/pipe/types.rs
@@ -0,0 +1,93 @@
+#[cfg(linux_kernel)]
+use core::marker::PhantomData;
+#[cfg(not(any(apple, target_os = "wasi")))]
+use {crate::backend::c, bitflags::bitflags};
+
+#[cfg(not(any(apple, target_os = "wasi")))]
+bitflags! {
+    /// `O_*` constants for use with [`pipe_with`].
+    ///
+    /// [`pipe_with`]: crate::io::pipe_with
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct PipeFlags: u32 {
+        /// `O_CLOEXEC`
+        const CLOEXEC = bitcast!(c::O_CLOEXEC);
+        /// `O_DIRECT`
+        #[cfg(not(any(
+            solarish,
+            target_os = "haiku",
+            target_os = "openbsd",
+            target_os = "redox",
+        )))]
+        const DIRECT = bitcast!(c::O_DIRECT);
+        /// `O_NONBLOCK`
+        const NONBLOCK = bitcast!(c::O_NONBLOCK);
+    }
+}
+
+#[cfg(linux_kernel)]
+bitflags! {
+    /// `SPLICE_F_*` constants for use with [`splice`], [`vmsplice`],
+    /// and [`tee`].
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct SpliceFlags: c::c_uint {
+        /// `SPLICE_F_MOVE`
+        const MOVE = c::SPLICE_F_MOVE;
+        /// `SPLICE_F_NONBLOCK`
+        const NONBLOCK = c::SPLICE_F_NONBLOCK;
+        /// `SPLICE_F_MORE`
+        const MORE = c::SPLICE_F_MORE;
+        /// `SPLICE_F_GIFT`
+        const GIFT = c::SPLICE_F_GIFT;
+    }
+}
+
+/// A buffer type used with `vmsplice`.
+///
+/// It is guaranteed to be ABI compatible with the iovec type on Unix platforms
+/// and `WSABUF` on Windows. Unlike `IoSlice` and `IoSliceMut` it is
+/// semantically like a raw pointer, and therefore can be shared or mutated as
+/// needed.
+#[cfg(linux_kernel)]
+#[repr(transparent)]
+pub struct IoSliceRaw<'a> {
+    _buf: c::iovec,
+    _lifetime: PhantomData<&'a ()>,
+}
+
+#[cfg(linux_kernel)]
+impl<'a> IoSliceRaw<'a> {
+    /// Creates a new `IoSlice` wrapping a byte slice.
+    pub fn from_slice(buf: &'a [u8]) -> Self {
+        IoSliceRaw {
+            _buf: c::iovec {
+                iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void,
+                iov_len: buf.len() as _,
+            },
+            _lifetime: PhantomData,
+        }
+    }
+
+    /// Creates a new `IoSlice` wrapping a mutable byte slice.
+    pub fn from_slice_mut(buf: &'a mut [u8]) -> Self {
+        IoSliceRaw {
+            _buf: c::iovec {
+                iov_base: buf.as_mut_ptr() as *mut c::c_void,
+                iov_len: buf.len() as _,
+            },
+            _lifetime: PhantomData,
+        }
+    }
+}
+
+#[cfg(not(any(apple, target_os = "wasi")))]
+#[test]
+fn test_types() {
+    use core::mem::size_of;
+    assert_eq!(size_of::<PipeFlags>(), size_of::<c::c_int>());
+
+    #[cfg(linux_kernel)]
+    assert_eq!(size_of::<SpliceFlags>(), size_of::<c::c_int>());
+}
diff --git a/vendor/rustix/src/backend/libc/prctl/mod.rs b/vendor/rustix/src/backend/libc/prctl/mod.rs
new file mode 100644
index 000000000..ef944f04d
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/prctl/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/prctl/syscalls.rs b/vendor/rustix/src/backend/libc/prctl/syscalls.rs
new file mode 100644
index 000000000..451cecc29
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/prctl/syscalls.rs
@@ -0,0 +1,14 @@
+use crate::backend::c;
+use crate::backend::conv::ret_c_int;
+use crate::io;
+
+#[inline]
+pub(crate) unsafe fn prctl(
+    option: c::c_int,
+    arg2: *mut c::c_void,
+    arg3: *mut c::c_void,
+    arg4: *mut c::c_void,
+    arg5: *mut c::c_void,
+) -> io::Result<c::c_int> {
+    ret_c_int(c::prctl(option, arg2, arg3, arg4, arg5))
+}
diff --git a/vendor/rustix/src/backend/libc/process/cpu_set.rs b/vendor/rustix/src/backend/libc/process/cpu_set.rs
index a9d6d89c2..4cf06b96a 100644
--- a/vendor/rustix/src/backend/libc/process/cpu_set.rs
+++ b/vendor/rustix/src/backend/libc/process/cpu_set.rs
@@ -2,8 +2,8 @@
 
 #![allow(non_snake_case)]
 
-use super::super::c;
 use super::types::{RawCpuSet, CPU_SETSIZE};
+use crate::backend::c;
 
 #[inline]
 pub(crate) fn CPU_SET(cpu: usize, cpuset: &mut RawCpuSet) {
@@ -43,9 +43,8 @@ pub(crate) fn CPU_ISSET(cpu: usize, cpuset: &RawCpuSet) -> bool {
     unsafe { c::CPU_ISSET(cpu, cpuset) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn CPU_COUNT(cpuset: &RawCpuSet) -> u32 {
-    use core::convert::TryInto;
     unsafe { c::CPU_COUNT(cpuset).try_into().unwrap() }
 }
diff --git a/vendor/rustix/src/backend/libc/process/mod.rs b/vendor/rustix/src/backend/libc/process/mod.rs
index 8675c1af9..24f43d443 100644
--- a/vendor/rustix/src/backend/libc/process/mod.rs
+++ b/vendor/rustix/src/backend/libc/process/mod.rs
@@ -1,9 +1,4 @@
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "dragonfly", target_os = "fuchsia"))]
 pub(crate) mod cpu_set;
 #[cfg(not(windows))]
 pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/process/syscalls.rs b/vendor/rustix/src/backend/libc/process/syscalls.rs
index d8f4fe3a4..0aa29b0b1 100644
--- a/vendor/rustix/src/backend/libc/process/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/process/syscalls.rs
@@ -1,52 +1,43 @@
 //! libc syscalls supporting `rustix::process`.
 
-use super::super::c;
-#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))]
-use super::super::conv::borrowed_fd;
-use super::super::conv::{c_str, ret, ret_c_int, ret_discarded_char_ptr};
-#[cfg(not(target_os = "wasi"))]
-use super::super::conv::{ret_infallible, ret_pid_t, ret_usize};
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::{syscall_ret, syscall_ret_u32};
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "dragonfly", target_os = "fuchsia"))]
 use super::types::RawCpuSet;
-#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))]
+use crate::backend::c;
+#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
+use crate::backend::conv::ret_infallible;
+#[cfg(linux_kernel)]
+use crate::backend::conv::ret_u32;
+#[cfg(not(target_os = "wasi"))]
+use crate::backend::conv::{borrowed_fd, ret_pid_t, ret_usize};
+#[cfg(feature = "fs")]
+use crate::backend::conv::{c_str, ret_discarded_char_ptr};
+use crate::backend::conv::{ret, ret_c_int};
+#[cfg(not(target_os = "wasi"))]
 use crate::fd::BorrowedFd;
 #[cfg(target_os = "linux")]
-use crate::fd::{AsRawFd, OwnedFd};
+use crate::fd::{AsRawFd, OwnedFd, RawFd};
+#[cfg(feature = "fs")]
 use crate::ffi::CStr;
 #[cfg(feature = "fs")]
 use crate::fs::Mode;
 use crate::io;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::process::Sysinfo;
-#[cfg(not(any(target_os = "wasi", target_os = "redox", target_os = "openbsd")))]
+#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
+use crate::process::Uid;
+#[cfg(linux_kernel)]
+use crate::process::{Cpuid, MembarrierCommand, MembarrierQuery};
+#[cfg(not(target_os = "wasi"))]
+use crate::process::{Gid, Pid, RawPid, Signal, WaitOptions, WaitStatus};
+#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
+use crate::process::{Resource, Rlimit};
+#[cfg(not(any(target_os = "redox", target_os = "openbsd", target_os = "wasi")))]
 use crate::process::{WaitId, WaitidOptions, WaitidStatus};
 use core::mem::MaybeUninit;
 #[cfg(target_os = "linux")]
-use {super::super::conv::syscall_ret_owned_fd, crate::process::PidfdFlags};
-#[cfg(any(target_os = "android", target_os = "linux"))]
 use {
-    super::super::offset::libc_prlimit,
-    crate::process::{Cpuid, MembarrierCommand, MembarrierQuery},
-};
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
-use {
-    super::super::offset::{libc_getrlimit, libc_rlimit, libc_setrlimit, LIBC_RLIM_INFINITY},
-    crate::process::{Resource, Rlimit},
-};
-#[cfg(not(target_os = "wasi"))]
-use {
-    super::types::RawUname,
-    crate::process::{Gid, Pid, RawNonZeroPid, RawPid, Signal, Uid, WaitOptions, WaitStatus},
-    core::convert::TryInto,
+    super::super::conv::ret_owned_fd, crate::process::PidfdFlags, crate::process::PidfdGetfdFlags,
 };
 
+#[cfg(feature = "fs")]
 #[cfg(not(target_os = "wasi"))]
 pub(crate) fn chdir(path: &CStr) -> io::Result<()> {
     unsafe { ret(c::chdir(c_str(path))) }
@@ -57,17 +48,29 @@ pub(crate) fn fchdir(dirfd: BorrowedFd<'_>) -> io::Result<()> {
     unsafe { ret(c::fchdir(borrowed_fd(dirfd))) }
 }
 
+#[cfg(feature = "fs")]
 #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
 pub(crate) fn chroot(path: &CStr) -> io::Result<()> {
     unsafe { ret(c::chroot(c_str(path))) }
 }
 
+#[cfg(feature = "fs")]
 #[cfg(not(target_os = "wasi"))]
-pub(crate) fn getcwd(buf: &mut [u8]) -> io::Result<()> {
+pub(crate) fn getcwd(buf: &mut [MaybeUninit<u8>]) -> io::Result<()> {
     unsafe { ret_discarded_char_ptr(c::getcwd(buf.as_mut_ptr().cast(), buf.len())) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+// The `membarrier` syscall has a third argument, but it's only used when
+// the `flags` argument is `MEMBARRIER_CMD_FLAG_CPU`.
+#[cfg(linux_kernel)]
+syscall! {
+    fn membarrier_all(
+        cmd: c::c_int,
+        flags: c::c_uint
+    ) via SYS_membarrier -> c::c_int
+}
+
+#[cfg(linux_kernel)]
 pub(crate) fn membarrier_query() -> MembarrierQuery {
     // glibc does not have a wrapper for `membarrier`; [the documentation]
     // says to use `syscall`.
@@ -75,79 +78,36 @@ pub(crate) fn membarrier_query() -> MembarrierQuery {
     // [the documentation]: https://man7.org/linux/man-pages/man2/membarrier.2.html#NOTES
     const MEMBARRIER_CMD_QUERY: u32 = 0;
     unsafe {
-        match syscall_ret_u32(c::syscall(c::SYS_membarrier, MEMBARRIER_CMD_QUERY, 0)) {
-            Ok(query) => MembarrierQuery::from_bits_unchecked(query),
+        match ret_u32(membarrier_all(MEMBARRIER_CMD_QUERY as i32, 0)) {
+            Ok(query) => MembarrierQuery::from_bits_retain(query),
             Err(_) => MembarrierQuery::empty(),
         }
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn membarrier(cmd: MembarrierCommand) -> io::Result<()> {
-    unsafe { syscall_ret(c::syscall(c::SYS_membarrier, cmd as u32, 0)) }
+    unsafe { ret(membarrier_all(cmd as i32, 0)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn membarrier_cpu(cmd: MembarrierCommand, cpu: Cpuid) -> io::Result<()> {
     const MEMBARRIER_CMD_FLAG_CPU: u32 = 1;
-    unsafe {
-        syscall_ret(c::syscall(
-            c::SYS_membarrier,
-            cmd as u32,
-            MEMBARRIER_CMD_FLAG_CPU,
-            cpu.as_raw(),
-        ))
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getuid() -> Uid {
-    unsafe {
-        let uid = c::getuid();
-        Uid::from_raw(uid)
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn geteuid() -> Uid {
-    unsafe {
-        let uid = c::geteuid();
-        Uid::from_raw(uid)
-    }
-}
 
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getgid() -> Gid {
-    unsafe {
-        let gid = c::getgid();
-        Gid::from_raw(gid)
+    syscall! {
+        fn membarrier_cpu(
+            cmd: c::c_int,
+            flags: c::c_uint,
+            cpu_id: c::c_int
+        ) via SYS_membarrier -> c::c_int
     }
-}
 
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getegid() -> Gid {
     unsafe {
-        let gid = c::getegid();
-        Gid::from_raw(gid)
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getpid() -> Pid {
-    unsafe {
-        let pid = c::getpid();
-        debug_assert_ne!(pid, 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid))
+        ret(membarrier_cpu(
+            cmd as i32,
+            MEMBARRIER_CMD_FLAG_CPU,
+            bitcast!(cpu.as_raw()),
+        ))
     }
 }
 
@@ -166,8 +126,7 @@ pub(crate) fn getppid() -> Option<Pid> {
 pub(crate) fn getpgid(pid: Option<Pid>) -> io::Result<Pid> {
     unsafe {
         let pgid = ret_pid_t(c::getpgid(Pid::as_raw(pid) as _))?;
-        debug_assert_ne!(pgid, 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pgid)))
+        Ok(Pid::from_raw_unchecked(pgid))
     }
 }
 
@@ -183,17 +142,11 @@ pub(crate) fn setpgid(pid: Option<Pid>, pgid: Option<Pid>) -> io::Result<()> {
 pub(crate) fn getpgrp() -> Pid {
     unsafe {
         let pgid = c::getpgrp();
-        debug_assert_ne!(pgid, 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pgid))
+        Pid::from_raw_unchecked(pgid)
     }
 }
 
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "dragonfly", target_os = "fuchsia"))]
 #[inline]
 pub(crate) fn sched_getaffinity(pid: Option<Pid>, cpuset: &mut RawCpuSet) -> io::Result<()> {
     unsafe {
@@ -205,12 +158,7 @@ pub(crate) fn sched_getaffinity(pid: Option<Pid>, cpuset: &mut RawCpuSet) -> io:
     }
 }
 
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "dragonfly", target_os = "fuchsia"))]
 #[inline]
 pub(crate) fn sched_setaffinity(pid: Option<Pid>, cpuset: &RawCpuSet) -> io::Result<()> {
     unsafe {
@@ -230,21 +178,10 @@ pub(crate) fn sched_yield() {
 }
 
 #[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn uname() -> RawUname {
-    let mut uname = MaybeUninit::<RawUname>::uninit();
-    unsafe {
-        ret_infallible(c::uname(uname.as_mut_ptr()));
-        uname.assume_init()
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
 #[cfg(feature = "fs")]
 #[inline]
 pub(crate) fn umask(mask: Mode) -> Mode {
-    // TODO: Use `from_bits_retain` when we switch to bitflags 2.0.
-    unsafe { Mode::from_bits_truncate(c::umask(mask.bits() as _) as _) }
+    unsafe { Mode::from_bits_retain(c::umask(mask.bits() as c::mode_t).into()) }
 }
 
 #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
@@ -259,7 +196,7 @@ pub(crate) fn nice(inc: i32) -> io::Result<i32> {
     }
 }
 
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
+#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
 #[inline]
 pub(crate) fn getpriority_user(uid: Uid) -> io::Result<i32> {
     libc_errno::set_errno(libc_errno::Errno(0));
@@ -271,7 +208,7 @@ pub(crate) fn getpriority_user(uid: Uid) -> io::Result<i32> {
     }
 }
 
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
+#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
 #[inline]
 pub(crate) fn getpriority_pgrp(pgid: Option<Pid>) -> io::Result<i32> {
     libc_errno::set_errno(libc_errno::Errno(0));
@@ -283,7 +220,7 @@ pub(crate) fn getpriority_pgrp(pgid: Option<Pid>) -> io::Result<i32> {
     }
 }
 
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
+#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
 #[inline]
 pub(crate) fn getpriority_process(pid: Option<Pid>) -> io::Result<i32> {
     libc_errno::set_errno(libc_errno::Errno(0));
@@ -295,13 +232,13 @@ pub(crate) fn getpriority_process(pid: Option<Pid>) -> io::Result<i32> {
     }
 }
 
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
+#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
 #[inline]
 pub(crate) fn setpriority_user(uid: Uid, priority: i32) -> io::Result<()> {
     unsafe { ret(c::setpriority(c::PRIO_USER, uid.as_raw() as _, priority)) }
 }
 
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
+#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
 #[inline]
 pub(crate) fn setpriority_pgrp(pgid: Option<Pid>, priority: i32) -> io::Result<()> {
     unsafe {
@@ -313,7 +250,7 @@ pub(crate) fn setpriority_pgrp(pgid: Option<Pid>, priority: i32) -> io::Result<(
     }
 }
 
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
+#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
 #[inline]
 pub(crate) fn setpriority_process(pid: Option<Pid>, priority: i32) -> io::Result<()> {
     unsafe {
@@ -328,9 +265,9 @@ pub(crate) fn setpriority_process(pid: Option<Pid>, priority: i32) -> io::Result
 #[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
 #[inline]
 pub(crate) fn getrlimit(limit: Resource) -> Rlimit {
-    let mut result = MaybeUninit::<libc_rlimit>::uninit();
+    let mut result = MaybeUninit::<c::rlimit>::uninit();
     unsafe {
-        ret_infallible(libc_getrlimit(limit as _, result.as_mut_ptr()));
+        ret_infallible(c::getrlimit(limit as _, result.as_mut_ptr()));
         rlimit_from_libc(result.assume_init())
     }
 }
@@ -339,16 +276,16 @@ pub(crate) fn getrlimit(limit: Resource) -> Rlimit {
 #[inline]
 pub(crate) fn setrlimit(limit: Resource, new: Rlimit) -> io::Result<()> {
     let lim = rlimit_to_libc(new)?;
-    unsafe { ret(libc_setrlimit(limit as _, &lim)) }
+    unsafe { ret(c::setrlimit(limit as _, &lim)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn prlimit(pid: Option<Pid>, limit: Resource, new: Rlimit) -> io::Result<Rlimit> {
     let lim = rlimit_to_libc(new)?;
-    let mut result = MaybeUninit::<libc_rlimit>::uninit();
+    let mut result = MaybeUninit::<c::rlimit>::uninit();
     unsafe {
-        ret(libc_prlimit(
+        ret(c::prlimit(
             Pid::as_raw(pid),
             limit as _,
             &lim,
@@ -358,15 +295,15 @@ pub(crate) fn prlimit(pid: Option<Pid>, limit: Resource, new: Rlimit) -> io::Res
     }
 }
 
-/// Convert a Rust [`Rlimit`] to a C `libc_rlimit`.
+/// Convert a Rust [`Rlimit`] to a C `c::rlimit`.
 #[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
-fn rlimit_from_libc(lim: libc_rlimit) -> Rlimit {
-    let current = if lim.rlim_cur == LIBC_RLIM_INFINITY {
+fn rlimit_from_libc(lim: c::rlimit) -> Rlimit {
+    let current = if lim.rlim_cur == c::RLIM_INFINITY {
         None
     } else {
         Some(lim.rlim_cur.try_into().unwrap())
     };
-    let maximum = if lim.rlim_max == LIBC_RLIM_INFINITY {
+    let maximum = if lim.rlim_max == c::RLIM_INFINITY {
         None
     } else {
         Some(lim.rlim_max.try_into().unwrap())
@@ -374,19 +311,19 @@ fn rlimit_from_libc(lim: libc_rlimit) -> Rlimit {
     Rlimit { current, maximum }
 }
 
-/// Convert a C `libc_rlimit` to a Rust `Rlimit`.
+/// Convert a C `c::rlimit` to a Rust `Rlimit`.
 #[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
-fn rlimit_to_libc(lim: Rlimit) -> io::Result<libc_rlimit> {
+fn rlimit_to_libc(lim: Rlimit) -> io::Result<c::rlimit> {
     let Rlimit { current, maximum } = lim;
     let rlim_cur = match current {
         Some(r) => r.try_into().map_err(|_e| io::Errno::INVAL)?,
-        None => LIBC_RLIM_INFINITY as _,
+        None => c::RLIM_INFINITY as _,
     };
     let rlim_max = match maximum {
         Some(r) => r.try_into().map_err(|_e| io::Errno::INVAL)?,
-        None => LIBC_RLIM_INFINITY as _,
+        None => c::RLIM_INFINITY as _,
     };
-    Ok(libc_rlimit { rlim_cur, rlim_max })
+    Ok(c::rlimit { rlim_cur, rlim_max })
 }
 
 #[cfg(not(target_os = "wasi"))]
@@ -413,12 +350,7 @@ pub(crate) fn _waitpid(
     unsafe {
         let mut status: c::c_int = 0;
         let pid = ret_c_int(c::waitpid(pid as _, &mut status, waitopts.bits() as _))?;
-        Ok(RawNonZeroPid::new(pid).map(|non_zero| {
-            (
-                Pid::from_raw_nonzero(non_zero),
-                WaitStatus::new(status as _),
-            )
-        }))
+        Ok(Pid::from_raw(pid).map(|pid| (pid, WaitStatus::new(status as _))))
     }
 }
 
@@ -503,8 +435,8 @@ unsafe fn cvt_waitid_status(status: MaybeUninit<c::siginfo_t>) -> Option<WaitidS
     // `si_pid` is supposedly the better way to check that the struct has been
     // filled, e.g. the Linux manpage says about the `WNOHANG` case “zero out
     // the si_pid field before the call and check for a nonzero value”.
-    // But e.g. NetBSD/OpenBSD don't have it exposed in the libc crate for now, and
-    // some platforms don't have it at all. For simplicity, always check
+    // But e.g. NetBSD/OpenBSD don't have it exposed in the libc crate for now,
+    // and some platforms don't have it at all. For simplicity, always check
     // `si_signo`. We have zero-initialized the whole struct, and all kernels
     // should set `SIGCHLD` here.
     if status.si_signo == 0 {
@@ -514,27 +446,12 @@ unsafe fn cvt_waitid_status(status: MaybeUninit<c::siginfo_t>) -> Option<WaitidS
     }
 }
 
-#[inline]
-pub(crate) fn exit_group(code: c::c_int) -> ! {
-    // `_exit` and `_Exit` are the same; it's just a matter of which ones
-    // the libc bindings expose.
-    #[cfg(any(target_os = "wasi", target_os = "solid"))]
-    unsafe {
-        c::_Exit(code)
-    }
-    #[cfg(unix)]
-    unsafe {
-        c::_exit(code)
-    }
-}
-
 #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
 #[inline]
 pub(crate) fn getsid(pid: Option<Pid>) -> io::Result<Pid> {
     unsafe {
         let pid = ret_pid_t(c::getsid(Pid::as_raw(pid) as _))?;
-        debug_assert_ne!(pid, 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid)))
+        Ok(Pid::from_raw_unchecked(pid))
     }
 }
 
@@ -543,8 +460,7 @@ pub(crate) fn getsid(pid: Option<Pid>) -> io::Result<Pid> {
 pub(crate) fn setsid() -> io::Result<Pid> {
     unsafe {
         let pid = ret_c_int(c::setsid())?;
-        debug_assert_ne!(pid, 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid)))
+        Ok(Pid::from_raw_unchecked(pid))
     }
 }
 
@@ -589,18 +505,6 @@ pub(crate) fn test_kill_current_process_group() -> io::Result<()> {
     unsafe { ret(c::kill(0, 0)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) unsafe fn prctl(
-    option: c::c_int,
-    arg2: *mut c::c_void,
-    arg3: *mut c::c_void,
-    arg4: *mut c::c_void,
-    arg5: *mut c::c_void,
-) -> io::Result<c::c_int> {
-    ret_c_int(c::prctl(option, arg2, arg3, arg4, arg5))
-}
-
 #[cfg(freebsdlike)]
 #[inline]
 pub(crate) unsafe fn procctl(
@@ -614,11 +518,38 @@ pub(crate) unsafe fn procctl(
 
 #[cfg(target_os = "linux")]
 pub(crate) fn pidfd_open(pid: Pid, flags: PidfdFlags) -> io::Result<OwnedFd> {
+    syscall! {
+        fn pidfd_open(
+            pid: c::pid_t,
+            flags: c::c_uint
+        ) via SYS_pidfd_open -> c::c_int
+    }
     unsafe {
-        syscall_ret_owned_fd(c::syscall(
-            c::SYS_pidfd_open,
+        ret_owned_fd(pidfd_open(
             pid.as_raw_nonzero().get(),
-            flags.bits(),
+            bitflags_bits!(flags),
+        ))
+    }
+}
+
+#[cfg(target_os = "linux")]
+pub(crate) fn pidfd_getfd(
+    pidfd: BorrowedFd<'_>,
+    targetfd: RawFd,
+    flags: PidfdGetfdFlags,
+) -> io::Result<OwnedFd> {
+    syscall! {
+        fn pidfd_getfd(
+            pidfd: c::c_int,
+            targetfd: c::c_int,
+            flags: c::c_uint
+        ) via SYS_pidfd_getfd -> c::c_int
+    }
+    unsafe {
+        ret_owned_fd(pidfd_getfd(
+            borrowed_fd(pidfd),
+            targetfd,
+            bitflags_bits!(flags),
         ))
     }
 }
@@ -630,21 +561,8 @@ pub(crate) fn getgroups(buf: &mut [Gid]) -> io::Result<usize> {
     unsafe { ret_usize(c::getgroups(len, buf.as_mut_ptr().cast()) as isize) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn sysinfo() -> Sysinfo {
-    let mut info = MaybeUninit::<Sysinfo>::uninit();
-    unsafe {
-        ret_infallible(c::sysinfo(info.as_mut_ptr()));
-        info.assume_init()
-    }
-}
-
-#[cfg(not(any(target_os = "emscripten", target_os = "redox", target_os = "wasi")))]
-pub(crate) fn sethostname(name: &[u8]) -> io::Result<()> {
-    unsafe {
-        ret(c::sethostname(
-            name.as_ptr().cast(),
-            name.len().try_into().map_err(|_| io::Errno::INVAL)?,
-        ))
-    }
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+#[inline]
+pub(crate) fn ioctl_tiocsctty(fd: BorrowedFd<'_>) -> io::Result<()> {
+    unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCSCTTY as _, &0_u32)) }
 }
diff --git a/vendor/rustix/src/backend/libc/process/types.rs b/vendor/rustix/src/backend/libc/process/types.rs
index e7f10dbff..980c0effe 100644
--- a/vendor/rustix/src/backend/libc/process/types.rs
+++ b/vendor/rustix/src/backend/libc/process/types.rs
@@ -1,8 +1,4 @@
-use super::super::c;
-
-/// `sysinfo`
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub type Sysinfo = c::sysinfo;
+use crate::backend::c;
 
 /// A command for use with [`membarrier`] and [`membarrier_cpu`].
 ///
@@ -11,7 +7,7 @@ pub type Sysinfo = c::sysinfo;
 /// [`membarrier`]: crate::process::membarrier
 /// [`membarrier_cpu`]: crate::process::membarrier_cpu
 /// [`membarrier_query`]: crate::process::membarrier_query
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 #[repr(u32)]
 pub enum MembarrierCommand {
@@ -46,48 +42,48 @@ pub enum MembarrierCommand {
 /// [`prlimit`]: crate::process::prlimit
 #[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[repr(i32)]
+#[repr(u32)]
 pub enum Resource {
     /// `RLIMIT_CPU`
-    Cpu = c::RLIMIT_CPU as c::c_int,
+    Cpu = bitcast!(c::RLIMIT_CPU),
     /// `RLIMIT_FSIZE`
-    Fsize = c::RLIMIT_FSIZE as c::c_int,
+    Fsize = bitcast!(c::RLIMIT_FSIZE),
     /// `RLIMIT_DATA`
-    Data = c::RLIMIT_DATA as c::c_int,
+    Data = bitcast!(c::RLIMIT_DATA),
     /// `RLIMIT_STACK`
-    Stack = c::RLIMIT_STACK as c::c_int,
+    Stack = bitcast!(c::RLIMIT_STACK),
     /// `RLIMIT_CORE`
     #[cfg(not(target_os = "haiku"))]
-    Core = c::RLIMIT_CORE as c::c_int,
+    Core = bitcast!(c::RLIMIT_CORE),
     /// `RLIMIT_RSS`
     #[cfg(not(any(apple, solarish, target_os = "haiku")))]
-    Rss = c::RLIMIT_RSS as c::c_int,
+    Rss = bitcast!(c::RLIMIT_RSS),
     /// `RLIMIT_NPROC`
     #[cfg(not(any(solarish, target_os = "haiku")))]
-    Nproc = c::RLIMIT_NPROC as c::c_int,
+    Nproc = bitcast!(c::RLIMIT_NPROC),
     /// `RLIMIT_NOFILE`
-    Nofile = c::RLIMIT_NOFILE as c::c_int,
+    Nofile = bitcast!(c::RLIMIT_NOFILE),
     /// `RLIMIT_MEMLOCK`
     #[cfg(not(any(solarish, target_os = "aix", target_os = "haiku")))]
-    Memlock = c::RLIMIT_MEMLOCK as c::c_int,
+    Memlock = bitcast!(c::RLIMIT_MEMLOCK),
     /// `RLIMIT_AS`
     #[cfg(not(target_os = "openbsd"))]
-    As = c::RLIMIT_AS as c::c_int,
+    As = bitcast!(c::RLIMIT_AS),
     /// `RLIMIT_LOCKS`
     #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))]
-    Locks = c::RLIMIT_LOCKS as c::c_int,
+    Locks = bitcast!(c::RLIMIT_LOCKS),
     /// `RLIMIT_SIGPENDING`
     #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))]
-    Sigpending = c::RLIMIT_SIGPENDING as c::c_int,
+    Sigpending = bitcast!(c::RLIMIT_SIGPENDING),
     /// `RLIMIT_MSGQUEUE`
     #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))]
-    Msgqueue = c::RLIMIT_MSGQUEUE as c::c_int,
+    Msgqueue = bitcast!(c::RLIMIT_MSGQUEUE),
     /// `RLIMIT_NICE`
     #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))]
-    Nice = c::RLIMIT_NICE as c::c_int,
+    Nice = bitcast!(c::RLIMIT_NICE),
     /// `RLIMIT_RTPRIO`
     #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))]
-    Rtprio = c::RLIMIT_RTPRIO as c::c_int,
+    Rtprio = bitcast!(c::RLIMIT_RTPRIO),
     /// `RLIMIT_RTTIME`
     #[cfg(not(any(
         bsd,
@@ -97,7 +93,7 @@ pub enum Resource {
         target_os = "emscripten",
         target_os = "haiku",
     )))]
-    Rttime = c::RLIMIT_RTTIME as c::c_int,
+    Rttime = bitcast!(c::RLIMIT_RTTIME),
 }
 
 #[cfg(apple)]
@@ -107,224 +103,21 @@ impl Resource {
     pub const Rss: Self = Self::As;
 }
 
-/// A signal number for use with [`kill_process`], [`kill_process_group`],
-/// and [`kill_current_process_group`].
-///
-/// [`kill_process`]: crate::process::kill_process
-/// [`kill_process_group`]: crate::process::kill_process_group
-/// [`kill_current_process_group`]: crate::process::kill_current_process_group
-#[cfg(not(target_os = "wasi"))]
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[repr(i32)]
-pub enum Signal {
-    /// `SIGHUP`
-    Hup = c::SIGHUP,
-    /// `SIGINT`
-    Int = c::SIGINT,
-    /// `SIGQUIT`
-    Quit = c::SIGQUIT,
-    /// `SIGILL`
-    Ill = c::SIGILL,
-    /// `SIGTRAP`
-    Trap = c::SIGTRAP,
-    /// `SIGABRT`, aka `SIGIOT`
-    #[doc(alias = "Iot")]
-    #[doc(alias = "Abrt")]
-    Abort = c::SIGABRT,
-    /// `SIGBUS`
-    Bus = c::SIGBUS,
-    /// `SIGFPE`
-    Fpe = c::SIGFPE,
-    /// `SIGKILL`
-    Kill = c::SIGKILL,
-    /// `SIGUSR1`
-    Usr1 = c::SIGUSR1,
-    /// `SIGSEGV`
-    Segv = c::SIGSEGV,
-    /// `SIGUSR2`
-    Usr2 = c::SIGUSR2,
-    /// `SIGPIPE`
-    Pipe = c::SIGPIPE,
-    /// `SIGALRM`
-    #[doc(alias = "Alrm")]
-    Alarm = c::SIGALRM,
-    /// `SIGTERM`
-    Term = c::SIGTERM,
-    /// `SIGSTKFLT`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "aix",
-        target_os = "haiku",
-        all(
-            any(target_os = "android", target_os = "linux"),
-            any(
-                target_arch = "mips",
-                target_arch = "mips64",
-                target_arch = "sparc",
-                target_arch = "sparc64"
-            ),
-        )
-    )))]
-    Stkflt = c::SIGSTKFLT,
-    /// `SIGCHLD`
-    #[doc(alias = "Chld")]
-    Child = c::SIGCHLD,
-    /// `SIGCONT`
-    Cont = c::SIGCONT,
-    /// `SIGSTOP`
-    Stop = c::SIGSTOP,
-    /// `SIGTSTP`
-    Tstp = c::SIGTSTP,
-    /// `SIGTTIN`
-    Ttin = c::SIGTTIN,
-    /// `SIGTTOU`
-    Ttou = c::SIGTTOU,
-    /// `SIGURG`
-    Urg = c::SIGURG,
-    /// `SIGXCPU`
-    Xcpu = c::SIGXCPU,
-    /// `SIGXFSZ`
-    Xfsz = c::SIGXFSZ,
-    /// `SIGVTALRM`
-    #[doc(alias = "Vtalrm")]
-    Vtalarm = c::SIGVTALRM,
-    /// `SIGPROF`
-    Prof = c::SIGPROF,
-    /// `SIGWINCH`
-    Winch = c::SIGWINCH,
-    /// `SIGIO`, aka `SIGPOLL`
-    #[doc(alias = "Poll")]
-    #[cfg(not(target_os = "haiku"))]
-    Io = c::SIGIO,
-    /// `SIGPWR`
-    #[cfg(not(any(bsd, target_os = "haiku")))]
-    #[doc(alias = "Pwr")]
-    Power = c::SIGPWR,
-    /// `SIGSYS`, aka `SIGUNUSED`
-    #[doc(alias = "Unused")]
-    Sys = c::SIGSYS,
-    /// `SIGEMT`
-    #[cfg(bsd)]
-    Emt = c::SIGEMT,
-    /// `SIGINFO`
-    #[cfg(bsd)]
-    Info = c::SIGINFO,
-    /// `SIGTHR`
-    #[cfg(target_os = "freebsd")]
-    #[doc(alias = "Lwp")]
-    Thr = c::SIGTHR,
-    /// `SIGLIBRT`
-    #[cfg(target_os = "freebsd")]
-    Librt = c::SIGLIBRT,
-}
-
-#[cfg(not(target_os = "wasi"))]
-impl Signal {
-    /// Convert a raw signal number into a `Signal`, if possible.
-    pub fn from_raw(sig: i32) -> Option<Self> {
-        match sig as _ {
-            c::SIGHUP => Some(Self::Hup),
-            c::SIGINT => Some(Self::Int),
-            c::SIGQUIT => Some(Self::Quit),
-            c::SIGILL => Some(Self::Ill),
-            c::SIGTRAP => Some(Self::Trap),
-            c::SIGABRT => Some(Self::Abort),
-            c::SIGBUS => Some(Self::Bus),
-            c::SIGFPE => Some(Self::Fpe),
-            c::SIGKILL => Some(Self::Kill),
-            c::SIGUSR1 => Some(Self::Usr1),
-            c::SIGSEGV => Some(Self::Segv),
-            c::SIGUSR2 => Some(Self::Usr2),
-            c::SIGPIPE => Some(Self::Pipe),
-            c::SIGALRM => Some(Self::Alarm),
-            c::SIGTERM => Some(Self::Term),
-            #[cfg(not(any(
-                bsd,
-                solarish,
-                target_os = "aix",
-                target_os = "haiku",
-                all(
-                    any(target_os = "android", target_os = "linux"),
-                    any(
-                        target_arch = "mips",
-                        target_arch = "mips64",
-                        target_arch = "sparc",
-                        target_arch = "sparc64"
-                    ),
-                )
-            )))]
-            c::SIGSTKFLT => Some(Self::Stkflt),
-            c::SIGCHLD => Some(Self::Child),
-            c::SIGCONT => Some(Self::Cont),
-            c::SIGSTOP => Some(Self::Stop),
-            c::SIGTSTP => Some(Self::Tstp),
-            c::SIGTTIN => Some(Self::Ttin),
-            c::SIGTTOU => Some(Self::Ttou),
-            c::SIGURG => Some(Self::Urg),
-            c::SIGXCPU => Some(Self::Xcpu),
-            c::SIGXFSZ => Some(Self::Xfsz),
-            c::SIGVTALRM => Some(Self::Vtalarm),
-            c::SIGPROF => Some(Self::Prof),
-            c::SIGWINCH => Some(Self::Winch),
-            #[cfg(not(target_os = "haiku"))]
-            c::SIGIO => Some(Self::Io),
-            #[cfg(not(any(bsd, target_os = "haiku")))]
-            c::SIGPWR => Some(Self::Power),
-            c::SIGSYS => Some(Self::Sys),
-            #[cfg(bsd)]
-            c::SIGEMT => Some(Self::Emt),
-            #[cfg(bsd)]
-            c::SIGINFO => Some(Self::Info),
-            #[cfg(target_os = "freebsd")]
-            c::SIGTHR => Some(Self::Thr),
-            #[cfg(target_os = "freebsd")]
-            c::SIGLIBRT => Some(Self::Librt),
-            _ => None,
-        }
-    }
-}
-
 pub const EXIT_SUCCESS: c::c_int = c::EXIT_SUCCESS;
 pub const EXIT_FAILURE: c::c_int = c::EXIT_FAILURE;
 #[cfg(not(target_os = "wasi"))]
 pub const EXIT_SIGNALED_SIGABRT: c::c_int = 128 + c::SIGABRT;
 
-/// A process identifier as a raw integer.
-#[cfg(not(target_os = "wasi"))]
-pub type RawPid = c::pid_t;
-/// A non-zero process identifier as a raw non-zero integer.
-#[cfg(not(target_os = "wasi"))]
-pub type RawNonZeroPid = core::num::NonZeroI32;
-/// A group identifier as a raw integer.
-#[cfg(not(target_os = "wasi"))]
-pub type RawGid = c::gid_t;
-/// A user identifier as a raw integer.
-#[cfg(not(target_os = "wasi"))]
-pub type RawUid = c::uid_t;
 /// A CPU identifier as a raw integer.
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub type RawCpuid = u32;
-#[cfg(target_os = "freebsd")]
+#[cfg(freebsdlike)]
 pub type RawId = c::id_t;
 
-#[cfg(not(target_os = "wasi"))]
-pub(crate) type RawUname = c::utsname;
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "dragonfly", target_os = "fuchsia"))]
 pub(crate) type RawCpuSet = c::cpu_set_t;
 
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
+#[cfg(any(linux_kernel, target_os = "dragonfly", target_os = "fuchsia"))]
 #[inline]
 pub(crate) fn raw_cpu_set_new() -> RawCpuSet {
     let mut set = unsafe { core::mem::zeroed() };
@@ -332,7 +125,7 @@ pub(crate) fn raw_cpu_set_new() -> RawCpuSet {
     set
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 pub(crate) const CPU_SETSIZE: usize = c::CPU_SETSIZE as usize;
 #[cfg(target_os = "dragonfly")]
 pub(crate) const CPU_SETSIZE: usize = 256;
diff --git a/vendor/rustix/src/backend/libc/process/wait.rs b/vendor/rustix/src/backend/libc/process/wait.rs
index c09ee1002..9a932cfab 100644
--- a/vendor/rustix/src/backend/libc/process/wait.rs
+++ b/vendor/rustix/src/backend/libc/process/wait.rs
@@ -1,4 +1,4 @@
-use super::super::c;
+use crate::backend::c;
 
 pub(crate) use c::{
     WCONTINUED, WEXITSTATUS, WIFCONTINUED, WIFEXITED, WIFSIGNALED, WIFSTOPPED, WNOHANG, WSTOPSIG,
diff --git a/vendor/rustix/src/backend/libc/pty/mod.rs b/vendor/rustix/src/backend/libc/pty/mod.rs
new file mode 100644
index 000000000..ef944f04d
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/pty/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/pty/syscalls.rs b/vendor/rustix/src/backend/libc/pty/syscalls.rs
new file mode 100644
index 000000000..178201ead
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/pty/syscalls.rs
@@ -0,0 +1,86 @@
+//! libc syscalls supporting `rustix::pty`.
+
+use crate::backend::c;
+use crate::backend::conv::{borrowed_fd, ret};
+use crate::fd::BorrowedFd;
+use crate::io;
+#[cfg(not(target_os = "android"))]
+use {crate::backend::conv::ret_owned_fd, crate::fd::OwnedFd, crate::pty::OpenptFlags};
+#[cfg(any(apple, linux_like, target_os = "freebsd", target_os = "fuchsia"))]
+use {
+    crate::ffi::{CStr, CString},
+    crate::path::SMALL_PATH_BUFFER_SIZE,
+    alloc::borrow::ToOwned,
+    alloc::vec::Vec,
+};
+
+#[cfg(not(linux_kernel))]
+#[inline]
+pub(crate) fn openpt(flags: OpenptFlags) -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(c::posix_openpt(flags.bits() as _)) }
+}
+
+#[cfg(any(apple, linux_like, target_os = "freebsd", target_os = "fuchsia"))]
+#[inline]
+pub(crate) fn ptsname(fd: BorrowedFd, mut buffer: Vec<u8>) -> io::Result<CString> {
+    // This code would benefit from having a better way to read into
+    // uninitialized memory, but that requires `unsafe`.
+    buffer.clear();
+    buffer.reserve(SMALL_PATH_BUFFER_SIZE);
+    buffer.resize(buffer.capacity(), 0_u8);
+
+    loop {
+        // On platforms with `ptsname_r`, use it.
+        #[cfg(any(target_os = "freebsd", linux_like, target_os = "fuchsia"))]
+        let r = unsafe { c::ptsname_r(borrowed_fd(fd), buffer.as_mut_ptr().cast(), buffer.len()) };
+
+        // MacOS 10.13.4 has `ptsname_r`; use it if we have it, otherwise fall
+        // back to calling the underlying ioctl directly.
+        #[cfg(apple)]
+        let r = unsafe {
+            weak! { fn ptsname_r(c::c_int, *mut c::c_char, c::size_t) -> c::c_int }
+
+            if let Some(libc_ptsname_r) = ptsname_r.get() {
+                libc_ptsname_r(borrowed_fd(fd), buffer.as_mut_ptr().cast(), buffer.len())
+            } else {
+                // The size declared in the `TIOCPTYGNAME` macro in sys/ttycom.h is 128.
+                let mut name: [u8; 128] = [0_u8; 128];
+                match c::ioctl(borrowed_fd(fd), c::TIOCPTYGNAME as u64, &mut name) {
+                    0 => {
+                        let len = CStr::from_ptr(name.as_ptr().cast()).to_bytes().len();
+                        std::ptr::copy_nonoverlapping(name.as_ptr(), buffer.as_mut_ptr(), len + 1);
+                        0
+                    }
+                    _ => libc_errno::errno().0,
+                }
+            }
+        };
+
+        if r == 0 {
+            return Ok(unsafe { CStr::from_ptr(buffer.as_ptr().cast()).to_owned() });
+        }
+        if r != c::ERANGE {
+            return Err(io::Errno::from_raw_os_error(r));
+        }
+
+        buffer.reserve(1); // use `Vec` reallocation strategy to grow capacity exponentially
+        buffer.resize(buffer.capacity(), 0_u8);
+    }
+}
+
+#[inline]
+pub(crate) fn unlockpt(fd: BorrowedFd) -> io::Result<()> {
+    unsafe { ret(c::unlockpt(borrowed_fd(fd))) }
+}
+
+#[cfg(not(linux_kernel))]
+#[inline]
+pub(crate) fn grantpt(fd: BorrowedFd) -> io::Result<()> {
+    unsafe { ret(c::grantpt(borrowed_fd(fd))) }
+}
+
+#[cfg(target_os = "linux")]
+#[inline]
+pub(crate) fn ioctl_tiocgptpeer(fd: BorrowedFd, flags: OpenptFlags) -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(c::ioctl(borrowed_fd(fd), c::TIOCGPTPEER, flags.bits())) }
+}
diff --git a/vendor/rustix/src/backend/libc/rand/syscalls.rs b/vendor/rustix/src/backend/libc/rand/syscalls.rs
index 2dcff139e..8a995f2e6 100644
--- a/vendor/rustix/src/backend/libc/rand/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/rand/syscalls.rs
@@ -1,9 +1,9 @@
 //! libc syscalls supporting `rustix::rand`.
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use {super::super::c, super::super::conv::ret_usize, crate::io, crate::rand::GetRandomFlags};
+#[cfg(linux_kernel)]
+use {crate::backend::c, crate::backend::conv::ret_usize, crate::io, crate::rand::GetRandomFlags};
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 pub(crate) fn getrandom(buf: &mut [u8], flags: GetRandomFlags) -> io::Result<usize> {
     // `getrandom` wasn't supported in glibc until 2.25.
     weak_or_syscall! {
diff --git a/vendor/rustix/src/backend/libc/rand/types.rs b/vendor/rustix/src/backend/libc/rand/types.rs
index e12bd9cbd..730cf3a34 100644
--- a/vendor/rustix/src/backend/libc/rand/types.rs
+++ b/vendor/rustix/src/backend/libc/rand/types.rs
@@ -1,13 +1,15 @@
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::c;
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
+use crate::backend::c;
+#[cfg(linux_kernel)]
 use bitflags::bitflags;
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 bitflags! {
     /// `GRND_*` flags for use with [`getrandom`].
     ///
     /// [`getrandom`]: crate::rand::getrandom
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct GetRandomFlags: u32 {
         /// `GRND_RANDOM`
         const RANDOM = c::GRND_RANDOM;
diff --git a/vendor/rustix/src/backend/libc/system/mod.rs b/vendor/rustix/src/backend/libc/system/mod.rs
new file mode 100644
index 000000000..bff7fd564
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/system/mod.rs
@@ -0,0 +1,3 @@
+#[cfg(not(windows))]
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/libc/system/syscalls.rs b/vendor/rustix/src/backend/libc/system/syscalls.rs
new file mode 100644
index 000000000..a731e9302
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/system/syscalls.rs
@@ -0,0 +1,40 @@
+//! libc syscalls supporting `rustix::process`.
+
+use super::types::RawUname;
+use crate::backend::c;
+#[cfg(not(target_os = "wasi"))]
+use crate::backend::conv::ret_infallible;
+#[cfg(linux_kernel)]
+use crate::system::Sysinfo;
+use core::mem::MaybeUninit;
+#[cfg(not(any(target_os = "emscripten", target_os = "redox", target_os = "wasi")))]
+use {crate::backend::conv::ret, crate::io};
+
+#[cfg(not(target_os = "wasi"))]
+#[inline]
+pub(crate) fn uname() -> RawUname {
+    let mut uname = MaybeUninit::<RawUname>::uninit();
+    unsafe {
+        ret_infallible(c::uname(uname.as_mut_ptr()));
+        uname.assume_init()
+    }
+}
+
+#[cfg(linux_kernel)]
+pub(crate) fn sysinfo() -> Sysinfo {
+    let mut info = MaybeUninit::<Sysinfo>::uninit();
+    unsafe {
+        ret_infallible(c::sysinfo(info.as_mut_ptr()));
+        info.assume_init()
+    }
+}
+
+#[cfg(not(any(target_os = "emscripten", target_os = "redox", target_os = "wasi")))]
+pub(crate) fn sethostname(name: &[u8]) -> io::Result<()> {
+    unsafe {
+        ret(c::sethostname(
+            name.as_ptr().cast(),
+            name.len().try_into().map_err(|_| io::Errno::INVAL)?,
+        ))
+    }
+}
diff --git a/vendor/rustix/src/backend/libc/system/types.rs b/vendor/rustix/src/backend/libc/system/types.rs
new file mode 100644
index 000000000..731e89bed
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/system/types.rs
@@ -0,0 +1,8 @@
+use crate::backend::c;
+
+/// `sysinfo`
+#[cfg(linux_kernel)]
+pub type Sysinfo = c::sysinfo;
+
+#[cfg(not(target_os = "wasi"))]
+pub(crate) type RawUname = c::utsname;
diff --git a/vendor/rustix/src/backend/libc/termios/mod.rs b/vendor/rustix/src/backend/libc/termios/mod.rs
index c82c95958..ef944f04d 100644
--- a/vendor/rustix/src/backend/libc/termios/mod.rs
+++ b/vendor/rustix/src/backend/libc/termios/mod.rs
@@ -1,3 +1 @@
 pub(crate) mod syscalls;
-#[cfg(not(target_os = "wasi"))]
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/libc/termios/syscalls.rs b/vendor/rustix/src/backend/libc/termios/syscalls.rs
index dba73c960..d4182f4fe 100644
--- a/vendor/rustix/src/backend/libc/termios/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/termios/syscalls.rs
@@ -4,46 +4,62 @@
 //!
 //! See the `rustix::backend::syscalls` module documentation for details.
 
-use super::super::c;
-use super::super::conv::{borrowed_fd, ret, ret_pid_t};
+use crate::backend::c;
+use crate::backend::conv::{borrowed_fd, ret, ret_pid_t};
 use crate::fd::BorrowedFd;
 #[cfg(feature = "procfs")]
 #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
 use crate::ffi::CStr;
-#[cfg(not(target_os = "wasi"))]
-use crate::io;
-#[cfg(not(target_os = "wasi"))]
-use crate::process::{Pid, RawNonZeroPid};
-#[cfg(not(target_os = "wasi"))]
-use crate::termios::{Action, OptionalActions, QueueSelector, Speed, Termios, Winsize};
 use core::mem::MaybeUninit;
+#[cfg(not(target_os = "wasi"))]
+use {
+    crate::io,
+    crate::pid::Pid,
+    crate::termios::{Action, OptionalActions, QueueSelector, Termios, Winsize},
+    crate::utils::as_mut_ptr,
+};
 
 #[cfg(not(target_os = "wasi"))]
 pub(crate) fn tcgetattr(fd: BorrowedFd<'_>) -> io::Result<Termios> {
-    let mut result = MaybeUninit::<Termios>::uninit();
+    // If we have `TCGETS2`, use it, so that we fill in the `c_ispeed` and
+    // `c_ospeed` fields.
+    #[cfg(linux_kernel)]
     unsafe {
-        ret(c::tcgetattr(borrowed_fd(fd), result.as_mut_ptr()))?;
-        Ok(result.assume_init())
+        use crate::termios::{ControlModes, InputModes, LocalModes, OutputModes, SpecialCodes};
+        use core::mem::zeroed;
+
+        let mut termios2 = MaybeUninit::<c::termios2>::uninit();
+
+        ret(c::ioctl(
+            borrowed_fd(fd),
+            c::TCGETS2.into(),
+            termios2.as_mut_ptr(),
+        ))?;
+
+        let termios2 = termios2.assume_init();
+
+        // Convert from the Linux `termios2` to our `Termios`.
+        let mut result = Termios {
+            input_modes: InputModes::from_bits_retain(termios2.c_iflag),
+            output_modes: OutputModes::from_bits_retain(termios2.c_oflag),
+            control_modes: ControlModes::from_bits_retain(termios2.c_cflag),
+            local_modes: LocalModes::from_bits_retain(termios2.c_lflag),
+            line_discipline: termios2.c_line,
+            special_codes: SpecialCodes(zeroed()),
+            input_speed: termios2.c_ispeed,
+            output_speed: termios2.c_ospeed,
+        };
+        result.special_codes.0[..termios2.c_cc.len()].copy_from_slice(&termios2.c_cc);
+
+        Ok(result)
     }
-}
 
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    any(
-        target_arch = "x86",
-        target_arch = "x86_64",
-        target_arch = "x32",
-        target_arch = "riscv64",
-        target_arch = "aarch64",
-        target_arch = "arm",
-        target_arch = "mips",
-        target_arch = "mips64",
-    )
-))]
-pub(crate) fn tcgetattr2(fd: BorrowedFd<'_>) -> io::Result<crate::termios::Termios2> {
-    let mut result = MaybeUninit::<crate::termios::Termios2>::uninit();
+    #[cfg(not(linux_kernel))]
     unsafe {
-        ret(c::ioctl(borrowed_fd(fd), c::TCGETS2, result.as_mut_ptr()))?;
+        let mut result = MaybeUninit::<Termios>::uninit();
+
+        ret(c::tcgetattr(borrowed_fd(fd), result.as_mut_ptr().cast()))?;
+
         Ok(result.assume_init())
     }
 }
@@ -52,8 +68,7 @@ pub(crate) fn tcgetattr2(fd: BorrowedFd<'_>) -> io::Result<crate::termios::Termi
 pub(crate) fn tcgetpgrp(fd: BorrowedFd<'_>) -> io::Result<Pid> {
     unsafe {
         let pid = ret_pid_t(c::tcgetpgrp(borrowed_fd(fd)))?;
-        debug_assert_ne!(pid, 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid)))
+        Ok(Pid::from_raw_unchecked(pid))
     }
 }
 
@@ -68,38 +83,65 @@ pub(crate) fn tcsetattr(
     optional_actions: OptionalActions,
     termios: &Termios,
 ) -> io::Result<()> {
+    // If we have `TCSETS2`, use it, so that we use the `c_ispeed` and
+    // `c_ospeed` fields.
+    #[cfg(linux_kernel)]
     unsafe {
-        ret(c::tcsetattr(
-            borrowed_fd(fd),
-            optional_actions as _,
-            termios,
-        ))
+        use crate::termios::speed;
+        use core::mem::zeroed;
+        use linux_raw_sys::general::{termios2, BOTHER, CBAUD, IBSHIFT};
+
+        #[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))]
+        use linux_raw_sys::ioctl::{TCSETS, TCSETS2};
+
+        // linux-raw-sys' ioctl-generation script for sparc isn't working yet,
+        // so as a temporary workaround, declare these manually.
+        #[cfg(any(target_arch = "sparc", target_arch = "sparc64"))]
+        const TCSETS: u32 = 0x80245409;
+        #[cfg(any(target_arch = "sparc", target_arch = "sparc64"))]
+        const TCSETS2: u32 = 0x802c540d;
+
+        // Translate from `optional_actions` into an ioctl request code. On MIPS,
+        // `optional_actions` already has `TCGETS` added to it.
+        let request = TCSETS2
+            + if cfg!(any(target_arch = "mips", target_arch = "mips64")) {
+                optional_actions as u32 - TCSETS
+            } else {
+                optional_actions as u32
+            };
+
+        let input_speed = termios.input_speed();
+        let output_speed = termios.output_speed();
+        let mut termios2 = termios2 {
+            c_iflag: termios.input_modes.bits(),
+            c_oflag: termios.output_modes.bits(),
+            c_cflag: termios.control_modes.bits(),
+            c_lflag: termios.local_modes.bits(),
+            c_line: termios.line_discipline,
+            c_cc: zeroed(),
+            c_ispeed: input_speed,
+            c_ospeed: output_speed,
+        };
+        // Ensure that our input and output speeds are set, as `libc`
+        // routines don't always support setting these separately.
+        termios2.c_cflag &= !CBAUD;
+        termios2.c_cflag |= speed::encode(output_speed).unwrap_or(BOTHER);
+        termios2.c_cflag &= !(CBAUD << IBSHIFT);
+        termios2.c_cflag |= speed::encode(input_speed).unwrap_or(BOTHER) << IBSHIFT;
+        let nccs = termios2.c_cc.len();
+        termios2
+            .c_cc
+            .copy_from_slice(&termios.special_codes.0[..nccs]);
+
+        ret(c::ioctl(borrowed_fd(fd), request as _, &termios2))
     }
-}
 
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    any(
-        target_arch = "x86",
-        target_arch = "x86_64",
-        target_arch = "x32",
-        target_arch = "riscv64",
-        target_arch = "aarch64",
-        target_arch = "arm",
-        target_arch = "mips",
-        target_arch = "mips64",
-    )
-))]
-pub(crate) fn tcsetattr2(
-    fd: BorrowedFd,
-    optional_actions: OptionalActions,
-    termios: &crate::termios::Termios2,
-) -> io::Result<()> {
+    #[cfg(not(linux_kernel))]
     unsafe {
-        ret(c::ioctl(
+        ret(c::tcsetattr(
             borrowed_fd(fd),
-            (c::TCSETS2 as u32 + optional_actions as u32) as _,
-            termios,
+            optional_actions as _,
+            crate::utils::as_ptr(termios).cast(),
         ))
     }
 }
@@ -128,8 +170,7 @@ pub(crate) fn tcflow(fd: BorrowedFd, action: Action) -> io::Result<()> {
 pub(crate) fn tcgetsid(fd: BorrowedFd) -> io::Result<Pid> {
     unsafe {
         let pid = ret_pid_t(c::tcgetsid(borrowed_fd(fd)))?;
-        debug_assert_ne!(pid, 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid)))
+        Ok(Pid::from_raw_unchecked(pid))
     }
 }
 
@@ -151,42 +192,142 @@ pub(crate) fn tcgetwinsize(fd: BorrowedFd) -> io::Result<Winsize> {
     }
 }
 
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn cfgetospeed(termios: &Termios) -> Speed {
-    unsafe { c::cfgetospeed(termios) }
+#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
+pub(crate) fn ioctl_tiocexcl(fd: BorrowedFd) -> io::Result<()> {
+    unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCEXCL as _)) }
 }
 
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn cfgetispeed(termios: &Termios) -> Speed {
-    unsafe { c::cfgetispeed(termios) }
+#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
+pub(crate) fn ioctl_tiocnxcl(fd: BorrowedFd) -> io::Result<()> {
+    unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCNXCL as _)) }
 }
 
 #[cfg(not(target_os = "wasi"))]
 #[inline]
-pub(crate) fn cfmakeraw(termios: &mut Termios) {
-    unsafe { c::cfmakeraw(termios) }
+pub(crate) fn set_speed(termios: &mut Termios, arbitrary_speed: u32) -> io::Result<()> {
+    #[cfg(bsd)]
+    let encoded_speed = arbitrary_speed;
+
+    #[cfg(not(bsd))]
+    let encoded_speed = match crate::termios::speed::encode(arbitrary_speed) {
+        Some(encoded_speed) => encoded_speed,
+        #[cfg(linux_kernel)]
+        None => c::BOTHER,
+        #[cfg(not(linux_kernel))]
+        None => return Err(io::Errno::INVAL),
+    };
+
+    #[cfg(not(linux_kernel))]
+    unsafe {
+        ret(c::cfsetspeed(
+            as_mut_ptr(termios).cast(),
+            encoded_speed.into(),
+        ))
+    }
+
+    // Linux libc implementations don't support arbitrary speeds, so we encode
+    // the speed manually.
+    #[cfg(linux_kernel)]
+    {
+        use crate::termios::ControlModes;
+
+        debug_assert_eq!(encoded_speed & !c::CBAUD, 0);
+
+        termios.control_modes -= ControlModes::from_bits_retain(c::CBAUD | c::CIBAUD);
+        termios.control_modes |=
+            ControlModes::from_bits_retain(encoded_speed | (encoded_speed << c::IBSHIFT));
+
+        termios.input_speed = arbitrary_speed;
+        termios.output_speed = arbitrary_speed;
+
+        Ok(())
+    }
 }
 
 #[cfg(not(target_os = "wasi"))]
 #[inline]
-pub(crate) fn cfsetospeed(termios: &mut Termios, speed: Speed) -> io::Result<()> {
-    unsafe { ret(c::cfsetospeed(termios, speed)) }
+pub(crate) fn set_output_speed(termios: &mut Termios, arbitrary_speed: u32) -> io::Result<()> {
+    #[cfg(bsd)]
+    let encoded_speed = arbitrary_speed;
+
+    #[cfg(not(bsd))]
+    let encoded_speed = match crate::termios::speed::encode(arbitrary_speed) {
+        Some(encoded_speed) => encoded_speed,
+        #[cfg(linux_kernel)]
+        None => c::BOTHER,
+        #[cfg(not(linux_kernel))]
+        None => return Err(io::Errno::INVAL),
+    };
+
+    #[cfg(not(linux_kernel))]
+    unsafe {
+        ret(c::cfsetospeed(
+            as_mut_ptr(termios).cast(),
+            encoded_speed.into(),
+        ))
+    }
+
+    // Linux libc implementations don't support arbitrary speeds or setting the
+    // input and output speeds separately, so we encode the speed manually.
+    #[cfg(linux_kernel)]
+    {
+        use crate::termios::ControlModes;
+
+        debug_assert_eq!(encoded_speed & !c::CBAUD, 0);
+
+        termios.control_modes -= ControlModes::from_bits_retain(c::CBAUD);
+        termios.control_modes |= ControlModes::from_bits_retain(encoded_speed);
+
+        termios.output_speed = arbitrary_speed;
+
+        Ok(())
+    }
 }
 
 #[cfg(not(target_os = "wasi"))]
 #[inline]
-pub(crate) fn cfsetispeed(termios: &mut Termios, speed: Speed) -> io::Result<()> {
-    unsafe { ret(c::cfsetispeed(termios, speed)) }
+pub(crate) fn set_input_speed(termios: &mut Termios, arbitrary_speed: u32) -> io::Result<()> {
+    #[cfg(bsd)]
+    let encoded_speed = arbitrary_speed;
+
+    #[cfg(not(bsd))]
+    let encoded_speed = match crate::termios::speed::encode(arbitrary_speed) {
+        Some(encoded_speed) => encoded_speed,
+        #[cfg(linux_kernel)]
+        None => c::BOTHER,
+        #[cfg(not(linux_kernel))]
+        None => return Err(io::Errno::INVAL),
+    };
+
+    #[cfg(not(linux_kernel))]
+    unsafe {
+        ret(c::cfsetispeed(
+            as_mut_ptr(termios).cast(),
+            encoded_speed.into(),
+        ))
+    }
+
+    // Linux libc implementations don't support arbitrary speeds or setting the
+    // input and output speeds separately, so we encode the speed manually.
+    #[cfg(linux_kernel)]
+    {
+        use crate::termios::ControlModes;
+
+        debug_assert_eq!(encoded_speed & !c::CBAUD, 0);
+
+        termios.control_modes -= ControlModes::from_bits_retain(c::CIBAUD);
+        termios.control_modes |= ControlModes::from_bits_retain(encoded_speed << c::IBSHIFT);
+
+        termios.input_speed = arbitrary_speed;
+
+        Ok(())
+    }
 }
 
 #[cfg(not(target_os = "wasi"))]
 #[inline]
-pub(crate) fn cfsetspeed(termios: &mut Termios, speed: Speed) -> io::Result<()> {
-    unsafe { ret(c::cfsetspeed(termios, speed)) }
+pub(crate) fn cfmakeraw(termios: &mut Termios) {
+    unsafe { c::cfmakeraw(as_mut_ptr(termios).cast()) }
 }
 
 pub(crate) fn isatty(fd: BorrowedFd<'_>) -> bool {
@@ -200,7 +341,7 @@ pub(crate) fn isatty(fd: BorrowedFd<'_>) -> bool {
 
 #[cfg(feature = "procfs")]
 #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
-pub(crate) fn ttyname(dirfd: BorrowedFd<'_>, buf: &mut [u8]) -> io::Result<usize> {
+pub(crate) fn ttyname(dirfd: BorrowedFd<'_>, buf: &mut [MaybeUninit<u8>]) -> io::Result<usize> {
     unsafe {
         // `ttyname_r` returns its error status rather than using `errno`.
         match c::ttyname_r(borrowed_fd(dirfd), buf.as_mut_ptr().cast(), buf.len()) {
diff --git a/vendor/rustix/src/backend/libc/termios/types.rs b/vendor/rustix/src/backend/libc/termios/types.rs
deleted file mode 100644
index fdb7fc644..000000000
--- a/vendor/rustix/src/backend/libc/termios/types.rs
+++ /dev/null
@@ -1,736 +0,0 @@
-use super::super::c;
-
-/// `TCSA*` values for use with [`tcsetattr`].
-///
-/// [`tcsetattr`]: crate::termios::tcsetattr
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum OptionalActions {
-    /// `TCSANOW`—Make the change immediately.
-    #[doc(alias = "TCSANOW")]
-    Now = c::TCSANOW,
-
-    /// `TCSADRAIN`—Make the change after all output has been transmitted.
-    #[doc(alias = "TCSADRAIN")]
-    Drain = c::TCSADRAIN,
-
-    /// `TCSAFLUSH`—Discard any pending input and then make the change
-    /// after all output has been transmitted.
-    #[doc(alias = "TCSAFLUSH")]
-    Flush = c::TCSAFLUSH,
-}
-
-/// `TC*` values for use with [`tcflush`].
-///
-/// [`tcflush`]: crate::termios::tcflush
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum QueueSelector {
-    /// `TCIFLUSH`—Flush data received but not read.
-    #[doc(alias = "TCIFLUSH")]
-    IFlush = c::TCIFLUSH,
-
-    /// `TCOFLUSH`—Flush data written but not transmitted.
-    #[doc(alias = "TCOFLUSH")]
-    OFlush = c::TCOFLUSH,
-
-    /// `TCIOFLUSH`—`IFlush` and `OFlush` combined.
-    #[doc(alias = "TCIOFLUSH")]
-    IOFlush = c::TCIOFLUSH,
-}
-
-/// `TC*` values for use with [`tcflow`].
-///
-/// [`tcflow`]: crate::termios::tcflow
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum Action {
-    /// `TCOOFF`—Suspend output.
-    #[doc(alias = "TCOOFF")]
-    OOff = c::TCOOFF,
-
-    /// `TCOON`—Restart suspended output.
-    #[doc(alias = "TCOON")]
-    OOn = c::TCOON,
-
-    /// `TCIOFF`—Transmits a STOP byte.
-    #[doc(alias = "TCIOFF")]
-    IOff = c::TCIOFF,
-
-    /// `TCION`—Transmits a START byte.
-    #[doc(alias = "TCION")]
-    IOn = c::TCION,
-}
-
-/// `struct termios` for use with [`tcgetattr`] and [`tcsetattr`].
-///
-/// [`tcgetattr`]: crate::termios::tcgetattr
-/// [`tcsetattr`]: crate::termios::tcsetattr
-#[doc(alias = "termios")]
-pub type Termios = c::termios;
-
-/// `struct termios2` for use with [`tcgetattr2`] and [`tcsetattr2`].
-///
-/// [`tcgetattr2`]: crate::termios::tcgetattr2
-/// [`tcsetattr2`]: crate::termios::tcsetattr2
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    any(
-        target_arch = "x86",
-        target_arch = "x86_64",
-        target_arch = "x32",
-        target_arch = "riscv64",
-        target_arch = "aarch64",
-        target_arch = "arm",
-        target_arch = "mips",
-        target_arch = "mips64",
-    )
-))]
-#[doc(alias = "termios2")]
-pub type Termios2 = c::termios2;
-
-/// `struct winsize` for use with [`tcgetwinsize`].
-///
-/// [`tcgetwinsize`]: crate::termios::tcgetwinsize
-#[doc(alias = "winsize")]
-pub type Winsize = c::winsize;
-
-/// `tcflag_t`—A type for the flags fields of [`Termios`].
-#[doc(alias = "tcflag_t")]
-pub type Tcflag = c::tcflag_t;
-
-/// `speed_t`—A return type for [`cfsetspeed`] and similar.
-///
-/// [`cfsetspeed`]: crate::termios::cfsetspeed
-#[doc(alias = "speed_t")]
-pub type Speed = c::speed_t;
-
-/// `VINTR`
-pub const VINTR: usize = c::VINTR as usize;
-
-/// `VQUIT`
-pub const VQUIT: usize = c::VQUIT as usize;
-
-/// `VERASE`
-pub const VERASE: usize = c::VERASE as usize;
-
-/// `VKILL`
-pub const VKILL: usize = c::VKILL as usize;
-
-/// `VEOF`
-pub const VEOF: usize = c::VEOF as usize;
-
-/// `VTIME`
-pub const VTIME: usize = c::VTIME as usize;
-
-/// `VMIN`
-pub const VMIN: usize = c::VMIN as usize;
-
-/// `VSWTC`
-#[cfg(not(any(
-    apple,
-    solarish,
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "openbsd",
-)))]
-pub const VSWTC: usize = c::VSWTC as usize;
-
-/// `VSTART`
-pub const VSTART: usize = c::VSTART as usize;
-
-/// `VSTOP`
-pub const VSTOP: usize = c::VSTOP as usize;
-
-/// `VSUSP`
-pub const VSUSP: usize = c::VSUSP as usize;
-
-/// `VEOL`
-pub const VEOL: usize = c::VEOL as usize;
-
-/// `VREPRINT`
-#[cfg(not(target_os = "haiku"))]
-pub const VREPRINT: usize = c::VREPRINT as usize;
-
-/// `VDISCARD`
-#[cfg(not(any(target_os = "aix", target_os = "haiku")))]
-pub const VDISCARD: usize = c::VDISCARD as usize;
-
-/// `VWERASE`
-#[cfg(not(any(target_os = "aix", target_os = "haiku")))]
-pub const VWERASE: usize = c::VWERASE as usize;
-
-/// `VLNEXT`
-#[cfg(not(target_os = "haiku"))]
-pub const VLNEXT: usize = c::VLNEXT as usize;
-
-/// `VEOL2`
-pub const VEOL2: usize = c::VEOL2 as usize;
-
-/// `IGNBRK`
-pub const IGNBRK: Tcflag = c::IGNBRK;
-
-/// `BRKINT`
-pub const BRKINT: Tcflag = c::BRKINT;
-
-/// `IGNPAR`
-pub const IGNPAR: Tcflag = c::IGNPAR;
-
-/// `PARMRK`
-pub const PARMRK: Tcflag = c::PARMRK;
-
-/// `INPCK`
-pub const INPCK: Tcflag = c::INPCK;
-
-/// `ISTRIP`
-pub const ISTRIP: Tcflag = c::ISTRIP;
-
-/// `INLCR`
-pub const INLCR: Tcflag = c::INLCR;
-
-/// `IGNCR`
-pub const IGNCR: Tcflag = c::IGNCR;
-
-/// `ICRNL`
-pub const ICRNL: Tcflag = c::ICRNL;
-
-/// `IUCLC`
-#[cfg(any(solarish, target_os = "haiku"))]
-pub const IUCLC: Tcflag = c::IUCLC;
-
-/// `IXON`
-pub const IXON: Tcflag = c::IXON;
-
-/// `IXANY`
-#[cfg(not(target_os = "redox"))]
-pub const IXANY: Tcflag = c::IXANY;
-
-/// `IXOFF`
-pub const IXOFF: Tcflag = c::IXOFF;
-
-/// `IMAXBEL`
-#[cfg(not(any(target_os = "haiku", target_os = "redox")))]
-pub const IMAXBEL: Tcflag = c::IMAXBEL;
-
-/// `IUTF8`
-#[cfg(not(any(
-    solarish,
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-)))]
-pub const IUTF8: Tcflag = c::IUTF8;
-
-/// `OPOST`
-pub const OPOST: Tcflag = c::OPOST;
-
-/// `OLCUC`
-#[cfg(not(any(
-    apple,
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "redox",
-)))]
-pub const OLCUC: Tcflag = c::OLCUC;
-
-/// `ONLCR`
-pub const ONLCR: Tcflag = c::ONLCR;
-
-/// `OCRNL`
-pub const OCRNL: Tcflag = c::OCRNL;
-
-/// `ONOCR`
-pub const ONOCR: Tcflag = c::ONOCR;
-
-/// `ONLRET`
-pub const ONLRET: Tcflag = c::ONLRET;
-
-/// `OFILL`
-#[cfg(not(bsd))]
-pub const OFILL: Tcflag = c::OFILL;
-
-/// `OFDEL`
-#[cfg(not(bsd))]
-pub const OFDEL: Tcflag = c::OFDEL;
-
-/// `NLDLY`
-#[cfg(not(any(bsd, solarish, target_os = "redox")))]
-pub const NLDLY: Tcflag = c::NLDLY;
-
-/// `NL0`
-#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))]
-pub const NL0: Tcflag = c::NL0;
-
-/// `NL1`
-#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))]
-pub const NL1: Tcflag = c::NL1;
-
-/// `CRDLY`
-#[cfg(not(any(bsd, solarish, target_os = "redox")))]
-pub const CRDLY: Tcflag = c::CRDLY;
-
-/// `CR0`
-#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))]
-pub const CR0: Tcflag = c::CR0;
-
-/// `CR1`
-#[cfg(not(any(
-    target_env = "musl",
-    bsd,
-    solarish,
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const CR1: Tcflag = c::CR1;
-
-/// `CR2`
-#[cfg(not(any(
-    target_env = "musl",
-    bsd,
-    solarish,
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const CR2: Tcflag = c::CR2;
-
-/// `CR3`
-#[cfg(not(any(
-    target_env = "musl",
-    bsd,
-    solarish,
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const CR3: Tcflag = c::CR3;
-
-/// `TABDLY`
-#[cfg(not(any(netbsdlike, solarish, target_os = "dragonfly", target_os = "redox",)))]
-pub const TABDLY: Tcflag = c::TABDLY;
-
-/// `TAB0`
-#[cfg(not(any(
-    netbsdlike,
-    solarish,
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const TAB0: Tcflag = c::TAB0;
-
-/// `TAB1`
-#[cfg(not(any(
-    target_env = "musl",
-    bsd,
-    solarish,
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const TAB1: Tcflag = c::TAB1;
-
-/// `TAB2`
-#[cfg(not(any(
-    target_env = "musl",
-    bsd,
-    solarish,
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const TAB2: Tcflag = c::TAB2;
-
-/// `TAB3`
-#[cfg(not(any(
-    target_env = "musl",
-    bsd,
-    solarish,
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const TAB3: Tcflag = c::TAB3;
-
-/// `BSDLY`
-#[cfg(not(any(bsd, solarish, target_os = "redox")))]
-pub const BSDLY: Tcflag = c::BSDLY;
-
-/// `BS0`
-#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))]
-pub const BS0: Tcflag = c::BS0;
-
-/// `BS1`
-#[cfg(not(any(
-    target_env = "musl",
-    bsd,
-    solarish,
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const BS1: Tcflag = c::BS1;
-
-/// `FFDLY`
-#[cfg(not(any(target_env = "musl", bsd, solarish, target_os = "redox")))]
-pub const FFDLY: Tcflag = c::FFDLY;
-
-/// `FF0`
-#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))]
-pub const FF0: Tcflag = c::FF0;
-
-/// `FF1`
-#[cfg(not(any(
-    target_env = "musl",
-    bsd,
-    solarish,
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const FF1: Tcflag = c::FF1;
-
-/// `VTDLY`
-#[cfg(not(any(target_env = "musl", bsd, solarish, target_os = "redox")))]
-pub const VTDLY: Tcflag = c::VTDLY;
-
-/// `VT0`
-#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))]
-pub const VT0: Tcflag = c::VT0;
-
-/// `VT1`
-#[cfg(not(any(
-    target_env = "musl",
-    bsd,
-    solarish,
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "redox",
-)))]
-pub const VT1: Tcflag = c::VT1;
-
-/// `B0`
-pub const B0: Speed = c::B0;
-
-/// `B50`
-pub const B50: Speed = c::B50;
-
-/// `B75`
-pub const B75: Speed = c::B75;
-
-/// `B110`
-pub const B110: Speed = c::B110;
-
-/// `B134`
-pub const B134: Speed = c::B134;
-
-/// `B150`
-pub const B150: Speed = c::B150;
-
-/// `B200`
-pub const B200: Speed = c::B200;
-
-/// `B300`
-pub const B300: Speed = c::B300;
-
-/// `B600`
-pub const B600: Speed = c::B600;
-
-/// `B1200`
-pub const B1200: Speed = c::B1200;
-
-/// `B1800`
-pub const B1800: Speed = c::B1800;
-
-/// `B2400`
-pub const B2400: Speed = c::B2400;
-
-/// `B4800`
-pub const B4800: Speed = c::B4800;
-
-/// `B9600`
-pub const B9600: Speed = c::B9600;
-
-/// `B19200`
-pub const B19200: Speed = c::B19200;
-
-/// `B38400`
-pub const B38400: Speed = c::B38400;
-
-/// `B57600`
-#[cfg(not(target_os = "aix"))]
-pub const B57600: Speed = c::B57600;
-
-/// `B115200`
-#[cfg(not(target_os = "aix"))]
-pub const B115200: Speed = c::B115200;
-
-/// `B230400`
-#[cfg(not(target_os = "aix"))]
-pub const B230400: Speed = c::B230400;
-
-/// `B460800`
-#[cfg(not(any(
-    apple,
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "openbsd"
-)))]
-pub const B460800: Speed = c::B460800;
-
-/// `B500000`
-#[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))]
-pub const B500000: Speed = c::B500000;
-
-/// `B576000`
-#[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))]
-pub const B576000: Speed = c::B576000;
-
-/// `B921600`
-#[cfg(not(any(
-    apple,
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "openbsd"
-)))]
-pub const B921600: Speed = c::B921600;
-
-/// `B1000000`
-#[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "solaris")))]
-pub const B1000000: Speed = c::B1000000;
-
-/// `B1152000`
-#[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "solaris")))]
-pub const B1152000: Speed = c::B1152000;
-
-/// `B1500000`
-#[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "solaris")))]
-pub const B1500000: Speed = c::B1500000;
-
-/// `B2000000`
-#[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "solaris")))]
-pub const B2000000: Speed = c::B2000000;
-
-/// `B2500000`
-#[cfg(not(any(
-    target_arch = "sparc",
-    target_arch = "sparc64",
-    bsd,
-    target_os = "aix",
-    target_os = "haiku",
-    target_os = "solaris",
-)))]
-pub const B2500000: Speed = c::B2500000;
-
-/// `B3000000`
-#[cfg(not(any(
-    target_arch = "sparc",
-    target_arch = "sparc64",
-    bsd,
-    target_os = "aix",
-    target_os = "haiku",
-    target_os = "solaris",
-)))]
-pub const B3000000: Speed = c::B3000000;
-
-/// `B3500000`
-#[cfg(not(any(
-    target_arch = "sparc",
-    target_arch = "sparc64",
-    bsd,
-    target_os = "aix",
-    target_os = "haiku",
-    target_os = "solaris",
-)))]
-pub const B3500000: Speed = c::B3500000;
-
-/// `B4000000`
-#[cfg(not(any(
-    target_arch = "sparc",
-    target_arch = "sparc64",
-    bsd,
-    target_os = "aix",
-    target_os = "haiku",
-    target_os = "solaris",
-)))]
-pub const B4000000: Speed = c::B4000000;
-
-/// `BOTHER`
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub const BOTHER: Speed = c::BOTHER;
-
-/// `CSIZE`
-pub const CSIZE: Tcflag = c::CSIZE;
-
-/// `CS5`
-pub const CS5: Tcflag = c::CS5;
-
-/// `CS6`
-pub const CS6: Tcflag = c::CS6;
-
-/// `CS7`
-pub const CS7: Tcflag = c::CS7;
-
-/// `CS8`
-pub const CS8: Tcflag = c::CS8;
-
-/// `CSTOPB`
-pub const CSTOPB: Tcflag = c::CSTOPB;
-
-/// `CREAD`
-pub const CREAD: Tcflag = c::CREAD;
-
-/// `PARENB`
-pub const PARENB: Tcflag = c::PARENB;
-
-/// `PARODD`
-pub const PARODD: Tcflag = c::PARODD;
-
-/// `HUPCL`
-pub const HUPCL: Tcflag = c::HUPCL;
-
-/// `CLOCAL`
-pub const CLOCAL: Tcflag = c::CLOCAL;
-
-/// `ISIG`
-pub const ISIG: Tcflag = c::ISIG;
-
-/// `ICANON`—A flag for the `c_lflag` field of [`Termios`] indicating
-/// canonical mode.
-pub const ICANON: Tcflag = c::ICANON;
-
-/// `ECHO`
-pub const ECHO: Tcflag = c::ECHO;
-
-/// `ECHOE`
-pub const ECHOE: Tcflag = c::ECHOE;
-
-/// `ECHOK`
-pub const ECHOK: Tcflag = c::ECHOK;
-
-/// `ECHONL`
-pub const ECHONL: Tcflag = c::ECHONL;
-
-/// `NOFLSH`
-pub const NOFLSH: Tcflag = c::NOFLSH;
-
-/// `TOSTOP`
-pub const TOSTOP: Tcflag = c::TOSTOP;
-
-/// `IEXTEN`
-pub const IEXTEN: Tcflag = c::IEXTEN;
-
-/// `EXTA`
-#[cfg(not(any(
-    solarish,
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "redox",
-)))]
-pub const EXTA: Speed = c::EXTA;
-
-/// `EXTB`
-#[cfg(not(any(
-    solarish,
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "redox",
-)))]
-pub const EXTB: Speed = c::EXTB;
-
-/// `CBAUD`
-#[cfg(not(any(bsd, target_os = "haiku", target_os = "redox")))]
-pub const CBAUD: Tcflag = c::CBAUD;
-
-/// `CBAUDEX`
-#[cfg(not(any(
-    bsd,
-    solarish,
-    target_os = "aix",
-    target_os = "haiku",
-    target_os = "redox",
-)))]
-pub const CBAUDEX: Tcflag = c::CBAUDEX;
-
-/// `CIBAUD`
-#[cfg(not(any(
-    target_arch = "powerpc",
-    target_arch = "powerpc64",
-    bsd,
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "redox",
-)))]
-pub const CIBAUD: Tcflag = c::CIBAUD;
-
-/// `CIBAUD`
-// glibc on powerpc lacks a definition for `CIBAUD`, even though the Linux
-// headers and Musl on powerpc both have one. So define it manually.
-#[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
-pub const CIBAUD: Tcflag = 0o77600000;
-
-/// `CMSPAR`
-#[cfg(not(any(
-    bsd,
-    solarish,
-    target_os = "aix",
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "redox",
-)))]
-pub const CMSPAR: Tcflag = c::CMSPAR;
-
-/// `CRTSCTS`
-#[cfg(not(any(target_os = "aix", target_os = "redox")))]
-pub const CRTSCTS: Tcflag = c::CRTSCTS;
-
-/// `XCASE`
-#[cfg(any(target_arch = "s390x", target_os = "haiku"))]
-pub const XCASE: Tcflag = c::XCASE;
-
-/// `ECHOCTL`
-#[cfg(not(any(target_os = "redox")))]
-pub const ECHOCTL: Tcflag = c::ECHOCTL;
-
-/// `ECHOPRT`
-#[cfg(not(any(target_os = "redox")))]
-pub const ECHOPRT: Tcflag = c::ECHOPRT;
-
-/// `ECHOKE`
-#[cfg(not(any(target_os = "redox")))]
-pub const ECHOKE: Tcflag = c::ECHOKE;
-
-/// `FLUSHO`
-#[cfg(not(any(target_os = "redox")))]
-pub const FLUSHO: Tcflag = c::FLUSHO;
-
-/// `PENDIN`
-#[cfg(not(any(target_os = "redox")))]
-pub const PENDIN: Tcflag = c::PENDIN;
-
-/// `EXTPROC`
-#[cfg(not(any(target_os = "aix", target_os = "haiku", target_os = "redox")))]
-pub const EXTPROC: Tcflag = c::EXTPROC;
-
-/// `XTABS`
-#[cfg(not(any(
-    bsd,
-    solarish,
-    target_os = "aix",
-    target_os = "haiku",
-    target_os = "redox",
-)))]
-pub const XTABS: Tcflag = c::XTABS;
diff --git a/vendor/rustix/src/backend/libc/thread/syscalls.rs b/vendor/rustix/src/backend/libc/thread/syscalls.rs
index adf4bb700..6066fd0d4 100644
--- a/vendor/rustix/src/backend/libc/thread/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/thread/syscalls.rs
@@ -1,18 +1,23 @@
 //! libc syscalls supporting `rustix::thread`.
 
-use super::super::c;
-use super::super::conv::ret;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::{borrowed_fd, ret_c_int, syscall_ret};
-use super::super::time::types::LibcTimespec;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::fd::BorrowedFd;
+use crate::backend::c;
+use crate::backend::conv::ret;
 use crate::io;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::process::{Pid, RawNonZeroPid};
 #[cfg(not(target_os = "redox"))]
 use crate::thread::{NanosleepRelativeResult, Timespec};
+#[cfg(all(
+    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
+    target_env = "gnu",
+))]
+use crate::timespec::LibcTimespec;
 use core::mem::MaybeUninit;
+#[cfg(linux_kernel)]
+use {
+    crate::backend::conv::{borrowed_fd, ret_c_int},
+    crate::fd::BorrowedFd,
+    crate::pid::Pid,
+    crate::utils::as_mut_ptr,
+};
 #[cfg(not(any(
     apple,
     freebsdlike,
@@ -47,16 +52,17 @@ weak!(fn __nanosleep64(*const LibcTimespec, *mut LibcTimespec) -> c::c_int);
 )))]
 #[inline]
 pub(crate) fn clock_nanosleep_relative(id: ClockId, request: &Timespec) -> NanosleepRelativeResult {
-    let mut remain = MaybeUninit::<LibcTimespec>::uninit();
     let flags = 0;
 
-    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe by
-    // default.
+    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe
+    // by default.
     #[cfg(all(
         any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
         target_env = "gnu",
     ))]
     unsafe {
+        let mut remain = MaybeUninit::<LibcTimespec>::uninit();
+
         if let Some(libc_clock_nanosleep) = __clock_nanosleep_time64.get() {
             match libc_clock_nanosleep(
                 id as c::clockid_t,
@@ -81,6 +87,8 @@ pub(crate) fn clock_nanosleep_relative(id: ClockId, request: &Timespec) -> Nanos
         target_env = "gnu",
     )))]
     unsafe {
+        let mut remain = MaybeUninit::<Timespec>::uninit();
+
         match c::clock_nanosleep(id as c::clockid_t, flags, request, remain.as_mut_ptr()) {
             0 => NanosleepRelativeResult::Ok,
             err if err == io::Errno::INTR.0 => {
@@ -96,7 +104,6 @@ pub(crate) fn clock_nanosleep_relative(id: ClockId, request: &Timespec) -> Nanos
     target_env = "gnu",
 ))]
 unsafe fn clock_nanosleep_relative_old(id: ClockId, request: &Timespec) -> NanosleepRelativeResult {
-    use core::convert::TryInto;
     let tv_sec = match request.tv_sec.try_into() {
         Ok(tv_sec) => tv_sec,
         Err(_) => return NanosleepRelativeResult::Err(io::Errno::OVERFLOW),
@@ -142,8 +149,8 @@ unsafe fn clock_nanosleep_relative_old(id: ClockId, request: &Timespec) -> Nanos
 pub(crate) fn clock_nanosleep_absolute(id: ClockId, request: &Timespec) -> io::Result<()> {
     let flags = c::TIMER_ABSTIME;
 
-    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe by
-    // default.
+    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe
+    // by default.
     #[cfg(all(
         any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
         target_env = "gnu",
@@ -182,8 +189,6 @@ pub(crate) fn clock_nanosleep_absolute(id: ClockId, request: &Timespec) -> io::R
     target_env = "gnu",
 ))]
 fn clock_nanosleep_absolute_old(id: ClockId, request: &Timespec) -> io::Result<()> {
-    use core::convert::TryInto;
-
     let flags = c::TIMER_ABSTIME;
 
     let old_request = c::timespec {
@@ -199,8 +204,6 @@ fn clock_nanosleep_absolute_old(id: ClockId, request: &Timespec) -> io::Result<(
 #[cfg(not(target_os = "redox"))]
 #[inline]
 pub(crate) fn nanosleep(request: &Timespec) -> NanosleepRelativeResult {
-    let mut remain = MaybeUninit::<LibcTimespec>::uninit();
-
     // 32-bit gnu version: libc has `nanosleep` but it is not y2038 safe by
     // default.
     #[cfg(all(
@@ -208,6 +211,8 @@ pub(crate) fn nanosleep(request: &Timespec) -> NanosleepRelativeResult {
         target_env = "gnu",
     ))]
     unsafe {
+        let mut remain = MaybeUninit::<LibcTimespec>::uninit();
+
         if let Some(libc_nanosleep) = __nanosleep64.get() {
             match ret(libc_nanosleep(&request.clone().into(), remain.as_mut_ptr())) {
                 Ok(()) => NanosleepRelativeResult::Ok,
@@ -227,6 +232,8 @@ pub(crate) fn nanosleep(request: &Timespec) -> NanosleepRelativeResult {
         target_env = "gnu",
     )))]
     unsafe {
+        let mut remain = MaybeUninit::<Timespec>::uninit();
+
         match ret(c::nanosleep(request, remain.as_mut_ptr())) {
             Ok(()) => NanosleepRelativeResult::Ok,
             Err(io::Errno::INTR) => NanosleepRelativeResult::Interrupted(remain.assume_init()),
@@ -240,7 +247,6 @@ pub(crate) fn nanosleep(request: &Timespec) -> NanosleepRelativeResult {
     target_env = "gnu",
 ))]
 unsafe fn nanosleep_old(request: &Timespec) -> NanosleepRelativeResult {
-    use core::convert::TryInto;
     let tv_sec = match request.tv_sec.try_into() {
         Ok(tv_sec) => tv_sec,
         Err(_) => return NanosleepRelativeResult::Err(io::Errno::OVERFLOW),
@@ -266,7 +272,7 @@ unsafe fn nanosleep_old(request: &Timespec) -> NanosleepRelativeResult {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 #[must_use]
 pub(crate) fn gettid() -> Pid {
@@ -279,12 +285,11 @@ pub(crate) fn gettid() -> Pid {
 
     unsafe {
         let tid = gettid();
-        debug_assert_ne!(tid, 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(tid))
+        Pid::from_raw_unchecked(tid)
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn setns(fd: BorrowedFd, nstype: c::c_int) -> io::Result<c::c_int> {
     // `setns` wasn't supported in glibc until 2.14, and musl until 0.9.5,
@@ -296,68 +301,104 @@ pub(crate) fn setns(fd: BorrowedFd, nstype: c::c_int) -> io::Result<c::c_int> {
     unsafe { ret_c_int(setns(borrowed_fd(fd), nstype)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn unshare(flags: crate::thread::UnshareFlags) -> io::Result<()> {
     unsafe { ret(c::unshare(flags.bits() as i32)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn capget(
     header: &mut linux_raw_sys::general::__user_cap_header_struct,
     data: &mut [MaybeUninit<linux_raw_sys::general::__user_cap_data_struct>],
 ) -> io::Result<()> {
-    let header: *mut _ = header;
-    unsafe { syscall_ret(c::syscall(c::SYS_capget, header, data.as_mut_ptr())) }
+    syscall! {
+        fn capget(
+            hdrp: *mut linux_raw_sys::general::__user_cap_header_struct,
+            data: *mut linux_raw_sys::general::__user_cap_data_struct
+        ) via SYS_capget -> c::c_int
+    }
+
+    unsafe {
+        ret(capget(
+            as_mut_ptr(header),
+            data.as_mut_ptr()
+                .cast::<linux_raw_sys::general::__user_cap_data_struct>(),
+        ))
+    }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn capset(
     header: &mut linux_raw_sys::general::__user_cap_header_struct,
     data: &[linux_raw_sys::general::__user_cap_data_struct],
 ) -> io::Result<()> {
-    let header: *mut _ = header;
-    unsafe { syscall_ret(c::syscall(c::SYS_capset, header, data.as_ptr())) }
+    syscall! {
+        fn capset(
+            hdrp: *mut linux_raw_sys::general::__user_cap_header_struct,
+            data: *const linux_raw_sys::general::__user_cap_data_struct
+        ) via SYS_capset -> c::c_int
+    }
+
+    unsafe { ret(capset(as_mut_ptr(header), data.as_ptr())) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
-pub(crate) fn setuid_thread(uid: crate::process::Uid) -> io::Result<()> {
-    unsafe { syscall_ret(c::syscall(c::SYS_setuid, uid.as_raw())) }
+pub(crate) fn setuid_thread(uid: crate::ugid::Uid) -> io::Result<()> {
+    syscall! {
+        fn setuid(uid: c::uid_t) via SYS_setuid -> c::c_int
+    }
+
+    unsafe { ret(setuid(uid.as_raw())) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn setresuid_thread(
-    ruid: crate::process::Uid,
-    euid: crate::process::Uid,
-    suid: crate::process::Uid,
+    ruid: crate::ugid::Uid,
+    euid: crate::ugid::Uid,
+    suid: crate::ugid::Uid,
 ) -> io::Result<()> {
     #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))]
     const SYS: c::c_long = c::SYS_setresuid32 as c::c_long;
     #[cfg(not(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc")))]
     const SYS: c::c_long = c::SYS_setresuid as c::c_long;
-    unsafe { syscall_ret(c::syscall(SYS, ruid.as_raw(), euid.as_raw(), suid.as_raw())) }
+
+    syscall! {
+        fn setresuid(ruid: c::uid_t, euid: c::uid_t, suid: c::uid_t) via SYS -> c::c_int
+    }
+
+    unsafe { ret(setresuid(ruid.as_raw(), euid.as_raw(), suid.as_raw())) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
-pub(crate) fn setgid_thread(gid: crate::process::Gid) -> io::Result<()> {
-    unsafe { syscall_ret(c::syscall(c::SYS_setgid, gid.as_raw())) }
+pub(crate) fn setgid_thread(gid: crate::ugid::Gid) -> io::Result<()> {
+    syscall! {
+        fn setgid(gid: c::gid_t) via SYS_setgid -> c::c_int
+    }
+
+    unsafe { ret(setgid(gid.as_raw())) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(linux_kernel)]
 #[inline]
 pub(crate) fn setresgid_thread(
-    rgid: crate::process::Gid,
-    egid: crate::process::Gid,
-    sgid: crate::process::Gid,
+    rgid: crate::ugid::Gid,
+    egid: crate::ugid::Gid,
+    sgid: crate::ugid::Gid,
 ) -> io::Result<()> {
     #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))]
     const SYS: c::c_long = c::SYS_setresgid32 as c::c_long;
     #[cfg(not(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc")))]
     const SYS: c::c_long = c::SYS_setresgid as c::c_long;
-    unsafe { syscall_ret(c::syscall(SYS, rgid.as_raw(), egid.as_raw(), sgid.as_raw())) }
+
+    syscall! {
+        fn setresgid(rgid: c::gid_t, egid: c::gid_t, sgid: c::gid_t) via SYS -> c::c_int
+    }
+
+    unsafe { ret(setresgid(rgid.as_raw(), egid.as_raw(), sgid.as_raw())) }
 }
diff --git a/vendor/rustix/src/backend/libc/time/syscalls.rs b/vendor/rustix/src/backend/libc/time/syscalls.rs
index 9d341d886..14ca22b2d 100644
--- a/vendor/rustix/src/backend/libc/time/syscalls.rs
+++ b/vendor/rustix/src/backend/libc/time/syscalls.rs
@@ -1,20 +1,22 @@
 //! libc syscalls supporting `rustix::time`.
 
-use super::super::c;
-use super::super::conv::ret;
-#[cfg(feature = "time")]
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-use super::super::time::types::LibcItimerspec;
-use super::super::time::types::LibcTimespec;
-use super::types::Timespec;
+use crate::backend::c;
+use crate::backend::conv::ret;
 #[cfg(not(target_os = "wasi"))]
-use super::types::{ClockId, DynamicClockId};
+use crate::clockid::{ClockId, DynamicClockId};
 use crate::io;
+#[cfg(all(
+    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
+    target_env = "gnu",
+))]
+use crate::timespec::LibcTimespec;
+use crate::timespec::Timespec;
 use core::mem::MaybeUninit;
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(feature = "time")]
 use {
-    super::super::conv::{borrowed_fd, ret_owned_fd},
+    crate::backend::conv::{borrowed_fd, ret_owned_fd},
+    crate::backend::time::types::LibcItimerspec,
     crate::fd::{BorrowedFd, OwnedFd},
     crate::time::{Itimerspec, TimerfdClockId, TimerfdFlags, TimerfdTimerFlags},
 };
@@ -51,8 +53,6 @@ weak!(fn __timerfd_settime64(c::c_int, c::c_int, *const LibcItimerspec, *mut Lib
 #[inline]
 #[must_use]
 pub(crate) fn clock_getres(id: ClockId) -> Timespec {
-    let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
-
     // 32-bit gnu version: libc has `clock_getres` but it is not y2038 safe by
     // default.
     #[cfg(all(
@@ -60,6 +60,8 @@ pub(crate) fn clock_getres(id: ClockId) -> Timespec {
         target_env = "gnu",
     ))]
     unsafe {
+        let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
+
         if let Some(libc_clock_getres) = __clock_getres64.get() {
             ret(libc_clock_getres(id as c::clockid_t, timespec.as_mut_ptr())).unwrap();
             timespec.assume_init().into()
@@ -74,6 +76,7 @@ pub(crate) fn clock_getres(id: ClockId) -> Timespec {
         target_env = "gnu",
     )))]
     unsafe {
+        let mut timespec = MaybeUninit::<Timespec>::uninit();
         let _ = c::clock_getres(id as c::clockid_t, timespec.as_mut_ptr());
         timespec.assume_init()
     }
@@ -102,13 +105,13 @@ unsafe fn clock_getres_old(id: ClockId) -> Timespec {
 #[inline]
 #[must_use]
 pub(crate) fn clock_gettime(id: ClockId) -> Timespec {
-    let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
-
     #[cfg(all(
         any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
         target_env = "gnu",
     ))]
     unsafe {
+        let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
+
         if let Some(libc_clock_gettime) = __clock_gettime64.get() {
             ret(libc_clock_gettime(
                 id as c::clockid_t,
@@ -130,6 +133,7 @@ pub(crate) fn clock_gettime(id: ClockId) -> Timespec {
         target_env = "gnu",
     )))]
     unsafe {
+        let mut timespec = MaybeUninit::<Timespec>::uninit();
         ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr())).unwrap();
         timespec.assume_init()
     }
@@ -157,34 +161,33 @@ unsafe fn clock_gettime_old(id: ClockId) -> Timespec {
 #[cfg(not(target_os = "wasi"))]
 #[inline]
 pub(crate) fn clock_gettime_dynamic(id: DynamicClockId<'_>) -> io::Result<Timespec> {
-    let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
     unsafe {
         let id: c::clockid_t = match id {
             DynamicClockId::Known(id) => id as c::clockid_t,
 
-            #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(linux_kernel)]
             DynamicClockId::Dynamic(fd) => {
                 use crate::fd::AsRawFd;
                 const CLOCKFD: i32 = 3;
                 (!fd.as_raw_fd() << 3) | CLOCKFD
             }
 
-            #[cfg(not(any(target_os = "android", target_os = "linux")))]
+            #[cfg(not(linux_kernel))]
             DynamicClockId::Dynamic(_fd) => {
                 // Dynamic clocks are not supported on this platform.
                 return Err(io::Errno::INVAL);
             }
 
-            #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(linux_kernel)]
             DynamicClockId::RealtimeAlarm => c::CLOCK_REALTIME_ALARM,
 
-            #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(linux_kernel)]
             DynamicClockId::Tai => c::CLOCK_TAI,
 
-            #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(any(linux_kernel, target_os = "openbsd"))]
             DynamicClockId::Boottime => c::CLOCK_BOOTTIME,
 
-            #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(linux_kernel)]
             DynamicClockId::BoottimeAlarm => c::CLOCK_BOOTTIME_ALARM,
         };
 
@@ -193,6 +196,8 @@ pub(crate) fn clock_gettime_dynamic(id: DynamicClockId<'_>) -> io::Result<Timesp
             target_env = "gnu",
         ))]
         {
+            let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
+
             if let Some(libc_clock_gettime) = __clock_gettime64.get() {
                 ret(libc_clock_gettime(
                     id as c::clockid_t,
@@ -210,6 +215,8 @@ pub(crate) fn clock_gettime_dynamic(id: DynamicClockId<'_>) -> io::Result<Timesp
             target_env = "gnu",
         )))]
         {
+            let mut timespec = MaybeUninit::<Timespec>::uninit();
+
             ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr()))?;
 
             Ok(timespec.assume_init())
@@ -277,9 +284,7 @@ pub(crate) fn clock_settime(id: ClockId, timespec: Timespec) -> io::Result<()> {
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
 ))]
-#[must_use]
 unsafe fn clock_settime_old(id: ClockId, timespec: Timespec) -> io::Result<()> {
-    use core::convert::TryInto;
     let old_timespec = c::timespec {
         tv_sec: timespec
             .tv_sec
@@ -290,13 +295,13 @@ unsafe fn clock_settime_old(id: ClockId, timespec: Timespec) -> io::Result<()> {
     ret(c::clock_settime(id as c::clockid_t, &old_timespec))
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(feature = "time")]
 pub(crate) fn timerfd_create(id: TimerfdClockId, flags: TimerfdFlags) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::timerfd_create(id as c::clockid_t, flags.bits())) }
+    unsafe { ret_owned_fd(c::timerfd_create(id as c::clockid_t, bitflags_bits!(flags))) }
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(feature = "time")]
 pub(crate) fn timerfd_settime(
     fd: BorrowedFd<'_>,
@@ -313,7 +318,7 @@ pub(crate) fn timerfd_settime(
         if let Some(libc_timerfd_settime) = __timerfd_settime64.get() {
             ret(libc_timerfd_settime(
                 borrowed_fd(fd),
-                flags.bits(),
+                bitflags_bits!(flags),
                 &new_value.clone().into(),
                 result.as_mut_ptr(),
             ))?;
@@ -330,7 +335,7 @@ pub(crate) fn timerfd_settime(
     unsafe {
         ret(c::timerfd_settime(
             borrowed_fd(fd),
-            flags.bits(),
+            bitflags_bits!(flags),
             new_value,
             result.as_mut_ptr(),
         ))?;
@@ -338,7 +343,7 @@ pub(crate) fn timerfd_settime(
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
@@ -349,8 +354,6 @@ unsafe fn timerfd_settime_old(
     flags: TimerfdTimerFlags,
     new_value: &Itimerspec,
 ) -> io::Result<Itimerspec> {
-    use core::convert::TryInto;
-
     let mut old_result = MaybeUninit::<c::itimerspec>::uninit();
 
     // Convert `new_value` to the old `itimerspec` format.
@@ -383,7 +386,7 @@ unsafe fn timerfd_settime_old(
 
     ret(c::timerfd_settime(
         borrowed_fd(fd),
-        flags.bits(),
+        bitflags_bits!(flags),
         &old_new_value,
         old_result.as_mut_ptr(),
     ))?;
@@ -409,7 +412,7 @@ unsafe fn timerfd_settime_old(
     })
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(feature = "time")]
 pub(crate) fn timerfd_gettime(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> {
     let mut result = MaybeUninit::<LibcItimerspec>::uninit();
@@ -437,15 +440,13 @@ pub(crate) fn timerfd_gettime(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
 ))]
 #[cfg(feature = "time")]
 unsafe fn timerfd_gettime_old(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> {
-    use core::convert::TryInto;
-
     let mut old_result = MaybeUninit::<c::itimerspec>::uninit();
 
     ret(c::timerfd_gettime(borrowed_fd(fd), old_result.as_mut_ptr()))?;
diff --git a/vendor/rustix/src/backend/libc/time/types.rs b/vendor/rustix/src/backend/libc/time/types.rs
index c78aeb21a..e1d4a8736 100644
--- a/vendor/rustix/src/backend/libc/time/types.rs
+++ b/vendor/rustix/src/backend/libc/time/types.rs
@@ -1,220 +1,25 @@
-use super::super::c;
-#[cfg(not(target_os = "wasi"))]
-use crate::fd::BorrowedFd;
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-use bitflags::bitflags;
-
-/// `struct timespec`
-#[cfg(not(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-)))]
-pub type Timespec = c::timespec;
-
-/// `struct timespec`
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
+use crate::backend::c;
 #[cfg(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
 ))]
-#[derive(Debug, Clone, Copy)]
-#[repr(C)]
-pub struct Timespec {
-    /// Seconds.
-    pub tv_sec: Secs,
-
-    /// Nanoseconds. Must be less than 1_000_000_000.
-    pub tv_nsec: Nsecs,
-}
-
-/// A type for the `tv_sec` field of [`Timespec`].
-#[cfg(not(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-)))]
-#[allow(deprecated)]
-pub type Secs = c::time_t;
-
-/// A type for the `tv_sec` field of [`Timespec`].
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-pub type Secs = i64;
-
-/// A type for the `tv_nsec` field of [`Timespec`].
-#[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))]
-pub type Nsecs = i64;
-
-/// A type for the `tv_nsec` field of [`Timespec`].
-#[cfg(not(all(target_arch = "x86_64", target_pointer_width = "32")))]
-pub type Nsecs = c::c_long;
-
-/// On most platforms, `LibcTimespec` is just `Timespec`.
-#[cfg(not(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-)))]
-pub(crate) type LibcTimespec = Timespec;
-
-/// On 32-bit glibc platforms, `timespec` has anonymous padding fields, which
-/// Rust doesn't support yet (see `unnamed_fields`), so we define our own
-/// struct with explicit padding, with bidirectional `From` impls.
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub(crate) struct LibcTimespec {
-    pub(crate) tv_sec: Secs,
-
-    #[cfg(target_endian = "big")]
-    padding: core::mem::MaybeUninit<u32>,
-
-    pub(crate) tv_nsec: Nsecs,
-
-    #[cfg(target_endian = "little")]
-    padding: core::mem::MaybeUninit<u32>,
-}
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-impl From<LibcTimespec> for Timespec {
-    #[inline]
-    fn from(t: LibcTimespec) -> Self {
-        Self {
-            tv_sec: t.tv_sec,
-            tv_nsec: t.tv_nsec,
-        }
-    }
-}
-
+use crate::timespec::LibcTimespec;
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
 ))]
-impl From<Timespec> for LibcTimespec {
-    #[inline]
-    fn from(t: Timespec) -> Self {
-        Self {
-            tv_sec: t.tv_sec,
-            tv_nsec: t.tv_nsec,
-            padding: core::mem::MaybeUninit::uninit(),
-        }
-    }
-}
-
-/// `CLOCK_*` constants for use with [`clock_gettime`].
-///
-/// These constants are always supported at runtime, so `clock_gettime` never
-/// has to fail with `INVAL` due to an unsupported clock. See
-/// [`DynamicClockId`] for a greater set of clocks, with the caveat that not
-/// all of them are always supported.
-///
-/// [`clock_gettime`]: crate::time::clock_gettime
-#[cfg(not(any(apple, target_os = "wasi")))]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-#[cfg_attr(not(target_os = "dragonfly"), repr(i32))]
-#[cfg_attr(target_os = "dragonfly", repr(u64))]
-#[non_exhaustive]
-pub enum ClockId {
-    /// `CLOCK_REALTIME`
-    Realtime = c::CLOCK_REALTIME,
-
-    /// `CLOCK_MONOTONIC`
-    Monotonic = c::CLOCK_MONOTONIC,
-
-    /// `CLOCK_UPTIME`
-    #[cfg(any(freebsdlike))]
-    Uptime = c::CLOCK_UPTIME,
-
-    /// `CLOCK_PROCESS_CPUTIME_ID`
-    #[cfg(not(any(netbsdlike, solarish, target_os = "redox")))]
-    ProcessCPUTime = c::CLOCK_PROCESS_CPUTIME_ID,
-
-    /// `CLOCK_THREAD_CPUTIME_ID`
-    #[cfg(not(any(netbsdlike, solarish, target_os = "redox")))]
-    ThreadCPUTime = c::CLOCK_THREAD_CPUTIME_ID,
-
-    /// `CLOCK_REALTIME_COARSE`
-    #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
-    RealtimeCoarse = c::CLOCK_REALTIME_COARSE,
-
-    /// `CLOCK_MONOTONIC_COARSE`
-    #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
-    MonotonicCoarse = c::CLOCK_MONOTONIC_COARSE,
-
-    /// `CLOCK_MONOTONIC_RAW`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    MonotonicRaw = c::CLOCK_MONOTONIC_RAW,
-}
-
-/// `CLOCK_*` constants for use with [`clock_gettime`].
-///
-/// These constants are always supported at runtime, so `clock_gettime` never
-/// has to fail with `INVAL` due to an unsupported clock. See
-/// [`DynamicClockId`] for a greater set of clocks, with the caveat that not
-/// all of them are always supported.
-#[cfg(apple)]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-#[repr(u32)]
-#[non_exhaustive]
-pub enum ClockId {
-    /// `CLOCK_REALTIME`
-    Realtime = c::CLOCK_REALTIME,
-
-    /// `CLOCK_MONOTONIC`
-    Monotonic = c::CLOCK_MONOTONIC,
-
-    /// `CLOCK_PROCESS_CPUTIME_ID`
-    ProcessCPUTime = c::CLOCK_PROCESS_CPUTIME_ID,
-
-    /// `CLOCK_THREAD_CPUTIME_ID`
-    ThreadCPUTime = c::CLOCK_THREAD_CPUTIME_ID,
-}
-
-/// `CLOCK_*` constants for use with [`clock_gettime_dynamic`].
-///
-/// These constants may be unsupported at runtime, depending on the OS version,
-/// and `clock_gettime_dynamic` may fail with `INVAL`. See [`ClockId`] for
-/// clocks which are always supported at runtime.
-///
-/// [`clock_gettime_dynamic`]: crate::time::clock_gettime_dynamic
-#[cfg(not(target_os = "wasi"))]
-#[derive(Debug, Copy, Clone)]
-#[non_exhaustive]
-pub enum DynamicClockId<'a> {
-    /// `ClockId` values that are always supported at runtime.
-    Known(ClockId),
-
-    /// Linux dynamic clocks.
-    Dynamic(BorrowedFd<'a>),
-
-    /// `CLOCK_REALTIME_ALARM`, available on Linux >= 3.0
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    RealtimeAlarm,
-
-    /// `CLOCK_TAI`, available on Linux >= 3.10
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    Tai,
-
-    /// `CLOCK_BOOTTIME`, available on Linux >= 2.6.39
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    Boottime,
-
-    /// `CLOCK_BOOTTIME_ALARM`, available on Linux >= 2.6.39
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    BoottimeAlarm,
-}
+use crate::timespec::Timespec;
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
+use bitflags::bitflags;
 
 /// `struct itimerspec` for use with [`timerfd_gettime`] and
 /// [`timerfd_settime`].
 ///
 /// [`timerfd_gettime`]: crate::time::timerfd_gettime
 /// [`timerfd_settime`]: crate::time::timerfd_settime
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(not(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
@@ -226,7 +31,7 @@ pub type Itimerspec = c::itimerspec;
 ///
 /// [`timerfd_gettime`]: crate::time::timerfd_gettime
 /// [`timerfd_settime`]: crate::time::timerfd_settime
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
@@ -240,7 +45,7 @@ pub struct Itimerspec {
 }
 
 /// On most platforms, `LibcItimerspec` is just `Itimerspec`.
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(not(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
@@ -249,7 +54,7 @@ pub(crate) type LibcItimerspec = Itimerspec;
 
 /// On 32-bit glibc platforms, `LibcTimespec` differs from `Timespec`, so we
 /// define our own struct, with bidirectional `From` impls.
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
@@ -261,7 +66,7 @@ pub(crate) struct LibcItimerspec {
     pub it_value: LibcTimespec,
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
@@ -276,7 +81,7 @@ impl From<LibcItimerspec> for Itimerspec {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[cfg(all(
     any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
     target_env = "gnu",
@@ -291,41 +96,45 @@ impl From<Itimerspec> for LibcItimerspec {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 bitflags! {
     /// `TFD_*` flags for use with [`timerfd_create`].
     ///
     /// [`timerfd_create`]: crate::time::timerfd_create
-    pub struct TimerfdFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct TimerfdFlags: u32 {
         /// `TFD_NONBLOCK`
-        const NONBLOCK = c::TFD_NONBLOCK;
+        const NONBLOCK = bitcast!(c::TFD_NONBLOCK);
 
         /// `TFD_CLOEXEC`
-        const CLOEXEC = c::TFD_CLOEXEC;
+        const CLOEXEC = bitcast!(c::TFD_CLOEXEC);
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 bitflags! {
     /// `TFD_TIMER_*` flags for use with [`timerfd_settime`].
     ///
     /// [`timerfd_settime`]: crate::time::timerfd_settime
-    pub struct TimerfdTimerFlags: c::c_int {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct TimerfdTimerFlags: u32 {
         /// `TFD_TIMER_ABSTIME`
-        const ABSTIME = c::TFD_TIMER_ABSTIME;
+        const ABSTIME = bitcast!(c::TFD_TIMER_ABSTIME);
 
         /// `TFD_TIMER_CANCEL_ON_SET`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const CANCEL_ON_SET = c::TFD_TIMER_CANCEL_ON_SET;
+        #[cfg(linux_kernel)]
+        const CANCEL_ON_SET = bitcast!(c::TFD_TIMER_CANCEL_ON_SET);
     }
 }
 
 /// `CLOCK_*` constants for use with [`timerfd_create`].
 ///
 /// [`timerfd_create`]: crate::time::timerfd_create
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-#[repr(i32)]
+#[repr(u32)]
 #[non_exhaustive]
 pub enum TimerfdClockId {
     /// `CLOCK_REALTIME`—A clock that tells the “real” time.
@@ -334,7 +143,7 @@ pub enum TimerfdClockId {
     /// Unix epoch, 1970-01-01T00:00:00Z. The clock is externally settable, so
     /// it is not monotonic. Successive reads may see decreasing times, so it
     /// isn't reliable for measuring durations.
-    Realtime = c::CLOCK_REALTIME,
+    Realtime = bitcast!(c::CLOCK_REALTIME),
 
     /// `CLOCK_MONOTONIC`—A clock that tells an abstract time.
     ///
@@ -344,25 +153,33 @@ pub enum TimerfdClockId {
     ///
     /// This clock does not advance while the system is suspended; see
     /// `Boottime` for a clock that does.
-    Monotonic = c::CLOCK_MONOTONIC,
+    Monotonic = bitcast!(c::CLOCK_MONOTONIC),
 
     /// `CLOCK_BOOTTIME`—Like `Monotonic`, but advances while suspended.
     ///
     /// This clock is similar to `Monotonic`, but does advance while the system
     /// is suspended.
-    Boottime = c::CLOCK_BOOTTIME,
+    Boottime = bitcast!(c::CLOCK_BOOTTIME),
 
     /// `CLOCK_REALTIME_ALARM`—Like `Realtime`, but wakes a suspended system.
     ///
     /// This clock is like `Realtime`, but can wake up a suspended system.
     ///
     /// Use of this clock requires the `CAP_WAKE_ALARM` Linux capability.
-    RealtimeAlarm = c::CLOCK_REALTIME_ALARM,
+    RealtimeAlarm = bitcast!(c::CLOCK_REALTIME_ALARM),
 
     /// `CLOCK_BOOTTIME_ALARM`—Like `Boottime`, but wakes a suspended system.
     ///
     /// This clock is like `Boottime`, but can wake up a suspended system.
     ///
     /// Use of this clock requires the `CAP_WAKE_ALARM` Linux capability.
-    BoottimeAlarm = c::CLOCK_BOOTTIME_ALARM,
+    BoottimeAlarm = bitcast!(c::CLOCK_BOOTTIME_ALARM),
+}
+
+#[cfg(any(linux_kernel, target_os = "fuchsia"))]
+#[test]
+fn test_types() {
+    use core::mem::size_of;
+    assert_eq!(size_of::<TimerfdFlags>(), size_of::<c::c_int>());
+    assert_eq!(size_of::<TimerfdTimerFlags>(), size_of::<c::c_int>());
 }
diff --git a/vendor/rustix/src/backend/libc/ugid/mod.rs b/vendor/rustix/src/backend/libc/ugid/mod.rs
new file mode 100644
index 000000000..ef944f04d
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/ugid/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/ugid/syscalls.rs b/vendor/rustix/src/backend/libc/ugid/syscalls.rs
new file mode 100644
index 000000000..0d3f622dc
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/ugid/syscalls.rs
@@ -0,0 +1,42 @@
+use crate::backend::c;
+use crate::ugid::{Gid, Uid};
+
+#[cfg(not(target_os = "wasi"))]
+#[inline]
+#[must_use]
+pub(crate) fn getuid() -> Uid {
+    unsafe {
+        let uid = c::getuid();
+        Uid::from_raw(uid)
+    }
+}
+
+#[cfg(not(target_os = "wasi"))]
+#[inline]
+#[must_use]
+pub(crate) fn geteuid() -> Uid {
+    unsafe {
+        let uid = c::geteuid();
+        Uid::from_raw(uid)
+    }
+}
+
+#[cfg(not(target_os = "wasi"))]
+#[inline]
+#[must_use]
+pub(crate) fn getgid() -> Gid {
+    unsafe {
+        let gid = c::getgid();
+        Gid::from_raw(gid)
+    }
+}
+
+#[cfg(not(target_os = "wasi"))]
+#[inline]
+#[must_use]
+pub(crate) fn getegid() -> Gid {
+    unsafe {
+        let gid = c::getegid();
+        Gid::from_raw(gid)
+    }
+}
diff --git a/vendor/rustix/src/backend/libc/winsock_c.rs b/vendor/rustix/src/backend/libc/winsock_c.rs
index a30f2c86f..0a1554a86 100644
--- a/vendor/rustix/src/backend/libc/winsock_c.rs
+++ b/vendor/rustix/src/backend/libc/winsock_c.rs
@@ -2,6 +2,7 @@
 
 #![allow(unused_imports)]
 #![allow(non_camel_case_types)]
+#![allow(dead_code)]
 
 use windows_sys::Win32::Networking::WinSock;
 
@@ -32,16 +33,12 @@ pub(crate) const AF_UNSPEC: i32 = WinSock::AF_UNSPEC as _;
 // `WSAECANCELLED` will be removed in the future.
 // <https://docs.microsoft.com/en-us/windows/win32/api/ws2spi/nc-ws2spi-lpnsplookupserviceend#remarks>
 pub(crate) use WinSock::{
-    closesocket as close, ioctlsocket as ioctl, socklen_t, WSAPoll as poll,
-    ADDRESS_FAMILY as sa_family_t, ADDRINFOA as addrinfo, IN6_ADDR as in6_addr, IN_ADDR as in_addr,
-    IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_MREQ as ipv6_mreq, IPV6_MULTICAST_LOOP,
-    IPV6_V6ONLY, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_MREQ as ip_mreq, IP_MULTICAST_LOOP,
-    IP_MULTICAST_TTL, IP_TTL, LINGER as linger, POLLERR, POLLHUP, POLLIN, POLLNVAL, POLLOUT,
-    POLLPRI, POLLRDBAND, POLLRDNORM, POLLWRBAND, POLLWRNORM, SD_BOTH as SHUT_RDWR,
-    SD_RECEIVE as SHUT_RD, SD_SEND as SHUT_WR, SOCKADDR as sockaddr, SOCKADDR_IN as sockaddr_in,
-    SOCKADDR_IN6 as sockaddr_in6, SOCKADDR_STORAGE as sockaddr_storage, SOL_SOCKET, SO_BROADCAST,
-    SO_ERROR, SO_LINGER, SO_RCVTIMEO, SO_REUSEADDR, SO_SNDTIMEO, SO_TYPE, TCP_NODELAY,
-    WSAEACCES as EACCES, WSAEADDRINUSE as EADDRINUSE, WSAEADDRNOTAVAIL as EADDRNOTAVAIL,
+    closesocket as close, ioctlsocket as ioctl, WSAPoll as poll, ADDRESS_FAMILY as sa_family_t,
+    ADDRINFOA as addrinfo, IN6_ADDR as in6_addr, IN_ADDR as in_addr, IPV6_MREQ as ipv6_mreq,
+    IP_MREQ as ip_mreq, LINGER as linger, SD_BOTH as SHUT_RDWR, SD_RECEIVE as SHUT_RD,
+    SD_SEND as SHUT_WR, SOCKADDR as sockaddr, SOCKADDR_IN as sockaddr_in,
+    SOCKADDR_IN6 as sockaddr_in6, SOCKADDR_STORAGE as sockaddr_storage, WSAEACCES as EACCES,
+    WSAEADDRINUSE as EADDRINUSE, WSAEADDRNOTAVAIL as EADDRNOTAVAIL,
     WSAEAFNOSUPPORT as EAFNOSUPPORT, WSAEALREADY as EALREADY, WSAEBADF as EBADF,
     WSAECONNABORTED as ECONNABORTED, WSAECONNREFUSED as ECONNREFUSED, WSAECONNRESET as ECONNRESET,
     WSAEDESTADDRREQ as EDESTADDRREQ, WSAEDISCON as EDISCON, WSAEDQUOT as EDQUOT,
diff --git a/vendor/rustix/src/backend/linux_raw/arch/inline/mod.rs b/vendor/rustix/src/backend/linux_raw/arch/inline/mod.rs
index 4783747ac..7c26e23a4 100644
--- a/vendor/rustix/src/backend/linux_raw/arch/inline/mod.rs
+++ b/vendor/rustix/src/backend/linux_raw/arch/inline/mod.rs
@@ -19,4 +19,4 @@
 #[cfg_attr(target_arch = "x86_64", path = "x86_64.rs")]
 mod target_arch;
 
-pub(in crate::backend) use self::target_arch::*;
+pub(in crate::backend) use target_arch::*;
diff --git a/vendor/rustix/src/backend/linux_raw/arch/inline/x86.rs b/vendor/rustix/src/backend/linux_raw/arch/inline/x86.rs
index 8e115148d..62947cb04 100644
--- a/vendor/rustix/src/backend/linux_raw/arch/inline/x86.rs
+++ b/vendor/rustix/src/backend/linux_raw/arch/inline/x86.rs
@@ -113,7 +113,7 @@ pub(in crate::backend) unsafe fn indirect_syscall4(
 ) -> RetReg<R0> {
     let r0;
     // a3 should go in esi, but `asm!` won't let us use it as an operand.
-    // temporarily swap it into place, and then swap it back afterward.
+    // Temporarily swap it into place, and then swap it back afterward.
     //
     // We hard-code the callee operand to use edi instead of `in(reg)` because
     // even though we can't name esi as an operand, the compiler can use esi to
diff --git a/vendor/rustix/src/backend/linux_raw/arch/mod.rs b/vendor/rustix/src/backend/linux_raw/arch/mod.rs
index e13f675fd..cc93fc2c4 100644
--- a/vendor/rustix/src/backend/linux_raw/arch/mod.rs
+++ b/vendor/rustix/src/backend/linux_raw/arch/mod.rs
@@ -1,8 +1,8 @@
 //! Architecture-specific syscall code.
 //!
 //! `rustix` has inline assembly sequences using `asm!`, but that requires
-//! nightly Rust, so it also has out-of-line ("outline") assembly sequences
-//! in .s files. And 32-bit x86 is special (see comments below).
+//! Rust 1.59, so it also has out-of-line ("outline") assembly sequences in .s
+//! files. And 32-bit x86 is special (see comments below).
 //!
 //! This module also has a `choose` submodule which chooses a scheme and is
 //! what most of the `rustix` syscalls use.
@@ -133,6 +133,87 @@ macro_rules! syscall {
     };
 }
 
+// Macro to invoke a syscall that always uses direct assembly, rather than the
+// vDSO. Useful when still finding the vDSO.
+#[allow(unused_macros)]
+macro_rules! syscall_always_asm {
+    ($nr:ident) => {
+        $crate::backend::arch::asm::syscall0($crate::backend::reg::nr(linux_raw_sys::general::$nr))
+    };
+
+    ($nr:ident, $a0:expr) => {
+        $crate::backend::arch::asm::syscall1(
+            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
+            $a0.into(),
+        )
+    };
+
+    ($nr:ident, $a0:expr, $a1:expr) => {
+        $crate::backend::arch::asm::syscall2(
+            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
+            $a0.into(),
+            $a1.into(),
+        )
+    };
+
+    ($nr:ident, $a0:expr, $a1:expr, $a2:expr) => {
+        $crate::backend::arch::asm::syscall3(
+            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
+            $a0.into(),
+            $a1.into(),
+            $a2.into(),
+        )
+    };
+
+    ($nr:ident, $a0:expr, $a1:expr, $a2:expr, $a3:expr) => {
+        $crate::backend::arch::asm::syscall4(
+            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
+            $a0.into(),
+            $a1.into(),
+            $a2.into(),
+            $a3.into(),
+        )
+    };
+
+    ($nr:ident, $a0:expr, $a1:expr, $a2:expr, $a3:expr, $a4:expr) => {
+        $crate::backend::arch::asm::syscall5(
+            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
+            $a0.into(),
+            $a1.into(),
+            $a2.into(),
+            $a3.into(),
+            $a4.into(),
+        )
+    };
+
+    ($nr:ident, $a0:expr, $a1:expr, $a2:expr, $a3:expr, $a4:expr, $a5:expr) => {
+        $crate::backend::arch::asm::syscall6(
+            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
+            $a0.into(),
+            $a1.into(),
+            $a2.into(),
+            $a3.into(),
+            $a4.into(),
+            $a5.into(),
+        )
+    };
+
+    ($nr:ident, $a0:expr, $a1:expr, $a2:expr, $a3:expr, $a4:expr, $a5:expr, $a6:expr) => {
+        $crate::backend::arch::asm::syscall7(
+            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
+            $a0.into(),
+            $a1.into(),
+            $a2.into(),
+            $a3.into(),
+            $a4.into(),
+            $a5.into(),
+            $a6.into(),
+        )
+    };
+}
+
+/// Like `syscall`, but adds the `readonly` attribute to the inline asm, which
+/// indicates that the syscall does not mutate any memory.
 macro_rules! syscall_readonly {
     ($nr:ident) => {
         $crate::backend::arch::choose::syscall0_readonly($crate::backend::reg::nr(
@@ -211,6 +292,7 @@ macro_rules! syscall_readonly {
     };
 }
 
+/// Like `syscall`, but indicates that the syscall does not return.
 #[cfg(feature = "runtime")]
 macro_rules! syscall_noreturn {
     ($nr:ident, $a0:expr) => {
diff --git a/vendor/rustix/src/backend/linux_raw/arch/outline/aarch64.s b/vendor/rustix/src/backend/linux_raw/arch/outline/aarch64.s
deleted file mode 100644
index 1fad2fa6d..000000000
--- a/vendor/rustix/src/backend/linux_raw/arch/outline/aarch64.s
+++ /dev/null
@@ -1,119 +0,0 @@
-// Assembly code for making aarch64 syscalls.
-//
-// aarch64 syscall argument register ordering is the same as the aarch64
-// userspace argument register ordering except that the syscall number
-// (nr) is passed in w8.
-//
-// outline.rs takes care of reordering the nr argument to the end for us,
-// so we only need to move nr into w8.
-//
-// arm64-ilp32 is not yet supported.
-
-    .file       "aarch64.s"
-    .arch       armv8-a
-
-    .section    .text.rustix_syscall0_nr_last,"ax",@progbits
-    .p2align    2
-    .weak       rustix_syscall0_nr_last
-    .hidden     rustix_syscall0_nr_last
-    .type       rustix_syscall0_nr_last, @function
-rustix_syscall0_nr_last:
-    .cfi_startproc
-    mov    w8, w0
-    svc    #0
-    ret
-    .cfi_endproc
-    .size rustix_syscall0_nr_last, .-rustix_syscall0_nr_last
-
-    .section    .text.rustix_syscall1_nr_last,"ax",@progbits
-    .p2align    2
-    .weak       rustix_syscall1_nr_last
-    .hidden     rustix_syscall1_nr_last
-    .type       rustix_syscall1_nr_last, @function
-rustix_syscall1_nr_last:
-    .cfi_startproc
-    mov    w8, w1
-    svc    #0
-    ret
-    .cfi_endproc
-    .size rustix_syscall1_nr_last, .-rustix_syscall1_nr_last
-
-    .section    .text.rustix_syscall1_noreturn_nr_last,"ax",@progbits
-    .p2align    2
-    .weak       rustix_syscall1_noreturn_nr_last
-    .hidden     rustix_syscall1_noreturn_nr_last
-    .type       rustix_syscall1_noreturn_nr_last, @function
-rustix_syscall1_noreturn_nr_last:
-    .cfi_startproc
-    mov    w8, w1
-    svc    #0
-    brk    #0x1
-    .cfi_endproc
-    .size rustix_syscall1_noreturn_nr_last, .-rustix_syscall1_noreturn_nr_last
-
-    .section    .text.rustix_syscall2_nr_last,"ax",@progbits
-    .p2align    2
-    .weak       rustix_syscall2_nr_last
-    .hidden     rustix_syscall2_nr_last
-    .type       rustix_syscall2_nr_last, @function
-rustix_syscall2_nr_last:
-    .cfi_startproc
-    mov    w8, w2
-    svc    #0
-    ret
-    .cfi_endproc
-    .size rustix_syscall2_nr_last, .-rustix_syscall2_nr_last
-
-    .section    .text.rustix_syscall3_nr_last,"ax",@progbits
-    .p2align    2
-    .weak       rustix_syscall3_nr_last
-    .hidden     rustix_syscall3_nr_last
-    .type       rustix_syscall3_nr_last, @function
-rustix_syscall3_nr_last:
-    .cfi_startproc
-    mov    w8, w3
-    svc    #0
-    ret
-    .cfi_endproc
-    .size rustix_syscall3_nr_last, .-rustix_syscall3_nr_last
-
-    .section    .text.rustix_syscall4_nr_last,"ax",@progbits
-    .p2align    2
-    .weak       rustix_syscall4_nr_last
-    .hidden     rustix_syscall4_nr_last
-    .type       rustix_syscall4_nr_last, @function
-rustix_syscall4_nr_last:
-    .cfi_startproc
-    mov    w8, w4
-    svc    #0
-    ret
-    .cfi_endproc
-    .size rustix_syscall4_nr_last, .-rustix_syscall4_nr_last
-
-    .section    .text.rustix_syscall5_nr_last,"ax",@progbits
-    .p2align    2
-    .weak       rustix_syscall5_nr_last
-    .hidden     rustix_syscall5_nr_last
-    .type       rustix_syscall5_nr_last, @function
-rustix_syscall5_nr_last:
-    .cfi_startproc
-    mov    w8, w5
-    svc    #0
-    ret
-    .cfi_endproc
-    .size rustix_syscall5_nr_last, .-rustix_syscall5_nr_last
-
-    .section    .text.rustix_syscall6_nr_last,"ax",@progbits
-    .p2align    2
-    .weak       rustix_syscall6_nr_last
-    .hidden     rustix_syscall6_nr_last
-    .type       rustix_syscall6_nr_last, @function
-rustix_syscall6_nr_last:
-    .cfi_startproc
-    mov    w8, w6
-    svc    #0
-    ret
-    .cfi_endproc
-    .size rustix_syscall6_nr_last, .-rustix_syscall6_nr_last
-
-    .section .note.GNU-stack,"",@progbits
diff --git a/vendor/rustix/src/backend/linux_raw/arch/outline/arm.s b/vendor/rustix/src/backend/linux_raw/arch/outline/arm.s
deleted file mode 100644
index 7001686f1..000000000
--- a/vendor/rustix/src/backend/linux_raw/arch/outline/arm.s
+++ /dev/null
@@ -1,135 +0,0 @@
-// Assembly code for making arm syscalls.
-//
-// arm syscall argument register ordering is the similar to the arm
-// userspace argument register ordering except that the syscall number
-// (nr) is passed in r7.
-//
-// nr_last.rs takes care of reordering the nr argument to the end for us,
-// so we only need to move nr into r7 and take care of r4 and r5 if needed.
-
-    .file       "arm.s"
-    .arch       armv5t
-
-    .section    .text.rustix_syscall0_nr_last,"ax",%progbits
-    .p2align    4
-    .weak       rustix_syscall0_nr_last
-    .hidden     rustix_syscall0_nr_last
-    .type       rustix_syscall0_nr_last, %function
-rustix_syscall0_nr_last:
-    .fnstart
-    .cantunwind
-    push    {r7, lr}
-    mov     r7, r0
-    svc     #0
-    pop     {r7, pc}
-    .fnend
-    .size rustix_syscall0_nr_last, .-rustix_syscall0_nr_last
-
-    .section    .text.rustix_syscall1_nr_last,"ax",%progbits
-    .p2align 4
-    .weak       rustix_syscall1_nr_last
-    .hidden     rustix_syscall1_nr_last
-    .type       rustix_syscall1_nr_last, %function
-rustix_syscall1_nr_last:
-    .fnstart
-    .cantunwind
-    push    {r7, lr}
-    mov     r7, r1
-    svc     #0
-    pop     {r7, pc}
-    .fnend
-    .size rustix_syscall1_nr_last, .-rustix_syscall1_nr_last
-
-    .section    .text.rustix_syscall1_noreturn_nr_last,"ax",%progbits
-    .p2align    4
-    .weak       rustix_syscall1_noreturn_nr_last
-    .hidden     rustix_syscall1_noreturn_nr_last
-    .type       rustix_syscall1_noreturn_nr_last, %function
-rustix_syscall1_noreturn_nr_last:
-    .fnstart
-    .cantunwind
-    // Don't save r7 and lr; this is noreturn, so we'll never restore them.
-    mov     r7, r1
-    svc     #0
-    udf     #16 // Trap instruction
-    .fnend
-    .size rustix_syscall1_noreturn_nr_last, .-rustix_syscall1_noreturn_nr_last
-
-    .section    .text.rustix_syscall2_nr_last,"ax",%progbits
-    .p2align 4
-    .weak       rustix_syscall2_nr_last
-    .hidden     rustix_syscall2_nr_last
-    .type       rustix_syscall2_nr_last, %function
-rustix_syscall2_nr_last:
-    .fnstart
-    .cantunwind
-    push    {r7, lr}
-    mov     r7, r2
-    svc     #0
-    pop     {r7, pc}
-    .fnend
-    .size rustix_syscall2_nr_last, .-rustix_syscall2_nr_last
-
-    .section    .text.rustix_syscall3_nr_last,"ax",%progbits
-    .p2align 4
-    .weak       rustix_syscall3_nr_last
-    .hidden     rustix_syscall3_nr_last
-    .type       rustix_syscall3_nr_last, %function
-rustix_syscall3_nr_last:
-    .fnstart
-    .cantunwind
-    push    {r7, lr}
-    mov     r7, r3
-    svc     #0
-    pop     {r7, pc}
-    .fnend
-    .size rustix_syscall3_nr_last, .-rustix_syscall3_nr_last
-
-    .section    .text.rustix_syscall4_nr_last,"ax",%progbits
-    .p2align 4
-    .weak       rustix_syscall4_nr_last
-    .hidden     rustix_syscall4_nr_last
-    .type       rustix_syscall4_nr_last, %function
-rustix_syscall4_nr_last:
-    .fnstart
-    .cantunwind
-    push    {r7, lr}
-    ldr     r7, [sp, #8]
-    svc     #0
-    pop     {r7, pc}
-    .fnend
-    .size rustix_syscall4_nr_last, .-rustix_syscall4_nr_last
-
-    .section    .text.rustix_syscall5_nr_last,"ax",%progbits
-    .p2align 4
-    .weak       rustix_syscall5_nr_last
-    .hidden     rustix_syscall5_nr_last
-    .type       rustix_syscall5_nr_last, %function
-rustix_syscall5_nr_last:
-    .fnstart
-    .cantunwind
-    push    {r4, r7, r11, lr}
-    ldr     r7, [sp, #20]
-    ldr     r4, [sp, #16]
-    svc     #0
-    pop     {r4, r7, r11, pc}
-    .fnend
-    .size rustix_syscall5_nr_last, .-rustix_syscall5_nr_last
-
-    .section    .text.rustix_syscall6_nr_last,"ax",%progbits
-    .p2align 4
-    .weak       rustix_syscall6_nr_last
-    .hidden     rustix_syscall6_nr_last
-    .type       rustix_syscall6_nr_last, %function
-rustix_syscall6_nr_last:
-    .fnstart
-    .cantunwind
-    push    {r4, r5, r7, lr}
-    add     r7, sp, #16
-    ldm     r7, {r4, r5, r7}
-    svc     #0
-    pop     {r4, r5, r7, pc}
-    .fnend
-    .size rustix_syscall6_nr_last, .-rustix_syscall6_nr_last
-
-    .section .note.GNU-stack,"",%progbits
diff --git a/vendor/rustix/src/backend/linux_raw/arch/outline/mips.s b/vendor/rustix/src/backend/linux_raw/arch/outline/mips.s
index ab1bbfa2d..b016ae124 100644
--- a/vendor/rustix/src/backend/linux_raw/arch/outline/mips.s
+++ b/vendor/rustix/src/backend/linux_raw/arch/outline/mips.s
@@ -186,8 +186,6 @@ rustix_syscall6_nr_last:
     .end        rustix_syscall6_nr_last
     .size       rustix_syscall6_nr_last, .-rustix_syscall6_nr_last
 
-    .section .note.GNU-stack,"",@progbits
-
     .section    .text.rustix_syscall7_nr_last,"ax",@progbits
     .p2align    2
     .weak       rustix_syscall7_nr_last
diff --git a/vendor/rustix/src/backend/linux_raw/arch/outline/mips64.s b/vendor/rustix/src/backend/linux_raw/arch/outline/mips64.s
index 3c5e76e36..a6473990e 100644
--- a/vendor/rustix/src/backend/linux_raw/arch/outline/mips64.s
+++ b/vendor/rustix/src/backend/linux_raw/arch/outline/mips64.s
@@ -7,7 +7,7 @@
 # outline.rs takes care of reordering the nr argument to the end for us,
 # so we only need to move nr into v0.
 
-    .file       "mips.s"
+    .file       "mips64.s"
     .section    .mdebug.abi64
     .previous
     .abicalls
diff --git a/vendor/rustix/src/backend/linux_raw/arch/outline/mod.rs b/vendor/rustix/src/backend/linux_raw/arch/outline/mod.rs
index 5e6f5e1f5..202a2cce9 100644
--- a/vendor/rustix/src/backend/linux_raw/arch/outline/mod.rs
+++ b/vendor/rustix/src/backend/linux_raw/arch/outline/mod.rs
@@ -5,32 +5,23 @@
 //! they match with the kernel convention as closely as possible, to minimize
 //! the amount of out-of-line code we need.
 //!
-//! This is needed in order to support our MSRV of 1.48, which doesn't support
-//! inline asm. When using newer Rust versions, inline asm code is used instead
-//! and these outline libraries are unused.
+//! This is needed because as of our MSRV of 1.63, inline asm and naked
+//! functions are experimental.
 
 #[cfg(target_arch = "x86")]
 mod x86;
 // For these architectures, pass the `nr` argument last.
 #[cfg(any(
-    target_arch = "arm",
-    target_arch = "aarch64",
     target_arch = "mips",
     target_arch = "mips64",
     target_arch = "powerpc64",
-    target_arch = "riscv64",
-    target_arch = "x86_64",
 ))]
 mod nr_last;
 
 #[cfg(any(
-    target_arch = "arm",
-    target_arch = "aarch64",
     target_arch = "mips",
     target_arch = "mips64",
     target_arch = "powerpc64",
-    target_arch = "riscv64",
-    target_arch = "x86_64",
 ))]
 pub(in crate::backend) use nr_last::*;
 #[cfg(target_arch = "x86")]
diff --git a/vendor/rustix/src/backend/linux_raw/arch/outline/riscv64.s b/vendor/rustix/src/backend/linux_raw/arch/outline/riscv64.s
deleted file mode 100644
index 28d692f7c..000000000
--- a/vendor/rustix/src/backend/linux_raw/arch/outline/riscv64.s
+++ /dev/null
@@ -1,116 +0,0 @@
-# Assembly code for making riscv64 syscalls.
-#
-# riscv64 syscall argument register ordering is the same as the riscv64
-# userspace argument register ordering except that the syscall number
-# (nr) is passed in a7.
-#
-# nr_last.rs takes care of reordering the nr argument to the end for us,
-# so we only need to move nr into a7.
-
-    .file       "riscv64.s"
-
-    .section    .text.rustix_syscall0_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall0_nr_last
-    .hidden     rustix_syscall0_nr_last
-    .type       rustix_syscall0_nr_last, @function
-rustix_syscall0_nr_last:
-    .cfi_startproc
-    mv      a7, a0
-    ecall
-    ret
-    .cfi_endproc
-    .size rustix_syscall0_nr_last, .-rustix_syscall0_nr_last
-
-    .section    .text.rustix_syscall1_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall1_nr_last
-    .hidden     rustix_syscall1_nr_last
-    .type       rustix_syscall1_nr_last, @function
-rustix_syscall1_nr_last:
-    .cfi_startproc
-    mv      a7, a1
-    ecall
-    ret
-    .cfi_endproc
-    .size rustix_syscall1_nr_last, .-rustix_syscall1_nr_last
-
-    .section    .text.rustix_syscall1_noreturn_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall1_noreturn_nr_last
-    .hidden     rustix_syscall1_noreturn_nr_last
-    .type       rustix_syscall1_noreturn_nr_last, @function
-rustix_syscall1_noreturn_nr_last:
-    .cfi_startproc
-    mv      a7, a1
-    ecall
-    unimp
-    .cfi_endproc
-    .size rustix_syscall1_noreturn_nr_last, .-rustix_syscall1_noreturn_nr_last
-
-    .section    .text.rustix_syscall2_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall2_nr_last
-    .hidden     rustix_syscall2_nr_last
-    .type       rustix_syscall2_nr_last, @function
-rustix_syscall2_nr_last:
-    .cfi_startproc
-    mv      a7, a2
-    ecall
-    ret
-    .cfi_endproc
-    .size rustix_syscall2_nr_last, .-rustix_syscall2_nr_last
-
-    .section    .text.rustix_syscall3_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall3_nr_last
-    .hidden     rustix_syscall3_nr_last
-    .type       rustix_syscall3_nr_last, @function
-rustix_syscall3_nr_last:
-    .cfi_startproc
-    mv      a7, a3
-    ecall
-    ret
-    .cfi_endproc
-    .size rustix_syscall3_nr_last, .-rustix_syscall3_nr_last
-
-    .section    .text.rustix_syscall4_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall4_nr_last
-    .hidden     rustix_syscall4_nr_last
-    .type       rustix_syscall4_nr_last, @function
-rustix_syscall4_nr_last:
-    .cfi_startproc
-    mv      a7, a4
-    ecall
-    ret
-    .cfi_endproc
-    .size rustix_syscall4_nr_last, .-rustix_syscall4_nr_last
-
-    .section    .text.rustix_syscall5_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall5_nr_last
-    .hidden     rustix_syscall5_nr_last
-    .type       rustix_syscall5_nr_last, @function
-rustix_syscall5_nr_last:
-    .cfi_startproc
-    mv      a7, a5
-    ecall
-    ret
-    .cfi_endproc
-    .size rustix_syscall5_nr_last, .-rustix_syscall5_nr_last
-
-    .section    .text.rustix_syscall6_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall6_nr_last
-    .hidden     rustix_syscall6_nr_last
-    .type       rustix_syscall6_nr_last, @function
-rustix_syscall6_nr_last:
-    .cfi_startproc
-    mv      a7, a6
-    ecall
-    ret
-    .cfi_endproc
-    .size rustix_syscall6_nr_last, .-rustix_syscall6_nr_last
-
-    .section .note.GNU-stack,"",@progbits
diff --git a/vendor/rustix/src/backend/linux_raw/arch/outline/x86_64.s b/vendor/rustix/src/backend/linux_raw/arch/outline/x86_64.s
deleted file mode 100644
index 2beda323b..000000000
--- a/vendor/rustix/src/backend/linux_raw/arch/outline/x86_64.s
+++ /dev/null
@@ -1,122 +0,0 @@
-// Assembly code for making x86-64 syscalls.
-//
-// x86-64 syscall argument register ordering is the same as the x86-64
-// userspace argument register ordering except that a3 is passed in r10
-// instead of rcx, and the syscall number (nr) is passed in eax.
-//
-// outline.rs takes care of reordering the nr argument to the end for us,
-// so we only need to move nr into eax and move rcx into r10 as needed.
-//
-// x32 is not yet supported.
-
-    .file       "x86_64.s"
-    .intel_syntax noprefix
-
-    .section    .text.rustix_syscall0_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall0_nr_last
-    .hidden     rustix_syscall0_nr_last
-    .type       rustix_syscall0_nr_last, @function
-rustix_syscall0_nr_last:
-    .cfi_startproc
-    mov    eax,edi
-    syscall
-    ret
-    .cfi_endproc
-    .size rustix_syscall0_nr_last, .-rustix_syscall0_nr_last
-
-    .section    .text.rustix_syscall1_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall1_nr_last
-    .hidden     rustix_syscall1_nr_last
-    .type       rustix_syscall1_nr_last, @function
-rustix_syscall1_nr_last:
-    .cfi_startproc
-    mov    eax,esi
-    syscall
-    ret
-    .cfi_endproc
-    .size rustix_syscall1_nr_last, .-rustix_syscall1_nr_last
-
-    .section    .text.rustix_syscall1_noreturn_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall1_noreturn_nr_last
-    .hidden     rustix_syscall1_noreturn_nr_last
-    .type       rustix_syscall1_noreturn_nr_last, @function
-rustix_syscall1_noreturn_nr_last:
-    .cfi_startproc
-    mov    eax,esi
-    syscall
-    ud2
-    .cfi_endproc
-    .size rustix_syscall1_noreturn_nr_last, .-rustix_syscall1_noreturn_nr_last
-
-    .section    .text.rustix_syscall2_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall2_nr_last
-    .hidden     rustix_syscall2_nr_last
-    .type       rustix_syscall2_nr_last, @function
-rustix_syscall2_nr_last:
-    .cfi_startproc
-    mov    eax,edx
-    syscall
-    ret
-    .cfi_endproc
-    .size rustix_syscall2_nr_last, .-rustix_syscall2_nr_last
-
-    .section    .text.rustix_syscall3_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall3_nr_last
-    .hidden     rustix_syscall3_nr_last
-    .type       rustix_syscall3_nr_last, @function
-rustix_syscall3_nr_last:
-    .cfi_startproc
-    mov    eax,ecx
-    syscall
-    ret
-    .cfi_endproc
-    .size rustix_syscall3_nr_last, .-rustix_syscall3_nr_last
-
-    .section    .text.rustix_syscall4_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall4_nr_last
-    .hidden     rustix_syscall4_nr_last
-    .type       rustix_syscall4_nr_last, @function
-rustix_syscall4_nr_last:
-    .cfi_startproc
-    mov    eax,r8d
-    mov    r10,rcx
-    syscall
-    ret
-    .cfi_endproc
-    .size rustix_syscall4_nr_last, .-rustix_syscall4_nr_last
-
-    .section    .text.rustix_syscall5_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall5_nr_last
-    .hidden     rustix_syscall5_nr_last
-    .type       rustix_syscall5_nr_last, @function
-rustix_syscall5_nr_last:
-    .cfi_startproc
-    mov    eax,r9d
-    mov    r10,rcx
-    syscall
-    ret
-    .cfi_endproc
-    .size rustix_syscall5_nr_last, .-rustix_syscall5_nr_last
-
-    .section    .text.rustix_syscall6_nr_last,"ax",@progbits
-    .p2align    4
-    .weak       rustix_syscall6_nr_last
-    .hidden     rustix_syscall6_nr_last
-    .type       rustix_syscall6_nr_last, @function
-rustix_syscall6_nr_last:
-    .cfi_startproc
-    mov    eax,DWORD PTR [rsp+0x8]
-    mov    r10,rcx
-    syscall
-    ret
-    .cfi_endproc
-    .size rustix_syscall6_nr_last, .-rustix_syscall6_nr_last
-
-    .section .note.GNU-stack,"",@progbits
diff --git a/vendor/rustix/src/backend/linux_raw/c.rs b/vendor/rustix/src/backend/linux_raw/c.rs
index 89fee82f9..8e77c82d7 100644
--- a/vendor/rustix/src/backend/linux_raw/c.rs
+++ b/vendor/rustix/src/backend/linux_raw/c.rs
@@ -4,30 +4,180 @@
 //! types that are convenient to have defined.
 
 #![allow(unused_imports)]
+#![allow(non_camel_case_types)]
 
+pub type size_t = usize;
 pub(crate) use linux_raw_sys::ctypes::*;
 pub(crate) use linux_raw_sys::errno::EINVAL;
+// Import the kernel's `uid_t` and `gid_t` if they're 32-bit.
+#[cfg(not(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86")))]
+pub(crate) use linux_raw_sys::general::{__kernel_gid_t as gid_t, __kernel_uid_t as uid_t};
 pub(crate) use linux_raw_sys::general::{
-    AF_DECnet, __kernel_sa_family_t as sa_family_t, __kernel_sockaddr_storage as sockaddr_storage,
-    in6_addr, in_addr, iovec, ip_mreq, ipv6_mreq, linger, siginfo_t, sockaddr, sockaddr_in,
-    sockaddr_in6, sockaddr_un, socklen_t, AF_APPLETALK, AF_ASH, AF_ATMPVC, AF_ATMSVC, AF_AX25,
-    AF_BLUETOOTH, AF_BRIDGE, AF_CAN, AF_ECONET, AF_IEEE802154, AF_INET, AF_INET6, AF_IPX, AF_IRDA,
-    AF_ISDN, AF_IUCV, AF_KEY, AF_LLC, AF_NETBEUI, AF_NETLINK, AF_NETROM, AF_PACKET, AF_PHONET,
-    AF_PPPOX, AF_RDS, AF_ROSE, AF_RXRPC, AF_SECURITY, AF_SNA, AF_TIPC, AF_UNIX, AF_UNSPEC,
-    AF_WANPIPE, AF_X25, CLD_CONTINUED, CLD_DUMPED, CLD_EXITED, CLD_KILLED, CLD_STOPPED,
-    CLD_TRAPPED, IPPROTO_AH, IPPROTO_BEETPH, IPPROTO_COMP, IPPROTO_DCCP, IPPROTO_EGP,
-    IPPROTO_ENCAP, IPPROTO_ESP, IPPROTO_ETHERNET, IPPROTO_FRAGMENT, IPPROTO_GRE, IPPROTO_ICMP,
-    IPPROTO_ICMPV6, IPPROTO_IDP, IPPROTO_IGMP, IPPROTO_IP, IPPROTO_IPIP, IPPROTO_IPV6, IPPROTO_MH,
-    IPPROTO_MPLS, IPPROTO_MPTCP, IPPROTO_MTP, IPPROTO_PIM, IPPROTO_PUP, IPPROTO_RAW,
-    IPPROTO_ROUTING, IPPROTO_RSVP, IPPROTO_SCTP, IPPROTO_TCP, IPPROTO_TP, IPPROTO_UDP,
-    IPPROTO_UDPLITE, IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_MULTICAST_LOOP,
-    IPV6_UNICAST_HOPS, IPV6_V6ONLY, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_MULTICAST_LOOP,
-    IP_MULTICAST_TTL, IP_TTL, MSG_CMSG_CLOEXEC, MSG_CONFIRM, MSG_DONTROUTE, MSG_DONTWAIT, MSG_EOR,
-    MSG_ERRQUEUE, MSG_MORE, MSG_NOSIGNAL, MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL, O_CLOEXEC,
-    O_NONBLOCK, O_NONBLOCK as PIDFD_NONBLOCK, P_ALL, P_PID, P_PIDFD, SHUT_RD, SHUT_RDWR, SHUT_WR,
-    SOCK_DGRAM, SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET, SOCK_STREAM, SOL_SOCKET, SO_BROADCAST,
-    SO_ERROR, SO_KEEPALIVE, SO_LINGER, SO_PASSCRED, SO_RCVBUF, SO_RCVTIMEO_NEW, SO_RCVTIMEO_OLD,
-    SO_REUSEADDR, SO_SNDBUF, SO_SNDTIMEO_NEW, SO_SNDTIMEO_OLD, SO_TYPE, TCP_NODELAY,
+    __kernel_pid_t as pid_t, __kernel_time64_t as time_t, __kernel_timespec as timespec, iovec,
+    O_CLOEXEC, O_NOCTTY, O_NONBLOCK, O_RDWR,
 };
-pub(crate) use linux_raw_sys::general::{NFS_SUPER_MAGIC, PROC_SUPER_MAGIC, UTIME_NOW, UTIME_OMIT};
-pub(crate) use linux_raw_sys::general::{XATTR_CREATE, XATTR_REPLACE};
+
+#[cfg(feature = "event")]
+#[cfg(test)]
+pub(crate) use linux_raw_sys::general::epoll_event;
+
+#[cfg(any(
+    feature = "fs",
+    all(
+        not(feature = "use-libc-auxv"),
+        not(target_vendor = "mustang"),
+        any(
+            feature = "param",
+            feature = "runtime",
+            feature = "time",
+            target_arch = "x86",
+        )
+    )
+))]
+pub(crate) use linux_raw_sys::general::{
+    AT_FDCWD, NFS_SUPER_MAGIC, O_LARGEFILE, PROC_SUPER_MAGIC, UTIME_NOW, UTIME_OMIT, XATTR_CREATE,
+    XATTR_REPLACE,
+};
+
+#[cfg(feature = "io_uring")]
+pub(crate) use linux_raw_sys::{general::open_how, io_uring::*};
+
+#[cfg(feature = "net")]
+pub(crate) use linux_raw_sys::{
+    cmsg_macros::*,
+    general::{O_CLOEXEC as SOCK_CLOEXEC, O_NONBLOCK as SOCK_NONBLOCK},
+    if_ether::*,
+    net::{
+        AF_DECnet, __kernel_sa_family_t as sa_family_t,
+        __kernel_sockaddr_storage as sockaddr_storage, cmsghdr, in6_addr, in_addr, ip_mreq,
+        ipv6_mreq, linger, msghdr, sockaddr, sockaddr_in, sockaddr_in6, sockaddr_un, socklen_t,
+        AF_APPLETALK, AF_ASH, AF_ATMPVC, AF_ATMSVC, AF_AX25, AF_BLUETOOTH, AF_BRIDGE, AF_CAN,
+        AF_ECONET, AF_IEEE802154, AF_INET, AF_INET6, AF_IPX, AF_IRDA, AF_ISDN, AF_IUCV, AF_KEY,
+        AF_LLC, AF_NETBEUI, AF_NETLINK, AF_NETROM, AF_PACKET, AF_PHONET, AF_PPPOX, AF_RDS, AF_ROSE,
+        AF_RXRPC, AF_SECURITY, AF_SNA, AF_TIPC, AF_UNIX, AF_UNSPEC, AF_WANPIPE, AF_X25, IPPROTO_AH,
+        IPPROTO_BEETPH, IPPROTO_COMP, IPPROTO_DCCP, IPPROTO_EGP, IPPROTO_ENCAP, IPPROTO_ESP,
+        IPPROTO_ETHERNET, IPPROTO_FRAGMENT, IPPROTO_GRE, IPPROTO_ICMP, IPPROTO_ICMPV6, IPPROTO_IDP,
+        IPPROTO_IGMP, IPPROTO_IP, IPPROTO_IPIP, IPPROTO_IPV6, IPPROTO_MH, IPPROTO_MPLS,
+        IPPROTO_MPTCP, IPPROTO_MTP, IPPROTO_PIM, IPPROTO_PUP, IPPROTO_RAW, IPPROTO_ROUTING,
+        IPPROTO_RSVP, IPPROTO_SCTP, IPPROTO_TCP, IPPROTO_TP, IPPROTO_UDP, IPPROTO_UDPLITE,
+        IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_MULTICAST_HOPS, IPV6_MULTICAST_LOOP,
+        IPV6_UNICAST_HOPS, IPV6_V6ONLY, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_MULTICAST_LOOP,
+        IP_MULTICAST_TTL, IP_TTL, MSG_CMSG_CLOEXEC, MSG_CONFIRM, MSG_DONTROUTE, MSG_DONTWAIT,
+        MSG_EOR, MSG_ERRQUEUE, MSG_MORE, MSG_NOSIGNAL, MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL,
+        SCM_CREDENTIALS, SCM_RIGHTS, SHUT_RD, SHUT_RDWR, SHUT_WR, SOCK_DGRAM, SOCK_RAW, SOCK_RDM,
+        SOCK_SEQPACKET, SOCK_STREAM, SOL_SOCKET, SO_BROADCAST, SO_ERROR, SO_KEEPALIVE, SO_LINGER,
+        SO_PASSCRED, SO_RCVBUF, SO_RCVTIMEO_NEW, SO_RCVTIMEO_NEW as SO_RCVTIMEO, SO_RCVTIMEO_OLD,
+        SO_REUSEADDR, SO_SNDBUF, SO_SNDTIMEO_NEW, SO_SNDTIMEO_NEW as SO_SNDTIMEO, SO_SNDTIMEO_OLD,
+        SO_TYPE, TCP_NODELAY,
+    },
+    netlink::*,
+};
+
+#[cfg(any(feature = "process", feature = "runtime"))]
+pub(crate) use linux_raw_sys::general::siginfo_t;
+
+#[cfg(feature = "process")]
+pub(crate) use linux_raw_sys::general::{
+    CLD_CONTINUED, CLD_DUMPED, CLD_EXITED, CLD_KILLED, CLD_STOPPED, CLD_TRAPPED,
+    O_NONBLOCK as PIDFD_NONBLOCK, P_ALL, P_PID, P_PIDFD,
+};
+
+#[cfg(feature = "termios")]
+pub(crate) use linux_raw_sys::{
+    general::{
+        cc_t, speed_t, tcflag_t, termios, termios2, winsize, B0, B1000000, B110, B115200, B1152000,
+        B1200, B134, B150, B1500000, B1800, B19200, B200, B2000000, B230400, B2400, B2500000, B300,
+        B3000000, B3500000, B38400, B4000000, B460800, B4800, B50, B500000, B57600, B576000, B600,
+        B75, B921600, B9600, BOTHER, BRKINT, BS0, BS1, BSDLY, CBAUD, CBAUDEX, CIBAUD, CLOCAL,
+        CMSPAR, CR0, CR1, CR2, CR3, CRDLY, CREAD, CRTSCTS, CS5, CS6, CS7, CS8, CSIZE, CSTOPB, ECHO,
+        ECHOCTL, ECHOE, ECHOK, ECHOKE, ECHONL, ECHOPRT, EXTA, EXTB, EXTPROC, FF0, FF1, FFDLY,
+        FLUSHO, HUPCL, IBSHIFT, ICANON, ICRNL, IEXTEN, IGNBRK, IGNCR, IGNPAR, IMAXBEL, INLCR,
+        INPCK, ISIG, ISTRIP, IUCLC, IUTF8, IXANY, IXOFF, IXON, NCCS, NL0, NL1, NLDLY, NOFLSH,
+        OCRNL, OFDEL, OFILL, OLCUC, ONLCR, ONLRET, ONOCR, OPOST, PARENB, PARMRK, PARODD, PENDIN,
+        TAB0, TAB1, TAB2, TAB3, TABDLY, TCIFLUSH, TCIOFF, TCIOFLUSH, TCION, TCOFLUSH, TCOOFF,
+        TCOON, TCSADRAIN, TCSAFLUSH, TCSANOW, TOSTOP, VDISCARD, VEOF, VEOL, VEOL2, VERASE, VINTR,
+        VKILL, VLNEXT, VMIN, VQUIT, VREPRINT, VSTART, VSTOP, VSUSP, VSWTC, VT0, VT1, VTDLY, VTIME,
+        VWERASE, XCASE, XTABS,
+    },
+    ioctl::{TCGETS2, TCSETS2, TCSETSF2, TCSETSW2},
+};
+
+// On MIPS, `TCSANOW` et al have `TCSETS` added to them, so we need it to
+// subtract it out.
+#[cfg(all(feature = "termios", any(target_arch = "mips", target_arch = "mips64")))]
+pub(crate) use linux_raw_sys::ioctl::TCSETS;
+
+// Define our own `uid_t` and `gid_t` if the kernel's versions are not 32-bit.
+#[cfg(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86"))]
+pub(crate) type uid_t = u32;
+#[cfg(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86"))]
+pub(crate) type gid_t = u32;
+
+// Bindgen infers `u32` for many of these macro types which meant to be
+// used with `c_int` in the C APIs, so cast them to `c_int`.
+
+// Convert the signal constants from `u32` to `c_int`.
+pub(crate) const SIGHUP: c_int = linux_raw_sys::general::SIGHUP as _;
+pub(crate) const SIGINT: c_int = linux_raw_sys::general::SIGINT as _;
+pub(crate) const SIGQUIT: c_int = linux_raw_sys::general::SIGQUIT as _;
+pub(crate) const SIGILL: c_int = linux_raw_sys::general::SIGILL as _;
+pub(crate) const SIGTRAP: c_int = linux_raw_sys::general::SIGTRAP as _;
+pub(crate) const SIGABRT: c_int = linux_raw_sys::general::SIGABRT as _;
+pub(crate) const SIGBUS: c_int = linux_raw_sys::general::SIGBUS as _;
+pub(crate) const SIGFPE: c_int = linux_raw_sys::general::SIGFPE as _;
+pub(crate) const SIGKILL: c_int = linux_raw_sys::general::SIGKILL as _;
+pub(crate) const SIGUSR1: c_int = linux_raw_sys::general::SIGUSR1 as _;
+pub(crate) const SIGSEGV: c_int = linux_raw_sys::general::SIGSEGV as _;
+pub(crate) const SIGUSR2: c_int = linux_raw_sys::general::SIGUSR2 as _;
+pub(crate) const SIGPIPE: c_int = linux_raw_sys::general::SIGPIPE as _;
+pub(crate) const SIGALRM: c_int = linux_raw_sys::general::SIGALRM as _;
+pub(crate) const SIGTERM: c_int = linux_raw_sys::general::SIGTERM as _;
+#[cfg(not(any(
+    target_arch = "mips",
+    target_arch = "mips64",
+    target_arch = "sparc",
+    target_arch = "sparc64"
+)))]
+pub(crate) const SIGSTKFLT: c_int = linux_raw_sys::general::SIGSTKFLT as _;
+pub(crate) const SIGCHLD: c_int = linux_raw_sys::general::SIGCHLD as _;
+pub(crate) const SIGCONT: c_int = linux_raw_sys::general::SIGCONT as _;
+pub(crate) const SIGSTOP: c_int = linux_raw_sys::general::SIGSTOP as _;
+pub(crate) const SIGTSTP: c_int = linux_raw_sys::general::SIGTSTP as _;
+pub(crate) const SIGTTIN: c_int = linux_raw_sys::general::SIGTTIN as _;
+pub(crate) const SIGTTOU: c_int = linux_raw_sys::general::SIGTTOU as _;
+pub(crate) const SIGURG: c_int = linux_raw_sys::general::SIGURG as _;
+pub(crate) const SIGXCPU: c_int = linux_raw_sys::general::SIGXCPU as _;
+pub(crate) const SIGXFSZ: c_int = linux_raw_sys::general::SIGXFSZ as _;
+pub(crate) const SIGVTALRM: c_int = linux_raw_sys::general::SIGVTALRM as _;
+pub(crate) const SIGPROF: c_int = linux_raw_sys::general::SIGPROF as _;
+pub(crate) const SIGWINCH: c_int = linux_raw_sys::general::SIGWINCH as _;
+pub(crate) const SIGIO: c_int = linux_raw_sys::general::SIGIO as _;
+pub(crate) const SIGPWR: c_int = linux_raw_sys::general::SIGPWR as _;
+pub(crate) const SIGSYS: c_int = linux_raw_sys::general::SIGSYS as _;
+#[cfg(any(
+    target_arch = "mips",
+    target_arch = "mips64",
+    target_arch = "sparc",
+    target_arch = "sparc64"
+))]
+pub(crate) const SIGEMT: c_int = linux_raw_sys::general::SIGEMT as _;
+
+#[cfg(feature = "stdio")]
+pub(crate) const STDIN_FILENO: c_int = linux_raw_sys::general::STDIN_FILENO as _;
+#[cfg(feature = "stdio")]
+pub(crate) const STDOUT_FILENO: c_int = linux_raw_sys::general::STDOUT_FILENO as _;
+#[cfg(feature = "stdio")]
+pub(crate) const STDERR_FILENO: c_int = linux_raw_sys::general::STDERR_FILENO as _;
+
+pub(crate) const PIPE_BUF: usize = linux_raw_sys::general::PIPE_BUF as _;
+
+pub(crate) const CLOCK_MONOTONIC: c_int = linux_raw_sys::general::CLOCK_MONOTONIC as _;
+pub(crate) const CLOCK_REALTIME: c_int = linux_raw_sys::general::CLOCK_REALTIME as _;
+pub(crate) const CLOCK_MONOTONIC_RAW: c_int = linux_raw_sys::general::CLOCK_MONOTONIC_RAW as _;
+pub(crate) const CLOCK_MONOTONIC_COARSE: c_int =
+    linux_raw_sys::general::CLOCK_MONOTONIC_COARSE as _;
+pub(crate) const CLOCK_REALTIME_COARSE: c_int = linux_raw_sys::general::CLOCK_REALTIME_COARSE as _;
+pub(crate) const CLOCK_THREAD_CPUTIME_ID: c_int =
+    linux_raw_sys::general::CLOCK_THREAD_CPUTIME_ID as _;
+pub(crate) const CLOCK_PROCESS_CPUTIME_ID: c_int =
+    linux_raw_sys::general::CLOCK_PROCESS_CPUTIME_ID as _;
diff --git a/vendor/rustix/src/backend/linux_raw/conv.rs b/vendor/rustix/src/backend/linux_raw/conv.rs
index f02b5c046..05d040204 100644
--- a/vendor/rustix/src/backend/linux_raw/conv.rs
+++ b/vendor/rustix/src/backend/linux_raw/conv.rs
@@ -20,22 +20,27 @@ use super::io::errno::try_decode_error;
 #[cfg(target_pointer_width = "64")]
 use super::io::errno::try_decode_u64;
 #[cfg(not(debug_assertions))]
-use super::io::errno::{decode_c_uint_infallible, decode_usize_infallible};
+use super::io::errno::{
+    decode_c_int_infallible, decode_c_uint_infallible, decode_usize_infallible,
+};
 use super::io::errno::{
     try_decode_c_int, try_decode_c_uint, try_decode_raw_fd, try_decode_usize, try_decode_void,
     try_decode_void_star,
 };
 use super::reg::{raw_arg, ArgNumber, ArgReg, RetReg, R0};
-#[cfg(any(feature = "thread", feature = "time", target_arch = "x86"))]
-use super::time::types::ClockId;
 #[cfg(feature = "time")]
 use super::time::types::TimerfdClockId;
+#[cfg(any(feature = "thread", feature = "time", target_arch = "x86"))]
+use crate::clockid::ClockId;
 use crate::fd::OwnedFd;
 use crate::ffi::CStr;
-#[cfg(feature = "fs")]
-use crate::fs::{FileType, Mode, OFlags};
 use crate::io;
-use crate::process::{Pid, Resource, Signal};
+#[cfg(any(feature = "process", feature = "runtime", feature = "termios"))]
+use crate::pid::Pid;
+#[cfg(feature = "process")]
+use crate::process::Resource;
+#[cfg(any(feature = "process", feature = "runtime"))]
+use crate::signal::Signal;
 use crate::utils::{as_mut_ptr, as_ptr};
 use core::mem::MaybeUninit;
 use core::ptr::null_mut;
@@ -44,10 +49,7 @@ use linux_raw_sys::general::__kernel_clockid_t;
 #[cfg(target_pointer_width = "64")]
 use linux_raw_sys::general::__kernel_loff_t;
 #[cfg(feature = "net")]
-use linux_raw_sys::general::socklen_t;
-#[cfg(target_pointer_width = "32")]
-#[cfg(feature = "fs")]
-use linux_raw_sys::general::O_LARGEFILE;
+use linux_raw_sys::net::socklen_t;
 
 /// Convert `SYS_*` constants for socketcall.
 #[cfg(target_arch = "x86")]
@@ -143,9 +145,9 @@ impl<'a, Num: ArgNumber> From<Option<&'a CStr>> for ArgReg<'a, Num> {
 impl<'a, Num: ArgNumber> From<BorrowedFd<'a>> for ArgReg<'a, Num> {
     #[inline]
     fn from(fd: BorrowedFd<'a>) -> Self {
-        // SAFETY: `BorrowedFd` ensures that the file descriptor is valid, and the
-        // lifetime parameter on the resulting `ArgReg` ensures that the result is
-        // bounded by the `BorrowedFd`'s lifetime.
+        // SAFETY: `BorrowedFd` ensures that the file descriptor is valid, and
+        // the lifetime parameter on the resulting `ArgReg` ensures that the
+        // result is bounded by the `BorrowedFd`'s lifetime.
         unsafe { raw_fd(fd.as_raw_fd()) }
     }
 }
@@ -160,7 +162,7 @@ impl<'a, Num: ArgNumber> From<BorrowedFd<'a>> for ArgReg<'a, Num> {
 pub(super) unsafe fn raw_fd<'a, Num: ArgNumber>(fd: RawFd) -> ArgReg<'a, Num> {
     // Use `no_fd` when passing `-1` is intended.
     #[cfg(feature = "fs")]
-    debug_assert!(fd == crate::fs::cwd().as_raw_fd() || fd >= 0);
+    debug_assert!(fd == crate::fs::CWD.as_raw_fd() || fd >= 0);
 
     // Don't pass the `io_uring_register_files_skip` sentry value this way.
     #[cfg(feature = "io_uring")]
@@ -294,116 +296,235 @@ pub(super) fn socklen_t<'a, Num: ArgNumber>(i: socklen_t) -> ArgReg<'a, Num> {
     pass_usize(i as usize)
 }
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<Mode> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(mode: Mode) -> Self {
-        pass_usize(mode.bits() as usize)
+#[cfg(any(
+    feature = "fs",
+    all(
+        not(feature = "use-libc-auxv"),
+        not(target_vendor = "mustang"),
+        any(
+            feature = "param",
+            feature = "runtime",
+            feature = "time",
+            target_arch = "x86",
+        )
+    )
+))]
+pub(crate) mod fs {
+    use super::*;
+    use crate::fs::{FileType, Mode, OFlags};
+    #[cfg(target_pointer_width = "32")]
+    use linux_raw_sys::general::O_LARGEFILE;
+
+    impl<'a, Num: ArgNumber> From<Mode> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(mode: Mode) -> Self {
+            pass_usize(mode.bits() as usize)
+        }
     }
-}
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<(Mode, FileType)> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(pair: (Mode, FileType)) -> Self {
-        pass_usize(pair.0.as_raw_mode() as usize | pair.1.as_raw_mode() as usize)
+    impl<'a, Num: ArgNumber> From<(Mode, FileType)> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(pair: (Mode, FileType)) -> Self {
+            pass_usize(pair.0.as_raw_mode() as usize | pair.1.as_raw_mode() as usize)
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::AtFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::fs::AtFlags) -> Self {
+            c_uint(flags.bits())
+        }
     }
-}
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::AtFlags> for ArgReg<'a, Num> {
+    impl<'a, Num: ArgNumber> From<crate::fs::XattrFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::fs::XattrFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::inotify::CreateFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::fs::inotify::CreateFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::inotify::WatchFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::fs::inotify::WatchFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::MemfdFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::fs::MemfdFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::RenameFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::fs::RenameFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::StatxFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::fs::StatxFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    #[cfg(target_pointer_width = "32")]
     #[inline]
-    fn from(flags: crate::fs::AtFlags) -> Self {
-        c_uint(flags.bits())
+    fn oflags_bits(oflags: OFlags) -> c::c_uint {
+        let mut bits = oflags.bits();
+        // Add `O_LARGEFILE`, unless `O_PATH` is set, as Linux returns `EINVAL`
+        // when both are set.
+        if !oflags.contains(OFlags::PATH) {
+            bits |= O_LARGEFILE;
+        }
+        bits
     }
-}
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::XattrFlags> for ArgReg<'a, Num> {
+    #[cfg(target_pointer_width = "64")]
     #[inline]
-    fn from(flags: crate::fs::XattrFlags) -> Self {
-        c_uint(flags.bits())
+    const fn oflags_bits(oflags: OFlags) -> c::c_uint {
+        oflags.bits()
     }
-}
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::inotify::CreateFlags> for ArgReg<'a, Num> {
+    impl<'a, Num: ArgNumber> From<OFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(oflags: OFlags) -> Self {
+            pass_usize(oflags_bits(oflags) as usize)
+        }
+    }
+
+    /// Convert an `OFlags` into a `u64` for use in the `open_how` struct.
     #[inline]
-    fn from(flags: crate::fs::inotify::CreateFlags) -> Self {
-        c_uint(flags.bits())
+    pub(crate) fn oflags_for_open_how(oflags: OFlags) -> u64 {
+        u64::from(oflags_bits(oflags))
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::FallocateFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::fs::FallocateFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::Advice> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(advice: crate::fs::Advice) -> Self {
+            c_uint(advice as c::c_uint)
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::SealFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::fs::SealFlags) -> Self {
+            c_uint(flags.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::fs::Access> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(access: crate::fs::Access) -> Self {
+            c_uint(access.bits())
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::backend::fs::types::MountFlagsArg> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::backend::fs::types::MountFlagsArg) -> Self {
+            c_uint(flags.0)
+        }
+    }
+
+    impl<'a, Num: ArgNumber> From<crate::backend::fs::types::UnmountFlags> for ArgReg<'a, Num> {
+        #[inline]
+        fn from(flags: crate::backend::fs::types::UnmountFlags) -> Self {
+            c_uint(flags.bits())
+        }
     }
 }
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::inotify::WatchFlags> for ArgReg<'a, Num> {
+impl<'a, Num: ArgNumber> From<crate::io::FdFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::fs::inotify::WatchFlags) -> Self {
+    fn from(flags: crate::io::FdFlags) -> Self {
         c_uint(flags.bits())
     }
 }
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::MemfdFlags> for ArgReg<'a, Num> {
+#[cfg(feature = "pipe")]
+impl<'a, Num: ArgNumber> From<crate::pipe::PipeFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::fs::MemfdFlags) -> Self {
+    fn from(flags: crate::pipe::PipeFlags) -> Self {
         c_uint(flags.bits())
     }
 }
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::RenameFlags> for ArgReg<'a, Num> {
+#[cfg(feature = "pipe")]
+impl<'a, Num: ArgNumber> From<crate::pipe::SpliceFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::fs::RenameFlags) -> Self {
+    fn from(flags: crate::pipe::SpliceFlags) -> Self {
         c_uint(flags.bits())
     }
 }
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::StatxFlags> for ArgReg<'a, Num> {
+impl<'a, Num: ArgNumber> From<crate::io::DupFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::fs::StatxFlags) -> Self {
+    fn from(flags: crate::io::DupFlags) -> Self {
         c_uint(flags.bits())
     }
 }
 
-impl<'a, Num: ArgNumber> From<crate::io::FdFlags> for ArgReg<'a, Num> {
+impl<'a, Num: ArgNumber> From<crate::io::ReadWriteFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::io::FdFlags) -> Self {
+    fn from(flags: crate::io::ReadWriteFlags) -> Self {
         c_uint(flags.bits())
     }
 }
 
-impl<'a, Num: ArgNumber> From<crate::io::PipeFlags> for ArgReg<'a, Num> {
+#[cfg(feature = "process")]
+impl<'a, Num: ArgNumber> From<crate::process::PidfdFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::io::PipeFlags) -> Self {
+    fn from(flags: crate::process::PidfdFlags) -> Self {
         c_uint(flags.bits())
     }
 }
 
-impl<'a, Num: ArgNumber> From<crate::io::DupFlags> for ArgReg<'a, Num> {
+#[cfg(feature = "pty")]
+impl<'a, Num: ArgNumber> From<crate::pty::OpenptFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::io::DupFlags) -> Self {
+    fn from(flags: crate::pty::OpenptFlags) -> Self {
         c_uint(flags.bits())
     }
 }
 
-impl<'a, Num: ArgNumber> From<crate::io::ReadWriteFlags> for ArgReg<'a, Num> {
+#[cfg(feature = "thread")]
+impl<'a, Num: ArgNumber> From<crate::thread::UnshareFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::io::ReadWriteFlags) -> Self {
+    fn from(flags: crate::thread::UnshareFlags) -> Self {
         c_uint(flags.bits())
     }
 }
 
-impl<'a, Num: ArgNumber> From<crate::io::EventfdFlags> for ArgReg<'a, Num> {
+#[cfg(feature = "event")]
+impl<'a, Num: ArgNumber> From<crate::event::EventfdFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::io::EventfdFlags) -> Self {
+    fn from(flags: crate::event::EventfdFlags) -> Self {
         c_uint(flags.bits())
     }
 }
 
-impl<'a, Num: ArgNumber> From<crate::io::epoll::CreateFlags> for ArgReg<'a, Num> {
+#[cfg(feature = "event")]
+impl<'a, Num: ArgNumber> From<crate::event::epoll::CreateFlags> for ArgReg<'a, Num> {
     #[inline]
-    fn from(flags: crate::io::epoll::CreateFlags) -> Self {
+    fn from(flags: crate::event::epoll::CreateFlags) -> Self {
         c_uint(flags.bits())
     }
 }
@@ -464,6 +585,7 @@ impl<'a, Num: ArgNumber> From<crate::backend::mm::types::UserfaultfdFlags> for A
     }
 }
 
+#[cfg(feature = "process")]
 impl<'a, Num: ArgNumber> From<crate::backend::process::types::MembarrierCommand>
     for ArgReg<'a, Num>
 {
@@ -473,6 +595,7 @@ impl<'a, Num: ArgNumber> From<crate::backend::process::types::MembarrierCommand>
     }
 }
 
+#[cfg(feature = "process")]
 impl<'a, Num: ArgNumber> From<crate::process::Cpuid> for ArgReg<'a, Num> {
     #[inline]
     fn from(cpuid: crate::process::Cpuid) -> Self {
@@ -489,54 +612,11 @@ pub(super) fn dev_t<'a, Num: ArgNumber>(dev: u64) -> ArgReg<'a, Num> {
 #[cfg(target_pointer_width = "32")]
 #[inline]
 pub(super) fn dev_t<'a, Num: ArgNumber>(dev: u64) -> io::Result<ArgReg<'a, Num>> {
-    use core::convert::TryInto;
     Ok(pass_usize(dev.try_into().map_err(|_err| io::Errno::INVAL)?))
 }
 
-#[cfg(target_pointer_width = "32")]
-#[cfg(feature = "fs")]
-#[inline]
-fn oflags_bits(oflags: OFlags) -> c::c_uint {
-    let mut bits = oflags.bits();
-    // Add `O_LARGEFILE`, unless `O_PATH` is set, as Linux returns `EINVAL`
-    // when both are set.
-    if !oflags.contains(OFlags::PATH) {
-        bits |= O_LARGEFILE;
-    }
-    bits
-}
-
-#[cfg(target_pointer_width = "64")]
-#[cfg(feature = "fs")]
-#[inline]
-const fn oflags_bits(oflags: OFlags) -> c::c_uint {
-    oflags.bits()
-}
-
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<OFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(oflags: OFlags) -> Self {
-        pass_usize(oflags_bits(oflags) as usize)
-    }
-}
-
-/// Convert an `OFlags` into a `u64` for use in the `open_how` struct.
-#[cfg(feature = "fs")]
-#[inline]
-pub(super) fn oflags_for_open_how(oflags: OFlags) -> u64 {
-    u64::from(oflags_bits(oflags))
-}
-
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::FallocateFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::fs::FallocateFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
 /// Convert a `Resource` into a syscall argument.
+#[cfg(feature = "process")]
 impl<'a, Num: ArgNumber> From<Resource> for ArgReg<'a, Num> {
     #[inline]
     fn from(resource: Resource) -> Self {
@@ -544,6 +624,7 @@ impl<'a, Num: ArgNumber> From<Resource> for ArgReg<'a, Num> {
     }
 }
 
+#[cfg(any(feature = "process", feature = "runtime", feature = "termios"))]
 impl<'a, Num: ArgNumber> From<Pid> for ArgReg<'a, Num> {
     #[inline]
     fn from(pid: Pid) -> Self {
@@ -551,11 +632,13 @@ impl<'a, Num: ArgNumber> From<Pid> for ArgReg<'a, Num> {
     }
 }
 
+#[cfg(feature = "process")]
 #[inline]
 pub(super) fn negative_pid<'a, Num: ArgNumber>(pid: Pid) -> ArgReg<'a, Num> {
     pass_usize(pid.as_raw_nonzero().get().wrapping_neg() as usize)
 }
 
+#[cfg(any(feature = "process", feature = "runtime"))]
 impl<'a, Num: ArgNumber> From<Signal> for ArgReg<'a, Num> {
     #[inline]
     fn from(sig: Signal) -> Self {
@@ -563,22 +646,6 @@ impl<'a, Num: ArgNumber> From<Signal> for ArgReg<'a, Num> {
     }
 }
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::Advice> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(advice: crate::fs::Advice) -> Self {
-        c_uint(advice as c::c_uint)
-    }
-}
-
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::SealFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::fs::SealFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
 #[cfg(feature = "io_uring")]
 impl<'a, Num: ArgNumber> From<crate::io_uring::IoringEnterFlags> for ArgReg<'a, Num> {
     #[inline]
@@ -663,14 +730,6 @@ impl<'a, Num: ArgNumber> From<(crate::thread::FutexOperation, crate::thread::Fut
     }
 }
 
-#[cfg(feature = "fs")]
-impl<'a, Num: ArgNumber> From<crate::fs::Access> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(access: crate::fs::Access) -> Self {
-        c_uint(access.bits())
-    }
-}
-
 #[cfg(feature = "net")]
 impl<'a, Num: ArgNumber> From<crate::net::SocketType> for ArgReg<'a, Num> {
     #[inline]
@@ -680,10 +739,13 @@ impl<'a, Num: ArgNumber> From<crate::net::SocketType> for ArgReg<'a, Num> {
 }
 
 #[cfg(feature = "net")]
-impl<'a, Num: ArgNumber> From<crate::net::Protocol> for ArgReg<'a, Num> {
+impl<'a, Num: ArgNumber> From<Option<crate::net::Protocol>> for ArgReg<'a, Num> {
     #[inline]
-    fn from(protocol: crate::net::Protocol) -> Self {
-        c_uint(protocol.0)
+    fn from(protocol: Option<crate::net::Protocol>) -> Self {
+        c_uint(match protocol {
+            Some(p) => p.0.get(),
+            None => 0,
+        })
     }
 }
 
@@ -701,34 +763,18 @@ impl<'a, Num: ArgNumber, T> From<&'a mut [MaybeUninit<T>]> for ArgReg<'a, Num> {
     }
 }
 
-#[cfg(feature = "fs")]
-#[cfg(any(target_os = "android", target_os = "linux"))]
-impl<'a, Num: ArgNumber> From<crate::backend::fs::types::MountFlagsArg> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::fs::types::MountFlagsArg) -> Self {
-        c_uint(flags.0)
-    }
-}
-
-#[cfg(feature = "fs")]
-#[cfg(any(target_os = "android", target_os = "linux"))]
-impl<'a, Num: ArgNumber> From<crate::backend::fs::types::UnmountFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::fs::types::UnmountFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-impl<'a, Num: ArgNumber> From<crate::process::Uid> for ArgReg<'a, Num> {
+#[cfg(any(feature = "process", feature = "thread"))]
+impl<'a, Num: ArgNumber> From<crate::ugid::Uid> for ArgReg<'a, Num> {
     #[inline]
-    fn from(t: crate::process::Uid) -> Self {
+    fn from(t: crate::ugid::Uid) -> Self {
         c_uint(t.as_raw())
     }
 }
 
-impl<'a, Num: ArgNumber> From<crate::process::Gid> for ArgReg<'a, Num> {
+#[cfg(any(feature = "process", feature = "thread"))]
+impl<'a, Num: ArgNumber> From<crate::ugid::Gid> for ArgReg<'a, Num> {
     #[inline]
-    fn from(t: crate::process::Gid) -> Self {
+    fn from(t: crate::ugid::Gid) -> Self {
         c_uint(t.as_raw())
     }
 }
@@ -830,6 +876,25 @@ pub(super) unsafe fn ret_usize_infallible(raw: RetReg<R0>) -> usize {
     }
 }
 
+/// Convert a `c_int` returned from a syscall that effectively always
+/// returns a `c_int`.
+///
+/// # Safety
+///
+/// This function must only be used with return values from infallible
+/// syscalls.
+#[inline]
+pub(super) unsafe fn ret_c_int_infallible(raw: RetReg<R0>) -> c::c_int {
+    #[cfg(debug_assertions)]
+    {
+        try_decode_c_int(raw).unwrap()
+    }
+    #[cfg(not(debug_assertions))]
+    {
+        decode_c_int_infallible(raw)
+    }
+}
+
 /// Convert a `c_uint` returned from a syscall that effectively always
 /// returns a `c_uint`.
 ///
diff --git a/vendor/rustix/src/backend/linux_raw/elf.rs b/vendor/rustix/src/backend/linux_raw/elf.rs
index 87fb5fa0f..7797f4e21 100644
--- a/vendor/rustix/src/backend/linux_raw/elf.rs
+++ b/vendor/rustix/src/backend/linux_raw/elf.rs
@@ -1,4 +1,4 @@
-//! The ELF ABI.
+//! The ELF ABI. 🧝
 
 #![allow(non_snake_case)]
 #![cfg_attr(
diff --git a/vendor/rustix/src/backend/linux_raw/io/epoll.rs b/vendor/rustix/src/backend/linux_raw/event/epoll.rs
index 3fc6462a2..6577feb51 100644
--- a/vendor/rustix/src/backend/linux_raw/io/epoll.rs
+++ b/vendor/rustix/src/backend/linux_raw/event/epoll.rs
@@ -7,45 +7,50 @@
 //! # Examples
 //!
 //! ```no_run
-//! # #![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
 //! # #[cfg(feature = "net")]
 //! # fn main() -> std::io::Result<()> {
-//! use io_lifetimes::AsFd;
-//! use rustix::io::{epoll, ioctl_fionbio, read, write};
+//! use rustix::event::epoll;
+//! use rustix::fd::AsFd;
+//! use rustix::io::{ioctl_fionbio, read, write};
 //! use rustix::net::{
-//!     accept, bind_v4, listen, socket, AddressFamily, Ipv4Addr, Protocol, SocketAddrV4,
-//!     SocketType,
+//!     accept, bind_v4, listen, socket, AddressFamily, Ipv4Addr, SocketAddrV4, SocketType,
 //! };
 //! use std::collections::HashMap;
 //! use std::os::unix::io::AsRawFd;
 //!
 //! // Create a socket and listen on it.
-//! let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+//! let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, None)?;
 //! bind_v4(&listen_sock, &SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0))?;
 //! listen(&listen_sock, 1)?;
 //!
 //! // Create an epoll object. Using `Owning` here means the epoll object will
 //! // take ownership of the file descriptors registered with it.
-//! let epoll = epoll::epoll_create(epoll::CreateFlags::CLOEXEC)?;
+//! let epoll = epoll::create(epoll::CreateFlags::CLOEXEC)?;
 //!
 //! // Register the socket with the epoll object.
-//! epoll::epoll_add(&epoll, &listen_sock, 1, epoll::EventFlags::IN)?;
+//! epoll::add(
+//!     &epoll,
+//!     &listen_sock,
+//!     epoll::EventData::new_u64(1),
+//!     epoll::EventFlags::IN,
+//! )?;
 //!
 //! // Keep track of the sockets we've opened.
-//! let mut next_id = 2;
+//! let mut next_id = epoll::EventData::new_u64(2);
 //! let mut sockets = HashMap::new();
 //!
 //! // Process events.
 //! let mut event_list = epoll::EventVec::with_capacity(4);
 //! loop {
-//!     epoll::epoll_wait(&epoll, &mut event_list, -1)?;
-//!     for (_event_flags, target) in &event_list {
-//!         if target == 1 {
+//!     epoll::wait(&epoll, &mut event_list, -1)?;
+//!     for event in &event_list {
+//!         let target = event.data;
+//!         if target.u64() == 1 {
 //!             // Accept a new connection, set it to non-blocking, and
 //!             // register to be notified when it's ready to write to.
 //!             let conn_sock = accept(&listen_sock)?;
 //!             ioctl_fionbio(&conn_sock, true)?;
-//!             epoll::epoll_add(
+//!             epoll::add(
 //!                 &epoll,
 //!                 &conn_sock,
 //!                 next_id,
@@ -54,12 +59,12 @@
 //!
 //!             // Keep track of the socket.
 //!             sockets.insert(next_id, conn_sock);
-//!             next_id += 1;
+//!             next_id = epoll::EventData::new_u64(next_id.u64() + 1);
 //!         } else {
 //!             // Write a message to the stream and then unregister it.
 //!             let target = sockets.remove(&target).unwrap();
 //!             write(&target, b"hello\n")?;
-//!             let _ = epoll::epoll_del(&epoll, &target)?;
+//!             let _ = epoll::delete(&epoll, &target)?;
 //!         }
 //!     }
 //! }
@@ -70,15 +75,20 @@
 
 #![allow(unsafe_code)]
 
-use super::super::c;
-use crate::backend::io::syscalls;
+use crate::backend::c;
+use crate::backend::event::syscalls;
 use crate::fd::{AsFd, AsRawFd, OwnedFd};
 use crate::io;
 use alloc::vec::Vec;
 use bitflags::bitflags;
+use core::ffi::c_void;
+use core::hash::{Hash, Hasher};
+use core::slice;
 
 bitflags! {
-    /// `EPOLL_*` for use with [`Epoll::new`].
+    /// `EPOLL_*` for use with [`new`].
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct CreateFlags: c::c_uint {
         /// `EPOLL_CLOEXEC`
         const CLOEXEC = linux_raw_sys::general::EPOLL_CLOEXEC;
@@ -86,8 +96,9 @@ bitflags! {
 }
 
 bitflags! {
-    /// `EPOLL*` for use with [`Epoll::add`].
-    #[derive(Default)]
+    /// `EPOLL*` for use with [`add`].
+    #[repr(transparent)]
+    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct EventFlags: u32 {
         /// `EPOLLIN`
         const IN = linux_raw_sys::general::EPOLLIN as u32;
@@ -136,33 +147,34 @@ bitflags! {
     }
 }
 
-/// `epoll_create1(flags)`—Creates a new `Epoll`.
+/// `epoll_create1(flags)`—Creates a new epoll object.
 ///
 /// Use the [`CreateFlags::CLOEXEC`] flag to prevent the resulting file
 /// descriptor from being implicitly passed across `exec` boundaries.
 #[inline]
 #[doc(alias = "epoll_create1")]
-pub fn epoll_create(flags: CreateFlags) -> io::Result<OwnedFd> {
+pub fn create(flags: CreateFlags) -> io::Result<OwnedFd> {
     syscalls::epoll_create(flags)
 }
 
 /// `epoll_ctl(self, EPOLL_CTL_ADD, data, event)`—Adds an element to an
-/// `Epoll`.
+/// epoll object.
 ///
 /// This registers interest in any of the events set in `events` occurring
 /// on the file descriptor associated with `data`.
 ///
-/// Note that if `epoll_del` is not called on the I/O source passed into
-/// this function before the I/O source is `close`d, then the `epoll` will
-/// act as if the I/O source is still registered with it. This can lead to
-/// spurious events being returned from `epoll_wait`. If a file descriptor
-/// is an `Arc<dyn SystemResource>`, then `epoll` can be thought to maintain
-/// a `Weak<dyn SystemResource>` to the file descriptor.
+/// If [`delete`] is not called on the I/O source passed into this function
+/// before the I/O source is `close`d, then the `epoll` will act as if the I/O
+/// source is still registered with it. This can lead to spurious events being
+/// returned from [`wait`]. If a file descriptor is an
+/// `Arc<dyn SystemResource>`, then `epoll` can be thought to maintain a
+/// `Weak<dyn SystemResource>` to the file descriptor.
 #[doc(alias = "epoll_ctl")]
-pub fn epoll_add(
+#[inline]
+pub fn add(
     epoll: impl AsFd,
     source: impl AsFd,
-    data: u64,
+    data: EventData,
     event_flags: EventFlags,
 ) -> io::Result<()> {
     // SAFETY: We're calling `epoll_ctl` via FFI and we know how it
@@ -171,8 +183,8 @@ pub fn epoll_add(
         syscalls::epoll_add(
             epoll.as_fd(),
             source.as_fd().as_raw_fd(),
-            &linux_raw_sys::general::epoll_event {
-                events: event_flags.bits(),
+            &Event {
+                flags: event_flags,
                 data,
             },
         )
@@ -180,14 +192,15 @@ pub fn epoll_add(
 }
 
 /// `epoll_ctl(self, EPOLL_CTL_MOD, target, event)`—Modifies an element in
-/// this `Epoll`.
+/// a given epoll object.
 ///
 /// This sets the events of interest with `target` to `events`.
 #[doc(alias = "epoll_ctl")]
-pub fn epoll_mod(
+#[inline]
+pub fn modify(
     epoll: impl AsFd,
     source: impl AsFd,
-    data: u64,
+    data: EventData,
     event_flags: EventFlags,
 ) -> io::Result<()> {
     // SAFETY: We're calling `epoll_ctl` via FFI and we know how it
@@ -197,8 +210,8 @@ pub fn epoll_mod(
         syscalls::epoll_mod(
             epoll.as_fd(),
             raw_fd,
-            &linux_raw_sys::general::epoll_event {
-                events: event_flags.bits(),
+            &Event {
+                flags: event_flags,
                 data,
             },
         )
@@ -206,11 +219,10 @@ pub fn epoll_mod(
 }
 
 /// `epoll_ctl(self, EPOLL_CTL_DEL, target, NULL)`—Removes an element in
-/// this `Epoll`.
-///
-/// This also returns the owning `Data`.
+/// a given epoll object.
 #[doc(alias = "epoll_ctl")]
-pub fn epoll_del(epoll: impl AsFd, source: impl AsFd) -> io::Result<()> {
+#[inline]
+pub fn delete(epoll: impl AsFd, source: impl AsFd) -> io::Result<()> {
     // SAFETY: We're calling `epoll_ctl` via FFI and we know how it
     // behaves.
     unsafe {
@@ -224,11 +236,8 @@ pub fn epoll_del(epoll: impl AsFd, source: impl AsFd) -> io::Result<()> {
 ///
 /// For each event of interest, an element is written to `events`. On
 /// success, this returns the number of written elements.
-pub fn epoll_wait(
-    epoll: impl AsFd,
-    event_list: &mut EventVec,
-    timeout: c::c_int,
-) -> io::Result<()> {
+#[inline]
+pub fn wait(epoll: impl AsFd, event_list: &mut EventVec, timeout: c::c_int) -> io::Result<()> {
     // SAFETY: We're calling `epoll_wait` via FFI and we know how it
     // behaves.
     unsafe {
@@ -247,27 +256,112 @@ pub fn epoll_wait(
 
 /// An iterator over the `Event`s in an `EventVec`.
 pub struct Iter<'a> {
-    iter: core::slice::Iter<'a, Event>,
+    /// Use `Copied` to copy the struct, since `Event` is `packed` on some
+    /// platforms, and it's common for users to directly destructure it,
+    /// which would lead to errors about forming references to packed fields.
+    iter: core::iter::Copied<slice::Iter<'a, Event>>,
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = (EventFlags, u64);
+    type Item = Event;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        self.iter
-            .next()
-            .map(|event| (event.event_flags, event.data))
+        self.iter.next()
     }
 }
 
 /// A record of an event that occurred.
 #[repr(C)]
 #[cfg_attr(target_arch = "x86_64", repr(packed))]
-struct Event {
-    // Match the layout of `linux_raw_sys::general::epoll_event`. We just use a
-    // `u64` instead of the full union.
-    event_flags: EventFlags,
-    data: u64,
+#[derive(Copy, Clone, Eq, PartialEq, Hash)]
+pub struct Event {
+    /// Which specific event(s) occurred.
+    pub flags: EventFlags,
+    /// User data.
+    pub data: EventData,
+}
+
+/// Data assocated with an [`Event`]. This can either be a 64-bit integer value
+/// or a pointer which preserves pointer provenance.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union EventData {
+    /// A 64-bit integer value.
+    as_u64: u64,
+
+    /// A `*mut c_void` which preserves pointer provenance, extended to be
+    /// 64-bit so that if we read the value as a `u64` union field, we don't
+    /// get uninitialized memory.
+    sixty_four_bit_pointer: SixtyFourBitPointer,
+}
+
+impl EventData {
+    /// Construct a new value containing a `u64`.
+    #[inline]
+    pub const fn new_u64(value: u64) -> Self {
+        Self { as_u64: value }
+    }
+
+    /// Construct a new value containing a `*mut c_void`.
+    #[inline]
+    pub const fn new_ptr(value: *mut c_void) -> Self {
+        Self {
+            sixty_four_bit_pointer: SixtyFourBitPointer {
+                pointer: value,
+                #[cfg(target_pointer_width = "32")]
+                _padding: 0,
+            },
+        }
+    }
+
+    /// Return the value as a `u64`.
+    ///
+    /// If the stored value was a pointer, the pointer is zero-extended to
+    /// a `u64`.
+    #[inline]
+    pub fn u64(self) -> u64 {
+        unsafe { self.as_u64 }
+    }
+
+    /// Return the value as a `*mut c_void`.
+    ///
+    /// If the stored value was a `u64`, the least-significant bits of the
+    /// `u64` are returned as a pointer value.
+    #[inline]
+    pub fn ptr(self) -> *mut c_void {
+        unsafe { self.sixty_four_bit_pointer.pointer }
+    }
+}
+
+impl PartialEq for EventData {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.u64() == other.u64()
+    }
+}
+
+impl Eq for EventData {}
+
+impl Hash for EventData {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.u64().hash(state)
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct SixtyFourBitPointer {
+    #[cfg(target_endian = "big")]
+    #[cfg(target_pointer_width = "32")]
+    _padding: u32,
+
+    pointer: *mut c_void,
+
+    #[cfg(target_endian = "little")]
+    #[cfg(target_pointer_width = "32")]
+    _padding: u32,
 }
 
 /// A vector of `Event`s, plus context for interpreting them.
@@ -276,6 +370,20 @@ pub struct EventVec {
 }
 
 impl EventVec {
+    /// Constructs an `EventVec` from raw pointer, length, and capacity.
+    ///
+    /// # Safety
+    ///
+    /// This function calls [`Vec::from_raw_parts`] with its arguments.
+    ///
+    /// [`Vec::from_raw_parts`]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.from_raw_parts
+    #[inline]
+    pub unsafe fn from_raw_parts(ptr: *mut Event, len: usize, capacity: usize) -> Self {
+        Self {
+            events: Vec::from_raw_parts(ptr, len, capacity),
+        }
+    }
+
     /// Constructs an `EventVec` with memory for `capacity` `Event`s.
     #[inline]
     pub fn with_capacity(capacity: usize) -> Self {
@@ -318,7 +426,7 @@ impl EventVec {
     #[inline]
     pub fn iter(&self) -> Iter<'_> {
         Iter {
-            iter: self.events.iter(),
+            iter: self.events.iter().copied(),
         }
     }
 
@@ -337,10 +445,18 @@ impl EventVec {
 
 impl<'a> IntoIterator for &'a EventVec {
     type IntoIter = Iter<'a>;
-    type Item = (EventFlags, u64);
+    type Item = Event;
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
+
+#[test]
+fn test_epoll_layouts() {
+    check_renamed_type!(Event, epoll_event);
+    check_renamed_type!(Event, epoll_event);
+    check_renamed_struct_renamed_field!(Event, epoll_event, flags, events);
+    check_renamed_struct_renamed_field!(Event, epoll_event, data, data);
+}
diff --git a/vendor/rustix/src/backend/linux_raw/event/mod.rs b/vendor/rustix/src/backend/linux_raw/event/mod.rs
new file mode 100644
index 000000000..605de2538
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/event/mod.rs
@@ -0,0 +1,4 @@
+pub mod epoll;
+pub(crate) mod poll_fd;
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/io/poll_fd.rs b/vendor/rustix/src/backend/linux_raw/event/poll_fd.rs
index 252358331..906efe0ef 100644
--- a/vendor/rustix/src/backend/linux_raw/io/poll_fd.rs
+++ b/vendor/rustix/src/backend/linux_raw/event/poll_fd.rs
@@ -5,6 +5,8 @@ bitflags! {
     /// `POLL*` flags for use with [`poll`].
     ///
     /// [`poll`]: crate::io::poll
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct PollFlags: u16 {
         /// `POLLIN`
         const IN = linux_raw_sys::general::POLLIN as u16;
@@ -33,7 +35,7 @@ bitflags! {
 
 /// `struct pollfd`—File descriptor and flags for use with [`poll`].
 ///
-/// [`poll`]: crate::io::poll
+/// [`poll`]: crate::event::poll
 #[doc(alias = "pollfd")]
 #[repr(C)]
 #[derive(Debug, Clone)]
diff --git a/vendor/rustix/src/backend/linux_raw/event/syscalls.rs b/vendor/rustix/src/backend/linux_raw/event/syscalls.rs
new file mode 100644
index 000000000..6d6b35d75
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/event/syscalls.rs
@@ -0,0 +1,131 @@
+//! linux_raw syscalls supporting `rustix::event`.
+//!
+//! # Safety
+//!
+//! See the `rustix::backend` module documentation for details.
+#![allow(unsafe_code)]
+#![allow(clippy::undocumented_unsafe_blocks)]
+
+use crate::backend::c;
+use crate::backend::conv::{
+    by_ref, c_int, c_uint, pass_usize, raw_fd, ret, ret_owned_fd, ret_usize, slice_mut, zero,
+};
+use crate::event::{epoll, EventfdFlags, PollFd};
+use crate::fd::{BorrowedFd, OwnedFd};
+use crate::io;
+use linux_raw_sys::general::{EPOLL_CTL_ADD, EPOLL_CTL_DEL, EPOLL_CTL_MOD};
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
+use {
+    crate::backend::conv::{opt_ref, size_of},
+    linux_raw_sys::general::{__kernel_timespec, kernel_sigset_t},
+};
+
+#[inline]
+pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> {
+    let (fds_addr_mut, fds_len) = slice_mut(fds);
+
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
+    unsafe {
+        let timeout = if timeout >= 0 {
+            Some(__kernel_timespec {
+                tv_sec: (timeout as i64) / 1000,
+                tv_nsec: (timeout as i64) % 1000 * 1_000_000,
+            })
+        } else {
+            None
+        };
+        ret_usize(syscall!(
+            __NR_ppoll,
+            fds_addr_mut,
+            fds_len,
+            opt_ref(timeout.as_ref()),
+            zero(),
+            size_of::<kernel_sigset_t, _>()
+        ))
+    }
+    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
+    unsafe {
+        ret_usize(syscall!(__NR_poll, fds_addr_mut, fds_len, c_int(timeout)))
+    }
+}
+
+#[inline]
+pub(crate) fn epoll_create(flags: epoll::CreateFlags) -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(syscall_readonly!(__NR_epoll_create1, flags)) }
+}
+
+#[inline]
+pub(crate) unsafe fn epoll_add(
+    epfd: BorrowedFd<'_>,
+    fd: c::c_int,
+    event: &epoll::Event,
+) -> io::Result<()> {
+    ret(syscall_readonly!(
+        __NR_epoll_ctl,
+        epfd,
+        c_uint(EPOLL_CTL_ADD),
+        raw_fd(fd),
+        by_ref(event)
+    ))
+}
+
+#[inline]
+pub(crate) unsafe fn epoll_mod(
+    epfd: BorrowedFd<'_>,
+    fd: c::c_int,
+    event: &epoll::Event,
+) -> io::Result<()> {
+    ret(syscall_readonly!(
+        __NR_epoll_ctl,
+        epfd,
+        c_uint(EPOLL_CTL_MOD),
+        raw_fd(fd),
+        by_ref(event)
+    ))
+}
+
+#[inline]
+pub(crate) unsafe fn epoll_del(epfd: BorrowedFd<'_>, fd: c::c_int) -> io::Result<()> {
+    ret(syscall_readonly!(
+        __NR_epoll_ctl,
+        epfd,
+        c_uint(EPOLL_CTL_DEL),
+        raw_fd(fd),
+        zero()
+    ))
+}
+
+#[inline]
+pub(crate) fn epoll_wait(
+    epfd: BorrowedFd<'_>,
+    events: *mut epoll::Event,
+    num_events: usize,
+    timeout: c::c_int,
+) -> io::Result<usize> {
+    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
+    unsafe {
+        ret_usize(syscall!(
+            __NR_epoll_wait,
+            epfd,
+            events,
+            pass_usize(num_events),
+            c_int(timeout)
+        ))
+    }
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
+    unsafe {
+        ret_usize(syscall!(
+            __NR_epoll_pwait,
+            epfd,
+            events,
+            pass_usize(num_events),
+            c_int(timeout),
+            zero()
+        ))
+    }
+}
+
+#[inline]
+pub(crate) fn eventfd(initval: u32, flags: EventfdFlags) -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(syscall_readonly!(__NR_eventfd2, c_uint(initval), flags)) }
+}
diff --git a/vendor/rustix/src/backend/linux_raw/event/types.rs b/vendor/rustix/src/backend/linux_raw/event/types.rs
new file mode 100644
index 000000000..e6273959c
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/event/types.rs
@@ -0,0 +1,18 @@
+use crate::backend::c;
+use bitflags::bitflags;
+
+bitflags! {
+    /// `EFD_*` flags for use with [`eventfd`].
+    ///
+    /// [`eventfd`]: crate::io::eventfd
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct EventfdFlags: c::c_uint {
+        /// `EFD_CLOEXEC`
+        const CLOEXEC = linux_raw_sys::general::EFD_CLOEXEC;
+        /// `EFD_NONBLOCK`
+        const NONBLOCK = linux_raw_sys::general::EFD_NONBLOCK;
+        /// `EFD_SEMAPHORE`
+        const SEMAPHORE = linux_raw_sys::general::EFD_SEMAPHORE;
+    }
+}
diff --git a/vendor/rustix/src/backend/linux_raw/fs/dir.rs b/vendor/rustix/src/backend/linux_raw/fs/dir.rs
index cfa347d03..4df589af5 100644
--- a/vendor/rustix/src/backend/linux_raw/fs/dir.rs
+++ b/vendor/rustix/src/backend/linux_raw/fs/dir.rs
@@ -4,6 +4,7 @@ use crate::fs::{
     fcntl_getfl, fstat, fstatfs, fstatvfs, openat, FileType, Mode, OFlags, Stat, StatFs, StatVfs,
 };
 use crate::io;
+#[cfg(feature = "process")]
 use crate::process::fchdir;
 use crate::utils::as_ptr;
 use alloc::borrow::ToOwned;
@@ -100,8 +101,7 @@ impl Dir {
             .iter()
             .position(|x| *x == b'\0')
             .unwrap();
-        let name =
-            CStr::from_bytes_with_nul(&self.buf[name_start..name_start + name_len + 1]).unwrap();
+        let name = CStr::from_bytes_with_nul(&self.buf[name_start..][..=name_len]).unwrap();
         let name = name.to_owned();
         assert!(name.as_bytes().len() <= self.buf.len() - name_start);
 
@@ -175,6 +175,8 @@ impl Dir {
     }
 
     /// `fchdir(self)`
+    #[cfg(feature = "process")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "process")))]
     #[inline]
     pub fn chdir(&self) -> io::Result<()> {
         fchdir(&self.fd)
diff --git a/vendor/rustix/src/backend/linux_raw/fs/inotify.rs b/vendor/rustix/src/backend/linux_raw/fs/inotify.rs
index a3c274741..cb9d87b82 100644
--- a/vendor/rustix/src/backend/linux_raw/fs/inotify.rs
+++ b/vendor/rustix/src/backend/linux_raw/fs/inotify.rs
@@ -1,6 +1,6 @@
 //! inotify support for working with inotifies
 
-use super::super::c;
+use crate::backend::c;
 use crate::backend::fs::syscalls;
 use crate::fd::{BorrowedFd, OwnedFd};
 use crate::io;
@@ -10,6 +10,8 @@ bitflags! {
     /// `IN_*` for use with [`inotify_init`].
     ///
     /// [`inotify_init`]: crate::fs::inotify::inotify_init
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct CreateFlags: c::c_uint {
         /// `IN_CLOEXEC`
         const CLOEXEC = linux_raw_sys::general::IN_CLOEXEC;
@@ -22,7 +24,8 @@ bitflags! {
     /// `IN*` for use with [`inotify_add_watch`].
     ///
     /// [`inotify_add_watch`]: crate::fs::inotify::inotify_add_watch
-    #[derive(Default)]
+    #[repr(transparent)]
+    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct WatchFlags: c::c_uint {
         /// `IN_ACCESS`
         const ACCESS = linux_raw_sys::general::IN_ACCESS;
@@ -76,6 +79,7 @@ bitflags! {
 /// Use the [`CreateFlags::CLOEXEC`] flag to prevent the resulting file
 /// descriptor from being implicitly passed across `exec` boundaries.
 #[doc(alias = "inotify_init1")]
+#[inline]
 pub fn inotify_init(flags: CreateFlags) -> io::Result<OwnedFd> {
     syscalls::inotify_init1(flags)
 }
@@ -89,6 +93,7 @@ pub fn inotify_init(flags: CreateFlags) -> io::Result<OwnedFd> {
 /// different paths to this method may result in it returning
 /// the same watch descriptor. An application should keep track of this
 /// externally to avoid logic errors.
+#[inline]
 pub fn inotify_add_watch<P: crate::path::Arg>(
     inot: BorrowedFd<'_>,
     path: P,
@@ -103,6 +108,7 @@ pub fn inotify_add_watch<P: crate::path::Arg>(
 /// The watch descriptor provided should have previously been returned
 /// by [`inotify_add_watch`] and not previously have been removed.
 #[doc(alias = "inotify_rm_watch")]
+#[inline]
 pub fn inotify_remove_watch(inot: BorrowedFd<'_>, wd: i32) -> io::Result<()> {
     syscalls::inotify_rm_watch(inot, wd)
 }
diff --git a/vendor/rustix/src/backend/linux_raw/fs/syscalls.rs b/vendor/rustix/src/backend/linux_raw/fs/syscalls.rs
index d0d855cc1..78a2088b2 100644
--- a/vendor/rustix/src/backend/linux_raw/fs/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/fs/syscalls.rs
@@ -4,16 +4,16 @@
 //!
 //! See the `rustix::backend` module documentation for details.
 #![allow(unsafe_code)]
-#![allow(dead_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::c;
-use super::super::conv::{
-    by_ref, c_int, c_uint, dev_t, oflags_for_open_how, opt_mut, pass_usize, raw_fd, ret, ret_c_int,
-    ret_c_uint, ret_infallible, ret_owned_fd, ret_usize, size_of, slice, slice_mut, zero,
+use crate::backend::c;
+use crate::backend::conv::fs::oflags_for_open_how;
+use crate::backend::conv::{
+    by_ref, c_int, c_uint, dev_t, opt_mut, pass_usize, raw_fd, ret, ret_c_int, ret_c_uint,
+    ret_infallible, ret_owned_fd, ret_usize, size_of, slice, slice_mut, zero,
 };
 #[cfg(target_pointer_width = "64")]
-use super::super::conv::{loff_t, loff_t_from_u64, ret_u64};
+use crate::backend::conv::{loff_t, loff_t_from_u64, ret_u64};
 #[cfg(any(
     target_arch = "aarch64",
     target_arch = "riscv64",
@@ -23,98 +23,77 @@ use super::super::conv::{loff_t, loff_t_from_u64, ret_u64};
 use crate::fd::AsFd;
 use crate::fd::{BorrowedFd, OwnedFd};
 use crate::ffi::CStr;
+#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
+use crate::fs::CWD;
 use crate::fs::{
-    inotify, Access, Advice, AtFlags, FallocateFlags, FileType, FlockOperation, MemfdFlags, Mode,
-    OFlags, RenameFlags, ResolveFlags, SealFlags, Stat, StatFs, StatVfs, StatVfsMountFlags,
-    StatxFlags, Timestamps, XattrFlags,
+    inotify, Access, Advice, AtFlags, FallocateFlags, FileType, FlockOperation, Gid, MemfdFlags,
+    Mode, OFlags, RenameFlags, ResolveFlags, SealFlags, SeekFrom, Stat, StatFs, StatVfs,
+    StatVfsMountFlags, StatxFlags, Timestamps, Uid, XattrFlags,
 };
-use crate::io::{self, SeekFrom};
-use crate::process::{Gid, Uid};
-#[cfg(any(target_pointer_width = "32", target_arch = "mips64"))]
-use core::convert::TryInto;
-use core::mem::MaybeUninit;
+use crate::io;
+use core::mem::{transmute, zeroed, MaybeUninit};
 #[cfg(target_arch = "mips64")]
 use linux_raw_sys::general::stat as linux_stat64;
 use linux_raw_sys::general::{
     __kernel_fsid_t, __kernel_timespec, open_how, statx, AT_EACCESS, AT_FDCWD, AT_REMOVEDIR,
-    AT_SYMLINK_NOFOLLOW, F_ADD_SEALS, F_GETFL, F_GETLEASE, F_GETOWN, F_GETPIPE_SZ, F_GETSIG,
-    F_GET_SEALS, F_SETFL, F_SETPIPE_SZ, SEEK_CUR, SEEK_DATA, SEEK_END, SEEK_HOLE, SEEK_SET,
-    STATX__RESERVED,
+    AT_SYMLINK_NOFOLLOW, F_ADD_SEALS, F_GETFL, F_GET_SEALS, F_SETFL, SEEK_CUR, SEEK_DATA, SEEK_END,
+    SEEK_HOLE, SEEK_SET, STATX__RESERVED,
 };
+use linux_raw_sys::ioctl::{BLKPBSZGET, BLKSSZGET, EXT4_IOC_RESIZE_FS, FICLONE};
 #[cfg(target_pointer_width = "32")]
 use {
-    super::super::conv::{hi, lo, slice_just_addr},
+    crate::backend::conv::{hi, lo, slice_just_addr},
     linux_raw_sys::general::stat64 as linux_stat64,
     linux_raw_sys::general::timespec as __kernel_old_timespec,
 };
 
 #[inline]
-pub(crate) fn open(filename: &CStr, flags: OFlags, mode: Mode) -> io::Result<OwnedFd> {
+pub(crate) fn open(path: &CStr, flags: OFlags, mode: Mode) -> io::Result<OwnedFd> {
+    // Always enable support for large files.
+    let flags = flags | OFlags::from_bits_retain(c::O_LARGEFILE);
+
     #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     {
-        openat(crate::fs::cwd().as_fd(), filename, flags, mode)
+        openat(CWD.as_fd(), path, flags, mode)
     }
-    #[cfg(all(
-        target_pointer_width = "32",
-        not(any(target_arch = "aarch64", target_arch = "riscv64")),
-    ))]
+    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
     unsafe {
-        ret_owned_fd(syscall_readonly!(__NR_open, filename, flags, mode))
-    }
-    #[cfg(all(
-        target_pointer_width = "64",
-        not(any(target_arch = "aarch64", target_arch = "riscv64")),
-    ))]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(__NR_open, filename, flags, mode))
+        ret_owned_fd(syscall_readonly!(__NR_open, path, flags, mode))
     }
 }
 
 #[inline]
 pub(crate) fn openat(
     dirfd: BorrowedFd<'_>,
-    filename: &CStr,
+    path: &CStr,
     flags: OFlags,
     mode: Mode,
 ) -> io::Result<OwnedFd> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(__NR_openat, dirfd, filename, flags, mode))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(__NR_openat, dirfd, filename, flags, mode))
-    }
+    // Always enable support for large files.
+    let flags = flags | OFlags::from_bits_retain(c::O_LARGEFILE);
+
+    unsafe { ret_owned_fd(syscall_readonly!(__NR_openat, dirfd, path, flags, mode)) }
 }
 
 #[inline]
 pub(crate) fn openat2(
     dirfd: BorrowedFd<'_>,
-    pathname: &CStr,
-    flags: OFlags,
+    path: &CStr,
+    mut flags: OFlags,
     mode: Mode,
     resolve: ResolveFlags,
 ) -> io::Result<OwnedFd> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(
-            __NR_openat2,
-            dirfd,
-            pathname,
-            by_ref(&open_how {
-                flags: oflags_for_open_how(flags),
-                mode: u64::from(mode.bits()),
-                resolve: resolve.bits(),
-            }),
-            size_of::<open_how, _>()
-        ))
+    // Enable support for large files, but not with `O_PATH` because
+    // `openat2` doesn't like those flags together.
+    if !flags.contains(OFlags::PATH) {
+        flags |= OFlags::from_bits_retain(c::O_LARGEFILE);
     }
-    #[cfg(target_pointer_width = "64")]
+
     unsafe {
         ret_owned_fd(syscall_readonly!(
             __NR_openat2,
             dirfd,
-            pathname,
+            path,
             by_ref(&open_how {
                 flags: oflags_for_open_how(flags),
                 mode: u64::from(mode.bits()),
@@ -126,12 +105,12 @@ pub(crate) fn openat2(
 }
 
 #[inline]
-pub(crate) fn chmod(filename: &CStr, mode: Mode) -> io::Result<()> {
+pub(crate) fn chmod(path: &CStr, mode: Mode) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_fchmodat,
             raw_fd(AT_FDCWD),
-            filename,
+            path,
             mode
         ))
     }
@@ -140,7 +119,7 @@ pub(crate) fn chmod(filename: &CStr, mode: Mode) -> io::Result<()> {
 #[inline]
 pub(crate) fn chmodat(
     dirfd: BorrowedFd<'_>,
-    filename: &CStr,
+    path: &CStr,
     mode: Mode,
     flags: AtFlags,
 ) -> io::Result<()> {
@@ -150,7 +129,7 @@ pub(crate) fn chmodat(
     if !flags.is_empty() {
         return Err(io::Errno::INVAL);
     }
-    unsafe { ret(syscall_readonly!(__NR_fchmodat, dirfd, filename, mode)) }
+    unsafe { ret(syscall_readonly!(__NR_fchmodat, dirfd, path, mode)) }
 }
 
 #[inline]
@@ -161,17 +140,17 @@ pub(crate) fn fchmod(fd: BorrowedFd<'_>, mode: Mode) -> io::Result<()> {
 #[inline]
 pub(crate) fn chownat(
     dirfd: BorrowedFd<'_>,
-    filename: &CStr,
+    path: &CStr,
     owner: Option<Uid>,
     group: Option<Gid>,
     flags: AtFlags,
 ) -> io::Result<()> {
     unsafe {
-        let (ow, gr) = crate::process::translate_fchown_args(owner, group);
+        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
         ret(syscall_readonly!(
             __NR_fchownat,
             dirfd,
-            filename,
+            path,
             c_uint(ow),
             c_uint(gr),
             flags
@@ -182,7 +161,7 @@ pub(crate) fn chownat(
 #[inline]
 pub(crate) fn fchown(fd: BorrowedFd<'_>, owner: Option<Uid>, group: Option<Gid>) -> io::Result<()> {
     unsafe {
-        let (ow, gr) = crate::process::translate_fchown_args(owner, group);
+        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
         ret(syscall_readonly!(__NR_fchown, fd, c_uint(ow), c_uint(gr)))
     }
 }
@@ -190,7 +169,7 @@ pub(crate) fn fchown(fd: BorrowedFd<'_>, owner: Option<Uid>, group: Option<Gid>)
 #[inline]
 pub(crate) fn mknodat(
     dirfd: BorrowedFd<'_>,
-    filename: &CStr,
+    path: &CStr,
     file_type: FileType,
     mode: Mode,
     dev: u64,
@@ -200,7 +179,7 @@ pub(crate) fn mknodat(
         ret(syscall_readonly!(
             __NR_mknodat,
             dirfd,
-            filename,
+            path,
             (mode, file_type),
             dev_t(dev)?
         ))
@@ -210,7 +189,7 @@ pub(crate) fn mknodat(
         ret(syscall_readonly!(
             __NR_mknodat,
             dirfd,
-            filename,
+            path,
             (mode, file_type),
             dev_t(dev)
         ))
@@ -442,9 +421,15 @@ pub(crate) fn sync() {
 
 #[inline]
 pub(crate) fn fstat(fd: BorrowedFd<'_>) -> io::Result<Stat> {
+    // 32-bit and mips64 Linux: `struct stat64` is not y2038 compatible; use
+    // `statx`.
+    //
+    // And, some old platforms don't support `statx`, and some fail with a
+    // confusing error code, so we call `crate::fs::statx` to handle that. If
+    // `statx` isn't available, fall back to the buggy system call.
     #[cfg(any(target_pointer_width = "32", target_arch = "mips64"))]
     {
-        match statx(fd, cstr!(""), AtFlags::EMPTY_PATH, StatxFlags::BASIC_STATS) {
+        match crate::fs::statx(fd, cstr!(""), AtFlags::EMPTY_PATH, StatxFlags::BASIC_STATS) {
             Ok(x) => statx_to_stat(x),
             Err(io::Errno::NOSYS) => fstat_old(fd),
             Err(err) => Err(err),
@@ -477,17 +462,18 @@ fn fstat_old(fd: BorrowedFd<'_>) -> io::Result<Stat> {
 }
 
 #[inline]
-pub(crate) fn stat(filename: &CStr) -> io::Result<Stat> {
+pub(crate) fn stat(path: &CStr) -> io::Result<Stat> {
+    // See the comments in `fstat` about using `crate::fs::statx` here.
     #[cfg(any(target_pointer_width = "32", target_arch = "mips64"))]
     {
-        match statx(
-            crate::fs::cwd().as_fd(),
-            filename,
+        match crate::fs::statx(
+            crate::fs::CWD.as_fd(),
+            path,
             AtFlags::empty(),
             StatxFlags::BASIC_STATS,
         ) {
             Ok(x) => statx_to_stat(x),
-            Err(io::Errno::NOSYS) => stat_old(filename),
+            Err(io::Errno::NOSYS) => stat_old(path),
             Err(err) => Err(err),
         }
     }
@@ -498,7 +484,7 @@ pub(crate) fn stat(filename: &CStr) -> io::Result<Stat> {
         ret(syscall!(
             __NR_newfstatat,
             raw_fd(AT_FDCWD),
-            filename,
+            path,
             &mut result,
             c_uint(0)
         ))?;
@@ -507,7 +493,7 @@ pub(crate) fn stat(filename: &CStr) -> io::Result<Stat> {
 }
 
 #[cfg(any(target_pointer_width = "32", target_arch = "mips64"))]
-fn stat_old(filename: &CStr) -> io::Result<Stat> {
+fn stat_old(path: &CStr) -> io::Result<Stat> {
     let mut result = MaybeUninit::<linux_stat64>::uninit();
 
     #[cfg(target_arch = "mips64")]
@@ -515,7 +501,7 @@ fn stat_old(filename: &CStr) -> io::Result<Stat> {
         ret(syscall!(
             __NR_newfstatat,
             raw_fd(AT_FDCWD),
-            filename,
+            path,
             &mut result,
             c_uint(0)
         ))?;
@@ -527,7 +513,7 @@ fn stat_old(filename: &CStr) -> io::Result<Stat> {
         ret(syscall!(
             __NR_fstatat64,
             raw_fd(AT_FDCWD),
-            filename,
+            path,
             &mut result,
             c_uint(0)
         ))?;
@@ -536,12 +522,13 @@ fn stat_old(filename: &CStr) -> io::Result<Stat> {
 }
 
 #[inline]
-pub(crate) fn statat(dirfd: BorrowedFd<'_>, filename: &CStr, flags: AtFlags) -> io::Result<Stat> {
+pub(crate) fn statat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> {
+    // See the comments in `fstat` about using `crate::fs::statx` here.
     #[cfg(any(target_pointer_width = "32", target_arch = "mips64"))]
     {
-        match statx(dirfd, filename, flags, StatxFlags::BASIC_STATS) {
+        match crate::fs::statx(dirfd, path, flags, StatxFlags::BASIC_STATS) {
             Ok(x) => statx_to_stat(x),
-            Err(io::Errno::NOSYS) => statat_old(dirfd, filename, flags),
+            Err(io::Errno::NOSYS) => statat_old(dirfd, path, flags),
             Err(err) => Err(err),
         }
     }
@@ -549,58 +536,41 @@ pub(crate) fn statat(dirfd: BorrowedFd<'_>, filename: &CStr, flags: AtFlags) ->
     #[cfg(all(target_pointer_width = "64", not(target_arch = "mips64")))]
     unsafe {
         let mut result = MaybeUninit::<Stat>::uninit();
-        ret(syscall!(
-            __NR_newfstatat,
-            dirfd,
-            filename,
-            &mut result,
-            flags
-        ))?;
+        ret(syscall!(__NR_newfstatat, dirfd, path, &mut result, flags))?;
         Ok(result.assume_init())
     }
 }
 
 #[cfg(any(target_pointer_width = "32", target_arch = "mips64"))]
-fn statat_old(dirfd: BorrowedFd<'_>, filename: &CStr, flags: AtFlags) -> io::Result<Stat> {
+fn statat_old(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> {
     let mut result = MaybeUninit::<linux_stat64>::uninit();
 
     #[cfg(target_arch = "mips64")]
     unsafe {
-        ret(syscall!(
-            __NR_newfstatat,
-            dirfd,
-            filename,
-            &mut result,
-            flags
-        ))?;
+        ret(syscall!(__NR_newfstatat, dirfd, path, &mut result, flags))?;
         stat_to_stat(result.assume_init())
     }
 
     #[cfg(target_pointer_width = "32")]
     unsafe {
-        ret(syscall!(
-            __NR_fstatat64,
-            dirfd,
-            filename,
-            &mut result,
-            flags
-        ))?;
+        ret(syscall!(__NR_fstatat64, dirfd, path, &mut result, flags))?;
         stat_to_stat(result.assume_init())
     }
 }
 
 #[inline]
-pub(crate) fn lstat(filename: &CStr) -> io::Result<Stat> {
+pub(crate) fn lstat(path: &CStr) -> io::Result<Stat> {
+    // See the comments in `fstat` about using `crate::fs::statx` here.
     #[cfg(any(target_pointer_width = "32", target_arch = "mips64"))]
     {
-        match statx(
-            crate::fs::cwd().as_fd(),
-            filename,
+        match crate::fs::statx(
+            crate::fs::CWD.as_fd(),
+            path,
             AtFlags::SYMLINK_NOFOLLOW,
             StatxFlags::BASIC_STATS,
         ) {
             Ok(x) => statx_to_stat(x),
-            Err(io::Errno::NOSYS) => lstat_old(filename),
+            Err(io::Errno::NOSYS) => lstat_old(path),
             Err(err) => Err(err),
         }
     }
@@ -611,7 +581,7 @@ pub(crate) fn lstat(filename: &CStr) -> io::Result<Stat> {
         ret(syscall!(
             __NR_newfstatat,
             raw_fd(AT_FDCWD),
-            filename,
+            path,
             &mut result,
             c_uint(AT_SYMLINK_NOFOLLOW)
         ))?;
@@ -620,7 +590,7 @@ pub(crate) fn lstat(filename: &CStr) -> io::Result<Stat> {
 }
 
 #[cfg(any(target_pointer_width = "32", target_arch = "mips64"))]
-fn lstat_old(filename: &CStr) -> io::Result<Stat> {
+fn lstat_old(path: &CStr) -> io::Result<Stat> {
     let mut result = MaybeUninit::<linux_stat64>::uninit();
 
     #[cfg(target_arch = "mips64")]
@@ -628,7 +598,7 @@ fn lstat_old(filename: &CStr) -> io::Result<Stat> {
         ret(syscall!(
             __NR_newfstatat,
             raw_fd(AT_FDCWD),
-            filename,
+            path,
             &mut result,
             c_uint(AT_SYMLINK_NOFOLLOW)
         ))?;
@@ -640,7 +610,7 @@ fn lstat_old(filename: &CStr) -> io::Result<Stat> {
         ret(syscall!(
             __NR_fstatat64,
             raw_fd(AT_FDCWD),
-            filename,
+            path,
             &mut result,
             c_uint(AT_SYMLINK_NOFOLLOW)
         ))?;
@@ -750,7 +720,7 @@ fn stat_to_stat(s: linux_raw_sys::general::stat) -> io::Result<Stat> {
 #[inline]
 pub(crate) fn statx(
     dirfd: BorrowedFd<'_>,
-    pathname: &CStr,
+    path: &CStr,
     flags: AtFlags,
     mask: StatxFlags,
 ) -> io::Result<statx> {
@@ -777,7 +747,7 @@ pub(crate) fn statx(
         ret(syscall!(
             __NR_statx,
             dirfd,
-            pathname,
+            path,
             flags,
             mask,
             &mut statx_buf
@@ -837,13 +807,13 @@ pub(crate) fn fstatvfs(fd: BorrowedFd<'_>) -> io::Result<StatVfs> {
 }
 
 #[inline]
-pub(crate) fn statfs(filename: &CStr) -> io::Result<StatFs> {
+pub(crate) fn statfs(path: &CStr) -> io::Result<StatFs> {
     #[cfg(target_pointer_width = "32")]
     unsafe {
         let mut result = MaybeUninit::<StatFs>::uninit();
         ret(syscall!(
             __NR_statfs64,
-            filename,
+            path,
             size_of::<StatFs, _>(),
             &mut result
         ))?;
@@ -852,16 +822,16 @@ pub(crate) fn statfs(filename: &CStr) -> io::Result<StatFs> {
     #[cfg(target_pointer_width = "64")]
     unsafe {
         let mut result = MaybeUninit::<StatFs>::uninit();
-        ret(syscall!(__NR_statfs, filename, &mut result))?;
+        ret(syscall!(__NR_statfs, path, &mut result))?;
         Ok(result.assume_init())
     }
 }
 
 #[inline]
-pub(crate) fn statvfs(filename: &CStr) -> io::Result<StatVfs> {
+pub(crate) fn statvfs(path: &CStr) -> io::Result<StatVfs> {
     // Linux doesn't have a `statvfs` syscall; we have to do `statfs` and
     // translate the fields as best we can.
-    let statfs = statfs(filename)?;
+    let statfs = statfs(path)?;
 
     Ok(statfs_to_statvfs(statfs))
 }
@@ -883,8 +853,8 @@ fn statfs_to_statvfs(statfs: StatFs) -> StatVfs {
         f_files: statfs.f_files as u64,
         f_ffree: statfs.f_ffree as u64,
         f_favail: statfs.f_ffree as u64,
-        f_fsid: f_fsid_val0 as u32 as u64 | ((f_fsid_val1 as u32 as u64) << 32),
-        f_flag: unsafe { StatVfsMountFlags::from_bits_unchecked(statfs.f_flags as u64) },
+        f_fsid: u64::from(f_fsid_val0 as u32) | u64::from(f_fsid_val1 as u32) << 32,
+        f_flag: StatVfsMountFlags::from_bits_retain(statfs.f_flags as u64),
         f_namemax: statfs.f_namelen as u64,
     }
 }
@@ -904,7 +874,11 @@ pub(crate) fn readlink(path: &CStr, buf: &mut [u8]) -> io::Result<usize> {
 }
 
 #[inline]
-pub(crate) fn readlinkat(dirfd: BorrowedFd<'_>, path: &CStr, buf: &mut [u8]) -> io::Result<usize> {
+pub(crate) fn readlinkat(
+    dirfd: BorrowedFd<'_>,
+    path: &CStr,
+    buf: &mut [MaybeUninit<u8>],
+) -> io::Result<usize> {
     let (buf_addr_mut, buf_len) = slice_mut(buf);
     unsafe {
         ret_usize(syscall!(
@@ -922,17 +896,19 @@ pub(crate) fn fcntl_getfl(fd: BorrowedFd<'_>) -> io::Result<OFlags> {
     #[cfg(target_pointer_width = "32")]
     unsafe {
         ret_c_uint(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GETFL)))
-            .map(OFlags::from_bits_truncate)
+            .map(OFlags::from_bits_retain)
     }
     #[cfg(target_pointer_width = "64")]
     unsafe {
-        ret_c_uint(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETFL)))
-            .map(OFlags::from_bits_truncate)
+        ret_c_uint(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETFL))).map(OFlags::from_bits_retain)
     }
 }
 
 #[inline]
 pub(crate) fn fcntl_setfl(fd: BorrowedFd<'_>, flags: OFlags) -> io::Result<()> {
+    // Always enable support for large files.
+    let flags = flags | OFlags::from_bits_retain(c::O_LARGEFILE);
+
     #[cfg(target_pointer_width = "32")]
     unsafe {
         ret(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_SETFL), flags))
@@ -944,86 +920,16 @@ pub(crate) fn fcntl_setfl(fd: BorrowedFd<'_>, flags: OFlags) -> io::Result<()> {
 }
 
 #[inline]
-pub(crate) fn fcntl_getlease(fd: BorrowedFd<'_>) -> io::Result<c::c_int> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret_c_int(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GETLEASE)))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_c_int(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETLEASE)))
-    }
-}
-
-#[inline]
-pub(crate) fn fcntl_getown(fd: BorrowedFd<'_>) -> io::Result<c::c_int> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret_c_int(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GETOWN)))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_c_int(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETOWN)))
-    }
-}
-
-#[inline]
-pub(crate) fn fcntl_getsig(fd: BorrowedFd<'_>) -> io::Result<c::c_int> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret_c_int(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GETSIG)))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_c_int(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETSIG)))
-    }
-}
-
-#[inline]
-pub(crate) fn fcntl_getpipe_sz(fd: BorrowedFd<'_>) -> io::Result<usize> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret_usize(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GETPIPE_SZ)))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_usize(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETPIPE_SZ)))
-    }
-}
-
-#[inline]
-pub(crate) fn fcntl_setpipe_sz(fd: BorrowedFd<'_>, size: c::c_int) -> io::Result<usize> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_fcntl64,
-            fd,
-            c_uint(F_SETPIPE_SZ),
-            c_int(size)
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_fcntl,
-            fd,
-            c_uint(F_SETPIPE_SZ),
-            c_int(size)
-        ))
-    }
-}
-
-#[inline]
 pub(crate) fn fcntl_get_seals(fd: BorrowedFd<'_>) -> io::Result<SealFlags> {
     #[cfg(target_pointer_width = "32")]
     unsafe {
         ret_c_int(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GET_SEALS)))
-            .map(|seals| SealFlags::from_bits_unchecked(seals as u32))
+            .map(|seals| SealFlags::from_bits_retain(seals as u32))
     }
     #[cfg(target_pointer_width = "64")]
     unsafe {
         ret_c_int(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GET_SEALS)))
-            .map(|seals| SealFlags::from_bits_unchecked(seals as u32))
+            .map(|seals| SealFlags::from_bits_retain(seals as u32))
     }
 }
 
@@ -1077,7 +983,7 @@ pub(crate) fn fcntl_lock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::R
             l_start: 0,
             l_len: 0,
 
-            ..core::mem::zeroed()
+            ..zeroed()
         };
 
         #[cfg(target_pointer_width = "32")]
@@ -1102,15 +1008,15 @@ pub(crate) fn fcntl_lock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::R
 }
 
 #[inline]
-pub(crate) fn rename(oldname: &CStr, newname: &CStr) -> io::Result<()> {
+pub(crate) fn rename(old_path: &CStr, new_path: &CStr) -> io::Result<()> {
     #[cfg(target_arch = "riscv64")]
     unsafe {
         ret(syscall_readonly!(
             __NR_renameat2,
             raw_fd(AT_FDCWD),
-            oldname,
+            old_path,
             raw_fd(AT_FDCWD),
-            newname,
+            new_path,
             c_uint(0)
         ))
     }
@@ -1119,9 +1025,9 @@ pub(crate) fn rename(oldname: &CStr, newname: &CStr) -> io::Result<()> {
         ret(syscall_readonly!(
             __NR_renameat,
             raw_fd(AT_FDCWD),
-            oldname,
+            old_path,
             raw_fd(AT_FDCWD),
-            newname
+            new_path
         ))
     }
 }
@@ -1129,18 +1035,18 @@ pub(crate) fn rename(oldname: &CStr, newname: &CStr) -> io::Result<()> {
 #[inline]
 pub(crate) fn renameat(
     old_dirfd: BorrowedFd<'_>,
-    oldname: &CStr,
+    old_path: &CStr,
     new_dirfd: BorrowedFd<'_>,
-    newname: &CStr,
+    new_path: &CStr,
 ) -> io::Result<()> {
     #[cfg(target_arch = "riscv64")]
     unsafe {
         ret(syscall_readonly!(
             __NR_renameat2,
             old_dirfd,
-            oldname,
+            old_path,
             new_dirfd,
-            newname,
+            new_path,
             c_uint(0)
         ))
     }
@@ -1149,9 +1055,9 @@ pub(crate) fn renameat(
         ret(syscall_readonly!(
             __NR_renameat,
             old_dirfd,
-            oldname,
+            old_path,
             new_dirfd,
-            newname
+            new_path
         ))
     }
 }
@@ -1159,61 +1065,61 @@ pub(crate) fn renameat(
 #[inline]
 pub(crate) fn renameat2(
     old_dirfd: BorrowedFd<'_>,
-    oldname: &CStr,
+    old_path: &CStr,
     new_dirfd: BorrowedFd<'_>,
-    newname: &CStr,
+    new_path: &CStr,
     flags: RenameFlags,
 ) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_renameat2,
             old_dirfd,
-            oldname,
+            old_path,
             new_dirfd,
-            newname,
+            new_path,
             flags
         ))
     }
 }
 
 #[inline]
-pub(crate) fn unlink(pathname: &CStr) -> io::Result<()> {
+pub(crate) fn unlink(path: &CStr) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_unlinkat,
             raw_fd(AT_FDCWD),
-            pathname,
+            path,
             c_uint(0)
         ))
     }
 }
 
 #[inline]
-pub(crate) fn unlinkat(dirfd: BorrowedFd<'_>, pathname: &CStr, flags: AtFlags) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_unlinkat, dirfd, pathname, flags)) }
+pub(crate) fn unlinkat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<()> {
+    unsafe { ret(syscall_readonly!(__NR_unlinkat, dirfd, path, flags)) }
 }
 
 #[inline]
-pub(crate) fn rmdir(pathname: &CStr) -> io::Result<()> {
+pub(crate) fn rmdir(path: &CStr) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_unlinkat,
             raw_fd(AT_FDCWD),
-            pathname,
+            path,
             c_uint(AT_REMOVEDIR)
         ))
     }
 }
 
 #[inline]
-pub(crate) fn link(oldname: &CStr, newname: &CStr) -> io::Result<()> {
+pub(crate) fn link(old_path: &CStr, new_path: &CStr) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_linkat,
             raw_fd(AT_FDCWD),
-            oldname,
+            old_path,
             raw_fd(AT_FDCWD),
-            newname,
+            new_path,
             c_uint(0)
         ))
     }
@@ -1222,55 +1128,55 @@ pub(crate) fn link(oldname: &CStr, newname: &CStr) -> io::Result<()> {
 #[inline]
 pub(crate) fn linkat(
     old_dirfd: BorrowedFd<'_>,
-    oldname: &CStr,
+    old_path: &CStr,
     new_dirfd: BorrowedFd<'_>,
-    newname: &CStr,
+    new_path: &CStr,
     flags: AtFlags,
 ) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_linkat,
             old_dirfd,
-            oldname,
+            old_path,
             new_dirfd,
-            newname,
+            new_path,
             flags
         ))
     }
 }
 
 #[inline]
-pub(crate) fn symlink(oldname: &CStr, newname: &CStr) -> io::Result<()> {
+pub(crate) fn symlink(old_path: &CStr, new_path: &CStr) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_symlinkat,
-            oldname,
+            old_path,
             raw_fd(AT_FDCWD),
-            newname
+            new_path
         ))
     }
 }
 
 #[inline]
-pub(crate) fn symlinkat(oldname: &CStr, dirfd: BorrowedFd<'_>, newname: &CStr) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_symlinkat, oldname, dirfd, newname)) }
+pub(crate) fn symlinkat(old_path: &CStr, dirfd: BorrowedFd<'_>, new_path: &CStr) -> io::Result<()> {
+    unsafe { ret(syscall_readonly!(__NR_symlinkat, old_path, dirfd, new_path)) }
 }
 
 #[inline]
-pub(crate) fn mkdir(pathname: &CStr, mode: Mode) -> io::Result<()> {
+pub(crate) fn mkdir(path: &CStr, mode: Mode) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_mkdirat,
             raw_fd(AT_FDCWD),
-            pathname,
+            path,
             mode
         ))
     }
 }
 
 #[inline]
-pub(crate) fn mkdirat(dirfd: BorrowedFd<'_>, pathname: &CStr, mode: Mode) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_mkdirat, dirfd, pathname, mode)) }
+pub(crate) fn mkdirat(dirfd: BorrowedFd<'_>, path: &CStr, mode: Mode) -> io::Result<()> {
+    unsafe { ret(syscall_readonly!(__NR_mkdirat, dirfd, path, mode)) }
 }
 
 #[inline]
@@ -1293,33 +1199,35 @@ pub(crate) fn getdents_uninit(
 #[inline]
 pub(crate) fn utimensat(
     dirfd: BorrowedFd<'_>,
-    pathname: &CStr,
+    path: &CStr,
     times: &Timestamps,
     flags: AtFlags,
 ) -> io::Result<()> {
-    _utimensat(dirfd, Some(pathname), times, flags)
+    _utimensat(dirfd, Some(path), times, flags)
 }
 
 #[inline]
 fn _utimensat(
     dirfd: BorrowedFd<'_>,
-    pathname: Option<&CStr>,
+    path: Option<&CStr>,
     times: &Timestamps,
     flags: AtFlags,
 ) -> io::Result<()> {
     // Assert that `Timestamps` has the expected layout.
-    let _ = unsafe { core::mem::transmute::<Timestamps, [__kernel_timespec; 2]>(times.clone()) };
+    let _ = unsafe { transmute::<Timestamps, [__kernel_timespec; 2]>(times.clone()) };
 
+    // `utimensat_time64` was introduced in Linux 5.1. The old `utimensat`
+    // syscall is not y2038-compatible on 32-bit architectures.
     #[cfg(target_pointer_width = "32")]
     unsafe {
         match ret(syscall_readonly!(
             __NR_utimensat_time64,
             dirfd,
-            pathname,
+            path,
             by_ref(times),
             flags
         )) {
-            Err(io::Errno::NOSYS) => _utimensat_old(dirfd, pathname, times, flags),
+            Err(io::Errno::NOSYS) => _utimensat_old(dirfd, path, times, flags),
             otherwise => otherwise,
         }
     }
@@ -1328,7 +1236,7 @@ fn _utimensat(
         ret(syscall_readonly!(
             __NR_utimensat,
             dirfd,
-            pathname,
+            path,
             by_ref(times),
             flags
         ))
@@ -1338,7 +1246,7 @@ fn _utimensat(
 #[cfg(target_pointer_width = "32")]
 unsafe fn _utimensat_old(
     dirfd: BorrowedFd<'_>,
-    pathname: Option<&CStr>,
+    path: Option<&CStr>,
     times: &Timestamps,
     flags: AtFlags,
 ) -> io::Result<()> {
@@ -1375,7 +1283,7 @@ unsafe fn _utimensat_old(
     ret(syscall_readonly!(
         __NR_utimensat,
         dirfd,
-        pathname,
+        path,
         old_times_addr,
         flags
     ))
@@ -1386,6 +1294,19 @@ pub(crate) fn futimens(fd: BorrowedFd<'_>, times: &Timestamps) -> io::Result<()>
     _utimensat(fd, None, times, AtFlags::empty())
 }
 
+#[inline]
+pub(crate) fn access(path: &CStr, access: Access) -> io::Result<()> {
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
+    {
+        accessat_noflags(CWD.as_fd(), path, access)
+    }
+
+    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
+    unsafe {
+        ret(syscall_readonly!(__NR_access, path, access))
+    }
+}
+
 pub(crate) fn accessat(
     dirfd: BorrowedFd<'_>,
     path: &CStr,
@@ -1400,36 +1321,47 @@ pub(crate) fn accessat(
     }
 
     // Linux's `faccessat` syscall doesn't have a flags argument, so if we have
-    // any flags, use the newer `faccessat2` which does. Unless we're on
-    // Android where using newer system calls can cause seccomp to abort the
-    // process.
+    // any flags, use the newer `faccessat2` introduced in Linux 5.8 which
+    // does. Unless we're on Android where using newer system calls can cause
+    // seccomp to abort the process.
     #[cfg(not(target_os = "android"))]
     if !flags.is_empty() {
-        return unsafe {
-            ret(syscall_readonly!(
+        unsafe {
+            match ret(syscall_readonly!(
                 __NR_faccessat2,
                 dirfd,
                 path,
                 access,
                 flags
-            ))
-        };
+            )) {
+                Ok(()) => return Ok(()),
+                Err(io::Errno::NOSYS) => {}
+                Err(other) => return Err(other),
+            }
+        }
     }
 
     // Linux's `faccessat` doesn't have a flags parameter. If we have
     // `AT_EACCESS` and we're not setuid or setgid, we can emulate it.
     if flags.is_empty()
         || (flags.bits() == AT_EACCESS
-            && crate::process::getuid() == crate::process::geteuid()
-            && crate::process::getgid() == crate::process::getegid())
+            && crate::backend::ugid::syscalls::getuid()
+                == crate::backend::ugid::syscalls::geteuid()
+            && crate::backend::ugid::syscalls::getgid()
+                == crate::backend::ugid::syscalls::getegid())
     {
-        return unsafe { ret(syscall_readonly!(__NR_faccessat, dirfd, path, access)) };
+        return accessat_noflags(dirfd, path, access);
     }
 
     Err(io::Errno::NOSYS)
 }
 
 #[inline]
+fn accessat_noflags(dirfd: BorrowedFd<'_>, path: &CStr, access: Access) -> io::Result<()> {
+    unsafe { ret(syscall_readonly!(__NR_faccessat, dirfd, path, access)) }
+}
+
+#[inline]
 pub(crate) fn copy_file_range(
     fd_in: BorrowedFd<'_>,
     off_in: Option<&mut u64>,
@@ -1485,7 +1417,6 @@ pub(crate) fn sendfile(
 }
 
 #[inline]
-#[cfg(any(target_os = "android", target_os = "linux"))]
 pub(crate) fn mount(
     source: Option<&CStr>,
     target: &CStr,
@@ -1506,7 +1437,6 @@ pub(crate) fn mount(
 }
 
 #[inline]
-#[cfg(any(target_os = "android", target_os = "linux"))]
 pub(crate) fn unmount(target: &CStr, flags: super::types::UnmountFlags) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_umount2, target, flags)) }
 }
@@ -1652,15 +1582,50 @@ pub(crate) fn flistxattr(fd: BorrowedFd<'_>, list: &mut [c::c_char]) -> io::Resu
 
 #[inline]
 pub(crate) fn removexattr(path: &CStr, name: &CStr) -> io::Result<()> {
-    unsafe { ret(syscall!(__NR_removexattr, path, name)) }
+    unsafe { ret(syscall_readonly!(__NR_removexattr, path, name)) }
 }
 
 #[inline]
 pub(crate) fn lremovexattr(path: &CStr, name: &CStr) -> io::Result<()> {
-    unsafe { ret(syscall!(__NR_lremovexattr, path, name)) }
+    unsafe { ret(syscall_readonly!(__NR_lremovexattr, path, name)) }
 }
 
 #[inline]
 pub(crate) fn fremovexattr(fd: BorrowedFd<'_>, name: &CStr) -> io::Result<()> {
-    unsafe { ret(syscall!(__NR_fremovexattr, fd, name)) }
+    unsafe { ret(syscall_readonly!(__NR_fremovexattr, fd, name)) }
+}
+
+#[inline]
+pub(crate) fn ioctl_blksszget(fd: BorrowedFd) -> io::Result<u32> {
+    let mut result = MaybeUninit::<c::c_uint>::uninit();
+    unsafe {
+        ret(syscall!(__NR_ioctl, fd, c_uint(BLKSSZGET), &mut result))?;
+        Ok(result.assume_init() as u32)
+    }
+}
+
+#[inline]
+pub(crate) fn ioctl_blkpbszget(fd: BorrowedFd) -> io::Result<u32> {
+    let mut result = MaybeUninit::<c::c_uint>::uninit();
+    unsafe {
+        ret(syscall!(__NR_ioctl, fd, c_uint(BLKPBSZGET), &mut result))?;
+        Ok(result.assume_init() as u32)
+    }
+}
+
+#[inline]
+pub(crate) fn ioctl_ficlone(fd: BorrowedFd<'_>, src_fd: BorrowedFd<'_>) -> io::Result<()> {
+    unsafe { ret(syscall_readonly!(__NR_ioctl, fd, c_uint(FICLONE), src_fd)) }
+}
+
+#[inline]
+pub(crate) fn ext4_ioc_resize_fs(fd: BorrowedFd<'_>, blocks: u64) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_ioctl,
+            fd,
+            c_uint(EXT4_IOC_RESIZE_FS),
+            by_ref(&blocks)
+        ))
+    }
 }
diff --git a/vendor/rustix/src/backend/linux_raw/fs/types.rs b/vendor/rustix/src/backend/linux_raw/fs/types.rs
index 68bb9ed46..df61cf721 100644
--- a/vendor/rustix/src/backend/linux_raw/fs/types.rs
+++ b/vendor/rustix/src/backend/linux_raw/fs/types.rs
@@ -1,10 +1,12 @@
-use super::super::c;
+use crate::backend::c;
 use bitflags::bitflags;
 
 bitflags! {
     /// `*_OK` constants for use with [`accessat`].
     ///
     /// [`accessat`]: fn.accessat.html
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct Access: c::c_uint {
         /// `R_OK`
         const READ_OK = linux_raw_sys::general::R_OK;
@@ -26,22 +28,27 @@ bitflags! {
     ///
     /// [`openat`]: crate::fs::openat
     /// [`statat`]: crate::fs::statat
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct AtFlags: c::c_uint {
+        /// `AT_SYMLINK_NOFOLLOW`
+        const SYMLINK_NOFOLLOW = linux_raw_sys::general::AT_SYMLINK_NOFOLLOW;
+
+        /// `AT_EACCESS`
+        const EACCESS = linux_raw_sys::general::AT_EACCESS;
+
         /// `AT_REMOVEDIR`
         const REMOVEDIR = linux_raw_sys::general::AT_REMOVEDIR;
 
         /// `AT_SYMLINK_FOLLOW`
         const SYMLINK_FOLLOW = linux_raw_sys::general::AT_SYMLINK_FOLLOW;
 
-        /// `AT_SYMLINK_NOFOLLOW`
-        const SYMLINK_NOFOLLOW = linux_raw_sys::general::AT_SYMLINK_NOFOLLOW;
+        /// `AT_NO_AUTOMOUNT`
+        const NO_AUTOMOUNT = linux_raw_sys::general::AT_NO_AUTOMOUNT;
 
         /// `AT_EMPTY_PATH`
         const EMPTY_PATH = linux_raw_sys::general::AT_EMPTY_PATH;
 
-        /// `AT_EACCESS`
-        const EACCESS = linux_raw_sys::general::AT_EACCESS;
-
         /// `AT_STATX_SYNC_AS_STAT`
         const STATX_SYNC_AS_STAT = linux_raw_sys::general::AT_STATX_SYNC_AS_STAT;
 
@@ -59,6 +66,8 @@ bitflags! {
     /// [`openat`]: crate::fs::openat
     /// [`chmodat`]: crate::fs::chmodat
     /// [`fchmod`]: crate::fs::fchmod
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct Mode: RawMode {
         /// `S_IRWXU`
         const RWXU = linux_raw_sys::general::S_IRWXU;
@@ -136,7 +145,7 @@ impl From<RawMode> for Mode {
 }
 
 impl From<Mode> for RawMode {
-    /// Support conversions from `Mode to raw mode values.
+    /// Support conversions from `Mode` to raw mode values.
     ///
     /// ```
     /// use rustix::fs::{Mode, RawMode};
@@ -152,6 +161,8 @@ bitflags! {
     /// `O_*` constants for use with [`openat`].
     ///
     /// [`openat`]: crate::fs::openat
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct OFlags: c::c_uint {
         /// `O_ACCMODE`
         const ACCMODE = linux_raw_sys::general::O_ACCMODE;
@@ -234,7 +245,8 @@ bitflags! {
     /// `RESOLVE_*` constants for use with [`openat2`].
     ///
     /// [`openat2`]: crate::fs::openat2
-    #[derive(Default)]
+    #[repr(transparent)]
+    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct ResolveFlags: u64 {
         /// `RESOLVE_NO_XDEV`
         const NO_XDEV = linux_raw_sys::general::RESOLVE_NO_XDEV as u64;
@@ -260,6 +272,8 @@ bitflags! {
     /// `RENAME_*` constants for use with [`renameat_with`].
     ///
     /// [`renameat_with`]: crate::fs::renameat_with
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct RenameFlags: c::c_uint {
         /// `RENAME_EXCHANGE`
         const EXCHANGE = linux_raw_sys::general::RENAME_EXCHANGE;
@@ -382,6 +396,8 @@ bitflags! {
     /// `MFD_*` constants for use with [`memfd_create`].
     ///
     /// [`memfd_create`]: crate::fs::memfd_create
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MemfdFlags: c::c_uint {
         /// `MFD_CLOEXEC`
         const CLOEXEC = linux_raw_sys::general::MFD_CLOEXEC;
@@ -425,6 +441,8 @@ bitflags! {
     ///
     /// [`fcntl_add_seals`]: crate::fs::fcntl_add_seals
     /// [`fcntl_get_seals`]: crate::fs::fcntl_get_seals
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct SealFlags: u32 {
        /// `F_SEAL_SEAL`.
        const SEAL = linux_raw_sys::general::F_SEAL_SEAL;
@@ -443,6 +461,8 @@ bitflags! {
     /// `STATX_*` constants for use with [`statx`].
     ///
     /// [`statx`]: crate::fs::statx
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct StatxFlags: u32 {
         /// `STATX_TYPE`
         const TYPE = linux_raw_sys::general::STATX_TYPE;
@@ -486,6 +506,9 @@ bitflags! {
         /// `STATX_MNT_ID` (since Linux 5.8)
         const MNT_ID = linux_raw_sys::general::STATX_MNT_ID;
 
+        /// `STATX_DIOALIGN` (since Linux 6.1)
+        const DIOALIGN = linux_raw_sys::general::STATX_DIOALIGN;
+
         /// `STATX_ALL`
         const ALL = linux_raw_sys::general::STATX_ALL;
     }
@@ -495,6 +518,8 @@ bitflags! {
     /// `FALLOC_FL_*` constants for use with [`fallocate`].
     ///
     /// [`fallocate`]: crate::fs::fallocate
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct FallocateFlags: u32 {
         /// `FALLOC_FL_KEEP_SIZE`
         const KEEP_SIZE = linux_raw_sys::general::FALLOC_FL_KEEP_SIZE;
@@ -515,6 +540,8 @@ bitflags! {
 
 bitflags! {
     /// `ST_*` constants for use with [`StatVfs`].
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct StatVfsMountFlags: u64 {
         /// `ST_MANDLOCK`
         const MANDLOCK = linux_raw_sys::general::MS_MANDLOCK as u64;
@@ -668,11 +695,12 @@ pub type FsWord = linux_raw_sys::general::__fsword_t;
 #[cfg(target_arch = "mips64")]
 pub type FsWord = i64;
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 bitflags! {
     /// `MS_*` constants for use with [`mount`].
     ///
     /// [`mount`]: crate::fs::mount
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MountFlags: c::c_uint {
         /// `MS_BIND`
         const BIND = linux_raw_sys::general::MS_BIND;
@@ -725,11 +753,12 @@ bitflags! {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 bitflags! {
     /// `MS_*` constants for use with [`change_mount`].
     ///
     /// [`change_mount`]: crate::fs::mount::change_mount
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MountPropagationFlags: c::c_uint {
         /// `MS_SHARED`
         const SHARED = linux_raw_sys::general::MS_SHARED;
@@ -744,22 +773,24 @@ bitflags! {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 bitflags! {
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub(crate) struct InternalMountFlags: c::c_uint {
         const REMOUNT = linux_raw_sys::general::MS_REMOUNT;
         const MOVE = linux_raw_sys::general::MS_MOVE;
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[repr(transparent)]
 pub(crate) struct MountFlagsArg(pub(crate) c::c_uint);
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 bitflags! {
     /// `MNT_*` constants for use with [`unmount`].
     ///
     /// [`unmount`]: crate::fs::mount::unmount
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct UnmountFlags: c::c_uint {
         /// `MNT_FORCE`
         const FORCE = linux_raw_sys::general::MNT_FORCE;
diff --git a/vendor/rustix/src/backend/linux_raw/io/errno.rs b/vendor/rustix/src/backend/linux_raw/io/errno.rs
index 9db14d06e..af057e2da 100644
--- a/vendor/rustix/src/backend/linux_raw/io/errno.rs
+++ b/vendor/rustix/src/backend/linux_raw/io/errno.rs
@@ -10,7 +10,7 @@
 #![allow(unsafe_code)]
 #![cfg_attr(not(rustc_attrs), allow(unused_unsafe))]
 
-use super::super::c;
+use crate::backend::c;
 use crate::backend::fd::RawFd;
 use crate::backend::reg::{RetNumber, RetReg};
 use crate::io;
@@ -62,12 +62,12 @@ impl Errno {
 
     /// Convert from a C `errno` value (which is positive) to an `Errno`.
     const fn from_errno(raw: u32) -> Self {
-        // We store error values in negated form, so that we don't have to negate
-        // them after every syscall.
+        // We store error values in negated form, so that we don't have to
+        // negate them after every syscall.
         let encoded = raw.wrapping_neg() as u16;
 
         // TODO: Use Range::contains, once that's `const`.
-        const_assert!(encoded >= 0xf001);
+        assert!(encoded >= 0xf001);
 
         // SAFETY: Linux syscalls return negated error values in the range
         // `-4095..0`, which we just asserted.
@@ -239,6 +239,13 @@ pub(in crate::backend) fn decode_usize_infallible<Num: RetNumber>(raw: RetReg<Nu
 /// Return the contained `c_int` value.
 #[cfg(not(debug_assertions))]
 #[inline]
+pub(in crate::backend) fn decode_c_int_infallible<Num: RetNumber>(raw: RetReg<Num>) -> c::c_int {
+    raw.decode_c_int()
+}
+
+/// Return the contained `c_uint` value.
+#[cfg(not(debug_assertions))]
+#[inline]
 pub(in crate::backend) fn decode_c_uint_infallible<Num: RetNumber>(raw: RetReg<Num>) -> c::c_uint {
     raw.decode_c_uint()
 }
diff --git a/vendor/rustix/src/backend/linux_raw/io/io_slice.rs b/vendor/rustix/src/backend/linux_raw/io/io_slice.rs
deleted file mode 100644
index fc8e64698..000000000
--- a/vendor/rustix/src/backend/linux_raw/io/io_slice.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/sys/unix/io.rs
-//! dca3f1b786efd27be3b325ed1e01e247aa589c3b.
-
-#![allow(unsafe_code)]
-use super::super::c;
-use core::marker::PhantomData;
-use core::slice;
-use linux_raw_sys::general::__kernel_size_t;
-
-/// <https://doc.rust-lang.org/nightly/std/io/struct.IoSlice.html>
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct IoSlice<'a> {
-    vec: c::iovec,
-    _p: PhantomData<&'a [u8]>,
-}
-
-impl<'a> IoSlice<'a> {
-    /// <https://doc.rust-lang.org/nightly/std/io/struct.IoSlice.html#method.new>
-    #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
-        IoSlice {
-            vec: c::iovec {
-                iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _p: PhantomData,
-        }
-    }
-
-    /// <https://doc.rust-lang.org/nightly/std/io/struct.IoSlice.html#method.advance>
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n as _ {
-            panic!("advancing IoSlice beyond its length");
-        }
-
-        unsafe {
-            self.vec.iov_len -= n as __kernel_size_t;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    /// <https://doc.rust-lang.org/nightly/std/io/struct.IoSlice.html#method.as_slice>
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len as usize) }
-    }
-}
-
-/// <https://doc.rust-lang.org/nightly/std/io/struct.IoSliceMut.html>
-#[repr(transparent)]
-pub struct IoSliceMut<'a> {
-    vec: c::iovec,
-    _p: PhantomData<&'a mut [u8]>,
-}
-
-impl<'a> IoSliceMut<'a> {
-    /// <https://doc.rust-lang.org/nightly/std/io/struct.IoSliceMut.html#method.new>
-    #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
-        IoSliceMut {
-            vec: c::iovec {
-                iov_base: buf.as_mut_ptr() as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _p: PhantomData,
-        }
-    }
-
-    /// <https://doc.rust-lang.org/nightly/std/io/struct.IoSliceMut.html#method.advance>
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n as _ {
-            panic!("advancing IoSliceMut beyond its length");
-        }
-
-        unsafe {
-            self.vec.iov_len -= n as __kernel_size_t;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    /// <https://doc.rust-lang.org/nightly/std/io/struct.IoSliceMut.html#method.as_slice>
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len as usize) }
-    }
-
-    /// <https://doc.rust-lang.org/nightly/std/io/struct.IoSliceMut.html#method.as_slice_mut>
-    #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
-        unsafe {
-            slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len as usize)
-        }
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/io/mod.rs b/vendor/rustix/src/backend/linux_raw/io/mod.rs
index f5c2bf3c0..9477b9b95 100644
--- a/vendor/rustix/src/backend/linux_raw/io/mod.rs
+++ b/vendor/rustix/src/backend/linux_raw/io/mod.rs
@@ -1,7 +1,3 @@
-pub mod epoll;
 pub(crate) mod errno;
-#[cfg(not(feature = "std"))]
-pub(crate) mod io_slice;
-pub(crate) mod poll_fd;
 pub(crate) mod syscalls;
 pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/io/syscalls.rs b/vendor/rustix/src/backend/linux_raw/io/syscalls.rs
index c76fb0635..45e0dd647 100644
--- a/vendor/rustix/src/backend/linux_raw/io/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/io/syscalls.rs
@@ -6,38 +6,30 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::c;
 #[cfg(target_pointer_width = "64")]
-use super::super::conv::loff_t_from_u64;
-use super::super::conv::{
-    by_ref, c_int, c_uint, opt_mut, pass_usize, raw_fd, ret, ret_c_uint, ret_discarded_fd,
-    ret_owned_fd, ret_usize, slice, slice_mut, zero,
+use crate::backend::conv::loff_t_from_u64;
+#[cfg(all(
+    target_pointer_width = "32",
+    any(target_arch = "arm", target_arch = "mips", target_arch = "power"),
+))]
+use crate::backend::conv::zero;
+use crate::backend::conv::{
+    by_ref, c_uint, raw_fd, ret, ret_c_uint, ret_discarded_fd, ret_owned_fd, ret_usize, slice,
+    slice_mut,
 };
 #[cfg(target_pointer_width = "32")]
-use super::super::conv::{hi, lo};
+use crate::backend::conv::{hi, lo};
+use crate::backend::{c, MAX_IOV};
 use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::io::SpliceFlags;
-use crate::io::{
-    self, epoll, DupFlags, EventfdFlags, FdFlags, IoSlice, IoSliceMut, IoSliceRaw, PipeFlags,
-    PollFd, ReadWriteFlags,
-};
+use crate::io::{self, DupFlags, FdFlags, IoSlice, IoSliceMut, ReadWriteFlags};
 #[cfg(all(feature = "fs", feature = "net"))]
 use crate::net::{RecvFlags, SendFlags};
 use core::cmp;
 use core::mem::MaybeUninit;
 #[cfg(target_os = "espidf")]
 use linux_raw_sys::general::F_DUPFD;
-use linux_raw_sys::general::{
-    epoll_event, EPOLL_CTL_ADD, EPOLL_CTL_DEL, EPOLL_CTL_MOD, F_DUPFD_CLOEXEC, F_GETFD, F_SETFD,
-    UIO_MAXIOV,
-};
-use linux_raw_sys::ioctl::{BLKPBSZGET, BLKSSZGET, FICLONE, FIONBIO, FIONREAD, TIOCEXCL, TIOCNXCL};
-#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-use {
-    super::super::conv::{opt_ref, size_of},
-    linux_raw_sys::general::{__kernel_timespec, kernel_sigset_t},
-};
+use linux_raw_sys::general::{F_DUPFD_CLOEXEC, F_GETFD, F_SETFD};
+use linux_raw_sys::ioctl::{FIONBIO, FIONREAD};
 
 #[inline]
 pub(crate) fn read(fd: BorrowedFd<'_>, buf: &mut [u8]) -> io::Result<usize> {
@@ -94,7 +86,7 @@ pub(crate) fn pread(fd: BorrowedFd<'_>, buf: &mut [u8], pos: u64) -> io::Result<
 
 #[inline]
 pub(crate) fn readv(fd: BorrowedFd<'_>, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), max_iov())]);
+    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
 
     unsafe { ret_usize(syscall!(__NR_readv, fd, bufs_addr, bufs_len)) }
 }
@@ -105,7 +97,7 @@ pub(crate) fn preadv(
     bufs: &mut [IoSliceMut<'_>],
     pos: u64,
 ) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), max_iov())]);
+    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
 
     #[cfg(target_pointer_width = "32")]
     unsafe {
@@ -137,7 +129,7 @@ pub(crate) fn preadv2(
     pos: u64,
     flags: ReadWriteFlags,
 ) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), max_iov())]);
+    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
 
     #[cfg(target_pointer_width = "32")]
     unsafe {
@@ -219,14 +211,14 @@ pub(crate) fn pwrite(fd: BorrowedFd<'_>, buf: &[u8], pos: u64) -> io::Result<usi
 
 #[inline]
 pub(crate) fn writev(fd: BorrowedFd<'_>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), max_iov())]);
+    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
 
     unsafe { ret_usize(syscall_readonly!(__NR_writev, fd, bufs_addr, bufs_len)) }
 }
 
 #[inline]
 pub(crate) fn pwritev(fd: BorrowedFd<'_>, bufs: &[IoSlice<'_>], pos: u64) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), max_iov())]);
+    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
 
     #[cfg(target_pointer_width = "32")]
     unsafe {
@@ -258,7 +250,7 @@ pub(crate) fn pwritev2(
     pos: u64,
     flags: ReadWriteFlags,
 ) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), max_iov())]);
+    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
 
     #[cfg(target_pointer_width = "32")]
     unsafe {
@@ -285,12 +277,6 @@ pub(crate) fn pwritev2(
     }
 }
 
-/// The maximum number of buffers that can be passed into a vectored I/O system
-/// call on the current platform.
-const fn max_iov() -> usize {
-    UIO_MAXIOV as usize
-}
-
 #[inline]
 pub(crate) unsafe fn close(fd: RawFd) {
     // See the documentation for [`io::close`] for why errors are ignored.
@@ -298,11 +284,6 @@ pub(crate) unsafe fn close(fd: RawFd) {
 }
 
 #[inline]
-pub(crate) fn eventfd(initval: u32, flags: EventfdFlags) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_eventfd2, c_uint(initval), flags)) }
-}
-
-#[inline]
 pub(crate) fn ioctl_fionread(fd: BorrowedFd<'_>) -> io::Result<u64> {
     unsafe {
         let mut result = MaybeUninit::<c::c_int>::uninit();
@@ -324,39 +305,6 @@ pub(crate) fn ioctl_fionbio(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
     }
 }
 
-#[inline]
-pub(crate) fn ioctl_tiocexcl(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_ioctl, fd, c_uint(TIOCEXCL))) }
-}
-
-#[inline]
-pub(crate) fn ioctl_tiocnxcl(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_ioctl, fd, c_uint(TIOCNXCL))) }
-}
-
-#[inline]
-pub(crate) fn ioctl_blksszget(fd: BorrowedFd) -> io::Result<u32> {
-    let mut result = MaybeUninit::<c::c_uint>::uninit();
-    unsafe {
-        ret(syscall!(__NR_ioctl, fd, c_uint(BLKSSZGET), &mut result))?;
-        Ok(result.assume_init() as u32)
-    }
-}
-
-#[inline]
-pub(crate) fn ioctl_blkpbszget(fd: BorrowedFd) -> io::Result<u32> {
-    let mut result = MaybeUninit::<c::c_uint>::uninit();
-    unsafe {
-        ret(syscall!(__NR_ioctl, fd, c_uint(BLKPBSZGET), &mut result))?;
-        Ok(result.assume_init() as u32)
-    }
-}
-
-#[inline]
-pub(crate) fn ioctl_ficlone(fd: BorrowedFd<'_>, src_fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_ioctl, fd, c_uint(FICLONE), src_fd)) }
-}
-
 #[cfg(all(feature = "fs", feature = "net"))]
 pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
     let (mut read, mut write) = crate::fs::fd::_is_file_read_write(fd)?;
@@ -369,8 +317,11 @@ pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
         // TODO: This code would benefit from having a better way to read into
         // uninitialized memory.
         let mut buf = [0];
-        match super::super::net::syscalls::recv(fd, &mut buf, RecvFlags::PEEK | RecvFlags::DONTWAIT)
-        {
+        match crate::backend::net::syscalls::recv(
+            fd,
+            &mut buf,
+            RecvFlags::PEEK | RecvFlags::DONTWAIT,
+        ) {
             Ok(0) => read = false,
             Err(err) => {
                 #[allow(unreachable_patterns)] // `EAGAIN` may equal `EWOULDBLOCK`
@@ -387,7 +338,7 @@ pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
         // Do a `send` with `DONTWAIT` for 0 bytes. An `EPIPE` indicates
         // the write side is shut down.
         #[allow(unreachable_patterns)] // `EAGAIN` equals `EWOULDBLOCK`
-        match super::super::net::syscalls::send(fd, &[], SendFlags::DONTWAIT) {
+        match crate::backend::net::syscalls::send(fd, &[], SendFlags::DONTWAIT) {
             // TODO or-patterns when we don't need 1.51
             Err(io::Errno::AGAIN) => (),
             Err(io::Errno::WOULDBLOCK) => (),
@@ -431,12 +382,12 @@ pub(crate) fn fcntl_getfd(fd: BorrowedFd<'_>) -> io::Result<FdFlags> {
     #[cfg(target_pointer_width = "32")]
     unsafe {
         ret_c_uint(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GETFD)))
-            .map(FdFlags::from_bits_truncate)
+            .map(FdFlags::from_bits_retain)
     }
     #[cfg(target_pointer_width = "64")]
     unsafe {
         ret_c_uint(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETFD)))
-            .map(FdFlags::from_bits_truncate)
+            .map(FdFlags::from_bits_retain)
     }
 }
 
@@ -496,186 +447,3 @@ pub(crate) fn fcntl_dupfd_cloexec(fd: BorrowedFd<'_>, min: RawFd) -> io::Result<
         ))
     }
 }
-
-#[inline]
-pub(crate) fn pipe_with(flags: PipeFlags) -> io::Result<(OwnedFd, OwnedFd)> {
-    unsafe {
-        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
-        ret(syscall!(__NR_pipe2, &mut result, flags))?;
-        let [p0, p1] = result.assume_init();
-        Ok((p0, p1))
-    }
-}
-
-#[inline]
-pub(crate) fn pipe() -> io::Result<(OwnedFd, OwnedFd)> {
-    // aarch64 and risc64 omit `__NR_pipe`. On mips, `__NR_pipe` uses a special
-    // calling convention, but using it is not worth complicating our syscall
-    // wrapping infrastructure at this time.
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "mips",
-        target_arch = "mips64",
-        target_arch = "riscv64",
-    ))]
-    {
-        pipe_with(PipeFlags::empty())
-    }
-    #[cfg(not(any(
-        target_arch = "aarch64",
-        target_arch = "mips",
-        target_arch = "mips64",
-        target_arch = "riscv64",
-    )))]
-    unsafe {
-        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
-        ret(syscall!(__NR_pipe, &mut result))?;
-        let [p0, p1] = result.assume_init();
-        Ok((p0, p1))
-    }
-}
-
-#[inline]
-pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> {
-    let (fds_addr_mut, fds_len) = slice_mut(fds);
-
-    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-    unsafe {
-        let timeout = if timeout >= 0 {
-            Some(__kernel_timespec {
-                tv_sec: (timeout as i64) / 1000,
-                tv_nsec: (timeout as i64) % 1000 * 1_000_000,
-            })
-        } else {
-            None
-        };
-        ret_usize(syscall!(
-            __NR_ppoll,
-            fds_addr_mut,
-            fds_len,
-            opt_ref(timeout.as_ref()),
-            zero(),
-            size_of::<kernel_sigset_t, _>()
-        ))
-    }
-    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
-    unsafe {
-        ret_usize(syscall!(__NR_poll, fds_addr_mut, fds_len, c_int(timeout)))
-    }
-}
-
-#[inline]
-pub(crate) fn epoll_create(flags: epoll::CreateFlags) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_epoll_create1, flags)) }
-}
-
-#[inline]
-pub(crate) unsafe fn epoll_add(
-    epfd: BorrowedFd<'_>,
-    fd: c::c_int,
-    event: &epoll_event,
-) -> io::Result<()> {
-    ret(syscall_readonly!(
-        __NR_epoll_ctl,
-        epfd,
-        c_uint(EPOLL_CTL_ADD),
-        raw_fd(fd),
-        by_ref(event)
-    ))
-}
-
-#[inline]
-pub(crate) unsafe fn epoll_mod(
-    epfd: BorrowedFd<'_>,
-    fd: c::c_int,
-    event: &epoll_event,
-) -> io::Result<()> {
-    ret(syscall_readonly!(
-        __NR_epoll_ctl,
-        epfd,
-        c_uint(EPOLL_CTL_MOD),
-        raw_fd(fd),
-        by_ref(event)
-    ))
-}
-
-#[inline]
-pub(crate) unsafe fn epoll_del(epfd: BorrowedFd<'_>, fd: c::c_int) -> io::Result<()> {
-    ret(syscall_readonly!(
-        __NR_epoll_ctl,
-        epfd,
-        c_uint(EPOLL_CTL_DEL),
-        raw_fd(fd),
-        zero()
-    ))
-}
-
-#[inline]
-pub(crate) fn epoll_wait(
-    epfd: BorrowedFd<'_>,
-    events: *mut epoll_event,
-    num_events: usize,
-    timeout: c::c_int,
-) -> io::Result<usize> {
-    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
-    unsafe {
-        ret_usize(syscall!(
-            __NR_epoll_wait,
-            epfd,
-            events,
-            pass_usize(num_events),
-            c_int(timeout)
-        ))
-    }
-    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-    unsafe {
-        ret_usize(syscall!(
-            __NR_epoll_pwait,
-            epfd,
-            events,
-            pass_usize(num_events),
-            c_int(timeout),
-            zero()
-        ))
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub fn splice(
-    fd_in: BorrowedFd,
-    off_in: Option<&mut u64>,
-    fd_out: BorrowedFd,
-    off_out: Option<&mut u64>,
-    len: usize,
-    flags: SpliceFlags,
-) -> io::Result<usize> {
-    unsafe {
-        ret_usize(syscall!(
-            __NR_splice,
-            fd_in,
-            opt_mut(off_in),
-            fd_out,
-            opt_mut(off_out),
-            pass_usize(len),
-            c_uint(flags.bits())
-        ))
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub unsafe fn vmsplice(
-    fd: BorrowedFd,
-    bufs: &[IoSliceRaw],
-    flags: SpliceFlags,
-) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), max_iov())]);
-    ret_usize(syscall!(
-        __NR_vmsplice,
-        fd,
-        bufs_addr,
-        bufs_len,
-        c_uint(flags.bits())
-    ))
-}
diff --git a/vendor/rustix/src/backend/linux_raw/io/types.rs b/vendor/rustix/src/backend/linux_raw/io/types.rs
index cb6c6acef..c06134440 100644
--- a/vendor/rustix/src/backend/linux_raw/io/types.rs
+++ b/vendor/rustix/src/backend/linux_raw/io/types.rs
@@ -1,12 +1,13 @@
-use super::super::c;
+use crate::backend::c;
 use bitflags::bitflags;
-use core::marker::PhantomData;
 
 bitflags! {
     /// `FD_*` constants for use with [`fcntl_getfd`] and [`fcntl_setfd`].
     ///
     /// [`fcntl_getfd`]: crate::io::fcntl_getfd
     /// [`fcntl_setfd`]: crate::io::fcntl_setfd
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct FdFlags: c::c_uint {
         /// `FD_CLOEXEC`
         const CLOEXEC = linux_raw_sys::general::FD_CLOEXEC;
@@ -18,6 +19,8 @@ bitflags! {
     ///
     /// [`preadv2`]: crate::io::preadv2
     /// [`pwritev2`]: crate::io::pwritev
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct ReadWriteFlags: c::c_uint {
         /// `RWF_DSYNC` (since Linux 4.7)
         const DSYNC = linux_raw_sys::general::RWF_DSYNC;
@@ -32,98 +35,14 @@ bitflags! {
     }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
-bitflags! {
-    /// `SPLICE_F_*` constants for use with [`splice`] and [`vmsplice`].
-    pub struct SpliceFlags: c::c_uint {
-        /// `SPLICE_F_MOVE`
-        const MOVE = linux_raw_sys::general::SPLICE_F_MOVE;
-        /// `SPLICE_F_NONBLOCK`
-        const NONBLOCK = linux_raw_sys::general::SPLICE_F_NONBLOCK;
-        /// `SPLICE_F_MORE`
-        const MORE = linux_raw_sys::general::SPLICE_F_MORE;
-        /// `SPLICE_F_GIFT`
-        const GIFT = linux_raw_sys::general::SPLICE_F_GIFT;
-    }
-}
-
 bitflags! {
     /// `O_*` constants for use with [`dup2`].
     ///
     /// [`dup2`]: crate::io::dup2
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct DupFlags: c::c_uint {
         /// `O_CLOEXEC`
         const CLOEXEC = linux_raw_sys::general::O_CLOEXEC;
     }
 }
-
-bitflags! {
-    /// `O_*` constants for use with [`pipe_with`].
-    ///
-    /// [`pipe_with`]: crate::io::pipe_with
-    pub struct PipeFlags: c::c_uint {
-        /// `O_CLOEXEC`
-        const CLOEXEC = linux_raw_sys::general::O_CLOEXEC;
-        /// `O_DIRECT`
-        const DIRECT = linux_raw_sys::general::O_DIRECT;
-        /// `O_NONBLOCK`
-        const NONBLOCK = linux_raw_sys::general::O_NONBLOCK;
-    }
-}
-
-bitflags! {
-    /// `EFD_*` flags for use with [`eventfd`].
-    ///
-    /// [`eventfd`]: crate::io::eventfd
-    pub struct EventfdFlags: c::c_uint {
-        /// `EFD_CLOEXEC`
-        const CLOEXEC = linux_raw_sys::general::EFD_CLOEXEC;
-        /// `EFD_NONBLOCK`
-        const NONBLOCK = linux_raw_sys::general::EFD_NONBLOCK;
-        /// `EFD_SEMAPHORE`
-        const SEMAPHORE = linux_raw_sys::general::EFD_SEMAPHORE;
-    }
-}
-
-/// `PIPE_BUF`—The maximum size of a write to a pipe guaranteed to be atomic.
-pub const PIPE_BUF: usize = linux_raw_sys::general::PIPE_BUF as usize;
-
-pub(crate) const AT_FDCWD: c::c_int = linux_raw_sys::general::AT_FDCWD;
-pub(crate) const STDIN_FILENO: c::c_uint = linux_raw_sys::general::STDIN_FILENO;
-pub(crate) const STDOUT_FILENO: c::c_uint = linux_raw_sys::general::STDOUT_FILENO;
-pub(crate) const STDERR_FILENO: c::c_uint = linux_raw_sys::general::STDERR_FILENO;
-
-/// A buffer type used with `vmsplice`.
-/// It is guaranteed to be ABI compatible with the iovec type on Unix platforms
-/// and `WSABUF` on Windows. Unlike `IoSlice` and `IoSliceMut` it is
-/// semantically like a raw pointer, and therefore can be shared or mutated as
-/// needed.
-#[repr(transparent)]
-pub struct IoSliceRaw<'a> {
-    _buf: c::iovec,
-    _lifetime: PhantomData<&'a ()>,
-}
-
-impl<'a> IoSliceRaw<'a> {
-    /// Creates a new `IoSlice` wrapping a byte slice.
-    pub fn from_slice(buf: &'a [u8]) -> Self {
-        IoSliceRaw {
-            _buf: c::iovec {
-                iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _lifetime: PhantomData,
-        }
-    }
-
-    /// Creates a new `IoSlice` wrapping a mutable byte slice.
-    pub fn from_slice_mut(buf: &'a mut [u8]) -> Self {
-        IoSliceRaw {
-            _buf: c::iovec {
-                iov_base: buf.as_mut_ptr() as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _lifetime: PhantomData,
-        }
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/io_uring/syscalls.rs b/vendor/rustix/src/backend/linux_raw/io_uring/syscalls.rs
index 16655fe77..90c82c129 100644
--- a/vendor/rustix/src/backend/linux_raw/io_uring/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/io_uring/syscalls.rs
@@ -6,7 +6,7 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::conv::{by_mut, c_uint, pass_usize, ret_c_uint, ret_owned_fd};
+use crate::backend::conv::{by_mut, c_uint, pass_usize, ret_c_uint, ret_owned_fd};
 use crate::fd::{BorrowedFd, OwnedFd};
 use crate::io;
 use crate::io_uring::{io_uring_params, IoringEnterFlags, IoringRegisterOp};
diff --git a/vendor/rustix/src/backend/linux_raw/mm/syscalls.rs b/vendor/rustix/src/backend/linux_raw/mm/syscalls.rs
index 8fa6a3ec3..b51f826a9 100644
--- a/vendor/rustix/src/backend/linux_raw/mm/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/mm/syscalls.rs
@@ -6,18 +6,16 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::c;
-#[cfg(target_pointer_width = "64")]
-use super::super::conv::loff_t_from_u64;
-use super::super::conv::{c_uint, no_fd, pass_usize, ret, ret_owned_fd, ret_void_star};
 use super::types::{
     Advice, MapFlags, MlockFlags, MprotectFlags, MremapFlags, MsyncFlags, ProtFlags,
     UserfaultfdFlags,
 };
+use crate::backend::c;
+#[cfg(target_pointer_width = "64")]
+use crate::backend::conv::loff_t_from_u64;
+use crate::backend::conv::{c_uint, no_fd, pass_usize, ret, ret_owned_fd, ret_void_star};
 use crate::fd::{BorrowedFd, OwnedFd};
 use crate::io;
-#[cfg(target_pointer_width = "32")]
-use core::convert::TryInto;
 use linux_raw_sys::general::MAP_ANONYMOUS;
 
 #[inline]
diff --git a/vendor/rustix/src/backend/linux_raw/mm/types.rs b/vendor/rustix/src/backend/linux_raw/mm/types.rs
index a34c41f4f..576f08a3d 100644
--- a/vendor/rustix/src/backend/linux_raw/mm/types.rs
+++ b/vendor/rustix/src/backend/linux_raw/mm/types.rs
@@ -1,4 +1,4 @@
-use super::super::c;
+use crate::backend::c;
 use bitflags::bitflags;
 
 bitflags! {
@@ -7,6 +7,8 @@ bitflags! {
     /// For `PROT_NONE`, use `ProtFlags::empty()`.
     ///
     /// [`mmap`]: crate::io::mmap
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct ProtFlags: u32 {
         /// `PROT_READ`
         const READ = linux_raw_sys::general::PROT_READ;
@@ -23,6 +25,8 @@ bitflags! {
     /// For `PROT_NONE`, use `MprotectFlags::empty()`.
     ///
     /// [`mprotect`]: crate::io::mprotect
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MprotectFlags: u32 {
         /// `PROT_READ`
         const READ = linux_raw_sys::general::PROT_READ;
@@ -44,6 +48,8 @@ bitflags! {
     ///
     /// [`mmap`]: crate::io::mmap
     /// [`mmap_anonymous`]: crates::io::mmap_anonymous
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MapFlags: u32 {
         /// `MAP_SHARED`
         const SHARED = linux_raw_sys::general::MAP_SHARED;
@@ -89,6 +95,8 @@ bitflags! {
     ///
     /// [`mremap`]: crate::io::mremap
     /// [`mremap_fixed`]: crate::io::mremap_fixed
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MremapFlags: u32 {
         /// `MREMAP_MAYMOVE`
         const MAYMOVE = linux_raw_sys::general::MREMAP_MAYMOVE;
@@ -101,6 +109,8 @@ bitflags! {
     /// `MLOCK_*` flags for use with [`mlock_with`].
     ///
     /// [`mlock_with`]: crate::io::mlock_with
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MlockFlags: u32 {
         /// `MLOCK_ONFAULT`
         const ONFAULT = linux_raw_sys::general::MLOCK_ONFAULT;
@@ -111,6 +121,8 @@ bitflags! {
     /// `MS_*` flags for use with [`msync`].
     ///
     /// [`msync`]: crate::io::msync
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct MsyncFlags: u32 {
         /// `MS_SYNC`—Requests an update and waits for it to complete.
         const SYNC = linux_raw_sys::general::MS_SYNC;
@@ -128,6 +140,8 @@ bitflags! {
     /// `O_*` flags for use with [`userfaultfd`].
     ///
     /// [`userfaultfd`]: crate::io::userfaultfd
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct UserfaultfdFlags: c::c_uint {
         /// `O_CLOEXEC`
         const CLOEXEC = linux_raw_sys::general::O_CLOEXEC;
@@ -195,6 +209,8 @@ pub enum Advice {
     LinuxPopulateRead = linux_raw_sys::general::MADV_POPULATE_READ,
     /// `MADV_POPULATE_WRITE` (since Linux 5.14)
     LinuxPopulateWrite = linux_raw_sys::general::MADV_POPULATE_WRITE,
+    /// `MADV_DONTNEED_LOCKED` (since Linux 5.18)
+    LinuxDontneedLocked = linux_raw_sys::general::MADV_DONTNEED_LOCKED,
 }
 
 #[allow(non_upper_case_globals)]
diff --git a/vendor/rustix/src/backend/linux_raw/mod.rs b/vendor/rustix/src/backend/linux_raw/mod.rs
index e7e073e32..cd5805f88 100644
--- a/vendor/rustix/src/backend/linux_raw/mod.rs
+++ b/vendor/rustix/src/backend/linux_raw/mod.rs
@@ -17,6 +17,12 @@
 #[macro_use]
 mod arch;
 mod conv;
+#[cfg(any(
+    feature = "param",
+    feature = "runtime",
+    feature = "time",
+    target_arch = "x86"
+))]
 mod elf;
 mod reg;
 #[cfg(any(feature = "time", target_arch = "x86"))]
@@ -24,7 +30,21 @@ mod vdso;
 #[cfg(any(feature = "time", target_arch = "x86"))]
 mod vdso_wrappers;
 
-#[cfg(feature = "fs")]
+#[cfg(feature = "event")]
+pub(crate) mod event;
+#[cfg(any(
+    feature = "fs",
+    all(
+        not(feature = "use-libc-auxv"),
+        not(target_vendor = "mustang"),
+        any(
+            feature = "param",
+            feature = "runtime",
+            feature = "time",
+            target_arch = "x86",
+        )
+    )
+))]
 pub(crate) mod fs;
 pub(crate) mod io;
 #[cfg(feature = "io_uring")]
@@ -40,28 +60,57 @@ pub(crate) mod net;
     target_arch = "x86",
 ))]
 pub(crate) mod param;
+#[cfg(feature = "pipe")]
+pub(crate) mod pipe;
+#[cfg(feature = "process")]
 pub(crate) mod process;
+#[cfg(feature = "pty")]
+pub(crate) mod pty;
 #[cfg(feature = "rand")]
 pub(crate) mod rand;
 #[cfg(feature = "runtime")]
 pub(crate) mod runtime;
+#[cfg(feature = "system")]
+pub(crate) mod system;
 #[cfg(feature = "termios")]
 pub(crate) mod termios;
 #[cfg(feature = "thread")]
 pub(crate) mod thread;
+#[cfg(feature = "time")]
 pub(crate) mod time;
 
-#[cfg(feature = "std")]
 pub(crate) mod fd {
-    pub use io_lifetimes::*;
-    #[allow(unused_imports)]
-    pub(crate) use std::os::unix::io::RawFd as LibcFd;
-    pub use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+    pub use crate::maybe_polyfill::os::fd::{
+        AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd,
+    };
 }
 
-#[cfg(not(feature = "std"))]
-pub(crate) use crate::io::fd;
-
 // The linux_raw backend doesn't use actual libc, so we define selected
 // libc-like definitions in a module called `c`.
 pub(crate) mod c;
+
+// Private modules used by multiple public modules.
+#[cfg(any(feature = "procfs", feature = "process", feature = "runtime"))]
+pub(crate) mod pid;
+#[cfg(any(feature = "process", feature = "thread"))]
+pub(crate) mod prctl;
+#[cfg(any(
+    feature = "fs",
+    feature = "process",
+    feature = "thread",
+    all(
+        not(feature = "use-libc-auxv"),
+        not(target_vendor = "mustang"),
+        any(
+            feature = "param",
+            feature = "runtime",
+            feature = "time",
+            target_arch = "x86",
+        )
+    )
+))]
+pub(crate) mod ugid;
+
+/// The maximum number of buffers that can be passed into a vectored I/O system
+/// call on the current platform.
+const MAX_IOV: usize = linux_raw_sys::general::UIO_MAXIOV as usize;
diff --git a/vendor/rustix/src/backend/linux_raw/net/addr.rs b/vendor/rustix/src/backend/linux_raw/net/addr.rs
index b69c6deca..4a203ed16 100644
--- a/vendor/rustix/src/backend/linux_raw/net/addr.rs
+++ b/vendor/rustix/src/backend/linux_raw/net/addr.rs
@@ -1,15 +1,17 @@
-//! IPv4, IPv6, and Socket addresses.
+//! Socket address utilities.
 //!
 //! # Safety
 //!
-//! Linux's IPv6 type contains a union.
+//! This file uses `CStr::from_bytes_with_nul_unchecked` on a string it knows
+//! to be NUL-terminated.
 #![allow(unsafe_code)]
 
-use super::super::c;
+use crate::backend::c;
 use crate::ffi::CStr;
 use crate::{io, path};
-use core::convert::TryInto;
-use core::{fmt, slice};
+use core::cmp::Ordering;
+use core::fmt;
+use core::hash::{Hash, Hasher};
 
 /// `struct sockaddr_un`
 #[derive(Clone)]
@@ -34,7 +36,7 @@ impl SocketAddrUnix {
             return Err(io::Errno::NAMETOOLONG);
         }
         for (i, b) in bytes.iter().enumerate() {
-            unix.sun_path[i] = *b as c::c_char;
+            unix.sun_path[i] = *b;
         }
         let len = offsetof_sun_path() + bytes.len();
         let len = len.try_into().unwrap();
@@ -45,19 +47,18 @@ impl SocketAddrUnix {
     #[inline]
     pub fn new_abstract_name(name: &[u8]) -> io::Result<Self> {
         let mut unix = Self::init();
-        if 1 + name.len() > unix.sun_path.len() {
-            return Err(io::Errno::NAMETOOLONG);
-        }
-        unix.sun_path[0] = b'\0' as c::c_char;
-        for (i, b) in name.iter().enumerate() {
-            unix.sun_path[1 + i] = *b as c::c_char;
+        let id = &mut unix.sun_path[1..];
+        if let Some(id) = id.get_mut(..name.len()) {
+            id.copy_from_slice(name);
+            let len = offsetof_sun_path() + 1 + name.len();
+            let len = len.try_into().unwrap();
+            Ok(Self { unix, len })
+        } else {
+            Err(io::Errno::NAMETOOLONG)
         }
-        let len = offsetof_sun_path() + 1 + name.len();
-        let len = len.try_into().unwrap();
-        Ok(Self { unix, len })
     }
 
-    fn init() -> c::sockaddr_un {
+    const fn init() -> c::sockaddr_un {
         c::sockaddr_un {
             sun_family: c::AF_UNIX as _,
             sun_path: [0; 108],
@@ -68,17 +69,12 @@ impl SocketAddrUnix {
     #[inline]
     pub fn path(&self) -> Option<&CStr> {
         let len = self.len();
-        if len != 0 && self.unix.sun_path[0] != b'\0' as c::c_char {
+        if len != 0 && self.unix.sun_path[0] != b'\0' {
             let end = len as usize - offsetof_sun_path();
             let bytes = &self.unix.sun_path[..end];
-            // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`. And
-            // `from_bytes_with_nul_unchecked` since the string is NUL-terminated.
-            unsafe {
-                Some(CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(
-                    bytes.as_ptr().cast(),
-                    bytes.len(),
-                )))
-            }
+            // SAFETY: `from_bytes_with_nul_unchecked` since the string is
+            // NUL-terminated.
+            unsafe { Some(CStr::from_bytes_with_nul_unchecked(bytes)) }
         } else {
             None
         }
@@ -88,11 +84,9 @@ impl SocketAddrUnix {
     #[inline]
     pub fn abstract_name(&self) -> Option<&[u8]> {
         let len = self.len();
-        if len != 0 && self.unix.sun_path[0] == b'\0' as c::c_char {
+        if len != 0 && self.unix.sun_path[0] == b'\0' {
             let end = len as usize - offsetof_sun_path();
-            let bytes = &self.unix.sun_path[1..end];
-            // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`.
-            unsafe { Some(slice::from_raw_parts(bytes.as_ptr().cast(), bytes.len())) }
+            Some(&self.unix.sun_path[1..end])
         } else {
             None
         }
@@ -122,7 +116,7 @@ impl Eq for SocketAddrUnix {}
 
 impl PartialOrd for SocketAddrUnix {
     #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         let self_len = self.len() - offsetof_sun_path();
         let other_len = other.len() - offsetof_sun_path();
         self.unix.sun_path[..self_len].partial_cmp(&other.unix.sun_path[..other_len])
@@ -131,16 +125,16 @@ impl PartialOrd for SocketAddrUnix {
 
 impl Ord for SocketAddrUnix {
     #[inline]
-    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> Ordering {
         let self_len = self.len() - offsetof_sun_path();
         let other_len = other.len() - offsetof_sun_path();
         self.unix.sun_path[..self_len].cmp(&other.unix.sun_path[..other_len])
     }
 }
 
-impl core::hash::Hash for SocketAddrUnix {
+impl Hash for SocketAddrUnix {
     #[inline]
-    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: Hasher>(&self, state: &mut H) {
         let self_len = self.len() - offsetof_sun_path();
         self.unix.sun_path[..self_len].hash(state)
     }
diff --git a/vendor/rustix/src/backend/linux_raw/net/mod.rs b/vendor/rustix/src/backend/linux_raw/net/mod.rs
index f2273db1b..2b6ab34ba 100644
--- a/vendor/rustix/src/backend/linux_raw/net/mod.rs
+++ b/vendor/rustix/src/backend/linux_raw/net/mod.rs
@@ -1,6 +1,6 @@
 pub(crate) mod addr;
+pub(crate) mod msghdr;
 pub(crate) mod read_sockaddr;
 pub(crate) mod send_recv;
 pub(crate) mod syscalls;
-pub(crate) mod types;
 pub(crate) mod write_sockaddr;
diff --git a/vendor/rustix/src/backend/linux_raw/net/msghdr.rs b/vendor/rustix/src/backend/linux_raw/net/msghdr.rs
new file mode 100644
index 000000000..3c435bcfa
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/net/msghdr.rs
@@ -0,0 +1,143 @@
+//! Utilities for dealing with message headers.
+//!
+//! These take closures rather than returning a `c::msghdr` directly because
+//! the message headers may reference stack-local data.
+
+#![allow(unsafe_code)]
+
+use crate::backend::c;
+use crate::backend::net::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6};
+
+use crate::io::{self, IoSlice, IoSliceMut};
+use crate::net::{RecvAncillaryBuffer, SendAncillaryBuffer, SocketAddrV4, SocketAddrV6};
+use crate::utils::as_ptr;
+
+use core::mem::{size_of, zeroed, MaybeUninit};
+use core::ptr::null_mut;
+
+fn msg_iov_len(len: usize) -> c::size_t {
+    // This cast cannot overflow.
+    len as c::size_t
+}
+
+pub(crate) fn msg_control_len(len: usize) -> c::size_t {
+    // Same as above.
+    len as c::size_t
+}
+
+/// Create a message header intended to receive a datagram.
+pub(crate) fn with_recv_msghdr<R>(
+    name: &mut MaybeUninit<c::sockaddr_storage>,
+    iov: &mut [IoSliceMut<'_>],
+    control: &mut RecvAncillaryBuffer<'_>,
+    f: impl FnOnce(&mut c::msghdr) -> io::Result<R>,
+) -> io::Result<R> {
+    control.clear();
+
+    let namelen = size_of::<c::sockaddr_storage>() as c::c_int;
+    let mut msghdr = c::msghdr {
+        msg_name: name.as_mut_ptr().cast(),
+        msg_namelen: namelen,
+        msg_iov: iov.as_mut_ptr().cast(),
+        msg_iovlen: msg_iov_len(iov.len()),
+        msg_control: control.as_control_ptr().cast(),
+        msg_controllen: msg_control_len(control.control_len()),
+
+        // Zero-initialize any padding bytes.
+        ..unsafe { zeroed() }
+    };
+
+    let res = f(&mut msghdr);
+
+    // Reset the control length.
+    if res.is_ok() {
+        unsafe {
+            control.set_control_len(msghdr.msg_controllen.try_into().unwrap_or(usize::MAX));
+        }
+    }
+
+    res
+}
+
+/// Create a message header intended to send without an address.
+pub(crate) fn with_noaddr_msghdr<R>(
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    f: impl FnOnce(c::msghdr) -> R,
+) -> R {
+    f(c::msghdr {
+        msg_name: null_mut(),
+        msg_namelen: 0,
+        msg_iov: iov.as_ptr() as _,
+        msg_iovlen: msg_iov_len(iov.len()),
+        msg_control: control.as_control_ptr().cast(),
+        msg_controllen: msg_control_len(control.control_len()),
+
+        // Zero-initialize any padding bytes.
+        ..unsafe { zeroed() }
+    })
+}
+
+/// Create a message header intended to send with an IPv4 address.
+pub(crate) fn with_v4_msghdr<R>(
+    addr: &SocketAddrV4,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    f: impl FnOnce(c::msghdr) -> R,
+) -> R {
+    let encoded = unsafe { encode_sockaddr_v4(addr) };
+
+    f(c::msghdr {
+        msg_name: as_ptr(&encoded) as _,
+        msg_namelen: size_of::<SocketAddrV4>() as _,
+        msg_iov: iov.as_ptr() as _,
+        msg_iovlen: msg_iov_len(iov.len()),
+        msg_control: control.as_control_ptr().cast(),
+        msg_controllen: msg_control_len(control.control_len()),
+
+        // Zero-initialize any padding bytes.
+        ..unsafe { zeroed() }
+    })
+}
+
+/// Create a message header intended to send with an IPv6 address.
+pub(crate) fn with_v6_msghdr<R>(
+    addr: &SocketAddrV6,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    f: impl FnOnce(c::msghdr) -> R,
+) -> R {
+    let encoded = unsafe { encode_sockaddr_v6(addr) };
+
+    f(c::msghdr {
+        msg_name: as_ptr(&encoded) as _,
+        msg_namelen: size_of::<SocketAddrV6>() as _,
+        msg_iov: iov.as_ptr() as _,
+        msg_iovlen: msg_iov_len(iov.len()),
+        msg_control: control.as_control_ptr().cast(),
+        msg_controllen: msg_control_len(control.control_len()),
+
+        // Zero-initialize any padding bytes.
+        ..unsafe { zeroed() }
+    })
+}
+
+/// Create a message header intended to send with a Unix address.
+pub(crate) fn with_unix_msghdr<R>(
+    addr: &crate::net::SocketAddrUnix,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    f: impl FnOnce(c::msghdr) -> R,
+) -> R {
+    f(c::msghdr {
+        msg_name: as_ptr(addr) as _,
+        msg_namelen: addr.addr_len() as _,
+        msg_iov: iov.as_ptr() as _,
+        msg_iovlen: msg_iov_len(iov.len()),
+        msg_control: control.as_control_ptr().cast(),
+        msg_controllen: msg_control_len(control.control_len()),
+
+        // Zero-initialize any padding bytes.
+        ..unsafe { zeroed() }
+    })
+}
diff --git a/vendor/rustix/src/backend/linux_raw/net/read_sockaddr.rs b/vendor/rustix/src/backend/linux_raw/net/read_sockaddr.rs
index b9bc09b96..f4b7d9914 100644
--- a/vendor/rustix/src/backend/linux_raw/net/read_sockaddr.rs
+++ b/vendor/rustix/src/backend/linux_raw/net/read_sockaddr.rs
@@ -2,10 +2,9 @@
 //! we can interpret the rest of a `sockaddr` produced by the kernel.
 #![allow(unsafe_code)]
 
-use super::super::c;
+use crate::backend::c;
 use crate::io;
 use crate::net::{Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrUnix, SocketAddrV4, SocketAddrV6};
-use alloc::vec::Vec;
 use core::mem::size_of;
 
 // This must match the header of `sockaddr`.
@@ -24,9 +23,9 @@ unsafe fn read_ss_family(storage: *const c::sockaddr) -> u16 {
     // Assert that we know the layout of `sockaddr`.
     let _ = c::sockaddr {
         __storage: c::sockaddr_storage {
-            __bindgen_anon_1: linux_raw_sys::general::__kernel_sockaddr_storage__bindgen_ty_1 {
+            __bindgen_anon_1: linux_raw_sys::net::__kernel_sockaddr_storage__bindgen_ty_1 {
                 __bindgen_anon_1:
-                    linux_raw_sys::general::__kernel_sockaddr_storage__bindgen_ty_1__bindgen_ty_1 {
+                    linux_raw_sys::net::__kernel_sockaddr_storage__bindgen_ty_1__bindgen_ty_1 {
                         ss_family: 0_u16,
                         __data: [0; 126_usize],
                     },
@@ -63,7 +62,7 @@ pub(crate) unsafe fn read_sockaddr(
             if len < size_of::<c::sockaddr_in>() {
                 return Err(io::Errno::INVAL);
             }
-            let decode = *storage.cast::<c::sockaddr_in>();
+            let decode = &*storage.cast::<c::sockaddr_in>();
             Ok(SocketAddrAny::V4(SocketAddrV4::new(
                 Ipv4Addr::from(u32::from_be(decode.sin_addr.s_addr)),
                 u16::from_be(decode.sin_port),
@@ -73,7 +72,7 @@ pub(crate) unsafe fn read_sockaddr(
             if len < size_of::<c::sockaddr_in6>() {
                 return Err(io::Errno::INVAL);
             }
-            let decode = *storage.cast::<c::sockaddr_in6>();
+            let decode = &*storage.cast::<c::sockaddr_in6>();
             Ok(SocketAddrAny::V6(SocketAddrV6::new(
                 Ipv6Addr::from(decode.sin6_addr.in6_u.u6_addr8),
                 u16::from_be(decode.sin6_port),
@@ -88,16 +87,22 @@ pub(crate) unsafe fn read_sockaddr(
             if len == offsetof_sun_path {
                 Ok(SocketAddrAny::Unix(SocketAddrUnix::new(&[][..])?))
             } else {
-                let decode = *storage.cast::<c::sockaddr_un>();
-                assert_eq!(
-                    decode.sun_path[len - 1 - offsetof_sun_path],
-                    b'\0' as c::c_char
-                );
+                let decode = &*storage.cast::<c::sockaddr_un>();
+
+                // On Linux check for Linux's [abstract namespace].
+                //
+                // [abstract namespace]: https://man7.org/linux/man-pages/man7/unix.7.html
+                if decode.sun_path[0] == 0 {
+                    return SocketAddrUnix::new_abstract_name(
+                        &decode.sun_path[1..len - offsetof_sun_path],
+                    )
+                    .map(SocketAddrAny::Unix);
+                }
+
+                // Otherwise we expect a NUL-terminated filesystem path.
+                assert_eq!(decode.sun_path[len - 1 - offsetof_sun_path], 0);
                 Ok(SocketAddrAny::Unix(SocketAddrUnix::new(
-                    decode.sun_path[..len - 1 - offsetof_sun_path]
-                        .iter()
-                        .map(|c| *c as u8)
-                        .collect::<Vec<u8>>(),
+                    &decode.sun_path[..len - 1 - offsetof_sun_path],
                 )?))
             }
         }
@@ -133,7 +138,7 @@ pub(crate) unsafe fn read_sockaddr_os(storage: *const c::sockaddr, len: usize) -
     match read_ss_family(storage).into() {
         c::AF_INET => {
             assert!(len >= size_of::<c::sockaddr_in>());
-            let decode = *storage.cast::<c::sockaddr_in>();
+            let decode = &*storage.cast::<c::sockaddr_in>();
             SocketAddrAny::V4(SocketAddrV4::new(
                 Ipv4Addr::from(u32::from_be(decode.sin_addr.s_addr)),
                 u16::from_be(decode.sin_port),
@@ -141,7 +146,7 @@ pub(crate) unsafe fn read_sockaddr_os(storage: *const c::sockaddr, len: usize) -
         }
         c::AF_INET6 => {
             assert!(len >= size_of::<c::sockaddr_in6>());
-            let decode = *storage.cast::<c::sockaddr_in6>();
+            let decode = &*storage.cast::<c::sockaddr_in6>();
             SocketAddrAny::V6(SocketAddrV6::new(
                 Ipv6Addr::from(decode.sin6_addr.in6_u.u6_addr8),
                 u16::from_be(decode.sin6_port),
@@ -154,19 +159,24 @@ pub(crate) unsafe fn read_sockaddr_os(storage: *const c::sockaddr, len: usize) -
             if len == offsetof_sun_path {
                 SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap())
             } else {
-                let decode = *storage.cast::<c::sockaddr_un>();
-                assert_eq!(
-                    decode.sun_path[len - 1 - offsetof_sun_path],
-                    b'\0' as c::c_char
-                );
+                let decode = &*storage.cast::<c::sockaddr_un>();
+
+                // On Linux check for Linux's [abstract namespace].
+                //
+                // [abstract namespace]: https://man7.org/linux/man-pages/man7/unix.7.html
+                if decode.sun_path[0] == 0 {
+                    return SocketAddrAny::Unix(
+                        SocketAddrUnix::new_abstract_name(
+                            &decode.sun_path[1..len - offsetof_sun_path],
+                        )
+                        .unwrap(),
+                    );
+                }
+
+                // Otherwise we expect a NUL-terminated filesystem path.
+                assert_eq!(decode.sun_path[len - 1 - offsetof_sun_path], 0);
                 SocketAddrAny::Unix(
-                    SocketAddrUnix::new(
-                        decode.sun_path[..len - 1 - offsetof_sun_path]
-                            .iter()
-                            .map(|c| *c as u8)
-                            .collect::<Vec<u8>>(),
-                    )
-                    .unwrap(),
+                    SocketAddrUnix::new(&decode.sun_path[..len - 1 - offsetof_sun_path]).unwrap(),
                 )
             }
         }
diff --git a/vendor/rustix/src/backend/linux_raw/net/send_recv.rs b/vendor/rustix/src/backend/linux_raw/net/send_recv.rs
index fb82eaef3..6e39a13aa 100644
--- a/vendor/rustix/src/backend/linux_raw/net/send_recv.rs
+++ b/vendor/rustix/src/backend/linux_raw/net/send_recv.rs
@@ -1,4 +1,4 @@
-use super::super::c;
+use crate::backend::c;
 use bitflags::bitflags;
 
 bitflags! {
@@ -6,6 +6,8 @@ bitflags! {
     ///
     /// [`send`]: crate::net::send
     /// [`sendto`]: crate::net::sendto
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct SendFlags: u32 {
         /// `MSG_CONFIRM`
         const CONFIRM = c::MSG_CONFIRM;
@@ -29,6 +31,8 @@ bitflags! {
     ///
     /// [`recv`]: crate::net::recv
     /// [`recvfrom`]: crate::net::recvfrom
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct RecvFlags: u32 {
         /// `MSG_CMSG_CLOEXEC`
         const CMSG_CLOEXEC = c::MSG_CMSG_CLOEXEC;
diff --git a/vendor/rustix/src/backend/linux_raw/net/syscalls.rs b/vendor/rustix/src/backend/linux_raw/net/syscalls.rs
index 7fe9f0ef4..dca331783 100644
--- a/vendor/rustix/src/backend/linux_raw/net/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/net/syscalls.rs
@@ -6,29 +6,33 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::c;
-use super::super::conv::{
-    by_mut, by_ref, c_int, c_uint, ret, ret_owned_fd, ret_usize, size_of, slice, slice_mut,
-    socklen_t, zero,
+use super::msghdr::{
+    with_noaddr_msghdr, with_recv_msghdr, with_unix_msghdr, with_v4_msghdr, with_v6_msghdr,
 };
 use super::read_sockaddr::{initialize_family_to_unspec, maybe_read_sockaddr_os, read_sockaddr_os};
 use super::send_recv::{RecvFlags, SendFlags};
-use super::types::{AddressFamily, Protocol, Shutdown, SocketFlags, SocketType};
 use super::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6};
+use crate::backend::c;
+use crate::backend::conv::{
+    by_mut, by_ref, c_int, c_uint, ret, ret_owned_fd, ret_usize, size_of, slice, slice_mut,
+    socklen_t, zero,
+};
 use crate::fd::{BorrowedFd, OwnedFd};
-use crate::io;
-use crate::net::{SocketAddrAny, SocketAddrUnix, SocketAddrV4, SocketAddrV6};
+use crate::io::{self, IoSlice, IoSliceMut};
+use crate::net::{
+    AddressFamily, Protocol, RecvAncillaryBuffer, RecvMsgReturn, SendAncillaryBuffer, Shutdown,
+    SocketAddrAny, SocketAddrUnix, SocketAddrV4, SocketAddrV6, SocketFlags, SocketType,
+};
 use c::{sockaddr, sockaddr_in, sockaddr_in6, socklen_t};
-use core::convert::TryInto;
 use core::mem::MaybeUninit;
 #[cfg(target_arch = "x86")]
 use {
-    super::super::conv::{slice_just_addr, x86_sys},
-    super::super::reg::{ArgReg, SocketArg},
-    linux_raw_sys::general::{
+    crate::backend::conv::{slice_just_addr, x86_sys},
+    crate::backend::reg::{ArgReg, SocketArg},
+    linux_raw_sys::net::{
         SYS_ACCEPT, SYS_ACCEPT4, SYS_BIND, SYS_CONNECT, SYS_GETPEERNAME, SYS_GETSOCKNAME,
-        SYS_GETSOCKOPT, SYS_LISTEN, SYS_RECV, SYS_RECVFROM, SYS_SEND, SYS_SENDTO, SYS_SETSOCKOPT,
-        SYS_SHUTDOWN, SYS_SOCKET, SYS_SOCKETPAIR,
+        SYS_GETSOCKOPT, SYS_LISTEN, SYS_RECV, SYS_RECVFROM, SYS_RECVMSG, SYS_SEND, SYS_SENDMSG,
+        SYS_SENDTO, SYS_SETSOCKOPT, SYS_SHUTDOWN, SYS_SOCKET, SYS_SOCKETPAIR,
     },
 };
 
@@ -36,7 +40,7 @@ use {
 pub(crate) fn socket(
     family: AddressFamily,
     type_: SocketType,
-    protocol: Protocol,
+    protocol: Option<Protocol>,
 ) -> io::Result<OwnedFd> {
     #[cfg(not(target_arch = "x86"))]
     unsafe {
@@ -61,7 +65,7 @@ pub(crate) fn socket_with(
     family: AddressFamily,
     type_: SocketType,
     flags: SocketFlags,
-    protocol: Protocol,
+    protocol: Option<Protocol>,
 ) -> io::Result<OwnedFd> {
     #[cfg(not(target_arch = "x86"))]
     unsafe {
@@ -91,7 +95,7 @@ pub(crate) fn socketpair(
     family: AddressFamily,
     type_: SocketType,
     flags: SocketFlags,
-    protocol: Protocol,
+    protocol: Option<Protocol>,
 ) -> io::Result<(OwnedFd, OwnedFd)> {
     #[cfg(not(target_arch = "x86"))]
     unsafe {
@@ -240,6 +244,166 @@ pub(crate) fn acceptfrom_with(
 }
 
 #[inline]
+pub(crate) fn recvmsg(
+    sockfd: BorrowedFd<'_>,
+    iov: &mut [IoSliceMut<'_>],
+    control: &mut RecvAncillaryBuffer<'_>,
+    msg_flags: RecvFlags,
+) -> io::Result<RecvMsgReturn> {
+    let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
+
+    with_recv_msghdr(&mut storage, iov, control, |msghdr| {
+        #[cfg(not(target_arch = "x86"))]
+        let result =
+            unsafe { ret_usize(syscall!(__NR_recvmsg, sockfd, by_mut(msghdr), msg_flags)) };
+
+        #[cfg(target_arch = "x86")]
+        let result = unsafe {
+            ret_usize(syscall!(
+                __NR_socketcall,
+                x86_sys(SYS_RECVMSG),
+                slice_just_addr::<ArgReg<SocketArg>, _>(&[
+                    sockfd.into(),
+                    by_mut(msghdr),
+                    msg_flags.into(),
+                ])
+            ))
+        };
+
+        result.map(|bytes| {
+            // Get the address of the sender, if any.
+            let addr =
+                unsafe { maybe_read_sockaddr_os(msghdr.msg_name as _, msghdr.msg_namelen as _) };
+
+            RecvMsgReturn {
+                bytes,
+                address: addr,
+                flags: RecvFlags::from_bits_retain(msghdr.msg_flags),
+            }
+        })
+    })
+}
+
+#[inline]
+pub(crate) fn sendmsg(
+    sockfd: BorrowedFd<'_>,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    msg_flags: SendFlags,
+) -> io::Result<usize> {
+    with_noaddr_msghdr(iov, control, |msghdr| {
+        #[cfg(not(target_arch = "x86"))]
+        let result =
+            unsafe { ret_usize(syscall!(__NR_sendmsg, sockfd, by_ref(&msghdr), msg_flags)) };
+
+        #[cfg(target_arch = "x86")]
+        let result = unsafe {
+            ret_usize(syscall!(
+                __NR_socketcall,
+                x86_sys(SYS_SENDMSG),
+                slice_just_addr::<ArgReg<SocketArg>, _>(&[
+                    sockfd.into(),
+                    by_ref(&msghdr),
+                    msg_flags.into()
+                ])
+            ))
+        };
+
+        result
+    })
+}
+
+#[inline]
+pub(crate) fn sendmsg_v4(
+    sockfd: BorrowedFd<'_>,
+    addr: &SocketAddrV4,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    msg_flags: SendFlags,
+) -> io::Result<usize> {
+    with_v4_msghdr(addr, iov, control, |msghdr| {
+        #[cfg(not(target_arch = "x86"))]
+        let result =
+            unsafe { ret_usize(syscall!(__NR_sendmsg, sockfd, by_ref(&msghdr), msg_flags)) };
+
+        #[cfg(target_arch = "x86")]
+        let result = unsafe {
+            ret_usize(syscall!(
+                __NR_socketcall,
+                x86_sys(SYS_SENDMSG),
+                slice_just_addr::<ArgReg<SocketArg>, _>(&[
+                    sockfd.into(),
+                    by_ref(&msghdr),
+                    msg_flags.into(),
+                ])
+            ))
+        };
+
+        result
+    })
+}
+
+#[inline]
+pub(crate) fn sendmsg_v6(
+    sockfd: BorrowedFd<'_>,
+    addr: &SocketAddrV6,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    msg_flags: SendFlags,
+) -> io::Result<usize> {
+    with_v6_msghdr(addr, iov, control, |msghdr| {
+        #[cfg(not(target_arch = "x86"))]
+        let result =
+            unsafe { ret_usize(syscall!(__NR_sendmsg, sockfd, by_ref(&msghdr), msg_flags)) };
+
+        #[cfg(target_arch = "x86")]
+        let result = unsafe {
+            ret_usize(syscall!(
+                __NR_socketcall,
+                x86_sys(SYS_SENDMSG),
+                slice_just_addr::<ArgReg<SocketArg>, _>(&[
+                    sockfd.into(),
+                    by_ref(&msghdr),
+                    msg_flags.into()
+                ])
+            ))
+        };
+
+        result
+    })
+}
+
+#[inline]
+pub(crate) fn sendmsg_unix(
+    sockfd: BorrowedFd<'_>,
+    addr: &SocketAddrUnix,
+    iov: &[IoSlice<'_>],
+    control: &mut SendAncillaryBuffer<'_, '_, '_>,
+    msg_flags: SendFlags,
+) -> io::Result<usize> {
+    with_unix_msghdr(addr, iov, control, |msghdr| {
+        #[cfg(not(target_arch = "x86"))]
+        let result =
+            unsafe { ret_usize(syscall!(__NR_sendmsg, sockfd, by_ref(&msghdr), msg_flags)) };
+
+        #[cfg(target_arch = "x86")]
+        let result = unsafe {
+            ret_usize(syscall!(
+                __NR_socketcall,
+                x86_sys(SYS_SENDMSG),
+                slice_just_addr::<ArgReg<SocketArg>, _>(&[
+                    sockfd.into(),
+                    by_ref(&msghdr),
+                    msg_flags.into()
+                ])
+            ))
+        };
+
+        result
+    })
+}
+
+#[inline]
 pub(crate) fn shutdown(fd: BorrowedFd<'_>, how: Shutdown) -> io::Result<()> {
     #[cfg(not(target_arch = "x86"))]
     unsafe {
@@ -754,13 +918,9 @@ pub(crate) mod sockopt {
     use crate::net::sockopt::Timeout;
     use crate::net::{Ipv4Addr, Ipv6Addr, SocketType};
     use c::{SO_RCVTIMEO_NEW, SO_RCVTIMEO_OLD, SO_SNDTIMEO_NEW, SO_SNDTIMEO_OLD};
-    use core::convert::TryInto;
     use core::time::Duration;
     use linux_raw_sys::general::{__kernel_timespec, timeval};
 
-    // TODO: With Rust 1.53 we can use `Duration::ZERO` instead.
-    const DURATION_ZERO: Duration = Duration::from_secs(0);
-
     #[inline]
     fn getsockopt<T: Copy>(fd: BorrowedFd<'_>, level: u32, optname: u32) -> io::Result<T> {
         use super::*;
@@ -910,12 +1070,7 @@ pub(crate) mod sockopt {
     #[inline]
     pub(crate) fn get_socket_linger(fd: BorrowedFd<'_>) -> io::Result<Option<Duration>> {
         let linger: c::linger = getsockopt(fd, c::SOL_SOCKET as _, c::SO_LINGER)?;
-        // TODO: With Rust 1.50, this could use `.then`.
-        Ok(if linger.l_onoff != 0 {
-            Some(Duration::from_secs(linger.l_linger as u64))
-        } else {
-            None
-        })
+        Ok((linger.l_onoff != 0).then(|| Duration::from_secs(linger.l_linger as u64)))
     }
 
     #[inline]
@@ -1020,7 +1175,7 @@ pub(crate) mod sockopt {
     fn duration_to_linux(timeout: Option<Duration>) -> io::Result<__kernel_timespec> {
         Ok(match timeout {
             Some(timeout) => {
-                if timeout == DURATION_ZERO {
+                if timeout == Duration::ZERO {
                     return Err(io::Errno::INVAL);
                 }
                 let mut timeout = __kernel_timespec {
@@ -1043,7 +1198,7 @@ pub(crate) mod sockopt {
     fn duration_to_linux_old(timeout: Option<Duration>) -> io::Result<timeval> {
         Ok(match timeout {
             Some(timeout) => {
-                if timeout == DURATION_ZERO {
+                if timeout == Duration::ZERO {
                     return Err(io::Errno::INVAL);
                 }
 
@@ -1186,14 +1341,14 @@ pub(crate) mod sockopt {
         setsockopt(
             fd,
             c::IPPROTO_IP as _,
-            c::IPV6_MULTICAST_LOOP,
+            c::IPV6_MULTICAST_HOPS,
             multicast_hops,
         )
     }
 
     #[inline]
     pub(crate) fn get_ipv6_multicast_hops(fd: BorrowedFd<'_>) -> io::Result<u32> {
-        getsockopt(fd, c::IPPROTO_IP as _, c::IPV6_MULTICAST_LOOP)
+        getsockopt(fd, c::IPPROTO_IP as _, c::IPV6_MULTICAST_HOPS)
     }
 
     #[inline]
@@ -1244,7 +1399,7 @@ pub(crate) mod sockopt {
     #[inline]
     pub(crate) fn set_ipv6_unicast_hops(fd: BorrowedFd<'_>, hops: Option<u8>) -> io::Result<()> {
         let hops = match hops {
-            Some(hops) => hops as c::c_int,
+            Some(hops) => hops.into(),
             None => -1,
         };
         setsockopt(fd, c::IPPROTO_IPV6 as _, c::IPV6_UNICAST_HOPS, hops)
@@ -1286,7 +1441,7 @@ pub(crate) mod sockopt {
     #[inline]
     fn to_ipv6mr_multiaddr(multiaddr: &Ipv6Addr) -> c::in6_addr {
         c::in6_addr {
-            in6_u: linux_raw_sys::general::in6_addr__bindgen_ty_1 {
+            in6_u: linux_raw_sys::net::in6_addr__bindgen_ty_1 {
                 u6_addr8: multiaddr.octets(),
             },
         }
diff --git a/vendor/rustix/src/backend/linux_raw/net/types.rs b/vendor/rustix/src/backend/linux_raw/net/types.rs
deleted file mode 100644
index 3f0b571a5..000000000
--- a/vendor/rustix/src/backend/linux_raw/net/types.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-use super::super::c;
-use bitflags::bitflags;
-
-/// A type for holding raw integer socket types.
-#[doc(hidden)]
-pub type RawSocketType = u32;
-
-/// `SOCK_*` constants for use with [`socket`].
-///
-/// [`socket`]: crate::net::socket
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct SocketType(pub(crate) RawSocketType);
-
-#[rustfmt::skip]
-impl SocketType {
-    /// `SOCK_STREAM`
-    pub const STREAM: Self = Self(c::SOCK_STREAM);
-
-    /// `SOCK_DGRAM`
-    pub const DGRAM: Self = Self(c::SOCK_DGRAM);
-
-    /// `SOCK_SEQPACKET`
-    pub const SEQPACKET: Self = Self(c::SOCK_SEQPACKET);
-
-    /// `SOCK_RAW`
-    pub const RAW: Self = Self(c::SOCK_RAW);
-
-    /// `SOCK_RDM`
-    pub const RDM: Self = Self(c::SOCK_RDM);
-
-    /// Constructs a `SocketType` from a raw integer.
-    #[inline]
-    pub const fn from_raw(raw: RawSocketType) -> Self {
-        Self(raw)
-    }
-
-    /// Returns the raw integer for this `SocketType`.
-    #[inline]
-    pub const fn as_raw(self) -> RawSocketType {
-        self.0
-    }
-}
-
-/// A type for holding raw integer address families.
-#[doc(hidden)]
-pub type RawAddressFamily = c::sa_family_t;
-
-/// `AF_*` constants.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct AddressFamily(pub(crate) RawAddressFamily);
-
-#[rustfmt::skip]
-#[allow(non_upper_case_globals)]
-impl AddressFamily {
-    /// `AF_UNSPEC`
-    pub const UNSPEC: Self = Self(c::AF_UNSPEC as _);
-    /// `AF_INET`
-    pub const INET: Self = Self(c::AF_INET as _);
-    /// `AF_INET6`
-    pub const INET6: Self = Self(c::AF_INET6 as _);
-    /// `AF_NETLINK`
-    pub const NETLINK: Self = Self(c::AF_NETLINK as _);
-    /// `AF_UNIX`, aka `AF_LOCAL`
-    #[doc(alias = "LOCAL")]
-    pub const UNIX: Self = Self(c::AF_UNIX as _);
-    /// `AF_AX25`
-    pub const AX25: Self = Self(c::AF_AX25 as _);
-    /// `AF_IPX`
-    pub const IPX: Self = Self(c::AF_IPX as _);
-    /// `AF_APPLETALK`
-    pub const APPLETALK: Self = Self(c::AF_APPLETALK as _);
-    /// `AF_NETROM`
-    pub const NETROM: Self = Self(c::AF_NETROM as _);
-    /// `AF_BRIDGE`
-    pub const BRIDGE: Self = Self(c::AF_BRIDGE as _);
-    /// `AF_ATMPVC`
-    pub const ATMPVC: Self = Self(c::AF_ATMPVC as _);
-    /// `AF_X25`
-    pub const X25: Self = Self(c::AF_X25 as _);
-    /// `AF_ROSE`
-    pub const ROSE: Self = Self(c::AF_ROSE as _);
-    /// `AF_DECnet`
-    pub const DECnet: Self = Self(c::AF_DECnet as _);
-    /// `AF_NETBEUI`
-    pub const NETBEUI: Self = Self(c::AF_NETBEUI as _);
-    /// `AF_SECURITY`
-    pub const SECURITY: Self = Self(c::AF_SECURITY as _);
-    /// `AF_KEY`
-    pub const KEY: Self = Self(c::AF_KEY as _);
-    /// `AF_PACKET`
-    pub const PACKET: Self = Self(c::AF_PACKET as _);
-    /// `AF_ASH`
-    pub const ASH: Self = Self(c::AF_ASH as _);
-    /// `AF_ECONET`
-    pub const ECONET: Self = Self(c::AF_ECONET as _);
-    /// `AF_ATMSVC`
-    pub const ATMSVC: Self = Self(c::AF_ATMSVC as _);
-    /// `AF_RDS`
-    pub const RDS: Self = Self(c::AF_RDS as _);
-    /// `AF_SNA`
-    pub const SNA: Self = Self(c::AF_SNA as _);
-    /// `AF_IRDA`
-    pub const IRDA: Self = Self(c::AF_IRDA as _);
-    /// `AF_PPPOX`
-    pub const PPPOX: Self = Self(c::AF_PPPOX as _);
-    /// `AF_WANPIPE`
-    pub const WANPIPE: Self = Self(c::AF_WANPIPE as _);
-    /// `AF_LLC`
-    pub const LLC: Self = Self(c::AF_LLC as _);
-    /// `AF_CAN`
-    pub const CAN: Self = Self(c::AF_CAN as _);
-    /// `AF_TIPC`
-    pub const TIPC: Self = Self(c::AF_TIPC as _);
-    /// `AF_BLUETOOTH`
-    pub const BLUETOOTH: Self = Self(c::AF_BLUETOOTH as _);
-    /// `AF_IUCV`
-    pub const IUCV: Self = Self(c::AF_IUCV as _);
-    /// `AF_RXRPC`
-    pub const RXRPC: Self = Self(c::AF_RXRPC as _);
-    /// `AF_ISDN`
-    pub const ISDN: Self = Self(c::AF_ISDN as _);
-    /// `AF_PHONET`
-    pub const PHONET: Self = Self(c::AF_PHONET as _);
-    /// `AF_IEEE802154`
-    pub const IEEE802154: Self = Self(c::AF_IEEE802154 as _);
-
-    /// Constructs a `AddressFamily` from a raw integer.
-    #[inline]
-    pub const fn from_raw(raw: RawAddressFamily) -> Self {
-        Self(raw)
-    }
-
-    /// Returns the raw integer for this `AddressFamily`.
-    #[inline]
-    pub const fn as_raw(self) -> RawAddressFamily {
-        self.0
-    }
-}
-
-/// A type for holding raw integer protocols.
-#[doc(hidden)]
-pub type RawProtocol = u32;
-
-/// `IPPROTO_*` constants for use with [`socket`] and [`socket_with`].
-///
-/// [`socket`]: crate::net::socket
-/// [`socket_with`]: crate::net::socket_with
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct Protocol(pub(crate) RawProtocol);
-
-#[rustfmt::skip]
-impl Protocol {
-    /// `IPPROTO_IP`
-    pub const IP: Self = Self(c::IPPROTO_IP as _);
-    /// `IPPROTO_ICMP`
-    pub const ICMP: Self = Self(c::IPPROTO_ICMP as _);
-    /// `IPPROTO_IGMP`
-    pub const IGMP: Self = Self(c::IPPROTO_IGMP as _);
-    /// `IPPROTO_IPIP`
-    pub const IPIP: Self = Self(c::IPPROTO_IPIP as _);
-    /// `IPPROTO_TCP`
-    pub const TCP: Self = Self(c::IPPROTO_TCP as _);
-    /// `IPPROTO_EGP`
-    pub const EGP: Self = Self(c::IPPROTO_EGP as _);
-    /// `IPPROTO_PUP`
-    pub const PUP: Self = Self(c::IPPROTO_PUP as _);
-    /// `IPPROTO_UDP`
-    pub const UDP: Self = Self(c::IPPROTO_UDP as _);
-    /// `IPPROTO_IDP`
-    pub const IDP: Self = Self(c::IPPROTO_IDP as _);
-    /// `IPPROTO_TP`
-    pub const TP: Self = Self(c::IPPROTO_TP as _);
-    /// `IPPROTO_DCCP`
-    pub const DCCP: Self = Self(c::IPPROTO_DCCP as _);
-    /// `IPPROTO_IPV6`
-    pub const IPV6: Self = Self(c::IPPROTO_IPV6 as _);
-    /// `IPPROTO_RSVP`
-    pub const RSVP: Self = Self(c::IPPROTO_RSVP as _);
-    /// `IPPROTO_GRE`
-    pub const GRE: Self = Self(c::IPPROTO_GRE as _);
-    /// `IPPROTO_ESP`
-    pub const ESP: Self = Self(c::IPPROTO_ESP as _);
-    /// `IPPROTO_AH`
-    pub const AH: Self = Self(c::IPPROTO_AH as _);
-    /// `IPPROTO_MTP`
-    pub const MTP: Self = Self(c::IPPROTO_MTP as _);
-    /// `IPPROTO_BEETPH`
-    pub const BEETPH: Self = Self(c::IPPROTO_BEETPH as _);
-    /// `IPPROTO_ENCAP`
-    pub const ENCAP: Self = Self(c::IPPROTO_ENCAP as _);
-    /// `IPPROTO_PIM`
-    pub const PIM: Self = Self(c::IPPROTO_PIM as _);
-    /// `IPPROTO_COMP`
-    pub const COMP: Self = Self(c::IPPROTO_COMP as _);
-    /// `IPPROTO_SCTP`
-    pub const SCTP: Self = Self(c::IPPROTO_SCTP as _);
-    /// `IPPROTO_UDPLITE`
-    pub const UDPLITE: Self = Self(c::IPPROTO_UDPLITE as _);
-    /// `IPPROTO_MPLS`
-    pub const MPLS: Self = Self(c::IPPROTO_MPLS as _);
-    /// `IPPROTO_ETHERNET`
-    pub const ETHERNET: Self = Self(c::IPPROTO_ETHERNET as _);
-    /// `IPPROTO_RAW`
-    pub const RAW: Self = Self(c::IPPROTO_RAW as _);
-    /// `IPPROTO_MPTCP`
-    pub const MPTCP: Self = Self(c::IPPROTO_MPTCP as _);
-    /// `IPPROTO_FRAGMENT`
-    pub const FRAGMENT: Self = Self(c::IPPROTO_FRAGMENT as _);
-    /// `IPPROTO_ICMPV6`
-    pub const ICMPV6: Self = Self(c::IPPROTO_ICMPV6 as _);
-    /// `IPPROTO_MH`
-    pub const MH: Self = Self(c::IPPROTO_MH as _);
-    /// `IPPROTO_ROUTING`
-    pub const ROUTING: Self = Self(c::IPPROTO_ROUTING as _);
-
-    /// Constructs a `Protocol` from a raw integer.
-    #[inline]
-    pub const fn from_raw(raw: RawProtocol) -> Self {
-        Self(raw)
-    }
-
-    /// Returns the raw integer for this `Protocol`.
-    #[inline]
-    pub const fn as_raw(self) -> RawProtocol {
-        self.0
-    }
-}
-
-/// `SHUT_*` constants for use with [`shutdown`].
-///
-/// [`shutdown`]: crate::net::shutdown
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(u32)]
-pub enum Shutdown {
-    /// `SHUT_RD`—Disable further read operations.
-    Read = c::SHUT_RD,
-    /// `SHUT_WR`—Disable further write operations.
-    Write = c::SHUT_WR,
-    /// `SHUT_RDWR`—Disable further read and write operations.
-    ReadWrite = c::SHUT_RDWR,
-}
-
-bitflags! {
-    /// `SOCK_*` constants for use with [`socket_with`], [`accept_with`] and
-    /// [`acceptfrom_with`].
-    ///
-    /// [`socket_with`]: crate::net::socket_with
-    /// [`accept_with`]: crate::net::accept_with
-    /// [`acceptfrom_with`]: crate::net::acceptfrom_with
-    pub struct SocketFlags: c::c_uint {
-        /// `SOCK_NONBLOCK`
-        const NONBLOCK = c::O_NONBLOCK;
-
-        /// `SOCK_CLOEXEC`
-        const CLOEXEC = c::O_CLOEXEC;
-    }
-}
-
-/// Timeout identifier for use with [`set_socket_timeout`] and
-/// [`get_socket_timeout`].
-///
-/// [`set_socket_timeout`]: crate::net::sockopt::set_socket_timeout.
-/// [`get_socket_timeout`]: crate::net::sockopt::get_socket_timeout.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(u32)]
-pub enum Timeout {
-    /// `SO_RCVTIMEO`—Timeout for receiving.
-    Recv = c::SO_RCVTIMEO_NEW,
-
-    /// `SO_SNDTIMEO`—Timeout for sending.
-    Send = c::SO_SNDTIMEO_NEW,
-}
diff --git a/vendor/rustix/src/backend/linux_raw/net/write_sockaddr.rs b/vendor/rustix/src/backend/linux_raw/net/write_sockaddr.rs
index 17abd96a0..28da05cd0 100644
--- a/vendor/rustix/src/backend/linux_raw/net/write_sockaddr.rs
+++ b/vendor/rustix/src/backend/linux_raw/net/write_sockaddr.rs
@@ -2,7 +2,7 @@
 //! we can interpret the rest of a `sockaddr` produced by the kernel.
 #![allow(unsafe_code)]
 
-use super::super::c;
+use crate::backend::c;
 use crate::net::{SocketAddrAny, SocketAddrStorage, SocketAddrUnix, SocketAddrV4, SocketAddrV6};
 use core::mem::size_of;
 
@@ -40,7 +40,7 @@ pub(crate) unsafe fn encode_sockaddr_v6(v6: &SocketAddrV6) -> c::sockaddr_in6 {
         sin6_port: u16::to_be(v6.port()),
         sin6_flowinfo: u32::to_be(v6.flowinfo()),
         sin6_addr: c::in6_addr {
-            in6_u: linux_raw_sys::general::in6_addr__bindgen_ty_1 {
+            in6_u: linux_raw_sys::net::in6_addr__bindgen_ty_1 {
                 u6_addr8: v6.ip().octets(),
             },
         },
diff --git a/vendor/rustix/src/backend/linux_raw/param/auxv.rs b/vendor/rustix/src/backend/linux_raw/param/auxv.rs
index 741a0564f..bf8935a0d 100644
--- a/vendor/rustix/src/backend/linux_raw/param/auxv.rs
+++ b/vendor/rustix/src/backend/linux_raw/param/auxv.rs
@@ -5,12 +5,11 @@
 //! This uses raw pointers to locate and read the kernel-provided auxv array.
 #![allow(unsafe_code)]
 
-use super::super::c;
-use super::super::elf::*;
+use crate::backend::c;
+use crate::backend::elf::*;
 use crate::fd::OwnedFd;
 #[cfg(feature = "param")]
 use crate::ffi::CStr;
-#[cfg(not(target_vendor = "mustang"))]
 use crate::fs::{Mode, OFlags};
 use crate::utils::{as_ptr, check_raw_pointer};
 use alloc::vec::Vec;
@@ -32,7 +31,7 @@ pub(crate) fn page_size() -> usize {
     let mut page_size = PAGE_SIZE.load(Relaxed);
 
     if page_size == 0 {
-        init_from_proc_self_auxv();
+        init_auxv();
         page_size = PAGE_SIZE.load(Relaxed);
     }
 
@@ -45,7 +44,7 @@ pub(crate) fn clock_ticks_per_second() -> u64 {
     let mut ticks = CLOCK_TICKS_PER_SECOND.load(Relaxed);
 
     if ticks == 0 {
-        init_from_proc_self_auxv();
+        init_auxv();
         ticks = CLOCK_TICKS_PER_SECOND.load(Relaxed);
     }
 
@@ -59,7 +58,7 @@ pub(crate) fn linux_hwcap() -> (usize, usize) {
     let mut hwcap2 = HWCAP2.load(Relaxed);
 
     if hwcap == 0 || hwcap2 == 0 {
-        init_from_proc_self_auxv();
+        init_auxv();
         hwcap = HWCAP.load(Relaxed);
         hwcap2 = HWCAP2.load(Relaxed);
     }
@@ -73,7 +72,7 @@ pub(crate) fn linux_execfn() -> &'static CStr {
     let mut execfn = EXECFN.load(Relaxed);
 
     if execfn.is_null() {
-        init_from_proc_self_auxv();
+        init_auxv();
         execfn = EXECFN.load(Relaxed);
     }
 
@@ -89,7 +88,7 @@ pub(crate) fn exe_phdrs() -> (*const c::c_void, usize) {
     let mut phnum = PHNUM.load(Relaxed);
 
     if phdr.is_null() || phnum == 0 {
-        init_from_proc_self_auxv();
+        init_auxv();
         phdr = PHDR.load(Relaxed);
         phnum = PHNUM.load(Relaxed);
     }
@@ -114,7 +113,7 @@ pub(in super::super) fn sysinfo_ehdr() -> *const Elf_Ehdr {
     let mut ehdr = SYSINFO_EHDR.load(Relaxed);
 
     if ehdr.is_null() {
-        init_from_proc_self_auxv();
+        init_auxv();
         ehdr = SYSINFO_EHDR.load(Relaxed);
     }
 
@@ -130,29 +129,61 @@ static PHDR: AtomicPtr<Elf_Phdr> = AtomicPtr::new(null_mut());
 static PHNUM: AtomicUsize = AtomicUsize::new(0);
 static EXECFN: AtomicPtr<c::c_char> = AtomicPtr::new(null_mut());
 
-/// On non-Mustang platforms, we read the aux vector from /proc/self/auxv.
-#[cfg(not(target_vendor = "mustang"))]
-fn init_from_proc_self_auxv() {
+fn pr_get_auxv() -> crate::io::Result<Vec<u8>> {
+    use super::super::conv::{c_int, pass_usize, ret_usize};
+    const PR_GET_AUXV: c::c_int = 0x41555856;
+    let mut buffer = alloc::vec![0u8; 512];
+    let len = unsafe {
+        ret_usize(syscall_always_asm!(
+            __NR_prctl,
+            c_int(PR_GET_AUXV),
+            buffer.as_ptr(),
+            pass_usize(buffer.len())
+        ))?
+    };
+    if len <= buffer.len() {
+        buffer.truncate(len);
+        return Ok(buffer);
+    }
+    buffer.resize(len, 0);
+    let len = unsafe {
+        ret_usize(syscall_always_asm!(
+            __NR_prctl,
+            c_int(PR_GET_AUXV),
+            buffer.as_ptr(),
+            pass_usize(buffer.len())
+        ))?
+    };
+    assert_eq!(len, buffer.len());
+    return Ok(buffer);
+}
+
+/// On non-Mustang platforms, we read the aux vector via the `prctl`
+/// `PR_GET_AUXV`, with a fallback to /proc/self/auxv for kernels that don't
+/// support `PR_GET_AUXV`.
+fn init_auxv() {
+    match pr_get_auxv() {
+        Ok(buffer) => {
+            // SAFETY: We assume the kernel returns a valid auxv.
+            unsafe {
+                init_from_auxp(buffer.as_ptr().cast());
+            }
+            return;
+        }
+        Err(_) => {
+            // Fall back to /proc/self/auxv on error.
+        }
+    }
+
     // Open "/proc/self/auxv", either because we trust "/proc", or because
     // we're running inside QEMU and `proc_self_auxv`'s extra checking foils
     // QEMU's emulation so we need to do a plain open to get the right
     // auxv records.
-    let file = crate::fs::openat(
-        crate::fs::cwd(),
-        "/proc/self/auxv",
-        OFlags::empty(),
-        Mode::empty(),
-    )
-    .unwrap();
+    let file = crate::fs::open("/proc/self/auxv", OFlags::RDONLY, Mode::empty()).unwrap();
 
     let _ = init_from_auxv_file(file);
 }
 
-#[cfg(target_vendor = "mustang")]
-fn init_from_proc_self_auxv() {
-    panic!("mustang should have initialized the auxv values");
-}
-
 /// Process auxv entries from the open file `auxv`.
 fn init_from_auxv_file(auxv: OwnedFd) -> Option<()> {
     let mut buffer = Vec::<u8>::with_capacity(512);
@@ -276,7 +307,7 @@ unsafe fn check_vdso_base(base: *const Elf_Ehdr) -> Option<NonNull<Elf_Ehdr>> {
     // as an arbitrary system call which writes to a buffer and fails with
     // `EFAULT` if the buffer is not writable.
     {
-        use super::super::conv::{c_uint, ret};
+        use crate::backend::conv::{c_uint, ret};
         if ret(syscall!(
             __NR_clock_getres,
             c_uint(linux_raw_sys::general::CLOCK_MONOTONIC),
diff --git a/vendor/rustix/src/backend/linux_raw/param/libc_auxv.rs b/vendor/rustix/src/backend/linux_raw/param/libc_auxv.rs
index a8e291ff6..d05a87e53 100644
--- a/vendor/rustix/src/backend/linux_raw/param/libc_auxv.rs
+++ b/vendor/rustix/src/backend/linux_raw/param/libc_auxv.rs
@@ -5,59 +5,124 @@
 //! This uses raw pointers to locate and read the kernel-provided auxv array.
 #![allow(unsafe_code)]
 
-use super::super::elf::*;
+use crate::backend::c;
+use crate::backend::elf::*;
 #[cfg(feature = "param")]
 use crate::ffi::CStr;
+#[cfg(not(feature = "runtime"))]
+use core::ptr::null;
 #[cfg(feature = "runtime")]
 use core::slice;
 
-// `getauxval` wasn't supported in glibc until 2.16.
-weak!(fn getauxval(libc::c_ulong) -> *mut libc::c_void);
+// `getauxval` wasn't supported in glibc until 2.16. Also this lets us use
+// `*mut` as the return type to preserve strict provenance.
+#[cfg(not(feature = "runtime"))]
+weak!(fn getauxval(c::c_ulong) -> *mut c::c_void);
+
+// With the "runtime" feature, go ahead and depend on `getauxval` existing
+// so that we never fail.
+#[cfg(feature = "runtime")]
+extern "C" {
+    fn getauxval(type_: c::c_ulong) -> *mut c::c_void;
+}
+
+const AT_PHDR: c::c_ulong = 3;
+const AT_PHNUM: c::c_ulong = 5;
+const AT_HWCAP: c::c_ulong = 16;
+const AT_HWCAP2: c::c_ulong = 26;
+const AT_EXECFN: c::c_ulong = 31;
+const AT_SYSINFO_EHDR: c::c_ulong = 33;
+
+// Declare `sysconf` ourselves so that we don't depend on all of libc
+// just for this.
+extern "C" {
+    fn sysconf(name: c::c_int) -> c::c_long;
+}
+
+#[cfg(target_os = "android")]
+const _SC_PAGESIZE: c::c_int = 39;
+#[cfg(target_os = "emscripten")]
+const _SC_PAGESIZE: c::c_int = 30;
+#[cfg(target_os = "linux")]
+const _SC_PAGESIZE: c::c_int = 30;
+#[cfg(target_os = "android")]
+const _SC_CLK_TCK: c::c_int = 6;
+#[cfg(target_os = "emscripten")]
+const _SC_CLK_TCK: c::c_int = 2;
+#[cfg(target_os = "linux")]
+const _SC_CLK_TCK: c::c_int = 2;
+
+#[test]
+fn test_abi() {
+    assert_eq!(self::_SC_PAGESIZE, ::libc::_SC_PAGESIZE);
+    assert_eq!(self::_SC_CLK_TCK, ::libc::_SC_CLK_TCK);
+    assert_eq!(self::AT_PHDR, ::libc::AT_PHDR);
+    assert_eq!(self::AT_PHNUM, ::libc::AT_PHNUM);
+    assert_eq!(self::AT_HWCAP, ::libc::AT_HWCAP);
+    assert_eq!(self::AT_HWCAP2, ::libc::AT_HWCAP2);
+    assert_eq!(self::AT_EXECFN, ::libc::AT_EXECFN);
+    assert_eq!(self::AT_SYSINFO_EHDR, ::libc::AT_SYSINFO_EHDR);
+}
 
 #[cfg(feature = "param")]
 #[inline]
 pub(crate) fn page_size() -> usize {
-    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
+    unsafe { sysconf(_SC_PAGESIZE) as usize }
 }
 
 #[cfg(feature = "param")]
 #[inline]
 pub(crate) fn clock_ticks_per_second() -> u64 {
-    unsafe { libc::sysconf(libc::_SC_CLK_TCK) as u64 }
+    unsafe { sysconf(_SC_CLK_TCK) as u64 }
 }
 
 #[cfg(feature = "param")]
 #[inline]
 pub(crate) fn linux_hwcap() -> (usize, usize) {
-    if let Some(libc_getauxval) = getauxval.get() {
-        unsafe {
-            let hwcap = libc_getauxval(libc::AT_HWCAP) as usize;
-            let hwcap2 = libc_getauxval(libc::AT_HWCAP2) as usize;
+    #[cfg(not(feature = "runtime"))]
+    unsafe {
+        if let Some(libc_getauxval) = getauxval.get() {
+            let hwcap = libc_getauxval(AT_HWCAP) as usize;
+            let hwcap2 = libc_getauxval(AT_HWCAP2) as usize;
             (hwcap, hwcap2)
+        } else {
+            (0, 0)
         }
-    } else {
-        (0, 0)
+    }
+
+    #[cfg(feature = "runtime")]
+    unsafe {
+        let hwcap = getauxval(AT_HWCAP) as usize;
+        let hwcap2 = getauxval(AT_HWCAP2) as usize;
+        (hwcap, hwcap2)
     }
 }
 
 #[cfg(feature = "param")]
 #[inline]
 pub(crate) fn linux_execfn() -> &'static CStr {
-    if let Some(libc_getauxval) = getauxval.get() {
-        unsafe { CStr::from_ptr(libc_getauxval(libc::AT_EXECFN).cast()) }
-    } else {
-        cstr!("")
+    #[cfg(not(feature = "runtime"))]
+    unsafe {
+        if let Some(libc_getauxval) = getauxval.get() {
+            CStr::from_ptr(libc_getauxval(AT_EXECFN).cast())
+        } else {
+            cstr!("")
+        }
+    }
+
+    #[cfg(feature = "runtime")]
+    unsafe {
+        CStr::from_ptr(getauxval(AT_EXECFN).cast())
     }
 }
 
 #[cfg(feature = "runtime")]
 #[inline]
-pub(crate) fn exe_phdrs() -> (*const libc::c_void, usize) {
+pub(crate) fn exe_phdrs() -> (*const c::c_void, usize) {
     unsafe {
-        (
-            libc::getauxval(libc::AT_PHDR) as *const libc::c_void,
-            libc::getauxval(libc::AT_PHNUM) as usize,
-        )
+        let phdr = getauxval(AT_PHDR) as *const c::c_void;
+        let phnum = getauxval(AT_PHNUM) as usize;
+        (phdr, phnum)
     }
 }
 
@@ -75,9 +140,17 @@ pub(in super::super) fn exe_phdrs_slice() -> &'static [Elf_Phdr] {
 /// so if we don't see it, this function returns a null pointer.
 #[inline]
 pub(in super::super) fn sysinfo_ehdr() -> *const Elf_Ehdr {
-    if let Some(libc_getauxval) = getauxval.get() {
-        unsafe { libc_getauxval(linux_raw_sys::general::AT_SYSINFO_EHDR.into()) as *const Elf_Ehdr }
-    } else {
-        core::ptr::null()
+    #[cfg(not(feature = "runtime"))]
+    unsafe {
+        if let Some(libc_getauxval) = getauxval.get() {
+            libc_getauxval(AT_SYSINFO_EHDR) as *const Elf_Ehdr
+        } else {
+            null()
+        }
+    }
+
+    #[cfg(feature = "runtime")]
+    unsafe {
+        getauxval(AT_SYSINFO_EHDR) as *const Elf_Ehdr
     }
 }
diff --git a/vendor/rustix/src/backend/linux_raw/param/mustang_auxv.rs b/vendor/rustix/src/backend/linux_raw/param/mustang_auxv.rs
index 49cb1457c..f45a25faf 100644
--- a/vendor/rustix/src/backend/linux_raw/param/mustang_auxv.rs
+++ b/vendor/rustix/src/backend/linux_raw/param/mustang_auxv.rs
@@ -5,8 +5,8 @@
 //! This uses raw pointers to locate and read the kernel-provided auxv array.
 #![allow(unsafe_code)]
 
-use super::super::c;
-use super::super::elf::*;
+use crate::backend::c;
+use crate::backend::elf::*;
 #[cfg(feature = "param")]
 use crate::ffi::CStr;
 use core::ffi::c_void;
diff --git a/vendor/rustix/src/backend/linux_raw/pid/mod.rs b/vendor/rustix/src/backend/linux_raw/pid/mod.rs
new file mode 100644
index 000000000..ef944f04d
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/pid/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/linux_raw/pid/syscalls.rs b/vendor/rustix/src/backend/linux_raw/pid/syscalls.rs
new file mode 100644
index 000000000..f36bac048
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/pid/syscalls.rs
@@ -0,0 +1,18 @@
+//! linux_raw syscalls for PIDs
+//!
+//! # Safety
+//!
+//! See the `rustix::backend` module documentation for details.
+#![allow(unsafe_code)]
+#![allow(clippy::undocumented_unsafe_blocks)]
+
+use crate::backend::conv::ret_usize_infallible;
+use crate::pid::{Pid, RawPid};
+
+#[inline]
+pub(crate) fn getpid() -> Pid {
+    unsafe {
+        let pid = ret_usize_infallible(syscall_readonly!(__NR_getpid)) as RawPid;
+        Pid::from_raw_unchecked(pid)
+    }
+}
diff --git a/vendor/rustix/src/backend/linux_raw/pipe/mod.rs b/vendor/rustix/src/backend/linux_raw/pipe/mod.rs
new file mode 100644
index 000000000..1e0181a99
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/pipe/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/pipe/syscalls.rs b/vendor/rustix/src/backend/linux_raw/pipe/syscalls.rs
new file mode 100644
index 000000000..ed121089d
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/pipe/syscalls.rs
@@ -0,0 +1,132 @@
+//! linux_raw syscalls supporting `rustix::pipe`.
+//!
+//! # Safety
+//!
+//! See the `rustix::backend` module documentation for details.
+#![allow(unsafe_code)]
+#![allow(clippy::undocumented_unsafe_blocks)]
+
+use crate::backend::conv::{c_int, c_uint, opt_mut, pass_usize, ret, ret_usize, slice};
+use crate::backend::{c, MAX_IOV};
+use crate::fd::{BorrowedFd, OwnedFd};
+use crate::io;
+use crate::pipe::{IoSliceRaw, PipeFlags, SpliceFlags};
+use core::cmp;
+use core::mem::MaybeUninit;
+use linux_raw_sys::general::{F_GETPIPE_SZ, F_SETPIPE_SZ};
+
+#[inline]
+pub(crate) fn pipe() -> io::Result<(OwnedFd, OwnedFd)> {
+    // aarch64 and risc64 omit `__NR_pipe`. On mips, `__NR_pipe` uses a special
+    // calling convention, but using it is not worth complicating our syscall
+    // wrapping infrastructure at this time.
+    #[cfg(any(
+        target_arch = "aarch64",
+        target_arch = "mips",
+        target_arch = "mips64",
+        target_arch = "riscv64",
+    ))]
+    {
+        pipe_with(PipeFlags::empty())
+    }
+    #[cfg(not(any(
+        target_arch = "aarch64",
+        target_arch = "mips",
+        target_arch = "mips64",
+        target_arch = "riscv64",
+    )))]
+    unsafe {
+        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
+        ret(syscall!(__NR_pipe, &mut result))?;
+        let [p0, p1] = result.assume_init();
+        Ok((p0, p1))
+    }
+}
+
+#[inline]
+pub(crate) fn pipe_with(flags: PipeFlags) -> io::Result<(OwnedFd, OwnedFd)> {
+    unsafe {
+        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
+        ret(syscall!(__NR_pipe2, &mut result, flags))?;
+        let [p0, p1] = result.assume_init();
+        Ok((p0, p1))
+    }
+}
+
+#[inline]
+pub fn splice(
+    fd_in: BorrowedFd,
+    off_in: Option<&mut u64>,
+    fd_out: BorrowedFd,
+    off_out: Option<&mut u64>,
+    len: usize,
+    flags: SpliceFlags,
+) -> io::Result<usize> {
+    unsafe {
+        ret_usize(syscall!(
+            __NR_splice,
+            fd_in,
+            opt_mut(off_in),
+            fd_out,
+            opt_mut(off_out),
+            pass_usize(len),
+            flags
+        ))
+    }
+}
+
+#[inline]
+pub unsafe fn vmsplice(
+    fd: BorrowedFd,
+    bufs: &[IoSliceRaw],
+    flags: SpliceFlags,
+) -> io::Result<usize> {
+    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
+    ret_usize(syscall!(__NR_vmsplice, fd, bufs_addr, bufs_len, flags))
+}
+
+#[inline]
+pub fn tee(
+    fd_in: BorrowedFd,
+    fd_out: BorrowedFd,
+    len: usize,
+    flags: SpliceFlags,
+) -> io::Result<usize> {
+    unsafe { ret_usize(syscall!(__NR_tee, fd_in, fd_out, pass_usize(len), flags)) }
+}
+
+#[inline]
+pub(crate) fn fcntl_getpipe_sz(fd: BorrowedFd<'_>) -> io::Result<usize> {
+    #[cfg(target_pointer_width = "32")]
+    unsafe {
+        ret_usize(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GETPIPE_SZ)))
+    }
+    #[cfg(target_pointer_width = "64")]
+    unsafe {
+        ret_usize(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETPIPE_SZ)))
+    }
+}
+
+#[inline]
+pub(crate) fn fcntl_setpipe_sz(fd: BorrowedFd<'_>, size: usize) -> io::Result<()> {
+    let size: c::c_int = size.try_into().map_err(|_| io::Errno::PERM)?;
+
+    #[cfg(target_pointer_width = "32")]
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fcntl64,
+            fd,
+            c_uint(F_SETPIPE_SZ),
+            c_int(size)
+        ))
+    }
+    #[cfg(target_pointer_width = "64")]
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_fcntl,
+            fd,
+            c_uint(F_SETPIPE_SZ),
+            c_int(size)
+        ))
+    }
+}
diff --git a/vendor/rustix/src/backend/linux_raw/pipe/types.rs b/vendor/rustix/src/backend/linux_raw/pipe/types.rs
new file mode 100644
index 000000000..90d2d79ab
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/pipe/types.rs
@@ -0,0 +1,72 @@
+use crate::backend::c;
+use bitflags::bitflags;
+use core::marker::PhantomData;
+
+bitflags! {
+    /// `O_*` constants for use with [`pipe_with`].
+    ///
+    /// [`pipe_with`]: crate::io::pipe_with
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct PipeFlags: c::c_uint {
+        /// `O_CLOEXEC`
+        const CLOEXEC = linux_raw_sys::general::O_CLOEXEC;
+        /// `O_DIRECT`
+        const DIRECT = linux_raw_sys::general::O_DIRECT;
+        /// `O_NONBLOCK`
+        const NONBLOCK = linux_raw_sys::general::O_NONBLOCK;
+    }
+}
+
+bitflags! {
+    /// `SPLICE_F_*` constants for use with [`splice`] [`vmsplice`], and
+    /// [`tee`].
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+    pub struct SpliceFlags: c::c_uint {
+        /// `SPLICE_F_MOVE`
+        const MOVE = linux_raw_sys::general::SPLICE_F_MOVE;
+        /// `SPLICE_F_NONBLOCK`
+        const NONBLOCK = linux_raw_sys::general::SPLICE_F_NONBLOCK;
+        /// `SPLICE_F_MORE`
+        const MORE = linux_raw_sys::general::SPLICE_F_MORE;
+        /// `SPLICE_F_GIFT`
+        const GIFT = linux_raw_sys::general::SPLICE_F_GIFT;
+    }
+}
+
+/// A buffer type used with `vmsplice`.
+///
+/// It is guaranteed to be ABI compatible with the iovec type on Unix platforms
+/// and `WSABUF` on Windows. Unlike `IoSlice` and `IoSliceMut` it is
+/// semantically like a raw pointer, and therefore can be shared or mutated as
+/// needed.
+#[repr(transparent)]
+pub struct IoSliceRaw<'a> {
+    _buf: c::iovec,
+    _lifetime: PhantomData<&'a ()>,
+}
+
+impl<'a> IoSliceRaw<'a> {
+    /// Creates a new `IoSlice` wrapping a byte slice.
+    pub fn from_slice(buf: &'a [u8]) -> Self {
+        IoSliceRaw {
+            _buf: c::iovec {
+                iov_base: (buf.as_ptr() as *mut u8).cast::<c::c_void>(),
+                iov_len: buf.len() as _,
+            },
+            _lifetime: PhantomData,
+        }
+    }
+
+    /// Creates a new `IoSlice` wrapping a mutable byte slice.
+    pub fn from_slice_mut(buf: &'a mut [u8]) -> Self {
+        IoSliceRaw {
+            _buf: c::iovec {
+                iov_base: buf.as_mut_ptr().cast::<c::c_void>(),
+                iov_len: buf.len() as _,
+            },
+            _lifetime: PhantomData,
+        }
+    }
+}
diff --git a/vendor/rustix/src/backend/linux_raw/prctl/mod.rs b/vendor/rustix/src/backend/linux_raw/prctl/mod.rs
new file mode 100644
index 000000000..ef944f04d
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/prctl/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/linux_raw/prctl/syscalls.rs b/vendor/rustix/src/backend/linux_raw/prctl/syscalls.rs
new file mode 100644
index 000000000..193f4b7b4
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/prctl/syscalls.rs
@@ -0,0 +1,22 @@
+//! linux_raw syscalls supporting modules that use `prctl`.
+//!
+//! # Safety
+//!
+//! See the `rustix::backend` module documentation for details.
+#![allow(unsafe_code)]
+#![allow(clippy::undocumented_unsafe_blocks)]
+
+use crate::backend::c;
+use crate::backend::conv::{c_int, ret_c_int};
+use crate::io;
+
+#[inline]
+pub(crate) unsafe fn prctl(
+    option: c::c_int,
+    arg2: *mut c::c_void,
+    arg3: *mut c::c_void,
+    arg4: *mut c::c_void,
+    arg5: *mut c::c_void,
+) -> io::Result<c::c_int> {
+    ret_c_int(syscall!(__NR_prctl, c_int(option), arg2, arg3, arg4, arg5))
+}
diff --git a/vendor/rustix/src/backend/linux_raw/process/cpu_set.rs b/vendor/rustix/src/backend/linux_raw/process/cpu_set.rs
index fc81859d8..35146cfd2 100644
--- a/vendor/rustix/src/backend/linux_raw/process/cpu_set.rs
+++ b/vendor/rustix/src/backend/linux_raw/process/cpu_set.rs
@@ -14,10 +14,7 @@ pub(crate) fn CPU_SET(cpu: usize, cpuset: &mut RawCpuSet) {
 
 #[inline]
 pub(crate) fn CPU_ZERO(cpuset: &mut RawCpuSet) {
-    // TODO: With, Rust 1.50, use `cpuset.bits.fill(0)` instead.
-    for element in &mut cpuset.bits {
-        *element = 0;
-    }
+    cpuset.bits.fill(0)
 }
 
 #[inline]
diff --git a/vendor/rustix/src/backend/linux_raw/process/syscalls.rs b/vendor/rustix/src/backend/linux_raw/process/syscalls.rs
index 0eb6489e7..ac6e28901 100644
--- a/vendor/rustix/src/backend/linux_raw/process/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/process/syscalls.rs
@@ -6,34 +6,38 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::c;
-use super::super::conv::{
-    by_mut, by_ref, c_int, c_uint, negative_pid, pass_usize, ret, ret_c_int, ret_c_uint,
-    ret_infallible, ret_usize, ret_usize_infallible, size_of, slice, slice_just_addr,
-    slice_just_addr_mut, slice_mut, zero,
+use super::types::RawCpuSet;
+use crate::backend::c;
+#[cfg(feature = "fs")]
+use crate::backend::conv::slice_mut;
+use crate::backend::conv::{
+    by_mut, by_ref, c_int, c_uint, negative_pid, pass_usize, raw_fd, ret, ret_c_int,
+    ret_c_int_infallible, ret_c_uint, ret_infallible, ret_owned_fd, ret_usize, size_of,
+    slice_just_addr, slice_just_addr_mut, zero,
 };
-use super::types::{RawCpuSet, RawUname};
-use crate::backend::conv::ret_owned_fd;
-use crate::fd::{AsRawFd, BorrowedFd, OwnedFd};
+use crate::fd::{AsRawFd, BorrowedFd, OwnedFd, RawFd};
+#[cfg(feature = "fs")]
 use crate::ffi::CStr;
 use crate::io;
+use crate::pid::RawPid;
 use crate::process::{
-    Cpuid, Gid, MembarrierCommand, MembarrierQuery, Pid, PidfdFlags, RawNonZeroPid, RawPid,
-    Resource, Rlimit, Signal, Sysinfo, Uid, WaitId, WaitOptions, WaitStatus, WaitidOptions,
-    WaitidStatus,
+    Cpuid, Gid, MembarrierCommand, MembarrierQuery, Pid, PidfdFlags, PidfdGetfdFlags, Resource,
+    Rlimit, Uid, WaitId, WaitOptions, WaitStatus, WaitidOptions, WaitidStatus,
 };
-use core::convert::TryInto;
+use crate::signal::Signal;
+use crate::utils::as_mut_ptr;
 use core::mem::MaybeUninit;
-use core::num::NonZeroU32;
 use core::ptr::{null, null_mut};
 use linux_raw_sys::general::{
-    __kernel_gid_t, __kernel_pid_t, __kernel_uid_t, membarrier_cmd, membarrier_cmd_flag, rlimit,
-    rlimit64, PRIO_PGRP, PRIO_PROCESS, PRIO_USER, RLIM64_INFINITY, RLIM_INFINITY,
+    membarrier_cmd, membarrier_cmd_flag, rlimit, rlimit64, PRIO_PGRP, PRIO_PROCESS, PRIO_USER,
+    RLIM64_INFINITY, RLIM_INFINITY,
 };
+use linux_raw_sys::ioctl::TIOCSCTTY;
 #[cfg(not(target_os = "wasi"))]
 #[cfg(feature = "fs")]
-use {super::super::conv::ret_c_uint_infallible, crate::fs::Mode};
+use {crate::backend::conv::ret_c_uint_infallible, crate::fs::Mode};
 
+#[cfg(feature = "fs")]
 #[inline]
 pub(crate) fn chdir(filename: &CStr) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_chdir, filename)) }
@@ -44,13 +48,15 @@ pub(crate) fn fchdir(fd: BorrowedFd<'_>) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_fchdir, fd)) }
 }
 
+#[cfg(feature = "fs")]
 #[inline]
 pub(crate) fn chroot(filename: &CStr) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_chroot, filename)) }
 }
 
+#[cfg(feature = "fs")]
 #[inline]
-pub(crate) fn getcwd(buf: &mut [u8]) -> io::Result<usize> {
+pub(crate) fn getcwd(buf: &mut [MaybeUninit<u8>]) -> io::Result<usize> {
     let (buf_addr_mut, buf_len) = slice_mut(buf);
     unsafe { ret_usize(syscall!(__NR_getcwd, buf_addr_mut, buf_len)) }
 }
@@ -63,15 +69,7 @@ pub(crate) fn membarrier_query() -> MembarrierQuery {
             c_int(membarrier_cmd::MEMBARRIER_CMD_QUERY as _),
             c_uint(0)
         )) {
-            Ok(query) => {
-                // SAFETY: The safety of `from_bits_unchecked` is discussed
-                // [here]. Our "source of truth" is Linux, and here, the
-                // `query` value is coming from Linux, so we know it only
-                // contains "source of truth" valid bits.
-                //
-                // [here]: https://github.com/bitflags/bitflags/pull/207#issuecomment-671668662
-                MembarrierQuery::from_bits_unchecked(query)
-            }
+            Ok(query) => MembarrierQuery::from_bits_retain(query),
             Err(_) => MembarrierQuery::empty(),
         }
     }
@@ -95,30 +93,19 @@ pub(crate) fn membarrier_cpu(cmd: MembarrierCommand, cpu: Cpuid) -> io::Result<(
 }
 
 #[inline]
-pub(crate) fn getpid() -> Pid {
-    unsafe {
-        let pid: i32 = ret_usize_infallible(syscall_readonly!(__NR_getpid)) as __kernel_pid_t;
-        debug_assert!(pid > 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid as u32))
-    }
-}
-
-#[inline]
 pub(crate) fn getppid() -> Option<Pid> {
     unsafe {
-        let ppid: i32 = ret_usize_infallible(syscall_readonly!(__NR_getppid)) as __kernel_pid_t;
-        Pid::from_raw(ppid as u32)
+        let ppid = ret_c_int_infallible(syscall_readonly!(__NR_getppid));
+        Pid::from_raw(ppid)
     }
 }
 
 #[inline]
 pub(crate) fn getpgid(pid: Option<Pid>) -> io::Result<Pid> {
     unsafe {
-        let pgid: i32 =
-            ret_usize(syscall_readonly!(__NR_getpgid, c_uint(Pid::as_raw(pid))))? as __kernel_pid_t;
-        Ok(Pid::from_raw_nonzero(NonZeroU32::new_unchecked(
-            pgid as u32,
-        )))
+        let pgid = ret_c_int(syscall_readonly!(__NR_getpgid, c_int(Pid::as_raw(pid))))?;
+        debug_assert!(pgid > 0);
+        Ok(Pid::from_raw_unchecked(pgid))
     }
 }
 
@@ -127,8 +114,8 @@ pub(crate) fn setpgid(pid: Option<Pid>, pgid: Option<Pid>) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_setpgid,
-            c_uint(Pid::as_raw(pid)),
-            c_uint(Pid::as_raw(pgid))
+            c_int(Pid::as_raw(pid)),
+            c_int(Pid::as_raw(pgid))
         ))
     }
 }
@@ -138,77 +125,17 @@ pub(crate) fn getpgrp() -> Pid {
     // Use the `getpgrp` syscall if available.
     #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
     unsafe {
-        let pgid: i32 = ret_usize_infallible(syscall_readonly!(__NR_getpgrp)) as __kernel_pid_t;
+        let pgid = ret_c_int_infallible(syscall_readonly!(__NR_getpgrp));
         debug_assert!(pgid > 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pgid as u32))
+        Pid::from_raw_unchecked(pgid)
     }
 
     // Otherwise use `getpgrp` and pass it zero.
     #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     unsafe {
-        let pgid: i32 =
-            ret_usize_infallible(syscall_readonly!(__NR_getpgid, c_uint(0))) as __kernel_pid_t;
+        let pgid = ret_c_int_infallible(syscall_readonly!(__NR_getpgid, c_uint(0)));
         debug_assert!(pgid > 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pgid as u32))
-    }
-}
-
-#[inline]
-pub(crate) fn getgid() -> Gid {
-    #[cfg(any(target_arch = "x86", target_arch = "sparc", target_arch = "arm"))]
-    unsafe {
-        let gid: i32 =
-            (ret_usize_infallible(syscall_readonly!(__NR_getgid32)) as __kernel_gid_t).into();
-        Gid::from_raw(gid as u32)
-    }
-    #[cfg(not(any(target_arch = "x86", target_arch = "sparc", target_arch = "arm")))]
-    unsafe {
-        let gid = ret_usize_infallible(syscall_readonly!(__NR_getgid)) as __kernel_gid_t;
-        Gid::from_raw(gid as u32)
-    }
-}
-
-#[inline]
-pub(crate) fn getegid() -> Gid {
-    #[cfg(any(target_arch = "x86", target_arch = "sparc", target_arch = "arm"))]
-    unsafe {
-        let gid: i32 =
-            (ret_usize_infallible(syscall_readonly!(__NR_getegid32)) as __kernel_gid_t).into();
-        Gid::from_raw(gid as u32)
-    }
-    #[cfg(not(any(target_arch = "x86", target_arch = "sparc", target_arch = "arm")))]
-    unsafe {
-        let gid = ret_usize_infallible(syscall_readonly!(__NR_getegid)) as __kernel_gid_t;
-        Gid::from_raw(gid as u32)
-    }
-}
-
-#[inline]
-pub(crate) fn getuid() -> Uid {
-    #[cfg(any(target_arch = "x86", target_arch = "sparc", target_arch = "arm"))]
-    unsafe {
-        let uid = (ret_usize_infallible(syscall_readonly!(__NR_getuid32)) as __kernel_uid_t).into();
-        Uid::from_raw(uid)
-    }
-    #[cfg(not(any(target_arch = "x86", target_arch = "sparc", target_arch = "arm")))]
-    unsafe {
-        let uid = ret_usize_infallible(syscall_readonly!(__NR_getuid)) as __kernel_uid_t;
-        Uid::from_raw(uid as u32)
-    }
-}
-
-#[inline]
-pub(crate) fn geteuid() -> Uid {
-    #[cfg(any(target_arch = "x86", target_arch = "sparc", target_arch = "arm"))]
-    unsafe {
-        let uid: i32 =
-            (ret_usize_infallible(syscall_readonly!(__NR_geteuid32)) as __kernel_uid_t).into();
-        Uid::from_raw(uid as u32)
-    }
-    #[cfg(not(any(target_arch = "x86", target_arch = "sparc", target_arch = "arm")))]
-    unsafe {
-        let uid = ret_usize_infallible(syscall_readonly!(__NR_geteuid)) as __kernel_uid_t;
-        Uid::from_raw(uid as u32)
+        Pid::from_raw_unchecked(pgid)
     }
 }
 
@@ -220,11 +147,11 @@ pub(crate) fn sched_getaffinity(pid: Option<Pid>, cpuset: &mut RawCpuSet) -> io:
         // set bit mask.
         let size = ret_usize(syscall!(
             __NR_sched_getaffinity,
-            c_uint(Pid::as_raw(pid)),
+            c_int(Pid::as_raw(pid)),
             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);
@@ -237,7 +164,7 @@ pub(crate) fn sched_setaffinity(pid: Option<Pid>, cpuset: &RawCpuSet) -> io::Res
     unsafe {
         ret(syscall_readonly!(
             __NR_sched_setaffinity,
-            c_uint(Pid::as_raw(pid)),
+            c_int(Pid::as_raw(pid)),
             size_of::<RawCpuSet, _>(),
             slice_just_addr(&cpuset.bits)
         ))
@@ -253,35 +180,20 @@ pub(crate) fn sched_yield() {
     }
 }
 
-#[inline]
-pub(crate) fn uname() -> RawUname {
-    let mut uname = MaybeUninit::<RawUname>::uninit();
-    unsafe {
-        ret_infallible(syscall!(__NR_uname, &mut uname));
-        uname.assume_init()
-    }
-}
-
 #[cfg(feature = "fs")]
 #[inline]
 pub(crate) fn umask(mode: Mode) -> Mode {
-    unsafe {
-        // TODO: Use `from_bits_retain` when we switch to bitflags 2.0.
-        Mode::from_bits_truncate(ret_c_uint_infallible(syscall_readonly!(__NR_umask, mode)))
-    }
+    unsafe { Mode::from_bits_retain(ret_c_uint_infallible(syscall_readonly!(__NR_umask, mode))) }
 }
 
 #[inline]
 pub(crate) fn nice(inc: i32) -> io::Result<i32> {
-    let priority = if inc > -40 && inc < 40 {
+    let priority = (if inc > -40 && inc < 40 {
         inc + getpriority_process(None)?
     } else {
         inc
-    }
-    // TODO: With Rust 1.50, use `.clamp` instead of `.min` and `.max`.
-    //.clamp(-20, 19);
-    .min(19)
-    .max(-20);
+    })
+    .clamp(-20, 19);
     setpriority_process(None, priority)?;
     Ok(priority)
 }
@@ -305,7 +217,7 @@ pub(crate) fn getpriority_pgrp(pgid: Option<Pid>) -> io::Result<i32> {
             - ret_c_int(syscall_readonly!(
                 __NR_getpriority,
                 c_uint(PRIO_PGRP),
-                c_uint(Pid::as_raw(pgid))
+                c_int(Pid::as_raw(pgid))
             ))?)
     }
 }
@@ -317,7 +229,7 @@ pub(crate) fn getpriority_process(pid: Option<Pid>) -> io::Result<i32> {
             - ret_c_int(syscall_readonly!(
                 __NR_getpriority,
                 c_uint(PRIO_PROCESS),
-                c_uint(Pid::as_raw(pid))
+                c_int(Pid::as_raw(pid))
             ))?)
     }
 }
@@ -340,7 +252,7 @@ pub(crate) fn setpriority_pgrp(pgid: Option<Pid>, priority: i32) -> io::Result<(
         ret(syscall_readonly!(
             __NR_setpriority,
             c_uint(PRIO_PGRP),
-            c_uint(Pid::as_raw(pgid)),
+            c_int(Pid::as_raw(pgid)),
             c_int(priority)
         ))
     }
@@ -352,7 +264,7 @@ pub(crate) fn setpriority_process(pid: Option<Pid>, priority: i32) -> io::Result
         ret(syscall_readonly!(
             __NR_setpriority,
             c_uint(PRIO_PROCESS),
-            c_uint(Pid::as_raw(pid)),
+            c_int(Pid::as_raw(pid)),
             c_int(priority)
         ))
     }
@@ -440,7 +352,7 @@ pub(crate) fn prlimit(pid: Option<Pid>, limit: Resource, new: Rlimit) -> io::Res
     unsafe {
         match ret(syscall!(
             __NR_prlimit64,
-            c_uint(Pid::as_raw(pid)),
+            c_int(Pid::as_raw(pid)),
             limit,
             by_ref(&lim),
             &mut result
@@ -531,19 +443,14 @@ pub(crate) fn _waitpid(
 ) -> io::Result<Option<(Pid, WaitStatus)>> {
     unsafe {
         let mut status = MaybeUninit::<u32>::uninit();
-        let pid = ret_c_uint(syscall!(
+        let pid = ret_c_int(syscall!(
             __NR_wait4,
             c_int(pid as _),
             &mut status,
             c_int(waitopts.bits() as _),
             zero()
         ))?;
-        Ok(RawNonZeroPid::new(pid).map(|non_zero| {
-            (
-                Pid::from_raw_nonzero(non_zero),
-                WaitStatus::new(status.assume_init()),
-            )
-        }))
+        Ok(Pid::from_raw(pid).map(|pid| (pid, WaitStatus::new(status.assume_init()))))
     }
 }
 
@@ -585,7 +492,7 @@ fn _waitid_pid(pid: Pid, options: WaitidOptions) -> io::Result<Option<WaitidStat
         ret(syscall!(
             __NR_waitid,
             c_uint(c::P_PID),
-            c_uint(Pid::as_raw(Some(pid))),
+            c_int(Pid::as_raw(Some(pid))),
             by_mut(&mut status),
             c_int(options.bits() as _),
             zero()
@@ -631,31 +538,19 @@ unsafe fn cvt_waitid_status(status: MaybeUninit<c::siginfo_t>) -> Option<WaitidS
     }
 }
 
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn exit_group(code: c::c_int) -> ! {
-    unsafe { syscall_noreturn!(__NR_exit_group, c_int(code)) }
-}
-
 #[inline]
 pub(crate) fn getsid(pid: Option<Pid>) -> io::Result<Pid> {
     unsafe {
-        let pid = ret_usize(syscall_readonly!(__NR_getsid, c_uint(Pid::as_raw(pid))))?;
-        debug_assert!(pid > 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(
-            pid as u32,
-        )))
+        let pid = ret_c_int(syscall_readonly!(__NR_getsid, c_int(Pid::as_raw(pid))))?;
+        Ok(Pid::from_raw_unchecked(pid))
     }
 }
 
 #[inline]
 pub(crate) fn setsid() -> io::Result<Pid> {
     unsafe {
-        let pid = ret_usize(syscall_readonly!(__NR_setsid))?;
-        debug_assert!(pid > 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(
-            pid as u32,
-        )))
+        let pid = ret_c_int(syscall_readonly!(__NR_setsid))?;
+        Ok(Pid::from_raw_unchecked(pid))
     }
 }
 
@@ -696,28 +591,27 @@ pub(crate) fn test_kill_current_process_group() -> io::Result<()> {
 }
 
 #[inline]
-pub(crate) unsafe fn prctl(
-    option: c::c_int,
-    arg2: *mut c::c_void,
-    arg3: *mut c::c_void,
-    arg4: *mut c::c_void,
-    arg5: *mut c::c_void,
-) -> io::Result<c::c_int> {
-    ret_c_int(syscall!(__NR_prctl, c_int(option), arg2, arg3, arg4, arg5))
-}
-
-#[inline]
-pub(crate) fn pidfd_open(pid: Pid, flags: PidfdFlags) -> io::Result<OwnedFd> {
+pub(crate) fn pidfd_getfd(
+    pidfd: BorrowedFd<'_>,
+    targetfd: RawFd,
+    flags: PidfdGetfdFlags,
+) -> io::Result<OwnedFd> {
     unsafe {
         ret_owned_fd(syscall_readonly!(
-            __NR_pidfd_open,
-            pid,
+            __NR_pidfd_getfd,
+            pidfd,
+            raw_fd(targetfd),
             c_int(flags.bits() as _)
         ))
     }
 }
 
 #[inline]
+pub(crate) fn pidfd_open(pid: Pid, flags: PidfdFlags) -> io::Result<OwnedFd> {
+    unsafe { ret_owned_fd(syscall_readonly!(__NR_pidfd_open, pid, flags)) }
+}
+
+#[inline]
 pub(crate) fn getgroups(buf: &mut [Gid]) -> io::Result<usize> {
     let len = buf.len().try_into().map_err(|_| io::Errno::NOMEM)?;
 
@@ -731,16 +625,13 @@ pub(crate) fn getgroups(buf: &mut [Gid]) -> io::Result<usize> {
 }
 
 #[inline]
-pub(crate) fn sysinfo() -> Sysinfo {
-    let mut info = MaybeUninit::<Sysinfo>::uninit();
+pub(crate) fn ioctl_tiocsctty(fd: BorrowedFd<'_>) -> io::Result<()> {
     unsafe {
-        ret_infallible(syscall!(__NR_sysinfo, &mut info));
-        info.assume_init()
+        ret(syscall_readonly!(
+            __NR_ioctl,
+            fd,
+            c_uint(TIOCSCTTY),
+            by_ref(&0_u32)
+        ))
     }
 }
-
-#[inline]
-pub(crate) fn sethostname(name: &[u8]) -> io::Result<()> {
-    let (ptr, len) = slice(name);
-    unsafe { ret(syscall_readonly!(__NR_sethostname, ptr, len)) }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/process/types.rs b/vendor/rustix/src/backend/linux_raw/process/types.rs
index efdaddbae..f31749b83 100644
--- a/vendor/rustix/src/backend/linux_raw/process/types.rs
+++ b/vendor/rustix/src/backend/linux_raw/process/types.rs
@@ -1,9 +1,6 @@
-use super::super::c;
+use crate::backend::c;
 use linux_raw_sys::general::membarrier_cmd;
 
-/// `sysinfo`
-pub type Sysinfo = linux_raw_sys::general::sysinfo;
-
 /// A command for use with [`membarrier`] and [`membarrier_cpu`].
 ///
 /// For `MEMBARRIER_CMD_QUERY`, see [`membarrier_query`].
@@ -81,152 +78,18 @@ pub enum Resource {
     Rttime = linux_raw_sys::general::RLIMIT_RTTIME,
 }
 
-/// A signal number for use with [`kill_process`], [`kill_process_group`],
-/// and [`kill_current_process_group`].
-///
-/// [`kill_process`]: crate::process::kill_process
-/// [`kill_process_group`]: crate::process::kill_process_group
-/// [`kill_current_process_group`]: crate::process::kill_current_process_group
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[repr(u32)]
-pub enum Signal {
-    /// `SIGHUP`
-    Hup = linux_raw_sys::general::SIGHUP,
-    /// `SIGINT`
-    Int = linux_raw_sys::general::SIGINT,
-    /// `SIGQUIT`
-    Quit = linux_raw_sys::general::SIGQUIT,
-    /// `SIGILL`
-    Ill = linux_raw_sys::general::SIGILL,
-    /// `SIGTRAP`
-    Trap = linux_raw_sys::general::SIGTRAP,
-    /// `SIGABRT`, aka `SIGIOT`
-    #[doc(alias = "Iot")]
-    #[doc(alias = "Abrt")]
-    Abort = linux_raw_sys::general::SIGABRT,
-    /// `SIGBUS`
-    Bus = linux_raw_sys::general::SIGBUS,
-    /// `SIGFPE`
-    Fpe = linux_raw_sys::general::SIGFPE,
-    /// `SIGKILL`
-    Kill = linux_raw_sys::general::SIGKILL,
-    /// `SIGUSR1`
-    Usr1 = linux_raw_sys::general::SIGUSR1,
-    /// `SIGSEGV`
-    Segv = linux_raw_sys::general::SIGSEGV,
-    /// `SIGUSR2`
-    Usr2 = linux_raw_sys::general::SIGUSR2,
-    /// `SIGPIPE`
-    Pipe = linux_raw_sys::general::SIGPIPE,
-    /// `SIGALRM`
-    #[doc(alias = "Alrm")]
-    Alarm = linux_raw_sys::general::SIGALRM,
-    /// `SIGTERM`
-    Term = linux_raw_sys::general::SIGTERM,
-    /// `SIGSTKFLT`
-    #[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
-    Stkflt = linux_raw_sys::general::SIGSTKFLT,
-    /// `SIGCHLD`
-    #[doc(alias = "Chld")]
-    Child = linux_raw_sys::general::SIGCHLD,
-    /// `SIGCONT`
-    Cont = linux_raw_sys::general::SIGCONT,
-    /// `SIGSTOP`
-    Stop = linux_raw_sys::general::SIGSTOP,
-    /// `SIGTSTP`
-    Tstp = linux_raw_sys::general::SIGTSTP,
-    /// `SIGTTIN`
-    Ttin = linux_raw_sys::general::SIGTTIN,
-    /// `SIGTTOU`
-    Ttou = linux_raw_sys::general::SIGTTOU,
-    /// `SIGURG`
-    Urg = linux_raw_sys::general::SIGURG,
-    /// `SIGXCPU`
-    Xcpu = linux_raw_sys::general::SIGXCPU,
-    /// `SIGXFSZ`
-    Xfsz = linux_raw_sys::general::SIGXFSZ,
-    /// `SIGVTALRM`
-    #[doc(alias = "Vtalrm")]
-    Vtalarm = linux_raw_sys::general::SIGVTALRM,
-    /// `SIGPROF`
-    Prof = linux_raw_sys::general::SIGPROF,
-    /// `SIGWINCH`
-    Winch = linux_raw_sys::general::SIGWINCH,
-    /// `SIGIO`, aka `SIGPOLL`
-    #[doc(alias = "Poll")]
-    Io = linux_raw_sys::general::SIGIO,
-    /// `SIGPWR`
-    #[doc(alias = "Pwr")]
-    Power = linux_raw_sys::general::SIGPWR,
-    /// `SIGSYS`, aka `SIGUNUSED`
-    #[doc(alias = "Unused")]
-    Sys = linux_raw_sys::general::SIGSYS,
-    /// `SIGRTMIN`
-    Rtmin = linux_raw_sys::general::SIGRTMIN,
-}
-
-impl Signal {
-    /// Convert a raw signal number into a `Signal`, if possible.
-    pub fn from_raw(sig: i32) -> Option<Self> {
-        match sig as _ {
-            linux_raw_sys::general::SIGHUP => Some(Self::Hup),
-            linux_raw_sys::general::SIGINT => Some(Self::Int),
-            linux_raw_sys::general::SIGQUIT => Some(Self::Quit),
-            linux_raw_sys::general::SIGILL => Some(Self::Ill),
-            linux_raw_sys::general::SIGTRAP => Some(Self::Trap),
-            linux_raw_sys::general::SIGABRT => Some(Self::Abort),
-            linux_raw_sys::general::SIGBUS => Some(Self::Bus),
-            linux_raw_sys::general::SIGFPE => Some(Self::Fpe),
-            linux_raw_sys::general::SIGKILL => Some(Self::Kill),
-            linux_raw_sys::general::SIGUSR1 => Some(Self::Usr1),
-            linux_raw_sys::general::SIGSEGV => Some(Self::Segv),
-            linux_raw_sys::general::SIGUSR2 => Some(Self::Usr2),
-            linux_raw_sys::general::SIGPIPE => Some(Self::Pipe),
-            linux_raw_sys::general::SIGALRM => Some(Self::Alarm),
-            linux_raw_sys::general::SIGTERM => Some(Self::Term),
-            #[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
-            linux_raw_sys::general::SIGSTKFLT => Some(Self::Stkflt),
-            linux_raw_sys::general::SIGCHLD => Some(Self::Child),
-            linux_raw_sys::general::SIGCONT => Some(Self::Cont),
-            linux_raw_sys::general::SIGSTOP => Some(Self::Stop),
-            linux_raw_sys::general::SIGTSTP => Some(Self::Tstp),
-            linux_raw_sys::general::SIGTTIN => Some(Self::Ttin),
-            linux_raw_sys::general::SIGTTOU => Some(Self::Ttou),
-            linux_raw_sys::general::SIGURG => Some(Self::Urg),
-            linux_raw_sys::general::SIGXCPU => Some(Self::Xcpu),
-            linux_raw_sys::general::SIGXFSZ => Some(Self::Xfsz),
-            linux_raw_sys::general::SIGVTALRM => Some(Self::Vtalarm),
-            linux_raw_sys::general::SIGPROF => Some(Self::Prof),
-            linux_raw_sys::general::SIGWINCH => Some(Self::Winch),
-            linux_raw_sys::general::SIGIO => Some(Self::Io),
-            linux_raw_sys::general::SIGPWR => Some(Self::Power),
-            linux_raw_sys::general::SIGSYS => Some(Self::Sys),
-            linux_raw_sys::general::SIGRTMIN => Some(Self::Rtmin),
-            _ => None,
-        }
-    }
-}
-
 /// `EXIT_SUCCESS`
 pub const EXIT_SUCCESS: c::c_int = 0;
 /// `EXIT_FAILURE`
 pub const EXIT_FAILURE: c::c_int = 1;
 /// The status value of a child terminated with a [`Signal::Abort`] signal.
+///
+/// [`Signal::Abort`]: crate::process::Signal::Abort
 pub const EXIT_SIGNALED_SIGABRT: c::c_int = 128 + linux_raw_sys::general::SIGABRT as i32;
 
-/// A process identifier as a raw integer.
-pub type RawPid = u32;
-/// A non-zero process identifier as a raw non-zero integer.
-pub type RawNonZeroPid = core::num::NonZeroU32;
-/// A group identifier as a raw integer.
-pub type RawGid = u32;
-/// A user identifier as a raw integer.
-pub type RawUid = u32;
 /// A CPU identifier as a raw integer.
 pub type RawCpuid = u32;
 
-pub(crate) type RawUname = linux_raw_sys::general::new_utsname;
-
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub(crate) struct RawCpuSet {
diff --git a/vendor/rustix/src/backend/linux_raw/pty/mod.rs b/vendor/rustix/src/backend/linux_raw/pty/mod.rs
new file mode 100644
index 000000000..ef944f04d
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/pty/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/linux_raw/pty/syscalls.rs b/vendor/rustix/src/backend/linux_raw/pty/syscalls.rs
new file mode 100644
index 000000000..c2d1b07c1
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/pty/syscalls.rs
@@ -0,0 +1,59 @@
+//! linux_raw syscalls supporting `rustix::pty`.
+//!
+//! # Safety
+//!
+//! See the `rustix::backend` module documentation for details.
+#![allow(unsafe_code)]
+#![allow(clippy::undocumented_unsafe_blocks)]
+
+use crate::backend::c;
+use crate::backend::conv::{by_ref, c_uint, ret, ret_owned_fd};
+use crate::fd::{BorrowedFd, OwnedFd};
+use crate::ffi::CString;
+use crate::io;
+use crate::path::DecInt;
+use crate::pty::OpenptFlags;
+#[cfg(any(apple, freebsdlike, linux_like, target_os = "fuchsia"))]
+use alloc::vec::Vec;
+use core::mem::MaybeUninit;
+use linux_raw_sys::ioctl::{TIOCGPTN, TIOCGPTPEER, TIOCSPTLCK};
+
+#[cfg(any(apple, freebsdlike, linux_like, target_os = "fuchsia"))]
+#[inline]
+pub(crate) fn ptsname(fd: BorrowedFd, mut buffer: Vec<u8>) -> io::Result<CString> {
+    unsafe {
+        let mut n = MaybeUninit::<c::c_int>::uninit();
+        ret(syscall!(__NR_ioctl, fd, c_uint(TIOCGPTN), &mut n))?;
+
+        buffer.clear();
+        buffer.extend_from_slice(b"/dev/pts/");
+        buffer.extend_from_slice(DecInt::new(n.assume_init()).as_bytes());
+        buffer.push(b'\0');
+        Ok(CString::from_vec_with_nul_unchecked(buffer))
+    }
+}
+
+#[inline]
+pub(crate) fn unlockpt(fd: BorrowedFd) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_ioctl,
+            fd,
+            c_uint(TIOCSPTLCK),
+            by_ref(&0)
+        ))
+    }
+}
+
+#[cfg(target_os = "linux")]
+#[inline]
+pub(crate) fn ioctl_tiocgptpeer(fd: BorrowedFd, flags: OpenptFlags) -> io::Result<OwnedFd> {
+    unsafe {
+        ret_owned_fd(syscall_readonly!(
+            __NR_ioctl,
+            fd,
+            c_uint(TIOCGPTPEER),
+            flags
+        ))
+    }
+}
diff --git a/vendor/rustix/src/backend/linux_raw/rand/syscalls.rs b/vendor/rustix/src/backend/linux_raw/rand/syscalls.rs
index 5533f75e0..95a6efcff 100644
--- a/vendor/rustix/src/backend/linux_raw/rand/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/rand/syscalls.rs
@@ -6,7 +6,7 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::conv::{ret_usize, slice_mut};
+use crate::backend::conv::{ret_usize, slice_mut};
 use crate::io;
 use crate::rand::GetRandomFlags;
 
diff --git a/vendor/rustix/src/backend/linux_raw/rand/types.rs b/vendor/rustix/src/backend/linux_raw/rand/types.rs
index 75f17443e..21e950015 100644
--- a/vendor/rustix/src/backend/linux_raw/rand/types.rs
+++ b/vendor/rustix/src/backend/linux_raw/rand/types.rs
@@ -4,6 +4,8 @@ bitflags! {
     /// `GRND_*` flags for use with [`getrandom`].
     ///
     /// [`getrandom`]: crate::rand::getrandom
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct GetRandomFlags: u32 {
         /// `GRND_RANDOM`
         const RANDOM = linux_raw_sys::general::GRND_RANDOM;
diff --git a/vendor/rustix/src/backend/linux_raw/reg.rs b/vendor/rustix/src/backend/linux_raw/reg.rs
index afe99c5f4..206031dde 100644
--- a/vendor/rustix/src/backend/linux_raw/reg.rs
+++ b/vendor/rustix/src/backend/linux_raw/reg.rs
@@ -16,6 +16,7 @@
 use super::c;
 use super::fd::RawFd;
 use core::marker::PhantomData;
+use core::ops::Range;
 
 pub(super) trait ToAsm: private::Sealed {
     /// Convert `self` to a `usize` ready to be passed to a syscall
@@ -188,7 +189,7 @@ impl<Num: RetNumber> RetReg<Num> {
     }
 
     #[inline]
-    pub(super) fn is_in_range(&self, range: core::ops::Range<isize>) -> bool {
+    pub(super) fn is_in_range(&self, range: Range<isize>) -> bool {
         range.contains(&(self.raw as isize))
     }
 }
diff --git a/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs b/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs
index 74363fc32..b9814e731 100644
--- a/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs
@@ -6,12 +6,11 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::c;
+use crate::backend::c;
 #[cfg(target_arch = "x86")]
-use super::super::conv::by_mut;
-use super::super::conv::{
-    by_ref, c_int, c_uint, ret, ret_c_int, ret_c_uint, ret_error, ret_usize_infallible, size_of,
-    zero,
+use crate::backend::conv::by_mut;
+use crate::backend::conv::{
+    by_ref, c_int, c_uint, ret, ret_c_int, ret_c_int_infallible, ret_error, size_of, zero,
 };
 #[cfg(feature = "fs")]
 use crate::fd::BorrowedFd;
@@ -19,23 +18,24 @@ use crate::ffi::CStr;
 #[cfg(feature = "fs")]
 use crate::fs::AtFlags;
 use crate::io;
-use crate::process::{Pid, RawNonZeroPid, Signal};
-use crate::runtime::{How, Sigaction, Siginfo, Sigset, Stack, Timespec};
+use crate::pid::Pid;
+use crate::runtime::{How, Sigaction, Siginfo, Sigset, Stack};
+use crate::signal::Signal;
+use crate::timespec::Timespec;
 use crate::utils::optional_as_ptr;
-#[cfg(target_pointer_width = "32")]
-use core::convert::TryInto;
 use core::mem::MaybeUninit;
 #[cfg(target_pointer_width = "32")]
 use linux_raw_sys::general::__kernel_old_timespec;
-use linux_raw_sys::general::{__kernel_pid_t, kernel_sigset_t, PR_SET_NAME, SIGCHLD};
+use linux_raw_sys::general::kernel_sigset_t;
+use linux_raw_sys::prctl::PR_SET_NAME;
 #[cfg(target_arch = "x86_64")]
-use {super::super::conv::ret_infallible, linux_raw_sys::general::ARCH_SET_FS};
+use {crate::backend::conv::ret_infallible, linux_raw_sys::general::ARCH_SET_FS};
 
 #[inline]
 pub(crate) unsafe fn fork() -> io::Result<Option<Pid>> {
-    let pid = ret_c_uint(syscall_readonly!(
+    let pid = ret_c_int(syscall_readonly!(
         __NR_clone,
-        c_uint(SIGCHLD),
+        c_int(c::SIGCHLD),
         zero(),
         zero(),
         zero(),
@@ -71,9 +71,9 @@ pub(crate) unsafe fn execve(
 }
 
 pub(crate) mod tls {
-    #[cfg(target_arch = "x86")]
-    use super::super::tls::UserDesc;
     use super::*;
+    #[cfg(target_arch = "x86")]
+    use crate::backend::runtime::tls::UserDesc;
 
     #[cfg(target_arch = "x86")]
     #[inline]
@@ -99,10 +99,8 @@ pub(crate) mod tls {
 
     #[inline]
     pub(crate) unsafe fn set_tid_address(data: *mut c::c_void) -> Pid {
-        let tid: i32 =
-            ret_usize_infallible(syscall_readonly!(__NR_set_tid_address, data)) as __kernel_pid_t;
-        debug_assert_ne!(tid, 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(tid as u32))
+        let tid: i32 = ret_c_int_infallible(syscall_readonly!(__NR_set_tid_address, data));
+        Pid::from_raw_unchecked(tid)
     }
 
     #[inline]
@@ -144,12 +142,13 @@ pub(crate) unsafe fn tkill(tid: Pid, sig: Signal) -> io::Result<()> {
 }
 
 #[inline]
-pub(crate) unsafe fn sigprocmask(how: How, set: &Sigset) -> io::Result<Sigset> {
+pub(crate) unsafe fn sigprocmask(how: How, new: Option<&Sigset>) -> io::Result<Sigset> {
     let mut old = MaybeUninit::<Sigset>::uninit();
+    let new = optional_as_ptr(new);
     ret(syscall!(
         __NR_rt_sigprocmask,
         how,
-        by_ref(set),
+        new,
         &mut old,
         size_of::<kernel_sigset_t, _>()
     ))?;
@@ -192,6 +191,9 @@ pub(crate) fn sigtimedwait(set: &Sigset, timeout: Option<Timespec>) -> io::Resul
     let mut info = MaybeUninit::<Siginfo>::uninit();
     let timeout_ptr = optional_as_ptr(timeout.as_ref());
 
+    // `rt_sigtimedwait_time64` was introduced in Linux 5.1. The old
+    // `rt_sigtimedwait` syscall is not y2038-compatible on 32-bit
+    // architectures.
     #[cfg(target_pointer_width = "32")]
     unsafe {
         match ret_c_int(syscall!(
@@ -247,3 +249,8 @@ unsafe fn sigtimedwait_old(
 
     Ok(())
 }
+
+#[inline]
+pub(crate) fn exit_group(code: c::c_int) -> ! {
+    unsafe { syscall_noreturn!(__NR_exit_group, c_int(code)) }
+}
diff --git a/vendor/rustix/src/backend/linux_raw/runtime/tls.rs b/vendor/rustix/src/backend/linux_raw/runtime/tls.rs
index 8cc156a71..763971591 100644
--- a/vendor/rustix/src/backend/linux_raw/runtime/tls.rs
+++ b/vendor/rustix/src/backend/linux_raw/runtime/tls.rs
@@ -6,9 +6,9 @@
 //! kernel-provided AUXV values.
 #![allow(unsafe_code)]
 
-use super::super::c;
-use super::super::elf::*;
-use super::super::param::auxv::exe_phdrs_slice;
+use crate::backend::c;
+use crate::backend::elf::*;
+use crate::backend::param::auxv::exe_phdrs_slice;
 use core::ptr::null;
 
 /// For use with [`set_thread_area`].
@@ -29,7 +29,7 @@ pub(crate) fn startup_tls_info() -> StartupTlsInfo {
     unsafe {
         for phdr in phdrs {
             match phdr.p_type {
-                PT_PHDR => base = phdrs.as_ptr().cast::<u8>().offset(-(phdr.p_vaddr as isize)),
+                PT_PHDR => base = phdrs.as_ptr().cast::<u8>().sub(phdr.p_vaddr),
                 PT_TLS => tls_phdr = phdr,
                 PT_GNU_STACK => stack_size = phdr.p_memsz,
                 _ => {}
diff --git a/vendor/rustix/src/backend/linux_raw/system/mod.rs b/vendor/rustix/src/backend/linux_raw/system/mod.rs
new file mode 100644
index 000000000..1e0181a99
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/system/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/system/syscalls.rs b/vendor/rustix/src/backend/linux_raw/system/syscalls.rs
new file mode 100644
index 000000000..514751d6f
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/system/syscalls.rs
@@ -0,0 +1,37 @@
+//! linux_raw syscalls supporting `rustix::system`.
+//!
+//! # Safety
+//!
+//! See the `rustix::backend` module documentation for details.
+#![allow(unsafe_code)]
+#![allow(clippy::undocumented_unsafe_blocks)]
+
+use super::types::RawUname;
+use crate::backend::conv::{ret, ret_infallible, slice};
+use crate::io;
+use crate::system::Sysinfo;
+use core::mem::MaybeUninit;
+
+#[inline]
+pub(crate) fn uname() -> RawUname {
+    let mut uname = MaybeUninit::<RawUname>::uninit();
+    unsafe {
+        ret_infallible(syscall!(__NR_uname, &mut uname));
+        uname.assume_init()
+    }
+}
+
+#[inline]
+pub(crate) fn sysinfo() -> Sysinfo {
+    let mut info = MaybeUninit::<Sysinfo>::uninit();
+    unsafe {
+        ret_infallible(syscall!(__NR_sysinfo, &mut info));
+        info.assume_init()
+    }
+}
+
+#[inline]
+pub(crate) fn sethostname(name: &[u8]) -> io::Result<()> {
+    let (ptr, len) = slice(name);
+    unsafe { ret(syscall_readonly!(__NR_sethostname, ptr, len)) }
+}
diff --git a/vendor/rustix/src/backend/linux_raw/system/types.rs b/vendor/rustix/src/backend/linux_raw/system/types.rs
new file mode 100644
index 000000000..47292735c
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/system/types.rs
@@ -0,0 +1,4 @@
+/// `sysinfo`
+pub type Sysinfo = linux_raw_sys::system::sysinfo;
+
+pub(crate) type RawUname = linux_raw_sys::system::new_utsname;
diff --git a/vendor/rustix/src/backend/linux_raw/termios/mod.rs b/vendor/rustix/src/backend/linux_raw/termios/mod.rs
index 1e0181a99..ef944f04d 100644
--- a/vendor/rustix/src/backend/linux_raw/termios/mod.rs
+++ b/vendor/rustix/src/backend/linux_raw/termios/mod.rs
@@ -1,2 +1 @@
 pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/termios/syscalls.rs b/vendor/rustix/src/backend/linux_raw/termios/syscalls.rs
index 3c8cbb0c9..5e21397bc 100644
--- a/vendor/rustix/src/backend/linux_raw/termios/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/termios/syscalls.rs
@@ -6,21 +6,24 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::conv::{by_ref, c_uint, ret};
+use crate::backend::c;
+use crate::backend::conv::{by_ref, c_uint, ret};
 use crate::fd::BorrowedFd;
 use crate::io;
-use crate::process::{Pid, RawNonZeroPid};
+use crate::pid::Pid;
+#[cfg(feature = "procfs")]
+use crate::procfs;
 use crate::termios::{
-    Action, OptionalActions, QueueSelector, Termios, Winsize, BRKINT, CBAUD, CS8, CSIZE, ECHO,
-    ECHONL, ICANON, ICRNL, IEXTEN, IGNBRK, IGNCR, INLCR, ISIG, ISTRIP, IXON, OPOST, PARENB, PARMRK,
-    VMIN, VTIME,
+    Action, ControlModes, InputModes, LocalModes, OptionalActions, OutputModes, QueueSelector,
+    SpecialCodeIndex, Termios, Winsize,
 };
 #[cfg(feature = "procfs")]
 use crate::{ffi::CStr, fs::FileType, path::DecInt};
 use core::mem::MaybeUninit;
-use linux_raw_sys::general::__kernel_pid_t;
+use linux_raw_sys::general::IBSHIFT;
 use linux_raw_sys::ioctl::{
-    TCFLSH, TCGETS, TCSBRK, TCSETS, TCXONC, TIOCGPGRP, TIOCGSID, TIOCGWINSZ, TIOCSPGRP, TIOCSWINSZ,
+    TCFLSH, TCSBRK, TCXONC, TIOCEXCL, TIOCGPGRP, TIOCGSID, TIOCGWINSZ, TIOCNXCL, TIOCSPGRP,
+    TIOCSWINSZ,
 };
 
 #[inline]
@@ -36,31 +39,7 @@ pub(crate) fn tcgetwinsize(fd: BorrowedFd<'_>) -> io::Result<Winsize> {
 pub(crate) fn tcgetattr(fd: BorrowedFd<'_>) -> io::Result<Termios> {
     unsafe {
         let mut result = MaybeUninit::<Termios>::uninit();
-        ret(syscall!(__NR_ioctl, fd, c_uint(TCGETS), &mut result))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[inline]
-#[cfg(any(
-    target_arch = "x86",
-    target_arch = "x86_64",
-    target_arch = "x32",
-    target_arch = "riscv64",
-    target_arch = "aarch64",
-    target_arch = "arm",
-    target_arch = "mips",
-    target_arch = "mips64",
-))]
-pub(crate) fn tcgetattr2(fd: BorrowedFd<'_>) -> io::Result<crate::termios::Termios2> {
-    unsafe {
-        let mut result = MaybeUninit::<crate::termios::Termios2>::uninit();
-        ret(syscall!(
-            __NR_ioctl,
-            fd,
-            c_uint(linux_raw_sys::ioctl::TCGETS2),
-            &mut result
-        ))?;
+        ret(syscall!(__NR_ioctl, fd, c_uint(c::TCGETS2), &mut result))?;
         Ok(result.assume_init())
     }
 }
@@ -68,13 +47,10 @@ pub(crate) fn tcgetattr2(fd: BorrowedFd<'_>) -> io::Result<crate::termios::Termi
 #[inline]
 pub(crate) fn tcgetpgrp(fd: BorrowedFd<'_>) -> io::Result<Pid> {
     unsafe {
-        let mut result = MaybeUninit::<__kernel_pid_t>::uninit();
+        let mut result = MaybeUninit::<c::pid_t>::uninit();
         ret(syscall!(__NR_ioctl, fd, c_uint(TIOCGPGRP), &mut result))?;
         let pid = result.assume_init();
-        debug_assert!(pid > 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(
-            pid as u32,
-        )))
+        Ok(Pid::from_raw_unchecked(pid))
     }
 }
 
@@ -86,42 +62,17 @@ pub(crate) fn tcsetattr(
 ) -> io::Result<()> {
     // Translate from `optional_actions` into an ioctl request code. On MIPS,
     // `optional_actions` already has `TCGETS` added to it.
-    let request = if cfg!(any(target_arch = "mips", target_arch = "mips64")) {
-        optional_actions as u32
-    } else {
-        TCSETS + optional_actions as u32
-    };
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_ioctl,
-            fd,
-            c_uint(request as u32),
-            by_ref(termios)
-        ))
-    }
-}
-
-#[inline]
-#[cfg(any(
-    target_arch = "x86",
-    target_arch = "x86_64",
-    target_arch = "x32",
-    target_arch = "riscv64",
-    target_arch = "aarch64",
-    target_arch = "arm",
-    target_arch = "mips",
-    target_arch = "mips64",
-))]
-pub(crate) fn tcsetattr2(
-    fd: BorrowedFd,
-    optional_actions: OptionalActions,
-    termios: &crate::termios::Termios2,
-) -> io::Result<()> {
+    let request = linux_raw_sys::ioctl::TCSETS2
+        + if cfg!(any(target_arch = "mips", target_arch = "mips64")) {
+            optional_actions as u32 - linux_raw_sys::ioctl::TCSETS
+        } else {
+            optional_actions as u32
+        };
     unsafe {
         ret(syscall_readonly!(
             __NR_ioctl,
             fd,
-            c_uint(linux_raw_sys::ioctl::TCSETS2 + optional_actions as u32),
+            c_uint(request),
             by_ref(termios)
         ))
     }
@@ -164,13 +115,10 @@ pub(crate) fn tcflow(fd: BorrowedFd, action: Action) -> io::Result<()> {
 #[inline]
 pub(crate) fn tcgetsid(fd: BorrowedFd) -> io::Result<Pid> {
     unsafe {
-        let mut result = MaybeUninit::<__kernel_pid_t>::uninit();
+        let mut result = MaybeUninit::<c::pid_t>::uninit();
         ret(syscall!(__NR_ioctl, fd, c_uint(TIOCGSID), &mut result))?;
         let pid = result.assume_init();
-        debug_assert!(pid > 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(
-            pid as u32,
-        )))
+        Ok(Pid::from_raw_unchecked(pid))
     }
 }
 
@@ -192,66 +140,90 @@ pub(crate) fn tcsetpgrp(fd: BorrowedFd<'_>, pid: Pid) -> io::Result<()> {
 }
 
 #[inline]
-#[must_use]
-#[allow(clippy::missing_const_for_fn)]
-pub(crate) fn cfgetospeed(termios: &Termios) -> u32 {
-    termios.c_cflag & CBAUD
+pub(crate) fn ioctl_tiocexcl(fd: BorrowedFd<'_>) -> io::Result<()> {
+    unsafe { ret(syscall_readonly!(__NR_ioctl, fd, c_uint(TIOCEXCL))) }
 }
 
 #[inline]
-#[must_use]
-#[allow(clippy::missing_const_for_fn)]
-pub(crate) fn cfgetispeed(termios: &Termios) -> u32 {
-    termios.c_cflag & CBAUD
+pub(crate) fn ioctl_tiocnxcl(fd: BorrowedFd<'_>) -> io::Result<()> {
+    unsafe { ret(syscall_readonly!(__NR_ioctl, fd, c_uint(TIOCNXCL))) }
 }
 
+/// A wrapper around a conceptual `cfsetspeed` which handles an arbitrary
+/// integer speed value.
 #[inline]
-pub(crate) fn cfmakeraw(termios: &mut Termios) {
-    // From the Linux [`cfmakeraw` manual page]:
-    //
-    // [`cfmakeraw` manual page]: https://man7.org/linux/man-pages/man3/cfmakeraw.3.html
-    termios.c_iflag &= !(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
-    termios.c_oflag &= !OPOST;
-    termios.c_lflag &= !(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
-    termios.c_cflag &= !(CSIZE | PARENB);
-    termios.c_cflag |= CS8;
+pub(crate) fn set_speed(termios: &mut Termios, arbitrary_speed: u32) -> io::Result<()> {
+    let encoded_speed = crate::termios::speed::encode(arbitrary_speed).unwrap_or(c::BOTHER);
 
-    // Musl and glibc also do these:
-    termios.c_cc[VMIN] = 1;
-    termios.c_cc[VTIME] = 0;
+    debug_assert_eq!(encoded_speed & !c::CBAUD, 0);
+
+    termios.control_modes -= ControlModes::from_bits_retain(c::CBAUD | c::CIBAUD);
+    termios.control_modes |=
+        ControlModes::from_bits_retain(encoded_speed | (encoded_speed << IBSHIFT));
+
+    termios.input_speed = arbitrary_speed;
+    termios.output_speed = arbitrary_speed;
+
+    Ok(())
 }
 
+/// A wrapper around a conceptual `cfsetospeed` which handles an arbitrary
+/// integer speed value.
 #[inline]
-pub(crate) fn cfsetospeed(termios: &mut Termios, speed: u32) -> io::Result<()> {
-    if (speed & !CBAUD) != 0 {
-        return Err(io::Errno::INVAL);
-    }
-    termios.c_cflag &= !CBAUD;
-    termios.c_cflag |= speed;
+pub(crate) fn set_output_speed(termios: &mut Termios, arbitrary_speed: u32) -> io::Result<()> {
+    let encoded_speed = crate::termios::speed::encode(arbitrary_speed).unwrap_or(c::BOTHER);
+
+    debug_assert_eq!(encoded_speed & !c::CBAUD, 0);
+
+    termios.control_modes -= ControlModes::from_bits_retain(c::CBAUD);
+    termios.control_modes |= ControlModes::from_bits_retain(encoded_speed);
+
+    termios.output_speed = arbitrary_speed;
+
     Ok(())
 }
 
+/// A wrapper around a conceptual `cfsetispeed` which handles an arbitrary
+/// integer speed value.
 #[inline]
-pub(crate) fn cfsetispeed(termios: &mut Termios, speed: u32) -> io::Result<()> {
-    if speed == 0 {
-        return Ok(());
-    }
-    if (speed & !CBAUD) != 0 {
-        return Err(io::Errno::INVAL);
-    }
-    termios.c_cflag &= !CBAUD;
-    termios.c_cflag |= speed;
+pub(crate) fn set_input_speed(termios: &mut Termios, arbitrary_speed: u32) -> io::Result<()> {
+    let encoded_speed = crate::termios::speed::encode(arbitrary_speed).unwrap_or(c::BOTHER);
+
+    debug_assert_eq!(encoded_speed & !c::CBAUD, 0);
+
+    termios.control_modes -= ControlModes::from_bits_retain(c::CIBAUD);
+    termios.control_modes |= ControlModes::from_bits_retain(encoded_speed << IBSHIFT);
+
+    termios.input_speed = arbitrary_speed;
+
     Ok(())
 }
 
 #[inline]
-pub(crate) fn cfsetspeed(termios: &mut Termios, speed: u32) -> io::Result<()> {
-    if (speed & !CBAUD) != 0 {
-        return Err(io::Errno::INVAL);
-    }
-    termios.c_cflag &= !CBAUD;
-    termios.c_cflag |= speed;
-    Ok(())
+pub(crate) fn cfmakeraw(termios: &mut Termios) {
+    // From the Linux [`cfmakeraw` manual page]:
+    //
+    // [`cfmakeraw` manual page]: https://man7.org/linux/man-pages/man3/cfmakeraw.3.html
+    termios.input_modes -= InputModes::IGNBRK
+        | InputModes::BRKINT
+        | InputModes::PARMRK
+        | InputModes::ISTRIP
+        | InputModes::INLCR
+        | InputModes::IGNCR
+        | InputModes::ICRNL
+        | InputModes::IXON;
+    termios.output_modes -= OutputModes::OPOST;
+    termios.local_modes -= LocalModes::ECHO
+        | LocalModes::ECHONL
+        | LocalModes::ICANON
+        | LocalModes::ISIG
+        | LocalModes::IEXTEN;
+    termios.control_modes -= ControlModes::CSIZE | ControlModes::PARENB;
+    termios.control_modes |= ControlModes::CS8;
+
+    // Musl and glibc also do these:
+    termios.special_codes[SpecialCodeIndex::VMIN] = 1;
+    termios.special_codes[SpecialCodeIndex::VTIME] = 0;
 }
 
 #[inline]
@@ -264,8 +236,9 @@ pub(crate) fn isatty(fd: BorrowedFd<'_>) -> bool {
 }
 
 #[cfg(feature = "procfs")]
-pub(crate) fn ttyname(fd: BorrowedFd<'_>, buf: &mut [u8]) -> io::Result<usize> {
-    let fd_stat = super::super::fs::syscalls::fstat(fd)?;
+#[allow(unsafe_code)]
+pub(crate) fn ttyname(fd: BorrowedFd<'_>, buf: &mut [MaybeUninit<u8>]) -> io::Result<usize> {
+    let fd_stat = crate::backend::fs::syscalls::fstat(fd)?;
 
     // Quick check: if `fd` isn't a character device, it's not a tty.
     if FileType::from_raw_mode(fd_stat.st_mode) != FileType::CharacterDevice {
@@ -276,11 +249,14 @@ pub(crate) fn ttyname(fd: BorrowedFd<'_>, buf: &mut [u8]) -> io::Result<usize> {
     tcgetwinsize(fd)?;
 
     // Get a fd to '/proc/self/fd'.
-    let proc_self_fd = io::proc_self_fd()?;
+    let proc_self_fd = procfs::proc_self_fd()?;
 
     // Gather the ttyname by reading the 'fd' file inside 'proc_self_fd'.
-    let r =
-        super::super::fs::syscalls::readlinkat(proc_self_fd, DecInt::from_fd(fd).as_c_str(), buf)?;
+    let r = crate::backend::fs::syscalls::readlinkat(
+        proc_self_fd,
+        DecInt::from_fd(fd).as_c_str(),
+        buf,
+    )?;
 
     // If the number of bytes is equal to the buffer length, truncation may
     // have occurred. This check also ensures that we have enough space for
@@ -288,14 +264,20 @@ pub(crate) fn ttyname(fd: BorrowedFd<'_>, buf: &mut [u8]) -> io::Result<usize> {
     if r == buf.len() {
         return Err(io::Errno::RANGE);
     }
-    buf[r] = b'\0';
+
+    // `readlinkat` returns the number of bytes placed in the buffer.
+    // NUL-terminate the string at that offset.
+    buf[r].write(b'\0');
 
     // Check that the path we read refers to the same file as `fd`.
-    let path = CStr::from_bytes_with_nul(&buf[..=r]).unwrap();
+    {
+        // SAFETY: We just wrote the NUL byte above
+        let path = unsafe { CStr::from_ptr(buf.as_ptr().cast()) };
 
-    let path_stat = super::super::fs::syscalls::stat(path)?;
-    if path_stat.st_dev != fd_stat.st_dev || path_stat.st_ino != fd_stat.st_ino {
-        return Err(io::Errno::NODEV);
+        let path_stat = crate::backend::fs::syscalls::stat(path)?;
+        if path_stat.st_dev != fd_stat.st_dev || path_stat.st_ino != fd_stat.st_ino {
+            return Err(io::Errno::NODEV);
+        }
     }
 
     Ok(r)
diff --git a/vendor/rustix/src/backend/linux_raw/termios/types.rs b/vendor/rustix/src/backend/linux_raw/termios/types.rs
deleted file mode 100644
index 3fe45af98..000000000
--- a/vendor/rustix/src/backend/linux_raw/termios/types.rs
+++ /dev/null
@@ -1,495 +0,0 @@
-use super::super::c;
-
-/// `TCSA*` values for use with [`tcsetattr`].
-///
-/// [`tcsetattr`]: crate::termios::tcsetattr
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(u32)]
-pub enum OptionalActions {
-    /// `TCSANOW`—Make the change immediately.
-    #[doc(alias = "TCSANOW")]
-    Now = linux_raw_sys::general::TCSANOW,
-
-    /// `TCSADRAIN`—Make the change after all output has been transmitted.
-    #[doc(alias = "TCSADRAIN")]
-    Drain = linux_raw_sys::general::TCSADRAIN,
-
-    /// `TCSAFLUSH`—Discard any pending input and then make the change
-    /// after all output has been transmitted.
-    #[doc(alias = "TCSAFLUSH")]
-    Flush = linux_raw_sys::general::TCSAFLUSH,
-}
-
-/// `TC*` values for use with [`tcflush`].
-///
-/// [`tcflush`]: crate::termios::tcflush
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(u32)]
-pub enum QueueSelector {
-    /// `TCIFLUSH`—Flush data received but not read.
-    #[doc(alias = "TCIFLUSH")]
-    IFlush = linux_raw_sys::general::TCIFLUSH,
-
-    /// `TCOFLUSH`—Flush data written but not transmitted.
-    #[doc(alias = "TCOFLUSH")]
-    OFlush = linux_raw_sys::general::TCOFLUSH,
-
-    /// `TCIOFLUSH`—`IFlush` and `OFlush` combined.
-    #[doc(alias = "TCIOFLUSH")]
-    IOFlush = linux_raw_sys::general::TCIOFLUSH,
-}
-
-/// `TC*` values for use with [`tcflow`].
-///
-/// [`tcflow`]: crate::termios::tcflow
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(u32)]
-pub enum Action {
-    /// `TCOOFF`—Suspend output.
-    #[doc(alias = "TCOOFF")]
-    OOff = linux_raw_sys::general::TCOOFF,
-
-    /// `TCOON`—Restart suspended output.
-    #[doc(alias = "TCOON")]
-    OOn = linux_raw_sys::general::TCOON,
-
-    /// `TCIOFF`—Transmits a STOP byte.
-    #[doc(alias = "TCIOFF")]
-    IOff = linux_raw_sys::general::TCIOFF,
-
-    /// `TCION`—Transmits a START byte.
-    #[doc(alias = "TCION")]
-    IOn = linux_raw_sys::general::TCION,
-}
-
-/// `struct termios` for use with [`tcgetattr`] and [`tcsetattr`].
-///
-/// [`tcgetattr`]: crate::termios::tcgetattr
-/// [`tcsetattr`]: crate::termios::tcsetattr
-#[doc(alias = "termios")]
-pub type Termios = linux_raw_sys::general::termios;
-
-/// `struct termios2` for use with [`tcgetattr2`] and [`tcsetattr2`].
-///
-/// [`tcgetattr2`]: crate::termios::tcgetattr2
-/// [`tcsetattr2`]: crate::termios::tcsetattr2
-#[cfg(any(
-    target_arch = "x86",
-    target_arch = "x86_64",
-    target_arch = "x32",
-    target_arch = "riscv64",
-    target_arch = "aarch64",
-    target_arch = "arm",
-    target_arch = "mips",
-    target_arch = "mips64",
-))]
-#[doc(alias = "termios2")]
-pub type Termios2 = linux_raw_sys::general::termios2;
-
-/// `struct winsize` for use with [`tcgetwinsize`].
-///
-/// [`tcgetwinsize`]: crate::termios::tcgetwinsize
-#[doc(alias = "winsize")]
-pub type Winsize = linux_raw_sys::general::winsize;
-
-/// `tcflag_t`—A type for the flags fields of [`Termios`].
-#[doc(alias = "tcflag_t")]
-pub type Tcflag = linux_raw_sys::general::tcflag_t;
-
-/// `speed_t`—A return type for [`cfsetspeed`] and similar.
-///
-/// [`cfsetspeed`]: crate::termios::cfsetspeed
-#[doc(alias = "speed_t")]
-pub type Speed = linux_raw_sys::general::speed_t;
-
-/// `VINTR`
-pub const VINTR: usize = linux_raw_sys::general::VINTR as usize;
-
-/// `VQUIT`
-pub const VQUIT: usize = linux_raw_sys::general::VQUIT as usize;
-
-/// `VERASE`
-pub const VERASE: usize = linux_raw_sys::general::VERASE as usize;
-
-/// `VKILL`
-pub const VKILL: usize = linux_raw_sys::general::VKILL as usize;
-
-/// `VEOF`
-pub const VEOF: usize = linux_raw_sys::general::VEOF as usize;
-
-/// `VTIME`
-pub const VTIME: usize = linux_raw_sys::general::VTIME as usize;
-
-/// `VMIN`
-pub const VMIN: usize = linux_raw_sys::general::VMIN as usize;
-
-/// `VSWTC`
-pub const VSWTC: usize = linux_raw_sys::general::VSWTC as usize;
-
-/// `VSTART`
-pub const VSTART: usize = linux_raw_sys::general::VSTART as usize;
-
-/// `VSTOP`
-pub const VSTOP: usize = linux_raw_sys::general::VSTOP as usize;
-
-/// `VSUSP`
-pub const VSUSP: usize = linux_raw_sys::general::VSUSP as usize;
-
-/// `VEOL`
-pub const VEOL: usize = linux_raw_sys::general::VEOL as usize;
-
-/// `VREPRINT`
-pub const VREPRINT: usize = linux_raw_sys::general::VREPRINT as usize;
-
-/// `VDISCARD`
-pub const VDISCARD: usize = linux_raw_sys::general::VDISCARD as usize;
-
-/// `VWERASE`
-pub const VWERASE: usize = linux_raw_sys::general::VWERASE as usize;
-
-/// `VLNEXT`
-pub const VLNEXT: usize = linux_raw_sys::general::VLNEXT as usize;
-
-/// `VEOL2`
-pub const VEOL2: usize = linux_raw_sys::general::VEOL2 as usize;
-
-/// `IGNBRK`
-pub const IGNBRK: c::c_uint = linux_raw_sys::general::IGNBRK;
-
-/// `BRKINT`
-pub const BRKINT: c::c_uint = linux_raw_sys::general::BRKINT;
-
-/// `IGNPAR`
-pub const IGNPAR: c::c_uint = linux_raw_sys::general::IGNPAR;
-
-/// `PARMRK`
-pub const PARMRK: c::c_uint = linux_raw_sys::general::PARMRK;
-
-/// `INPCK`
-pub const INPCK: c::c_uint = linux_raw_sys::general::INPCK;
-
-/// `ISTRIP`
-pub const ISTRIP: c::c_uint = linux_raw_sys::general::ISTRIP;
-
-/// `INLCR`
-pub const INLCR: c::c_uint = linux_raw_sys::general::INLCR;
-
-/// `IGNCR`
-pub const IGNCR: c::c_uint = linux_raw_sys::general::IGNCR;
-
-/// `ICRNL`
-pub const ICRNL: c::c_uint = linux_raw_sys::general::ICRNL;
-
-/// `IUCLC`
-pub const IUCLC: c::c_uint = linux_raw_sys::general::IUCLC;
-
-/// `IXON`
-pub const IXON: c::c_uint = linux_raw_sys::general::IXON;
-
-/// `IXANY`
-pub const IXANY: c::c_uint = linux_raw_sys::general::IXANY;
-
-/// `IXOFF`
-pub const IXOFF: c::c_uint = linux_raw_sys::general::IXOFF;
-
-/// `IMAXBEL`
-pub const IMAXBEL: c::c_uint = linux_raw_sys::general::IMAXBEL;
-
-/// `IUTF8`
-pub const IUTF8: c::c_uint = linux_raw_sys::general::IUTF8;
-
-/// `OPOST`
-pub const OPOST: c::c_uint = linux_raw_sys::general::OPOST;
-
-/// `OLCUC`
-pub const OLCUC: c::c_uint = linux_raw_sys::general::OLCUC;
-
-/// `ONLCR`
-pub const ONLCR: c::c_uint = linux_raw_sys::general::ONLCR;
-
-/// `OCRNL`
-pub const OCRNL: c::c_uint = linux_raw_sys::general::OCRNL;
-
-/// `ONOCR`
-pub const ONOCR: c::c_uint = linux_raw_sys::general::ONOCR;
-
-/// `ONLRET`
-pub const ONLRET: c::c_uint = linux_raw_sys::general::ONLRET;
-
-/// `OFILL`
-pub const OFILL: c::c_uint = linux_raw_sys::general::OFILL;
-
-/// `OFDEL`
-pub const OFDEL: c::c_uint = linux_raw_sys::general::OFDEL;
-
-/// `NLDLY`
-pub const NLDLY: c::c_uint = linux_raw_sys::general::NLDLY;
-
-/// `NL0`
-pub const NL0: c::c_uint = linux_raw_sys::general::NL0;
-
-/// `NL1`
-pub const NL1: c::c_uint = linux_raw_sys::general::NL1;
-
-/// `CRDLY`
-pub const CRDLY: c::c_uint = linux_raw_sys::general::CRDLY;
-
-/// `CR0`
-pub const CR0: c::c_uint = linux_raw_sys::general::CR0;
-
-/// `CR1`
-pub const CR1: c::c_uint = linux_raw_sys::general::CR1;
-
-/// `CR2`
-pub const CR2: c::c_uint = linux_raw_sys::general::CR2;
-
-/// `CR3`
-pub const CR3: c::c_uint = linux_raw_sys::general::CR3;
-
-/// `TABDLY`
-pub const TABDLY: c::c_uint = linux_raw_sys::general::TABDLY;
-
-/// `TAB0`
-pub const TAB0: c::c_uint = linux_raw_sys::general::TAB0;
-
-/// `TAB1`
-pub const TAB1: c::c_uint = linux_raw_sys::general::TAB1;
-
-/// `TAB2`
-pub const TAB2: c::c_uint = linux_raw_sys::general::TAB2;
-
-/// `TAB3`
-pub const TAB3: c::c_uint = linux_raw_sys::general::TAB3;
-
-/// `BSDLY`
-pub const BSDLY: c::c_uint = linux_raw_sys::general::BSDLY;
-
-/// `BS0`
-pub const BS0: c::c_uint = linux_raw_sys::general::BS0;
-
-/// `BS1`
-pub const BS1: c::c_uint = linux_raw_sys::general::BS1;
-
-/// `FFDLY`
-pub const FFDLY: c::c_uint = linux_raw_sys::general::FFDLY;
-
-/// `FF0`
-pub const FF0: c::c_uint = linux_raw_sys::general::FF0;
-
-/// `FF1`
-pub const FF1: c::c_uint = linux_raw_sys::general::FF1;
-
-/// `VTDLY`
-pub const VTDLY: c::c_uint = linux_raw_sys::general::VTDLY;
-
-/// `VT0`
-pub const VT0: c::c_uint = linux_raw_sys::general::VT0;
-
-/// `VT1`
-pub const VT1: c::c_uint = linux_raw_sys::general::VT1;
-
-/// `B0`
-pub const B0: Speed = linux_raw_sys::general::B0;
-
-/// `B50`
-pub const B50: Speed = linux_raw_sys::general::B50;
-
-/// `B75`
-pub const B75: Speed = linux_raw_sys::general::B75;
-
-/// `B110`
-pub const B110: Speed = linux_raw_sys::general::B110;
-
-/// `B134`
-pub const B134: Speed = linux_raw_sys::general::B134;
-
-/// `B150`
-pub const B150: Speed = linux_raw_sys::general::B150;
-
-/// `B200`
-pub const B200: Speed = linux_raw_sys::general::B200;
-
-/// `B300`
-pub const B300: Speed = linux_raw_sys::general::B300;
-
-/// `B600`
-pub const B600: Speed = linux_raw_sys::general::B600;
-
-/// `B1200`
-pub const B1200: Speed = linux_raw_sys::general::B1200;
-
-/// `B1800`
-pub const B1800: Speed = linux_raw_sys::general::B1800;
-
-/// `B2400`
-pub const B2400: Speed = linux_raw_sys::general::B2400;
-
-/// `B4800`
-pub const B4800: Speed = linux_raw_sys::general::B4800;
-
-/// `B9600`
-pub const B9600: Speed = linux_raw_sys::general::B9600;
-
-/// `B19200`
-pub const B19200: Speed = linux_raw_sys::general::B19200;
-
-/// `B38400`
-pub const B38400: Speed = linux_raw_sys::general::B38400;
-
-/// `B57600`
-pub const B57600: Speed = linux_raw_sys::general::B57600;
-
-/// `B115200`
-pub const B115200: Speed = linux_raw_sys::general::B115200;
-
-/// `B230400`
-pub const B230400: Speed = linux_raw_sys::general::B230400;
-
-/// `B460800`
-pub const B460800: Speed = linux_raw_sys::general::B460800;
-
-/// `B500000`
-pub const B500000: Speed = linux_raw_sys::general::B500000;
-
-/// `B576000`
-pub const B576000: Speed = linux_raw_sys::general::B576000;
-
-/// `B921600`
-pub const B921600: Speed = linux_raw_sys::general::B921600;
-
-/// `B1000000`
-pub const B1000000: Speed = linux_raw_sys::general::B1000000;
-
-/// `B1152000`
-pub const B1152000: Speed = linux_raw_sys::general::B1152000;
-
-/// `B1500000`
-pub const B1500000: Speed = linux_raw_sys::general::B1500000;
-
-/// `B2000000`
-pub const B2000000: Speed = linux_raw_sys::general::B2000000;
-
-/// `B2500000`
-#[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))]
-pub const B2500000: Speed = linux_raw_sys::general::B2500000;
-
-/// `B3000000`
-#[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))]
-pub const B3000000: Speed = linux_raw_sys::general::B3000000;
-
-/// `B3500000`
-#[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))]
-pub const B3500000: Speed = linux_raw_sys::general::B3500000;
-
-/// `B4000000`
-#[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))]
-pub const B4000000: Speed = linux_raw_sys::general::B4000000;
-
-/// `BOTHER`
-pub const BOTHER: c::c_uint = linux_raw_sys::general::BOTHER;
-
-/// `CSIZE`
-pub const CSIZE: c::c_uint = linux_raw_sys::general::CSIZE;
-
-/// `CS5`
-pub const CS5: c::c_uint = linux_raw_sys::general::CS5;
-
-/// `CS6`
-pub const CS6: c::c_uint = linux_raw_sys::general::CS6;
-
-/// `CS7`
-pub const CS7: c::c_uint = linux_raw_sys::general::CS7;
-
-/// `CS8`
-pub const CS8: c::c_uint = linux_raw_sys::general::CS8;
-
-/// `CSTOPB`
-pub const CSTOPB: c::c_uint = linux_raw_sys::general::CSTOPB;
-
-/// `CREAD`
-pub const CREAD: c::c_uint = linux_raw_sys::general::CREAD;
-
-/// `PARENB`
-pub const PARENB: c::c_uint = linux_raw_sys::general::PARENB;
-
-/// `PARODD`
-pub const PARODD: c::c_uint = linux_raw_sys::general::PARODD;
-
-/// `HUPCL`
-pub const HUPCL: c::c_uint = linux_raw_sys::general::HUPCL;
-
-/// `CLOCAL`
-pub const CLOCAL: c::c_uint = linux_raw_sys::general::CLOCAL;
-
-/// `ISIG`
-pub const ISIG: c::c_uint = linux_raw_sys::general::ISIG;
-
-/// `ICANON`—A flag for the `c_lflag` field of [`Termios`] indicating
-/// canonical mode.
-pub const ICANON: Tcflag = linux_raw_sys::general::ICANON;
-
-/// `ECHO`
-pub const ECHO: c::c_uint = linux_raw_sys::general::ECHO;
-
-/// `ECHOE`
-pub const ECHOE: c::c_uint = linux_raw_sys::general::ECHOE;
-
-/// `ECHOK`
-pub const ECHOK: c::c_uint = linux_raw_sys::general::ECHOK;
-
-/// `ECHONL`
-pub const ECHONL: c::c_uint = linux_raw_sys::general::ECHONL;
-
-/// `NOFLSH`
-pub const NOFLSH: c::c_uint = linux_raw_sys::general::NOFLSH;
-
-/// `TOSTOP`
-pub const TOSTOP: c::c_uint = linux_raw_sys::general::TOSTOP;
-
-/// `IEXTEN`
-pub const IEXTEN: c::c_uint = linux_raw_sys::general::IEXTEN;
-
-/// `EXTA`
-pub const EXTA: c::c_uint = linux_raw_sys::general::EXTA;
-
-/// `EXTB`
-pub const EXTB: c::c_uint = linux_raw_sys::general::EXTB;
-
-/// `CBAUD`
-pub const CBAUD: c::c_uint = linux_raw_sys::general::CBAUD;
-
-/// `CBAUDEX`
-pub const CBAUDEX: c::c_uint = linux_raw_sys::general::CBAUDEX;
-
-/// `CIBAUD`
-pub const CIBAUD: c::c_uint = linux_raw_sys::general::CIBAUD;
-
-/// `CMSPAR`
-pub const CMSPAR: c::c_uint = linux_raw_sys::general::CMSPAR;
-
-/// `CRTSCTS`
-pub const CRTSCTS: c::c_uint = linux_raw_sys::general::CRTSCTS;
-
-/// `XCASE`
-pub const XCASE: c::c_uint = linux_raw_sys::general::XCASE;
-
-/// `ECHOCTL`
-pub const ECHOCTL: c::c_uint = linux_raw_sys::general::ECHOCTL;
-
-/// `ECHOPRT`
-pub const ECHOPRT: c::c_uint = linux_raw_sys::general::ECHOPRT;
-
-/// `ECHOKE`
-pub const ECHOKE: c::c_uint = linux_raw_sys::general::ECHOKE;
-
-/// `FLUSHO`
-pub const FLUSHO: c::c_uint = linux_raw_sys::general::FLUSHO;
-
-/// `PENDIN`
-pub const PENDIN: c::c_uint = linux_raw_sys::general::PENDIN;
-
-/// `EXTPROC`
-pub const EXTPROC: c::c_uint = linux_raw_sys::general::EXTPROC;
-
-/// `XTABS`
-pub const XTABS: c::c_uint = linux_raw_sys::general::XTABS;
diff --git a/vendor/rustix/src/backend/linux_raw/thread/futex.rs b/vendor/rustix/src/backend/linux_raw/thread/futex.rs
index 9e087f9f1..4cde309a5 100644
--- a/vendor/rustix/src/backend/linux_raw/thread/futex.rs
+++ b/vendor/rustix/src/backend/linux_raw/thread/futex.rs
@@ -1,7 +1,9 @@
 bitflags::bitflags! {
-    /// Flags for use with [`futex`].
+    /// `FUTEX_*` flags for use with [`futex`].
     ///
     /// [`futex`]: crate::thread::futex
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct FutexFlags: u32 {
         /// `FUTEX_PRIVATE_FLAG`
         const PRIVATE = linux_raw_sys::general::FUTEX_PRIVATE_FLAG;
@@ -10,7 +12,7 @@ bitflags::bitflags! {
     }
 }
 
-/// Operations for use with [`futex`].
+/// `FUTEX_*` operations for use with [`futex`].
 ///
 /// [`futex`]: crate::thread::futex
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
diff --git a/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs b/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs
index 1895c8c6d..f23b7c2df 100644
--- a/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs
@@ -6,20 +6,19 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-use super::super::c;
-use super::super::conv::{
-    by_ref, c_int, c_uint, ret, ret_c_int, ret_usize, ret_usize_infallible, zero,
+use crate::backend::c;
+use crate::backend::conv::{
+    by_mut, by_ref, c_int, c_uint, ret, ret_c_int, ret_c_int_infallible, ret_usize,
+    slice_just_addr, slice_just_addr_mut, zero,
 };
 use crate::fd::BorrowedFd;
 use crate::io;
-use crate::process::{Pid, RawNonZeroPid};
+use crate::pid::Pid;
 use crate::thread::{ClockId, FutexFlags, FutexOperation, NanosleepRelativeResult, Timespec};
 use core::mem::MaybeUninit;
-use linux_raw_sys::general::{__kernel_pid_t, __kernel_timespec, TIMER_ABSTIME};
 #[cfg(target_pointer_width = "32")]
-use {
-    core::convert::TryInto, core::ptr, linux_raw_sys::general::timespec as __kernel_old_timespec,
-};
+use linux_raw_sys::general::timespec as __kernel_old_timespec;
+use linux_raw_sys::general::{__kernel_timespec, TIMER_ABSTIME};
 
 #[inline]
 pub(crate) fn clock_nanosleep_relative(
@@ -86,14 +85,10 @@ unsafe fn clock_nanosleep_relative_old(
         &mut old_rem
     ))?;
     let old_rem = old_rem.assume_init();
-    // TODO: With Rust 1.55, we can use MaybeUninit::write here.
-    ptr::write(
-        rem.as_mut_ptr(),
-        __kernel_timespec {
-            tv_sec: old_rem.tv_sec.into(),
-            tv_nsec: old_rem.tv_nsec.into(),
-        },
-    );
+    rem.write(__kernel_timespec {
+        tv_sec: old_rem.tv_sec.into(),
+        tv_nsec: old_rem.tv_nsec.into(),
+    });
     Ok(())
 }
 
@@ -194,23 +189,18 @@ unsafe fn nanosleep_old(
     let mut old_rem = MaybeUninit::<__kernel_old_timespec>::uninit();
     ret(syscall!(__NR_nanosleep, by_ref(&old_req), &mut old_rem))?;
     let old_rem = old_rem.assume_init();
-    // TODO: With Rust 1.55, we can use MaybeUninit::write here.
-    ptr::write(
-        rem.as_mut_ptr(),
-        __kernel_timespec {
-            tv_sec: old_rem.tv_sec.into(),
-            tv_nsec: old_rem.tv_nsec.into(),
-        },
-    );
+    rem.write(__kernel_timespec {
+        tv_sec: old_rem.tv_sec.into(),
+        tv_nsec: old_rem.tv_nsec.into(),
+    });
     Ok(())
 }
 
 #[inline]
 pub(crate) fn gettid() -> Pid {
     unsafe {
-        let tid: i32 = ret_usize_infallible(syscall_readonly!(__NR_gettid)) as __kernel_pid_t;
-        debug_assert_ne!(tid, 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(tid as u32))
+        let tid = ret_c_int_infallible(syscall_readonly!(__NR_gettid));
+        Pid::from_raw_unchecked(tid)
     }
 }
 
@@ -283,48 +273,48 @@ unsafe fn futex_old(
     ))
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 #[inline]
 pub(crate) fn setns(fd: BorrowedFd, nstype: c::c_int) -> io::Result<c::c_int> {
     unsafe { ret_c_int(syscall_readonly!(__NR_setns, fd, c_int(nstype))) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 #[inline]
 pub(crate) fn unshare(flags: crate::thread::UnshareFlags) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_unshare, c_uint(flags.bits()))) }
+    unsafe { ret(syscall_readonly!(__NR_unshare, flags)) }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 #[inline]
 pub(crate) fn capget(
     header: &mut linux_raw_sys::general::__user_cap_header_struct,
     data: &mut [MaybeUninit<linux_raw_sys::general::__user_cap_data_struct>],
 ) -> io::Result<()> {
-    let header: *mut _ = header;
-    unsafe { ret(syscall!(__NR_capget, header, data)) }
+    unsafe {
+        ret(syscall!(
+            __NR_capget,
+            by_mut(header),
+            slice_just_addr_mut(data)
+        ))
+    }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
 #[inline]
 pub(crate) fn capset(
     header: &mut linux_raw_sys::general::__user_cap_header_struct,
     data: &[linux_raw_sys::general::__user_cap_data_struct],
 ) -> io::Result<()> {
-    let header: *mut _ = header;
-    unsafe { ret(syscall!(__NR_capset, header, data.as_ptr())) }
+    unsafe { ret(syscall!(__NR_capset, by_mut(header), slice_just_addr(data))) }
 }
 
 #[inline]
-pub(crate) fn setuid_thread(uid: crate::process::Uid) -> io::Result<()> {
+pub(crate) fn setuid_thread(uid: crate::ugid::Uid) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_setuid, uid)) }
 }
 
 #[inline]
 pub(crate) fn setresuid_thread(
-    ruid: crate::process::Uid,
-    euid: crate::process::Uid,
-    suid: crate::process::Uid,
+    ruid: crate::ugid::Uid,
+    euid: crate::ugid::Uid,
+    suid: crate::ugid::Uid,
 ) -> io::Result<()> {
     #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))]
     unsafe {
@@ -337,15 +327,15 @@ pub(crate) fn setresuid_thread(
 }
 
 #[inline]
-pub(crate) fn setgid_thread(gid: crate::process::Gid) -> io::Result<()> {
+pub(crate) fn setgid_thread(gid: crate::ugid::Gid) -> io::Result<()> {
     unsafe { ret(syscall_readonly!(__NR_setgid, gid)) }
 }
 
 #[inline]
 pub(crate) fn setresgid_thread(
-    rgid: crate::process::Gid,
-    egid: crate::process::Gid,
-    sgid: crate::process::Gid,
+    rgid: crate::ugid::Gid,
+    egid: crate::ugid::Gid,
+    sgid: crate::ugid::Gid,
 ) -> io::Result<()> {
     #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))]
     unsafe {
diff --git a/vendor/rustix/src/backend/linux_raw/time/syscalls.rs b/vendor/rustix/src/backend/linux_raw/time/syscalls.rs
index c039393ef..634ce2674 100644
--- a/vendor/rustix/src/backend/linux_raw/time/syscalls.rs
+++ b/vendor/rustix/src/backend/linux_raw/time/syscalls.rs
@@ -6,34 +6,32 @@
 #![allow(unsafe_code)]
 #![allow(clippy::undocumented_unsafe_blocks)]
 
-#[cfg(feature = "time")]
-use super::super::conv::{by_ref, ret_owned_fd};
-use super::super::conv::{ret, ret_infallible};
-use super::types::ClockId;
-#[cfg(feature = "time")]
-use crate::fd::BorrowedFd;
-#[cfg(feature = "time")]
-use crate::fd::OwnedFd;
+use crate::backend::conv::{ret, ret_infallible};
+use crate::clockid::ClockId;
 use crate::io;
-#[cfg(feature = "time")]
-use crate::time::{Itimerspec, TimerfdClockId, TimerfdFlags, TimerfdTimerFlags};
+use crate::timespec::Timespec;
 use core::mem::MaybeUninit;
-use linux_raw_sys::general::__kernel_timespec;
-#[cfg(feature = "time")]
+#[cfg(all(feature = "time", target_pointer_width = "32"))]
+use linux_raw_sys::general::itimerspec as __kernel_old_itimerspec;
 #[cfg(target_pointer_width = "32")]
-use {core::convert::TryInto, linux_raw_sys::general::itimerspec as __kernel_old_itimerspec};
-#[cfg(target_pointer_width = "32")]
-use {core::ptr, linux_raw_sys::general::timespec as __kernel_old_timespec};
+use linux_raw_sys::general::timespec as __kernel_old_timespec;
+#[cfg(feature = "time")]
+use {
+    crate::backend::conv::{by_ref, ret_owned_fd},
+    crate::fd::BorrowedFd,
+    crate::fd::OwnedFd,
+    crate::time::{Itimerspec, TimerfdClockId, TimerfdFlags, TimerfdTimerFlags},
+};
 
 // `clock_gettime` has special optimizations via the vDSO.
 #[cfg(feature = "time")]
-pub(crate) use super::super::vdso_wrappers::{clock_gettime, clock_gettime_dynamic};
+pub(crate) use crate::backend::vdso_wrappers::{clock_gettime, clock_gettime_dynamic};
 
 #[inline]
-pub(crate) fn clock_getres(which_clock: ClockId) -> __kernel_timespec {
+pub(crate) fn clock_getres(which_clock: ClockId) -> Timespec {
     #[cfg(target_pointer_width = "32")]
     unsafe {
-        let mut result = MaybeUninit::<__kernel_timespec>::uninit();
+        let mut result = MaybeUninit::<Timespec>::uninit();
         if let Err(err) = ret(syscall!(__NR_clock_getres_time64, which_clock, &mut result)) {
             // See the comments in `rustix_clock_gettime_via_syscall` about
             // emulation.
@@ -44,30 +42,28 @@ pub(crate) fn clock_getres(which_clock: ClockId) -> __kernel_timespec {
     }
     #[cfg(target_pointer_width = "64")]
     unsafe {
-        let mut result = MaybeUninit::<__kernel_timespec>::uninit();
+        let mut result = MaybeUninit::<Timespec>::uninit();
         ret_infallible(syscall!(__NR_clock_getres, which_clock, &mut result));
         result.assume_init()
     }
 }
 
 #[cfg(target_pointer_width = "32")]
-unsafe fn clock_getres_old(which_clock: ClockId, result: &mut MaybeUninit<__kernel_timespec>) {
+unsafe fn clock_getres_old(which_clock: ClockId, result: &mut MaybeUninit<Timespec>) {
     let mut old_result = MaybeUninit::<__kernel_old_timespec>::uninit();
     ret_infallible(syscall!(__NR_clock_getres, which_clock, &mut old_result));
     let old_result = old_result.assume_init();
-    // TODO: With Rust 1.55, we can use MaybeUninit::write here.
-    ptr::write(
-        result.as_mut_ptr(),
-        __kernel_timespec {
-            tv_sec: old_result.tv_sec.into(),
-            tv_nsec: old_result.tv_nsec.into(),
-        },
-    );
+    result.write(Timespec {
+        tv_sec: old_result.tv_sec.into(),
+        tv_nsec: old_result.tv_nsec.into(),
+    });
 }
 
 #[cfg(feature = "time")]
 #[inline]
-pub(crate) fn clock_settime(which_clock: ClockId, timespec: __kernel_timespec) -> io::Result<()> {
+pub(crate) fn clock_settime(which_clock: ClockId, timespec: Timespec) -> io::Result<()> {
+    // `clock_settime64` was introduced in Linux 5.1. The old `clock_settime`
+    // syscall is not y2038-compatible on 32-bit architectures.
     #[cfg(target_pointer_width = "32")]
     unsafe {
         match ret(syscall_readonly!(
@@ -91,7 +87,7 @@ pub(crate) fn clock_settime(which_clock: ClockId, timespec: __kernel_timespec) -
 
 #[cfg(feature = "time")]
 #[cfg(target_pointer_width = "32")]
-unsafe fn clock_settime_old(which_clock: ClockId, timespec: __kernel_timespec) -> io::Result<()> {
+unsafe fn clock_settime_old(which_clock: ClockId, timespec: Timespec) -> io::Result<()> {
     let old_timespec = __kernel_old_timespec {
         tv_sec: timespec
             .tv_sec
@@ -200,20 +196,16 @@ unsafe fn timerfd_settime_old(
         &mut old_result
     ))?;
     let old_result = old_result.assume_init();
-    // TODO: With Rust 1.55, we can use MaybeUninit::write here.
-    ptr::write(
-        result.as_mut_ptr(),
-        Itimerspec {
-            it_interval: __kernel_timespec {
-                tv_sec: old_result.it_interval.tv_sec.into(),
-                tv_nsec: old_result.it_interval.tv_nsec.into(),
-            },
-            it_value: __kernel_timespec {
-                tv_sec: old_result.it_value.tv_sec.into(),
-                tv_nsec: old_result.it_value.tv_nsec.into(),
-            },
+    result.write(Itimerspec {
+        it_interval: Timespec {
+            tv_sec: old_result.it_interval.tv_sec.into(),
+            tv_nsec: old_result.it_interval.tv_nsec.into(),
         },
-    );
+        it_value: Timespec {
+            tv_sec: old_result.it_value.tv_sec.into(),
+            tv_nsec: old_result.it_value.tv_nsec.into(),
+        },
+    });
     Ok(())
 }
 
@@ -252,19 +244,15 @@ unsafe fn timerfd_gettime_old(
     let mut old_result = MaybeUninit::<__kernel_old_itimerspec>::uninit();
     ret(syscall!(__NR_timerfd_gettime, fd, &mut old_result))?;
     let old_result = old_result.assume_init();
-    // TODO: With Rust 1.55, we can use MaybeUninit::write here.
-    ptr::write(
-        result.as_mut_ptr(),
-        Itimerspec {
-            it_interval: __kernel_timespec {
-                tv_sec: old_result.it_interval.tv_sec.into(),
-                tv_nsec: old_result.it_interval.tv_nsec.into(),
-            },
-            it_value: __kernel_timespec {
-                tv_sec: old_result.it_value.tv_sec.into(),
-                tv_nsec: old_result.it_value.tv_nsec.into(),
-            },
+    result.write(Itimerspec {
+        it_interval: Timespec {
+            tv_sec: old_result.it_interval.tv_sec.into(),
+            tv_nsec: old_result.it_interval.tv_nsec.into(),
+        },
+        it_value: Timespec {
+            tv_sec: old_result.it_value.tv_sec.into(),
+            tv_nsec: old_result.it_value.tv_nsec.into(),
         },
-    );
+    });
     Ok(())
 }
diff --git a/vendor/rustix/src/backend/linux_raw/time/types.rs b/vendor/rustix/src/backend/linux_raw/time/types.rs
index fcdd7f6d6..62cb167e6 100644
--- a/vendor/rustix/src/backend/linux_raw/time/types.rs
+++ b/vendor/rustix/src/backend/linux_raw/time/types.rs
@@ -1,16 +1,6 @@
-use super::super::c;
-use crate::fd::BorrowedFd;
+use crate::backend::c;
 use bitflags::bitflags;
 
-/// `struct timespec`
-pub type Timespec = linux_raw_sys::general::__kernel_timespec;
-
-/// A type for the `tv_sec` field of [`Timespec`].
-pub type Secs = linux_raw_sys::general::__kernel_time64_t;
-
-/// A type for the `tv_nsec` field of [`Timespec`].
-pub type Nsecs = i64;
-
 /// `struct itimerspec` for use with [`timerfd_gettime`] and
 /// [`timerfd_settime`].
 ///
@@ -18,73 +8,12 @@ pub type Nsecs = i64;
 /// [`timerfd_settime`]: crate::time::timerfd_settime
 pub type Itimerspec = linux_raw_sys::general::__kernel_itimerspec;
 
-/// `CLOCK_*` constants for use with [`clock_gettime`].
-///
-/// These constants are always supported at runtime, so `clock_gettime` never
-/// has to fail with `INVAL` due to an unsupported clock. See
-/// [`DynamicClockId`] for a greater set of clocks, with the caveat that not
-/// all of them are always supported.
-///
-/// [`clock_gettime`]: crate::time::clock_gettime
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-#[repr(u32)]
-#[non_exhaustive]
-pub enum ClockId {
-    /// `CLOCK_REALTIME`
-    Realtime = linux_raw_sys::general::CLOCK_REALTIME,
-
-    /// `CLOCK_MONOTONIC`
-    Monotonic = linux_raw_sys::general::CLOCK_MONOTONIC,
-
-    /// `CLOCK_PROCESS_CPUTIME_ID`
-    ProcessCPUTime = linux_raw_sys::general::CLOCK_PROCESS_CPUTIME_ID,
-
-    /// `CLOCK_THREAD_CPUTIME_ID`
-    ThreadCPUTime = linux_raw_sys::general::CLOCK_THREAD_CPUTIME_ID,
-
-    /// `CLOCK_REALTIME_COARSE`
-    RealtimeCoarse = linux_raw_sys::general::CLOCK_REALTIME_COARSE,
-
-    /// `CLOCK_MONOTONIC_COARSE`
-    MonotonicCoarse = linux_raw_sys::general::CLOCK_MONOTONIC_COARSE,
-
-    /// `CLOCK_MONOTONIC_RAW`
-    MonotonicRaw = linux_raw_sys::general::CLOCK_MONOTONIC_RAW,
-}
-
-/// `CLOCK_*` constants for use with [`clock_gettime_dynamic`].
-///
-/// These constants may be unsupported at runtime, depending on the OS version,
-/// and `clock_gettime_dynamic` may fail with `INVAL`. See [`ClockId`] for
-/// clocks which are always supported at runtime.
-///
-/// [`clock_gettime_dynamic`]: crate::time::clock_gettime_dynamic
-#[derive(Debug, Copy, Clone)]
-#[non_exhaustive]
-pub enum DynamicClockId<'a> {
-    /// `ClockId` values that are always supported at runtime.
-    Known(ClockId),
-
-    /// Linux dynamic clocks.
-    Dynamic(BorrowedFd<'a>),
-
-    /// `CLOCK_REALTIME_ALARM`, available on Linux >= 3.0
-    RealtimeAlarm,
-
-    /// `CLOCK_TAI`, available on Linux >= 3.10
-    Tai,
-
-    /// `CLOCK_BOOTTIME`, available on Linux >= 2.6.39
-    Boottime,
-
-    /// `CLOCK_BOOTTIME_ALARM`, available on Linux >= 2.6.39
-    BoottimeAlarm,
-}
-
 bitflags! {
     /// `TFD_*` flags for use with [`timerfd_create`].
     ///
     /// [`timerfd_create`]: crate::time::timerfd_create
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct TimerfdFlags: c::c_uint {
         /// `TFD_NONBLOCK`
         const NONBLOCK = linux_raw_sys::general::TFD_NONBLOCK;
@@ -98,6 +27,8 @@ bitflags! {
     /// `TFD_TIMER_*` flags for use with [`timerfd_settime`].
     ///
     /// [`timerfd_settime`]: crate::time::timerfd_settime
+    #[repr(transparent)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct TimerfdTimerFlags: c::c_uint {
         /// `TFD_TIMER_ABSTIME`
         const ABSTIME = linux_raw_sys::general::TFD_TIMER_ABSTIME;
diff --git a/vendor/rustix/src/backend/linux_raw/ugid/mod.rs b/vendor/rustix/src/backend/linux_raw/ugid/mod.rs
new file mode 100644
index 000000000..ef944f04d
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/ugid/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/linux_raw/ugid/syscalls.rs b/vendor/rustix/src/backend/linux_raw/ugid/syscalls.rs
new file mode 100644
index 000000000..12ff6dce1
--- /dev/null
+++ b/vendor/rustix/src/backend/linux_raw/ugid/syscalls.rs
@@ -0,0 +1,67 @@
+//! linux_raw syscalls for UIDs and GIDs
+//!
+//! # Safety
+//!
+//! See the `rustix::backend` module documentation for details.
+#![allow(unsafe_code)]
+#![allow(clippy::undocumented_unsafe_blocks)]
+
+use crate::backend::c;
+use crate::backend::conv::ret_usize_infallible;
+use crate::ugid::{Gid, Uid};
+
+#[inline]
+pub(crate) fn getuid() -> Uid {
+    #[cfg(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86"))]
+    unsafe {
+        let uid = ret_usize_infallible(syscall_readonly!(__NR_getuid32)) as c::uid_t;
+        Uid::from_raw(uid)
+    }
+    #[cfg(not(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86")))]
+    unsafe {
+        let uid = ret_usize_infallible(syscall_readonly!(__NR_getuid)) as c::uid_t;
+        Uid::from_raw(uid)
+    }
+}
+
+#[inline]
+pub(crate) fn geteuid() -> Uid {
+    #[cfg(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86"))]
+    unsafe {
+        let uid = ret_usize_infallible(syscall_readonly!(__NR_geteuid32)) as c::uid_t;
+        Uid::from_raw(uid)
+    }
+    #[cfg(not(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86")))]
+    unsafe {
+        let uid = ret_usize_infallible(syscall_readonly!(__NR_geteuid)) as c::uid_t;
+        Uid::from_raw(uid)
+    }
+}
+
+#[inline]
+pub(crate) fn getgid() -> Gid {
+    #[cfg(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86"))]
+    unsafe {
+        let gid = ret_usize_infallible(syscall_readonly!(__NR_getgid32)) as c::gid_t;
+        Gid::from_raw(gid)
+    }
+    #[cfg(not(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86")))]
+    unsafe {
+        let gid = ret_usize_infallible(syscall_readonly!(__NR_getgid)) as c::gid_t;
+        Gid::from_raw(gid)
+    }
+}
+
+#[inline]
+pub(crate) fn getegid() -> Gid {
+    #[cfg(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86"))]
+    unsafe {
+        let gid = ret_usize_infallible(syscall_readonly!(__NR_getegid32)) as c::gid_t;
+        Gid::from_raw(gid)
+    }
+    #[cfg(not(any(target_arch = "arm", target_arch = "sparc", target_arch = "x86")))]
+    unsafe {
+        let gid = ret_usize_infallible(syscall_readonly!(__NR_getegid)) as c::gid_t;
+        Gid::from_raw(gid)
+    }
+}
diff --git a/vendor/rustix/src/backend/linux_raw/vdso_wrappers.rs b/vendor/rustix/src/backend/linux_raw/vdso_wrappers.rs
index 97d5862a0..422793690 100644
--- a/vendor/rustix/src/backend/linux_raw/vdso_wrappers.rs
+++ b/vendor/rustix/src/backend/linux_raw/vdso_wrappers.rs
@@ -9,22 +9,30 @@
 //! functions.
 #![allow(unsafe_code)]
 
-use super::conv::{c_int, ret};
 #[cfg(target_arch = "x86")]
 use super::reg::{ArgReg, RetReg, SyscallNumber, A0, A1, A2, A3, A4, A5, R0};
-use super::time::types::{ClockId, DynamicClockId, Timespec};
-use super::{c, vdso};
-use crate::io;
+use super::vdso;
 #[cfg(all(asm, target_arch = "x86"))]
 use core::arch::asm;
-use core::mem::{transmute, MaybeUninit};
+use core::mem::transmute;
 use core::ptr::null_mut;
 use core::sync::atomic::AtomicPtr;
 use core::sync::atomic::Ordering::Relaxed;
 #[cfg(target_pointer_width = "32")]
+#[cfg(feature = "time")]
 use linux_raw_sys::general::timespec as __kernel_old_timespec;
-use linux_raw_sys::general::{__kernel_clockid_t, __kernel_timespec};
-
+#[cfg(feature = "time")]
+use {
+    super::c,
+    super::conv::{c_int, ret},
+    crate::clockid::{ClockId, DynamicClockId},
+    crate::io,
+    crate::timespec::Timespec,
+    core::mem::MaybeUninit,
+    linux_raw_sys::general::{__kernel_clockid_t, __kernel_timespec},
+};
+
+#[cfg(feature = "time")]
 #[inline]
 pub(crate) fn clock_gettime(which_clock: ClockId) -> __kernel_timespec {
     // SAFETY: `CLOCK_GETTIME` contains either null or the address of a
@@ -42,6 +50,7 @@ pub(crate) fn clock_gettime(which_clock: ClockId) -> __kernel_timespec {
     }
 }
 
+#[cfg(feature = "time")]
 #[inline]
 pub(crate) fn clock_gettime_dynamic(which_clock: DynamicClockId<'_>) -> io::Result<Timespec> {
     let id = match which_clock {
@@ -198,6 +207,7 @@ pub(super) mod x86_via_vdso {
 
     // With the indirect call, it isn't meaningful to do a separate
     // `_readonly` optimization.
+    #[allow(unused_imports)]
     pub(in crate::backend) use {
         syscall0 as syscall0_readonly, syscall1 as syscall1_readonly,
         syscall2 as syscall2_readonly, syscall3 as syscall3_readonly,
@@ -206,6 +216,7 @@ pub(super) mod x86_via_vdso {
     };
 }
 
+#[cfg(feature = "time")]
 type ClockGettimeType = unsafe extern "C" fn(c::c_int, *mut Timespec) -> c::c_int;
 
 /// The underlying syscall functions are only called from asm, using the
@@ -215,6 +226,7 @@ type ClockGettimeType = unsafe extern "C" fn(c::c_int, *mut Timespec) -> c::c_in
 pub(super) type SyscallType = unsafe extern "C" fn();
 
 /// Initialize `CLOCK_GETTIME` and return its value.
+#[cfg(feature = "time")]
 fn init_clock_gettime() -> ClockGettimeType {
     init();
     // SAFETY: Load the function address from static storage that we
@@ -234,10 +246,12 @@ fn init_syscall() -> SyscallType {
 /// `AtomicPtr` can't hold a `fn` pointer, so we use a `*` pointer to this
 /// placeholder type, and cast it as needed.
 struct Function;
+#[cfg(feature = "time")]
 static mut CLOCK_GETTIME: AtomicPtr<Function> = AtomicPtr::new(null_mut());
 #[cfg(target_arch = "x86")]
 static mut SYSCALL: AtomicPtr<Function> = AtomicPtr::new(null_mut());
 
+#[cfg(feature = "time")]
 unsafe extern "C" fn rustix_clock_gettime_via_syscall(
     clockid: c::c_int,
     res: *mut Timespec,
@@ -248,6 +262,7 @@ unsafe extern "C" fn rustix_clock_gettime_via_syscall(
     }
 }
 
+#[cfg(feature = "time")]
 #[cfg(target_pointer_width = "32")]
 unsafe fn _rustix_clock_gettime_via_syscall(
     clockid: c::c_int,
@@ -260,6 +275,7 @@ unsafe fn _rustix_clock_gettime_via_syscall(
     }
 }
 
+#[cfg(feature = "time")]
 #[cfg(target_pointer_width = "32")]
 unsafe fn _rustix_clock_gettime_via_syscall_old(
     clockid: c::c_int,
@@ -285,6 +301,7 @@ unsafe fn _rustix_clock_gettime_via_syscall_old(
     }
 }
 
+#[cfg(feature = "time")]
 #[cfg(target_pointer_width = "64")]
 unsafe fn _rustix_clock_gettime_via_syscall(
     clockid: c::c_int,
@@ -314,14 +331,18 @@ fn minimal_init() {
     // If the memory happens to already be initialized, this is redundant, but
     // not harmful.
     unsafe {
-        CLOCK_GETTIME
-            .compare_exchange(
-                null_mut(),
-                rustix_clock_gettime_via_syscall as *mut Function,
-                Relaxed,
-                Relaxed,
-            )
-            .ok();
+        #[cfg(feature = "time")]
+        {
+            CLOCK_GETTIME
+                .compare_exchange(
+                    null_mut(),
+                    rustix_clock_gettime_via_syscall as *mut Function,
+                    Relaxed,
+                    Relaxed,
+                )
+                .ok();
+        }
+
         #[cfg(target_arch = "x86")]
         {
             SYSCALL
@@ -340,46 +361,49 @@ fn init() {
     minimal_init();
 
     if let Some(vdso) = vdso::Vdso::new() {
-        // Look up the platform-specific `clock_gettime` symbol as documented
-        // [here], except on 32-bit platforms where we look up the
-        // `64`-suffixed variant and fail if we don't find it.
-        //
-        // [here]: https://man7.org/linux/man-pages/man7/vdso.7.html
-        #[cfg(target_arch = "x86_64")]
-        let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime"));
-        #[cfg(target_arch = "arm")]
-        let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime64"));
-        #[cfg(target_arch = "aarch64")]
-        let ptr = vdso.sym(cstr!("LINUX_2.6.39"), cstr!("__kernel_clock_gettime"));
-        #[cfg(target_arch = "x86")]
-        let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime64"));
-        #[cfg(target_arch = "riscv64")]
-        let ptr = vdso.sym(cstr!("LINUX_4.15"), cstr!("__vdso_clock_gettime"));
-        #[cfg(target_arch = "powerpc64")]
-        let ptr = vdso.sym(cstr!("LINUX_2.6.15"), cstr!("__kernel_clock_gettime"));
-        #[cfg(target_arch = "mips")]
-        let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime64"));
-        #[cfg(target_arch = "mips64")]
-        let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime"));
-
-        // On all 64-bit platforms, the 64-bit `clock_gettime` symbols are
-        // always available.
-        #[cfg(target_pointer_width = "64")]
-        let ok = true;
-
-        // On some 32-bit platforms, the 64-bit `clock_gettime` symbols are not
-        // available on older kernel versions.
-        #[cfg(any(target_arch = "arm", target_arch = "mips", target_arch = "x86"))]
-        let ok = !ptr.is_null();
-
-        if ok {
-            assert!(!ptr.is_null());
-
-            // SAFETY: Store the computed function addresses in static storage
-            // so that we don't need to compute it again (but if we do, it doesn't
-            // hurt anything).
-            unsafe {
-                CLOCK_GETTIME.store(ptr.cast(), Relaxed);
+        #[cfg(feature = "time")]
+        {
+            // Look up the platform-specific `clock_gettime` symbol as documented
+            // [here], except on 32-bit platforms where we look up the
+            // `64`-suffixed variant and fail if we don't find it.
+            //
+            // [here]: https://man7.org/linux/man-pages/man7/vdso.7.html
+            #[cfg(target_arch = "x86_64")]
+            let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime"));
+            #[cfg(target_arch = "arm")]
+            let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime64"));
+            #[cfg(target_arch = "aarch64")]
+            let ptr = vdso.sym(cstr!("LINUX_2.6.39"), cstr!("__kernel_clock_gettime"));
+            #[cfg(target_arch = "x86")]
+            let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime64"));
+            #[cfg(target_arch = "riscv64")]
+            let ptr = vdso.sym(cstr!("LINUX_4.15"), cstr!("__vdso_clock_gettime"));
+            #[cfg(target_arch = "powerpc64")]
+            let ptr = vdso.sym(cstr!("LINUX_2.6.15"), cstr!("__kernel_clock_gettime"));
+            #[cfg(target_arch = "mips")]
+            let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime64"));
+            #[cfg(target_arch = "mips64")]
+            let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime"));
+
+            // On all 64-bit platforms, the 64-bit `clock_gettime` symbols are
+            // always available.
+            #[cfg(target_pointer_width = "64")]
+            let ok = true;
+
+            // On some 32-bit platforms, the 64-bit `clock_gettime` symbols are not
+            // available on older kernel versions.
+            #[cfg(any(target_arch = "arm", target_arch = "mips", target_arch = "x86"))]
+            let ok = !ptr.is_null();
+
+            if ok {
+                assert!(!ptr.is_null());
+
+                // SAFETY: Store the computed function addresses in static storage
+                // so that we don't need to compute it again (but if we do, it
+                // doesn't hurt anything).
+                unsafe {
+                    CLOCK_GETTIME.store(ptr.cast(), Relaxed);
+                }
             }
         }