Deleted vendor folder

162 files changed, 0 insertions, 34317 deletions

diff --git a/vendor/rustix/src/backend/libc/c.rs b/vendor/rustix/src/backend/libc/c.rs
deleted file mode 100644
index d3a1e5f..0000000
--- a/vendor/rustix/src/backend/libc/c.rs
+++ /dev/null
@@ -1,468 +0,0 @@
-//! Libc and supplemental types and constants.
-
-#![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(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(linux_kernel, target_env = "musl"))]
-pub(crate) const NFS_SUPER_MAGIC: u32 = 0x0000_6969;
-
-#[cfg(feature = "process")]
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) const EXIT_SIGNALED_SIGABRT: c_int = 128 + SIGABRT as c_int;
-
-// 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 = "mips32r6",
-        target_arch = "mips64",
-        target_arch = "mips64r6",
-        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 _;
-
-#[cfg(target_os = "aix")]
-pub(crate) const MSG_DONTWAIT: c_int = libc::MSG_NONBLOCK;
-
-// TODO: Remove once https://github.com/rust-lang/libc/pull/3377 is merged and released.
-#[cfg(target_os = "netbsd")]
-#[cfg(feature = "net")]
-pub(crate) const SO_NOSIGPIPE: c_int = 0x0800;
-
-// 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(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 = "hurd",
-    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};
-// TODO: AIX has `stat64x`, `fstat64x`, `lstat64x`, and `stat64xat`; add them
-// to the upstream libc crate and implement rustix's `statat` etc. with them.
-#[cfg(target_os = "aix")]
-pub(super) use libc::{
-    blksize64_t as blksize_t, fstat64 as fstat, fstatfs64 as fstatfs, fstatvfs64 as fstatvfs,
-    ftruncate64 as ftruncate, getrlimit64 as getrlimit, ino_t, lseek64 as lseek, mmap,
-    off64_t as off_t, openat, posix_fadvise64 as posix_fadvise, preadv, pwritev,
-    rlimit64 as rlimit, setrlimit64 as setrlimit, stat64at as fstatat, statfs64 as statfs,
-    statvfs64 as statvfs, RLIM_INFINITY,
-};
-#[cfg(any(linux_like, target_os = "hurd"))]
-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",
-        target_arch = "mips64r6"
-    )
-)))]
-#[cfg(any(linux_like, target_os = "aix", target_os = "hurd"))]
-pub(super) use libc::{lstat64 as lstat, stat64 as stat};
-#[cfg(any(
-    linux_kernel,
-    target_os = "aix",
-    target_os = "hurd",
-    target_os = "emscripten"
-))]
-pub(super) use libc::{pread64 as pread, pwrite64 as pwrite};
-#[cfg(any(target_os = "linux", target_os = "hurd", 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)
-}
-
-#[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 {
-            // Unlike the plain "p" functions, the "pv" functions pass their
-            // offset in an endian-independent way, and always in two registers.
-            syscall! {
-                fn preadv(
-                    fd: libc::c_int,
-                    iov: *const libc::iovec,
-                    iovcnt: libc::c_int,
-                    offset_lo: usize,
-                    offset_hi: usize
-                ) via SYS_preadv -> libc::ssize_t
-            }
-            preadv(fd, iov, iovcnt, offset as usize, (offset >> 32) as usize)
-        }
-    }
-    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 {
-            // Unlike the plain "p" functions, the "pv" functions pass their
-            // offset in an endian-independent way, and always in two registers.
-            syscall! {
-                fn pwritev(
-                    fd: libc::c_int,
-                    iov: *const libc::iovec,
-                    iovcnt: libc::c_int,
-                    offset_lo: usize,
-                    offset_hi: usize
-                ) via SYS_pwritev -> libc::ssize_t
-            }
-            pwritev(fd, iov, iovcnt, offset as usize, (offset >> 32) as usize)
-        }
-    }
-}
-#[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 {
-            // Unlike the plain "p" functions, the "pv" functions pass their
-            // offset in an endian-independent way, and always in two registers.
-            syscall! {
-                fn preadv2(
-                    fd: libc::c_int,
-                    iov: *const libc::iovec,
-                    iovcnt: libc::c_int,
-                    offset_lo: usize,
-                    offset_hi: usize,
-                    flags: libc::c_int
-                ) via SYS_preadv2 -> libc::ssize_t
-            }
-            preadv2(
-                fd,
-                iov,
-                iovcnt,
-                offset as usize,
-                (offset >> 32) as usize,
-                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 {
-            // Unlike the plain "p" functions, the "pv" functions pass their
-            // offset in an endian-independent way, and always in two registers.
-            syscall! {
-                fn pwritev2(
-                    fd: libc::c_int,
-                    iov: *const libc::iovec,
-                    iovec: libc::c_int,
-                    offset_lo: usize,
-                    offset_hi: usize,
-                    flags: libc::c_int
-                ) via SYS_pwritev2 -> libc::ssize_t
-            }
-            pwritev2(
-                fd,
-                iov,
-                iovcnt,
-                offset as usize,
-                (offset >> 32) as usize,
-                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 {
-        // Unlike the plain "p" functions, the "pv" functions pass their offset
-        // in an endian-independent way, and always in two registers.
-        syscall! {
-            fn preadv2(
-                fd: libc::c_int,
-                iov: *const libc::iovec,
-                iovcnt: libc::c_int,
-                offset_lo: usize,
-                offset_hi: usize,
-                flags: libc::c_int
-            ) via SYS_preadv2 -> libc::ssize_t
-        }
-        preadv2(
-            fd,
-            iov,
-            iovcnt,
-            offset as usize,
-            (offset >> 32) as usize,
-            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 {
-        // Unlike the plain "p" functions, the "pv" functions pass their offset
-        // in an endian-independent way, and always in two registers.
-        syscall! {
-            fn pwritev2(
-                fd: libc::c_int,
-                iov: *const libc::iovec,
-                iovcnt: libc::c_int,
-                offset_lo: usize,
-                offset_hi: usize,
-                flags: libc::c_int
-            ) via SYS_pwritev2 -> libc::ssize_t
-        }
-        pwritev2(
-            fd,
-            iov,
-            iovcnt,
-            offset as usize,
-            (offset >> 32) as usize,
-            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
deleted file mode 100644
index 2539510..0000000
--- a/vendor/rustix/src/backend/libc/conv.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-//! Libc call arguments and return values are often things like `c_int`,
-//! `c_uint`, or libc-specific pointer types. This module provides functions
-//! for converting between rustix's types and libc types.
-
-use super::c;
-#[cfg(all(feature = "alloc", not(any(windows, target_os = "espidf"))))]
-use super::fd::IntoRawFd;
-use super::fd::{AsRawFd, BorrowedFd, FromRawFd, LibcFd, OwnedFd, RawFd};
-#[cfg(not(windows))]
-use crate::ffi::CStr;
-use crate::io;
-
-#[cfg(not(windows))]
-#[inline]
-pub(super) fn c_str(c: &CStr) -> *const c::c_char {
-    c.as_ptr()
-}
-
-#[cfg(not(any(windows, target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-#[inline]
-pub(super) fn no_fd() -> LibcFd {
-    -1
-}
-
-#[inline]
-pub(super) fn borrowed_fd(fd: BorrowedFd<'_>) -> LibcFd {
-    fd.as_raw_fd() as LibcFd
-}
-
-#[cfg(all(
-    feature = "alloc",
-    not(any(windows, target_os = "espidf", target_os = "redox"))
-))]
-#[inline]
-pub(super) fn owned_fd(fd: OwnedFd) -> LibcFd {
-    fd.into_raw_fd() as LibcFd
-}
-
-#[inline]
-pub(super) fn ret(raw: c::c_int) -> io::Result<()> {
-    if raw == 0 {
-        Ok(())
-    } else {
-        Err(io::Errno::last_os_error())
-    }
-}
-
-#[cfg(apple)]
-#[inline]
-pub(super) fn nonnegative_ret(raw: c::c_int) -> io::Result<()> {
-    if raw >= 0 {
-        Ok(())
-    } else {
-        Err(io::Errno::last_os_error())
-    }
-}
-
-#[cfg(not(any(windows, target_os = "wasi")))]
-#[inline]
-pub(super) unsafe fn ret_infallible(raw: c::c_int) {
-    debug_assert_eq!(raw, 0, "unexpected error: {:?}", io::Errno::last_os_error());
-}
-
-#[inline]
-pub(super) fn ret_c_int(raw: c::c_int) -> io::Result<c::c_int> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(raw)
-    }
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(super) fn ret_u32(raw: c::c_int) -> io::Result<u32> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(raw as u32)
-    }
-}
-
-#[inline]
-pub(super) fn ret_usize(raw: c::ssize_t) -> io::Result<usize> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        debug_assert!(raw >= 0);
-        Ok(raw as usize)
-    }
-}
-
-#[cfg(not(windows))]
-#[cfg(feature = "fs")]
-#[inline]
-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 {
-        Ok(raw)
-    }
-}
-
-#[cfg(not(any(windows, target_os = "wasi")))]
-#[inline]
-pub(super) fn ret_pid_t(raw: c::pid_t) -> io::Result<c::pid_t> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(raw)
-    }
-}
-
-/// Convert a `c_int` returned from a libc function to an `OwnedFd`, if valid.
-///
-/// # Safety
-///
-/// The caller must ensure that this is the return value of a libc function
-/// which returns an owned file descriptor.
-#[inline]
-pub(super) unsafe fn ret_owned_fd(raw: LibcFd) -> io::Result<OwnedFd> {
-    if raw == !0 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(OwnedFd::from_raw_fd(raw as RawFd))
-    }
-}
-
-#[cfg(not(any(windows, target_os = "wasi")))]
-#[inline]
-pub(super) fn ret_discarded_fd(raw: LibcFd) -> io::Result<()> {
-    if raw == !0 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(())
-    }
-}
-
-#[cfg(all(feature = "alloc", not(any(windows, target_os = "wasi"))))]
-#[inline]
-pub(super) fn ret_discarded_char_ptr(raw: *mut c::c_char) -> io::Result<()> {
-    if raw.is_null() {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(())
-    }
-}
-
-/// Convert the buffer-length argument value of a `send` or `recv` call.
-#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
-#[inline]
-pub(super) fn send_recv_len(len: usize) -> usize {
-    len
-}
-
-/// Convert the buffer-length argument value of a `send` or `recv` call.
-#[cfg(windows)]
-#[inline]
-pub(super) fn send_recv_len(len: usize) -> i32 {
-    // On Windows, the length argument has type `i32`; saturate the length,
-    // since `send` and `recv` are allowed to send and recv less data than
-    // requested.
-    len.try_into().unwrap_or(i32::MAX)
-}
-
-/// Convert the return value of a `send` or `recv` call.
-#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
-#[inline]
-pub(super) fn ret_send_recv(len: isize) -> io::Result<usize> {
-    ret_usize(len)
-}
-
-/// Convert the return value of a `send` or `recv` call.
-#[cfg(windows)]
-#[inline]
-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 = "espidf", target_os = "redox", 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 = "espidf",
-        target_os = "redox",
-        target_os = "vita",
-        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 = "aix",
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "haiku",
-    target_os = "nto",
-))]
-#[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,
-    windows,
-    target_env = "musl",
-    target_os = "aix",
-    target_os = "emscripten",
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "haiku",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-#[inline]
-pub(crate) fn msg_control_len(len: usize) -> c::size_t {
-    len
-}
diff --git a/vendor/rustix/src/backend/libc/event/epoll.rs b/vendor/rustix/src/backend/libc/event/epoll.rs
deleted file mode 100644
index ced3be1..0000000
--- a/vendor/rustix/src/backend/libc/event/epoll.rs
+++ /dev/null
@@ -1,496 +0,0 @@
-//! Linux `epoll` support.
-//!
-//! # Examples
-//!
-//! ```no_run
-//! # #[cfg(feature = "net")]
-//! # fn main() -> std::io::Result<()> {
-//! 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, 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, 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::create(epoll::CreateFlags::CLOEXEC)?;
-//!
-//! // Register the socket with the epoll object.
-//! 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 = epoll::EventData::new_u64(2);
-//! let mut sockets = HashMap::new();
-//!
-//! // Process events.
-//! let mut event_list = epoll::EventVec::with_capacity(4);
-//! loop {
-//!     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::add(
-//!                 &epoll,
-//!                 &conn_sock,
-//!                 next_id,
-//!                 epoll::EventFlags::OUT | epoll::EventFlags::ET,
-//!             )?;
-//!
-//!             // Keep track of the socket.
-//!             sockets.insert(next_id, conn_sock);
-//!             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::delete(&epoll, &target)?;
-//!         }
-//!     }
-//! }
-//! # }
-//! # #[cfg(not(feature = "net"))]
-//! # fn main() {}
-//! ```
-
-use crate::backend::c;
-#[cfg(feature = "alloc")]
-use crate::backend::conv::ret_u32;
-use crate::backend::conv::{ret, ret_owned_fd};
-use crate::fd::{AsFd, AsRawFd, OwnedFd};
-use crate::io;
-use crate::utils::as_mut_ptr;
-#[cfg(feature = "alloc")]
-use alloc::vec::Vec;
-use bitflags::bitflags;
-use core::ffi::c_void;
-use core::hash::{Hash, Hasher};
-use core::ptr::null_mut;
-use core::slice;
-
-bitflags! {
-    /// `EPOLL_*` for use with [`new`].
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct CreateFlags: u32 {
-        /// `EPOLL_CLOEXEC`
-        const CLOEXEC = bitcast!(c::EPOLL_CLOEXEC);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `EPOLL*` for use with [`add`].
-    #[repr(transparent)]
-    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct EventFlags: u32 {
-        /// `EPOLLIN`
-        const IN = bitcast!(c::EPOLLIN);
-
-        /// `EPOLLOUT`
-        const OUT = bitcast!(c::EPOLLOUT);
-
-        /// `EPOLLPRI`
-        const PRI = bitcast!(c::EPOLLPRI);
-
-        /// `EPOLLERR`
-        const ERR = bitcast!(c::EPOLLERR);
-
-        /// `EPOLLHUP`
-        const HUP = bitcast!(c::EPOLLHUP);
-
-        /// `EPOLLRDNORM`
-        const RDNORM = bitcast!(c::EPOLLRDNORM);
-
-        /// `EPOLLRDBAND`
-        const RDBAND = bitcast!(c::EPOLLRDBAND);
-
-        /// `EPOLLWRNORM`
-        const WRNORM = bitcast!(c::EPOLLWRNORM);
-
-        /// `EPOLLWRBAND`
-        const WRBAND = bitcast!(c::EPOLLWRBAND);
-
-        /// `EPOLLMSG`
-        const MSG = bitcast!(c::EPOLLMSG);
-
-        /// `EPOLLRDHUP`
-        const RDHUP = bitcast!(c::EPOLLRDHUP);
-
-        /// `EPOLLET`
-        const ET = bitcast!(c::EPOLLET);
-
-        /// `EPOLLONESHOT`
-        const ONESHOT = bitcast!(c::EPOLLONESHOT);
-
-        /// `EPOLLWAKEUP`
-        const WAKEUP = bitcast!(c::EPOLLWAKEUP);
-
-        /// `EPOLLEXCLUSIVE`
-        #[cfg(not(target_os = "android"))]
-        const EXCLUSIVE = bitcast!(c::EPOLLEXCLUSIVE);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `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 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(bitflags_bits!(flags))) }
-}
-
-/// `epoll_ctl(self, EPOLL_CTL_ADD, data, event)`—Adds an element to an epoll
-/// object.
-///
-/// 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 add(
-    epoll: impl AsFd,
-    source: impl AsFd,
-    data: EventData,
-    event_flags: EventFlags,
-) -> io::Result<()> {
-    // SAFETY: We're calling `epoll_ctl` via FFI and we know how it
-    // 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,
-            as_mut_ptr(&mut Event {
-                flags: event_flags,
-                data,
-            })
-            .cast(),
-        ))
-    }
-}
-
-/// `epoll_ctl(self, EPOLL_CTL_MOD, target, event)`—Modifies an element in a
-/// given epoll object.
-///
-/// This sets the events of interest with `target` to `events`.
-#[doc(alias = "epoll_ctl")]
-pub fn modify(
-    epoll: impl AsFd,
-    source: impl AsFd,
-    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. 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,
-            as_mut_ptr(&mut Event {
-                flags: event_flags,
-                data,
-            })
-            .cast(),
-        ))
-    }
-}
-
-/// `epoll_ctl(self, EPOLL_CTL_DEL, target, NULL)`—Removes an element in a
-/// given epoll object.
-#[doc(alias = "epoll_ctl")]
-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 {
-        let raw_fd = source.as_fd().as_raw_fd();
-        ret(c::epoll_ctl(
-            epoll.as_fd().as_raw_fd(),
-            c::EPOLL_CTL_DEL,
-            raw_fd,
-            null_mut(),
-        ))
-    }
-}
-
-/// `epoll_wait(self, events, timeout)`—Waits for registered events of
-/// interest.
-///
-/// For each event of interest, an element is written to `events`. On
-/// success, this returns the number of written elements.
-#[cfg(feature = "alloc")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
-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 {
-        event_list.events.set_len(0);
-        let nfds = ret_u32(c::epoll_wait(
-            epoll.as_fd().as_raw_fd(),
-            event_list.events.as_mut_ptr().cast::<c::epoll_event>(),
-            event_list.events.capacity().try_into().unwrap_or(i32::MAX),
-            timeout,
-        ))?;
-        event_list.events.set_len(nfds as usize);
-    }
-
-    Ok(())
-}
-
-/// An iterator over the `Event`s in an `EventVec`.
-pub struct Iter<'a> {
-    /// 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 = Event;
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next()
-    }
-}
-
-/// A record of an event that occurred.
-#[repr(C)]
-#[cfg_attr(
-    any(
-        all(
-            target_arch = "x86",
-            not(target_env = "musl"),
-            not(target_os = "android"),
-        ),
-        target_arch = "x86_64",
-    ),
-    repr(packed)
-)]
-#[derive(Copy, Clone, Eq, PartialEq, Hash)]
-pub struct Event {
-    /// Which specific event(s) occurred.
-    pub flags: EventFlags,
-    /// User data.
-    pub data: EventData,
-}
-
-/// Data associated 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.
-#[cfg(feature = "alloc")]
-pub struct EventVec {
-    events: Vec<Event>,
-}
-
-#[cfg(feature = "alloc")]
-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 {
-        Self {
-            events: Vec::with_capacity(capacity),
-        }
-    }
-
-    /// Returns the current `Event` capacity of this `EventVec`.
-    #[inline]
-    pub fn capacity(&self) -> usize {
-        self.events.capacity()
-    }
-
-    /// Reserves enough memory for at least `additional` more `Event`s.
-    #[inline]
-    pub fn reserve(&mut self, additional: usize) {
-        self.events.reserve(additional);
-    }
-
-    /// Reserves enough memory for exactly `additional` more `Event`s.
-    #[inline]
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.events.reserve_exact(additional);
-    }
-
-    /// Clears all the `Events` out of this `EventVec`.
-    #[inline]
-    pub fn clear(&mut self) {
-        self.events.clear();
-    }
-
-    /// Shrinks the capacity of this `EventVec` as much as possible.
-    #[inline]
-    pub fn shrink_to_fit(&mut self) {
-        self.events.shrink_to_fit();
-    }
-
-    /// Returns an iterator over the `Event`s in this `EventVec`.
-    #[inline]
-    pub fn iter(&self) -> Iter<'_> {
-        Iter {
-            iter: self.events.iter().copied(),
-        }
-    }
-
-    /// Returns the number of `Event`s logically contained in this `EventVec`.
-    #[inline]
-    pub fn len(&mut self) -> usize {
-        self.events.len()
-    }
-
-    /// Tests whether this `EventVec` is logically empty.
-    #[inline]
-    pub fn is_empty(&mut self) -> bool {
-        self.events.is_empty()
-    }
-}
-
-#[cfg(feature = "alloc")]
-impl<'a> IntoIterator for &'a EventVec {
-    type IntoIter = Iter<'a>;
-    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
deleted file mode 100644
index 6aed461..0000000
--- a/vendor/rustix/src/backend/libc/event/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-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/event/poll_fd.rs b/vendor/rustix/src/backend/libc/event/poll_fd.rs
deleted file mode 100644
index 32fd83d..0000000
--- a/vendor/rustix/src/backend/libc/event/poll_fd.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-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 {
-    crate::backend::fd::{AsSocket, RawFd},
-    core::fmt,
-};
-
-bitflags! {
-    /// `POLL*` flags for use with [`poll`].
-    ///
-    /// [`poll`]: crate::event::poll
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct PollFlags: c::c_short {
-        /// `POLLIN`
-        const IN = c::POLLIN;
-        /// `POLLPRI`
-        #[cfg(not(target_os = "wasi"))]
-        const PRI = c::POLLPRI;
-        /// `POLLOUT`
-        const OUT = c::POLLOUT;
-        /// `POLLRDNORM`
-        const RDNORM = c::POLLRDNORM;
-        /// `POLLWRNORM`
-        #[cfg(not(target_os = "l4re"))]
-        const WRNORM = c::POLLWRNORM;
-        /// `POLLRDBAND`
-        #[cfg(not(any(target_os = "l4re", target_os = "wasi")))]
-        const RDBAND = c::POLLRDBAND;
-        /// `POLLWRBAND`
-        #[cfg(not(any(target_os = "l4re", target_os = "wasi")))]
-        const WRBAND = c::POLLWRBAND;
-        /// `POLLERR`
-        const ERR = c::POLLERR;
-        /// `POLLHUP`
-        const HUP = c::POLLHUP;
-        /// `POLLNVAL`
-        #[cfg(not(target_os = "espidf"))]
-        const NVAL = c::POLLNVAL;
-        /// `POLLRDHUP`
-        #[cfg(all(
-            linux_kernel,
-            not(any(target_arch = "sparc", target_arch = "sparc64"))),
-        )]
-        const RDHUP = c::POLLRDHUP;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `struct pollfd`—File descriptor and flags for use with [`poll`].
-///
-/// [`poll`]: crate::event::poll
-#[doc(alias = "pollfd")]
-#[derive(Clone)]
-#[cfg_attr(not(windows), derive(Debug))]
-#[repr(transparent)]
-pub struct PollFd<'fd> {
-    pollfd: c::pollfd,
-    _phantom: PhantomData<BorrowedFd<'fd>>,
-}
-
-#[cfg(windows)]
-impl<'fd> fmt::Debug for PollFd<'fd> {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.debug_struct("pollfd")
-            .field("fd", &self.pollfd.fd)
-            .field("events", &self.pollfd.events)
-            .field("revents", &self.pollfd.revents)
-            .finish()
-    }
-}
-
-impl<'fd> PollFd<'fd> {
-    /// Constructs a new `PollFd` holding `fd` and `events`.
-    #[inline]
-    pub fn new<Fd: AsFd>(fd: &'fd Fd, events: PollFlags) -> Self {
-        Self::from_borrowed_fd(fd.as_fd(), events)
-    }
-
-    /// Sets the contained file descriptor to `fd`.
-    #[inline]
-    pub fn set_fd<Fd: AsFd>(&mut self, fd: &'fd Fd) {
-        self.pollfd.fd = fd.as_fd().as_raw_fd() as LibcFd;
-    }
-
-    /// Clears the ready events.
-    #[inline]
-    pub fn clear_revents(&mut self) {
-        self.pollfd.revents = 0;
-    }
-
-    /// Constructs a new `PollFd` holding `fd` and `events`.
-    ///
-    /// This is the same as `new`, but can be used to avoid borrowing the
-    /// `BorrowedFd`, which can be tricky in situations where the `BorrowedFd`
-    /// is a temporary.
-    #[inline]
-    pub fn from_borrowed_fd(fd: BorrowedFd<'fd>, events: PollFlags) -> Self {
-        Self {
-            pollfd: c::pollfd {
-                fd: borrowed_fd(fd),
-                events: events.bits(),
-                revents: 0,
-            },
-            _phantom: PhantomData,
-        }
-    }
-
-    /// Returns the ready events.
-    #[inline]
-    pub fn revents(&self) -> PollFlags {
-        // Use `.unwrap()` here because in theory we know we know all the bits
-        // the OS might set here, but OS's have added extensions in the past.
-        PollFlags::from_bits(self.pollfd.revents).unwrap()
-    }
-}
-
-#[cfg(not(windows))]
-impl<'fd> AsFd for PollFd<'fd> {
-    #[inline]
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        // SAFETY: Our constructors and `set_fd` require `pollfd.fd` to be
-        // valid for the `'fd` lifetime.
-        unsafe { BorrowedFd::borrow_raw(self.pollfd.fd) }
-    }
-}
-
-#[cfg(windows)]
-impl<'fd> AsSocket for PollFd<'fd> {
-    #[inline]
-    fn as_socket(&self) -> BorrowedFd<'_> {
-        // SAFETY: Our constructors and `set_fd` require `pollfd.fd` to be
-        // valid for the `'fd` lifetime.
-        unsafe { BorrowedFd::borrow_raw(self.pollfd.fd as RawFd) }
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/event/syscalls.rs b/vendor/rustix/src/backend/libc/event/syscalls.rs
deleted file mode 100644
index 725ec82..0000000
--- a/vendor/rustix/src/backend/libc/event/syscalls.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-//! 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, target_os = "espidf"))]
-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",
-    target_os = "espidf"
-))]
-use {crate::backend::conv::ret_owned_fd, crate::event::EventfdFlags};
-#[cfg(all(feature = "alloc", bsd))]
-use {crate::event::kqueue::Event, crate::utils::as_ptr, core::ptr::null};
-
-#[cfg(any(
-    linux_kernel,
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "espidf"
-))]
-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)))
-    }
-
-    // `eventfd` was added in FreeBSD 13, so it isn't available on FreeBSD 12.
-    #[cfg(target_os = "freebsd")]
-    unsafe {
-        weakcall! {
-            fn eventfd(
-                initval: c::c_uint,
-                flags: c::c_int
-            ) -> c::c_int
-        }
-        ret_owned_fd(eventfd(initval, bitflags_bits!(flags)))
-    }
-
-    #[cfg(any(target_os = "illumos", target_os = "espidf"))]
-    unsafe {
-        ret_owned_fd(c::eventfd(initval, bitflags_bits!(flags)))
-    }
-}
-
-#[cfg(all(feature = "alloc", bsd))]
-pub(crate) fn kqueue() -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::kqueue()) }
-}
-
-#[cfg(all(feature = "alloc", 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(all(feature = "alloc", 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)) }
-}
-
-#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
-pub(crate) fn pause() {
-    let r = unsafe { libc::pause() };
-    let errno = libc_errno::errno().0;
-    debug_assert_eq!(r, -1);
-    debug_assert_eq!(errno, libc::EINTR);
-}
diff --git a/vendor/rustix/src/backend/libc/event/types.rs b/vendor/rustix/src/backend/libc/event/types.rs
deleted file mode 100644
index a04d7e6..0000000
--- a/vendor/rustix/src/backend/libc/event/types.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "illumos"))]
-use crate::backend::c;
-#[cfg(any(
-    linux_kernel,
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "espidf"
-))]
-use bitflags::bitflags;
-
-#[cfg(any(
-    linux_kernel,
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "espidf"
-))]
-bitflags! {
-    /// `EFD_*` flags for use with [`eventfd`].
-    ///
-    /// [`eventfd`]: crate::event::eventfd
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct EventfdFlags: u32 {
-        /// `EFD_CLOEXEC`
-        #[cfg(not(target_os = "espidf"))]
-        const CLOEXEC = bitcast!(c::EFD_CLOEXEC);
-        /// `EFD_NONBLOCK`
-        #[cfg(not(target_os = "espidf"))]
-        const NONBLOCK = bitcast!(c::EFD_NONBLOCK);
-        /// `EFD_SEMAPHORE`
-        #[cfg(not(target_os = "espidf"))]
-        const SEMAPHORE = bitcast!(c::EFD_SEMAPHORE);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/event/windows_syscalls.rs b/vendor/rustix/src/backend/libc/event/windows_syscalls.rs
deleted file mode 100644
index 8ccad47..0000000
--- a/vendor/rustix/src/backend/libc/event/windows_syscalls.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! 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
deleted file mode 100644
index 82a0a90..0000000
--- a/vendor/rustix/src/backend/libc/fs/dir.rs
+++ /dev/null
@@ -1,423 +0,0 @@
-#[cfg(not(any(solarish, target_os = "haiku", target_os = "nto", target_os = "vita")))]
-use super::types::FileType;
-use crate::backend::c;
-use crate::backend::conv::owned_fd;
-use crate::fd::{AsFd, BorrowedFd, OwnedFd};
-use crate::ffi::{CStr, CString};
-use crate::fs::{fcntl_getfl, openat, Mode, OFlags};
-#[cfg(not(target_os = "vita"))]
-use crate::fs::{fstat, Stat};
-#[cfg(not(any(
-    solarish,
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-use crate::fs::{fstatfs, StatFs};
-#[cfg(not(any(
-    solarish,
-    target_os = "haiku",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-use crate::fs::{fstatvfs, StatVfs};
-use crate::io;
-#[cfg(not(any(target_os = "fuchsia", target_os = "vita", target_os = "wasi")))]
-#[cfg(feature = "process")]
-use crate::process::fchdir;
-use alloc::borrow::ToOwned;
-#[cfg(not(any(linux_like, target_os = "hurd")))]
-use c::readdir as libc_readdir;
-#[cfg(any(linux_like, target_os = "hurd"))]
-use c::readdir64 as libc_readdir;
-use core::fmt;
-use core::ptr::NonNull;
-use libc_errno::{errno, set_errno, Errno};
-
-/// `DIR*`
-pub struct Dir {
-    /// The `libc` `DIR` pointer.
-    libc_dir: NonNull<c::DIR>,
-
-    /// Have we seen any errors in this iteration?
-    any_errors: bool,
-}
-
-impl Dir {
-    /// Take ownership of `fd` and construct a `Dir` that reads entries from
-    /// the given directory file descriptor.
-    #[inline]
-    pub fn new<Fd: Into<OwnedFd>>(fd: Fd) -> io::Result<Self> {
-        Self::_new(fd.into())
-    }
-
-    #[inline]
-    fn _new(fd: OwnedFd) -> io::Result<Self> {
-        let raw = owned_fd(fd);
-        unsafe {
-            let libc_dir = c::fdopendir(raw);
-
-            if let Some(libc_dir) = NonNull::new(libc_dir) {
-                Ok(Self {
-                    libc_dir,
-                    any_errors: false,
-                })
-            } else {
-                let err = io::Errno::last_os_error();
-                let _ = c::close(raw);
-                Err(err)
-            }
-        }
-    }
-
-    /// Borrow `fd` and construct a `Dir` that reads entries from the given
-    /// directory file descriptor.
-    #[inline]
-    pub fn read_from<Fd: AsFd>(fd: Fd) -> io::Result<Self> {
-        Self::_read_from(fd.as_fd())
-    }
-
-    #[inline]
-    #[allow(unused_mut)]
-    fn _read_from(fd: BorrowedFd<'_>) -> io::Result<Self> {
-        let mut any_errors = false;
-
-        // Given an arbitrary `OwnedFd`, it's impossible to know whether the
-        // user holds a `dup`'d copy which could continue to modify the
-        // file description state, which would cause Undefined Behavior after
-        // our call to `fdopendir`. To prevent this, we obtain an independent
-        // `OwnedFd`.
-        let flags = fcntl_getfl(fd)?;
-        let fd_for_dir = match openat(fd, cstr!("."), flags | OFlags::CLOEXEC, Mode::empty()) {
-            Ok(fd) => fd,
-            #[cfg(not(target_os = "wasi"))]
-            Err(io::Errno::NOENT) => {
-                // If "." doesn't exist, it means the directory was removed.
-                // We treat that as iterating through a directory with no
-                // entries.
-                any_errors = true;
-                crate::io::dup(fd)?
-            }
-            Err(err) => return Err(err),
-        };
-
-        let raw = owned_fd(fd_for_dir);
-        unsafe {
-            let libc_dir = c::fdopendir(raw);
-
-            if let Some(libc_dir) = NonNull::new(libc_dir) {
-                Ok(Self {
-                    libc_dir,
-                    any_errors,
-                })
-            } else {
-                let err = io::Errno::last_os_error();
-                let _ = c::close(raw);
-                Err(err)
-            }
-        }
-    }
-
-    /// `rewinddir(self)`
-    #[inline]
-    pub fn rewind(&mut self) {
-        self.any_errors = false;
-        unsafe { c::rewinddir(self.libc_dir.as_ptr()) }
-    }
-
-    /// `readdir(self)`, where `None` means the end of the directory.
-    pub fn read(&mut self) -> Option<io::Result<DirEntry>> {
-        // If we've seen errors, don't continue to try to read anyting further.
-        if self.any_errors {
-            return None;
-        }
-
-        set_errno(Errno(0));
-        let dirent_ptr = unsafe { libc_readdir(self.libc_dir.as_ptr()) };
-        if dirent_ptr.is_null() {
-            let curr_errno = errno().0;
-            if curr_errno == 0 {
-                // We successfully reached the end of the stream.
-                None
-            } else {
-                // `errno` is unknown or non-zero, so an error occurred.
-                self.any_errors = true;
-                Some(Err(io::Errno(curr_errno)))
-            }
-        } else {
-            // We successfully read an entry.
-            unsafe {
-                let dirent = &*dirent_ptr;
-
-                // We have our own copy of OpenBSD's dirent; check that the
-                // layout minimally matches libc's.
-                #[cfg(target_os = "openbsd")]
-                check_dirent_layout(dirent);
-
-                let result = DirEntry {
-                    #[cfg(not(any(
-                        solarish,
-                        target_os = "aix",
-                        target_os = "haiku",
-                        target_os = "nto",
-                        target_os = "vita"
-                    )))]
-                    d_type: dirent.d_type,
-
-                    #[cfg(not(any(freebsdlike, netbsdlike, target_os = "vita")))]
-                    d_ino: dirent.d_ino,
-
-                    #[cfg(any(freebsdlike, netbsdlike))]
-                    d_fileno: dirent.d_fileno,
-
-                    name: CStr::from_ptr(dirent.d_name.as_ptr()).to_owned(),
-                };
-
-                Some(Ok(result))
-            }
-        }
-    }
-
-    /// `fstat(self)`
-    #[cfg(not(target_os = "vita"))]
-    #[inline]
-    pub fn stat(&self) -> io::Result<Stat> {
-        fstat(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.libc_dir.as_ptr())) })
-    }
-
-    /// `fstatfs(self)`
-    #[cfg(not(any(
-        solarish,
-        target_os = "haiku",
-        target_os = "netbsd",
-        target_os = "nto",
-        target_os = "redox",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    #[inline]
-    pub fn statfs(&self) -> io::Result<StatFs> {
-        fstatfs(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.libc_dir.as_ptr())) })
-    }
-
-    /// `fstatvfs(self)`
-    #[cfg(not(any(
-        solarish,
-        target_os = "haiku",
-        target_os = "redox",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    #[inline]
-    pub fn statvfs(&self) -> io::Result<StatVfs> {
-        fstatvfs(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.libc_dir.as_ptr())) })
-    }
-
-    /// `fchdir(self)`
-    #[cfg(feature = "process")]
-    #[cfg(not(any(target_os = "fuchsia", target_os = "vita", 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.libc_dir.as_ptr())) })
-    }
-}
-
-/// `Dir` implements `Send` but not `Sync`, because we use `readdir` which is
-/// not guaranteed to be thread-safe. Users can wrap this in a `Mutex` if they
-/// need `Sync`, which is effectively what'd need to do to implement `Sync`
-/// ourselves.
-unsafe impl Send for Dir {}
-
-impl Drop for Dir {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe { c::closedir(self.libc_dir.as_ptr()) };
-    }
-}
-
-impl Iterator for Dir {
-    type Item = io::Result<DirEntry>;
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        Self::read(self)
-    }
-}
-
-impl fmt::Debug for Dir {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut s = f.debug_struct("Dir");
-        #[cfg(not(target_os = "vita"))]
-        s.field("fd", unsafe { &c::dirfd(self.libc_dir.as_ptr()) });
-        s.finish()
-    }
-}
-
-/// `struct dirent`
-#[derive(Debug)]
-pub struct DirEntry {
-    #[cfg(not(any(
-        solarish,
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "nto",
-        target_os = "vita"
-    )))]
-    d_type: u8,
-
-    #[cfg(not(any(freebsdlike, netbsdlike, target_os = "vita")))]
-    d_ino: c::ino_t,
-
-    #[cfg(any(freebsdlike, netbsdlike))]
-    d_fileno: c::ino_t,
-
-    name: CString,
-}
-
-impl DirEntry {
-    /// Returns the file name of this directory entry.
-    #[inline]
-    pub fn file_name(&self) -> &CStr {
-        &self.name
-    }
-
-    /// Returns the type of this directory entry.
-    #[cfg(not(any(
-        solarish,
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "nto",
-        target_os = "vita"
-    )))]
-    #[inline]
-    pub fn file_type(&self) -> FileType {
-        FileType::from_dirent_d_type(self.d_type)
-    }
-
-    /// Return the inode number of this directory entry.
-    #[cfg(not(any(freebsdlike, netbsdlike, target_os = "vita")))]
-    #[inline]
-    pub fn ino(&self) -> u64 {
-        self.d_ino as u64
-    }
-
-    /// Return the inode number of this directory entry.
-    #[cfg(any(freebsdlike, netbsdlike))]
-    #[inline]
-    pub fn ino(&self) -> u64 {
-        #[allow(clippy::useless_conversion)]
-        self.d_fileno.into()
-    }
-}
-
-/// libc's OpenBSD `dirent` has a private field so we can't construct it
-/// directly, so we declare it ourselves to make all fields accessible.
-#[cfg(target_os = "openbsd")]
-#[repr(C)]
-#[derive(Debug)]
-struct libc_dirent {
-    d_fileno: c::ino_t,
-    d_off: c::off_t,
-    d_reclen: u16,
-    d_type: u8,
-    d_namlen: u8,
-    __d_padding: [u8; 4],
-    d_name: [c::c_char; 256],
-}
-
-/// We have our own copy of OpenBSD's dirent; check that the layout
-/// minimally matches libc's.
-#[cfg(target_os = "openbsd")]
-fn check_dirent_layout(dirent: &c::dirent) {
-    use crate::utils::as_ptr;
-
-    // Check that the basic layouts match.
-    #[cfg(test)]
-    {
-        assert_eq_size!(libc_dirent, c::dirent);
-        assert_eq_size!(libc_dirent, c::dirent);
-    }
-
-    // Check that the field offsets match.
-    assert_eq!(
-        {
-            let z = libc_dirent {
-                d_fileno: 0_u64,
-                d_off: 0_i64,
-                d_reclen: 0_u16,
-                d_type: 0_u8,
-                d_namlen: 0_u8,
-                __d_padding: [0_u8; 4],
-                d_name: [0 as c::c_char; 256],
-            };
-            let base = as_ptr(&z) as usize;
-            (
-                (as_ptr(&z.d_fileno) as usize) - base,
-                (as_ptr(&z.d_off) as usize) - base,
-                (as_ptr(&z.d_reclen) as usize) - base,
-                (as_ptr(&z.d_type) as usize) - base,
-                (as_ptr(&z.d_namlen) as usize) - base,
-                (as_ptr(&z.d_name) as usize) - base,
-            )
-        },
-        {
-            let z = dirent;
-            let base = as_ptr(z) as usize;
-            (
-                (as_ptr(&z.d_fileno) as usize) - base,
-                (as_ptr(&z.d_off) as usize) - base,
-                (as_ptr(&z.d_reclen) as usize) - base,
-                (as_ptr(&z.d_type) as usize) - base,
-                (as_ptr(&z.d_namlen) as usize) - base,
-                (as_ptr(&z.d_name) as usize) - base,
-            )
-        }
-    );
-}
-
-#[test]
-fn dir_iterator_handles_io_errors() {
-    // create a dir, keep the FD, then delete the dir
-    let tmp = tempfile::tempdir().unwrap();
-    let fd = crate::fs::openat(
-        crate::fs::CWD,
-        tmp.path(),
-        crate::fs::OFlags::RDONLY | crate::fs::OFlags::CLOEXEC,
-        crate::fs::Mode::empty(),
-    )
-    .unwrap();
-
-    let file_fd = crate::fs::openat(
-        &fd,
-        tmp.path().join("test.txt"),
-        crate::fs::OFlags::WRONLY | crate::fs::OFlags::CREATE,
-        crate::fs::Mode::RWXU,
-    )
-    .unwrap();
-
-    let mut dir = Dir::read_from(&fd).unwrap();
-
-    // Reach inside the `Dir` and replace its directory with a file, which
-    // will cause the subsequent `readdir` to fail.
-    unsafe {
-        let raw_fd = c::dirfd(dir.libc_dir.as_ptr());
-        let mut owned_fd: crate::fd::OwnedFd = crate::fd::FromRawFd::from_raw_fd(raw_fd);
-        crate::io::dup2(&file_fd, &mut owned_fd).unwrap();
-        core::mem::forget(owned_fd);
-    }
-
-    // FreeBSD and macOS seem to read some directory entries before we call
-    // `.next()`.
-    #[cfg(any(apple, freebsdlike))]
-    {
-        dir.rewind();
-    }
-
-    assert!(matches!(dir.next(), Some(Err(_))));
-    assert!(dir.next().is_none());
-}
diff --git a/vendor/rustix/src/backend/libc/fs/inotify.rs b/vendor/rustix/src/backend/libc/fs/inotify.rs
deleted file mode 100644
index 2044bd9..0000000
--- a/vendor/rustix/src/backend/libc/fs/inotify.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-//! inotify support for working with inotifies
-
-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;
-
-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: u32 {
-        /// `IN_CLOEXEC`
-        const CLOEXEC = bitcast!(c::IN_CLOEXEC);
-        /// `IN_NONBLOCK`
-        const NONBLOCK = bitcast!(c::IN_NONBLOCK);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `IN*` for use with [`inotify_add_watch`].
-    ///
-    /// [`inotify_add_watch`]: crate::fs::inotify::inotify_add_watch
-    #[repr(transparent)]
-    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct WatchFlags: u32 {
-        /// `IN_ACCESS`
-        const ACCESS = c::IN_ACCESS;
-        /// `IN_ATTRIB`
-        const ATTRIB = c::IN_ATTRIB;
-        /// `IN_CLOSE_NOWRITE`
-        const CLOSE_NOWRITE = c::IN_CLOSE_NOWRITE;
-        /// `IN_CLOSE_WRITE`
-        const CLOSE_WRITE = c::IN_CLOSE_WRITE;
-        /// `IN_CREATE`
-        const CREATE = c::IN_CREATE;
-        /// `IN_DELETE`
-        const DELETE = c::IN_DELETE;
-        /// `IN_DELETE_SELF`
-        const DELETE_SELF = c::IN_DELETE_SELF;
-        /// `IN_MODIFY`
-        const MODIFY = c::IN_MODIFY;
-        /// `IN_MOVE_SELF`
-        const MOVE_SELF = c::IN_MOVE_SELF;
-        /// `IN_MOVED_FROM`
-        const MOVED_FROM = c::IN_MOVED_FROM;
-        /// `IN_MOVED_TO`
-        const MOVED_TO = c::IN_MOVED_TO;
-        /// `IN_OPEN`
-        const OPEN = c::IN_OPEN;
-
-        /// `IN_CLOSE`
-        const CLOSE = c::IN_CLOSE;
-        /// `IN_MOVE`
-        const MOVE = c::IN_MOVE;
-        /// `IN_ALL_EVENTS`
-        const ALL_EVENTS = c::IN_ALL_EVENTS;
-
-        /// `IN_DONT_FOLLOW`
-        const DONT_FOLLOW = c::IN_DONT_FOLLOW;
-        /// `IN_EXCL_UNLINK`
-        const EXCL_UNLINK = 1;
-        /// `IN_MASK_ADD`
-        const MASK_ADD = 1;
-        /// `IN_MASK_CREATE`
-        const MASK_CREATE = 1;
-        /// `IN_ONESHOT`
-        const ONESHOT = c::IN_ONESHOT;
-        /// `IN_ONLYDIR`
-        const ONLYDIR = c::IN_ONLYDIR;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `inotify_init1(flags)`—Creates a new inotify object.
-///
-/// Use the [`CreateFlags::CLOEXEC`] flag to prevent the resulting file
-/// descriptor from being implicitly passed across `exec` boundaries.
-#[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(bitflags_bits!(flags))) }
-}
-
-/// `inotify_add_watch(self, path, flags)`—Adds a watch to inotify.
-///
-/// This registers or updates a watch for the filesystem path `path` and
-/// returns a watch descriptor corresponding to this watch.
-///
-/// Note: Due to the existence of hardlinks, providing two 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.
-pub fn inotify_add_watch<P: crate::path::Arg>(
-    inot: BorrowedFd<'_>,
-    path: P,
-    flags: WatchFlags,
-) -> io::Result<i32> {
-    path.into_with_c_str(|path| {
-        // SAFETY: The fd and path we are passing is guaranteed valid by the
-        // type system.
-        unsafe {
-            ret_c_int(c::inotify_add_watch(
-                borrowed_fd(inot),
-                c_str(path),
-                flags.bits(),
-            ))
-        }
-    })
-}
-
-/// `inotify_rm_watch(self, wd)`—Removes a watch from this inotify.
-///
-/// The watch descriptor provided should have previously been returned 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 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.
-    unsafe { ret(c::inotify_rm_watch(borrowed_fd(inot), wd)) }
-}
diff --git a/vendor/rustix/src/backend/libc/fs/makedev.rs b/vendor/rustix/src/backend/libc/fs/makedev.rs
deleted file mode 100644
index aa12102..0000000
--- a/vendor/rustix/src/backend/libc/fs/makedev.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-#[cfg(not(all(target_os = "android", target_pointer_width = "32")))]
-use crate::backend::c;
-use crate::fs::Dev;
-
-#[cfg(not(any(
-    apple,
-    solarish,
-    target_os = "aix",
-    target_os = "android",
-    target_os = "emscripten",
-)))]
-#[inline]
-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 {
-    c::makedev(maj, min)
-}
-
-#[cfg(all(target_os = "android", target_pointer_width = "32"))]
-#[inline]
-pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
-    // 32-bit Android's `dev_t` is 32-bit, but its `st_dev` is 64-bit, so we do
-    // it ourselves.
-    ((u64::from(maj) & 0xffff_f000_u64) << 32)
-        | ((u64::from(maj) & 0x0000_0fff_u64) << 8)
-        | ((u64::from(min) & 0xffff_ff00_u64) << 12)
-        | (u64::from(min) & 0x0000_00ff_u64)
-}
-
-#[cfg(target_os = "emscripten")]
-#[inline]
-pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
-    // Emscripten's `makedev` has a 32-bit return value.
-    Dev::from(c::makedev(maj, min))
-}
-
-#[cfg(apple)]
-#[inline]
-pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
-    // Apple's `makedev` oddly has signed argument types and is `unsafe`.
-    unsafe { c::makedev(maj as i32, min as i32) }
-}
-
-#[cfg(target_os = "aix")]
-#[inline]
-pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
-    // AIX's `makedev` oddly is `unsafe`.
-    unsafe { c::makedev(maj, min) }
-}
-
-#[cfg(not(any(
-    apple,
-    freebsdlike,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "netbsd"
-)))]
-#[inline]
-pub(crate) fn major(dev: Dev) -> u32 {
-    unsafe { c::major(dev) }
-}
-
-#[cfg(any(
-    apple,
-    freebsdlike,
-    target_os = "netbsd",
-    all(target_os = "android", not(target_pointer_width = "32")),
-))]
-#[inline]
-pub(crate) fn major(dev: Dev) -> u32 {
-    // On some platforms `major` oddly has signed return types.
-    (unsafe { c::major(dev) }) as u32
-}
-
-#[cfg(all(target_os = "android", target_pointer_width = "32"))]
-#[inline]
-pub(crate) fn major(dev: Dev) -> u32 {
-    // 32-bit Android's `dev_t` is 32-bit, but its `st_dev` is 64-bit, so we do
-    // it ourselves.
-    (((dev >> 31 >> 1) & 0xffff_f000) | ((dev >> 8) & 0x0000_0fff)) as u32
-}
-
-#[cfg(target_os = "emscripten")]
-#[inline]
-pub(crate) fn major(dev: Dev) -> u32 {
-    // Emscripten's `major` has a 32-bit argument value.
-    unsafe { c::major(dev as u32) }
-}
-
-#[cfg(not(any(
-    apple,
-    freebsdlike,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "netbsd"
-)))]
-#[inline]
-pub(crate) fn minor(dev: Dev) -> u32 {
-    unsafe { c::minor(dev) }
-}
-
-#[cfg(any(
-    apple,
-    freebsdlike,
-    target_os = "netbsd",
-    all(target_os = "android", not(target_pointer_width = "32"))
-))]
-#[inline]
-pub(crate) fn minor(dev: Dev) -> u32 {
-    // On some platforms, `minor` oddly has signed return types.
-    (unsafe { c::minor(dev) }) as u32
-}
-
-#[cfg(all(target_os = "android", target_pointer_width = "32"))]
-#[inline]
-pub(crate) fn minor(dev: Dev) -> u32 {
-    // 32-bit Android's `dev_t` is 32-bit, but its `st_dev` is 64-bit, so we do
-    // it ourselves.
-    (((dev >> 12) & 0xffff_ff00) | (dev & 0x0000_00ff)) as u32
-}
-
-#[cfg(target_os = "emscripten")]
-#[inline]
-pub(crate) fn minor(dev: Dev) -> u32 {
-    // Emscripten's `minor` has a 32-bit argument value.
-    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
deleted file mode 100644
index c17e863..0000000
--- a/vendor/rustix/src/backend/libc/fs/mod.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#[cfg(all(feature = "alloc", not(any(target_os = "espidf", target_os = "redox"))))]
-pub(crate) mod dir;
-#[cfg(linux_kernel)]
-pub mod inotify;
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-pub(crate) mod makedev;
-#[cfg(not(windows))]
-pub(crate) mod syscalls;
-pub(crate) mod types;
-
-// TODO: Fix linux-raw-sys to define ioctl codes for sparc.
-#[cfg(all(linux_kernel, any(target_arch = "sparc", target_arch = "sparc64")))]
-pub(crate) const EXT4_IOC_RESIZE_FS: crate::ioctl::RawOpcode = 0x8008_6610;
-
-#[cfg(all(linux_kernel, not(any(target_arch = "sparc", target_arch = "sparc64"))))]
-pub(crate) const EXT4_IOC_RESIZE_FS: crate::ioctl::RawOpcode =
-    linux_raw_sys::ioctl::EXT4_IOC_RESIZE_FS as crate::ioctl::RawOpcode;
diff --git a/vendor/rustix/src/backend/libc/fs/syscalls.rs b/vendor/rustix/src/backend/libc/fs/syscalls.rs
deleted file mode 100644
index 70e86cf..0000000
--- a/vendor/rustix/src/backend/libc/fs/syscalls.rs
+++ /dev/null
@@ -1,2514 +0,0 @@
-//! libc syscalls supporting `rustix::fs`.
-
-use crate::backend::c;
-#[cfg(any(
-    not(target_os = "redox"),
-    feature = "alloc",
-    all(linux_kernel, feature = "procfs")
-))]
-use crate::backend::conv::ret_usize;
-use crate::backend::conv::{borrowed_fd, c_str, ret, ret_c_int, ret_off_t, ret_owned_fd};
-use crate::fd::{BorrowedFd, OwnedFd};
-use crate::ffi::CStr;
-#[cfg(all(apple, feature = "alloc"))]
-use crate::ffi::CString;
-#[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-use crate::fs::Access;
-#[cfg(not(any(
-    apple,
-    netbsdlike,
-    solarish,
-    target_os = "dragonfly",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "redox",
-    target_os = "vita",
-)))]
-use crate::fs::Advice;
-#[cfg(not(any(target_os = "espidf", target_os = "redox")))]
-use crate::fs::AtFlags;
-#[cfg(not(any(
-    netbsdlike,
-    solarish,
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "espidf",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-)))]
-use crate::fs::FallocateFlags;
-#[cfg(not(any(target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-use crate::fs::FlockOperation;
-#[cfg(any(linux_kernel, target_os = "freebsd"))]
-use crate::fs::MemfdFlags;
-#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "fuchsia"))]
-use crate::fs::SealFlags;
-#[cfg(not(any(
-    solarish,
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-use crate::fs::StatFs;
-#[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-use crate::fs::Timestamps;
-#[cfg(not(any(
-    apple,
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-use crate::fs::{Dev, FileType};
-use crate::fs::{Mode, OFlags, SeekFrom, Stat};
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-use crate::fs::{StatVfs, StatVfsMountFlags};
-use crate::io;
-#[cfg(all(target_env = "gnu", fix_y2038))]
-use crate::timespec::LibcTimespec;
-#[cfg(not(target_os = "wasi"))]
-use crate::ugid::{Gid, Uid};
-#[cfg(all(apple, feature = "alloc"))]
-use alloc::vec;
-use core::mem::MaybeUninit;
-#[cfg(apple)]
-use {
-    crate::backend::conv::nonnegative_ret,
-    crate::fs::{copyfile_state_t, CloneFlags, CopyfileFlags},
-};
-#[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(target_env = "gnu", fix_y2038))]
-weak!(fn __utimensat64(c::c_int, *const c::c_char, *const LibcTimespec, c::c_int) -> c::c_int);
-#[cfg(all(target_env = "gnu", fix_y2038))]
-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, loongarch64 and riscv64 has no `open` syscall so use
-    // `openat`.
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "riscv32",
-        target_arch = "riscv64",
-        target_arch = "csky",
-        target_arch = "loongarch64"
-    ))]
-    {
-        openat_via_syscall(CWD, path, oflags, mode)
-    }
-
-    // Use the `open` syscall.
-    #[cfg(not(any(
-        target_arch = "aarch64",
-        target_arch = "riscv32",
-        target_arch = "riscv64",
-        target_arch = "csky",
-        target_arch = "loongarch64"
-    )))]
-    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", not(target_os = "hurd")))]
-    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.
-#[cfg(all(unix, target_env = "gnu", not(target_os = "hurd")))]
-fn openat_via_syscall(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    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 {
-        ret_owned_fd(openat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            bitflags_bits!(oflags),
-            bitflags_bits!(mode),
-        ))
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-pub(crate) fn openat(
-    dirfd: BorrowedFd<'_>,
-    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", not(target_os = "hurd")))]
-    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 {
-        ret_owned_fd(c::openat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            bitflags_bits!(oflags),
-            mode,
-        ))
-    }
-}
-
-#[cfg(not(any(
-    solarish,
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-#[inline]
-pub(crate) fn statfs(filename: &CStr) -> io::Result<StatFs> {
-    unsafe {
-        let mut result = MaybeUninit::<StatFs>::uninit();
-        ret(c::statfs(c_str(filename), result.as_mut_ptr()))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-#[inline]
-pub(crate) fn statvfs(filename: &CStr) -> io::Result<StatVfs> {
-    unsafe {
-        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()))
-    }
-}
-
-#[cfg(feature = "alloc")]
-#[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()) as isize,
-        )
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-#[inline]
-pub(crate) fn readlinkat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    buf: &mut [MaybeUninit<u8>],
-) -> io::Result<usize> {
-    unsafe {
-        ret_usize(c::readlinkat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            buf.as_mut_ptr().cast::<c::c_char>(),
-            buf.len(),
-        ) as isize)
-    }
-}
-
-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 {
-        ret(c::mkdirat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            mode.bits() as c::mode_t,
-        ))
-    }
-}
-
-#[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 {
-        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(any(target_os = "espidf", target_os = "redox")))]
-pub(crate) fn linkat(
-    old_dirfd: BorrowedFd<'_>,
-    old_path: &CStr,
-    new_dirfd: BorrowedFd<'_>,
-    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),
-            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(any(target_os = "espidf", target_os = "redox")))]
-pub(crate) fn unlinkat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<()> {
-    // 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"))]
-pub(crate) fn renameat(
-    old_dirfd: BorrowedFd<'_>,
-    old_path: &CStr,
-    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),
-            c_str(old_path),
-            borrowed_fd(new_dirfd),
-            c_str(new_path),
-        ))
-    }
-}
-
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-pub(crate) fn renameat2(
-    old_dirfd: BorrowedFd<'_>,
-    old_path: &CStr,
-    new_dirfd: BorrowedFd<'_>,
-    new_path: &CStr,
-    flags: RenameFlags,
-) -> io::Result<()> {
-    // `renameat2` wasn't supported in glibc until 2.28.
-    weak_or_syscall! {
-        fn renameat2(
-            olddirfd: c::c_int,
-            oldpath: *const c::c_char,
-            newdirfd: c::c_int,
-            newpath: *const c::c_char,
-            flags: c::c_uint
-        ) via SYS_renameat2 -> c::c_int
-    }
-
-    unsafe {
-        ret(renameat2(
-            borrowed_fd(old_dirfd),
-            c_str(old_path),
-            borrowed_fd(new_dirfd),
-            c_str(new_path),
-            flags.bits(),
-        ))
-    }
-}
-
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-#[inline]
-pub(crate) fn renameat2(
-    old_dirfd: BorrowedFd<'_>,
-    old_path: &CStr,
-    new_dirfd: BorrowedFd<'_>,
-    new_path: &CStr,
-    flags: RenameFlags,
-) -> io::Result<()> {
-    // At present, `libc` only has `renameat2` defined for glibc. If we have
-    // no flags, we can use plain `renameat`, but otherwise we use `syscall!`.
-    // to call `renameat2` ourselves.
-    if flags.is_empty() {
-        renameat(old_dirfd, old_path, new_dirfd, new_path)
-    } else {
-        syscall! {
-            fn renameat2(
-                olddirfd: c::c_int,
-                oldpath: *const c::c_char,
-                newdirfd: c::c_int,
-                newpath: *const c::c_char,
-                flags: c::c_uint
-            ) via SYS_renameat2 -> c::c_int
-        }
-
-        unsafe {
-            ret(renameat2(
-                borrowed_fd(old_dirfd),
-                c_str(old_path),
-                borrowed_fd(new_dirfd),
-                c_str(new_path),
-                flags.bits(),
-            ))
-        }
-    }
-}
-
-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,
-    new_dirfd: BorrowedFd<'_>,
-    new_path: &CStr,
-) -> io::Result<()> {
-    unsafe {
-        ret(c::symlinkat(
-            c_str(old_path),
-            borrowed_fd(new_dirfd),
-            c_str(new_path),
-        ))
-    }
-}
-
-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",
-            target_arch = "mips64r6"
-        )
-    ))]
-    {
-        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",
-            target_arch = "mips64r6"
-        )
-    )))]
-    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",
-            target_arch = "mips64r6"
-        )
-    ))]
-    {
-        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::SYMLINK_NOFOLLOW),
-            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",
-            target_arch = "mips64r6"
-        )
-    )))]
-    unsafe {
-        let mut stat = MaybeUninit::<Stat>::uninit();
-        ret(c::lstat(c_str(path), stat.as_mut_ptr()))?;
-        Ok(stat.assume_init())
-    }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "redox")))]
-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(all(
-        linux_kernel,
-        any(
-            target_pointer_width = "32",
-            target_arch = "mips64",
-            target_arch = "mips64r6"
-        )
-    ))]
-    {
-        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),
-        }
-    }
-
-    // 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",
-            target_arch = "mips64r6"
-        )
-    )))]
-    unsafe {
-        let mut stat = MaybeUninit::<Stat>::uninit();
-        ret(c::fstatat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            stat.as_mut_ptr(),
-            bitflags_bits!(flags),
-        ))?;
-        Ok(stat.assume_init())
-    }
-}
-
-#[cfg(all(
-    linux_kernel,
-    any(
-        target_pointer_width = "32",
-        target_arch = "mips64",
-        target_arch = "mips64r6"
-    )
-))]
-fn statat_old(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> {
-    unsafe {
-        let mut result = MaybeUninit::<c::stat64>::uninit();
-        ret(c::fstatat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            result.as_mut_ptr(),
-            bitflags_bits!(flags),
-        ))?;
-        stat64_to_stat(result.assume_init())
-    }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "emscripten", target_os = "vita")))]
-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 = "espidf",
-    target_os = "redox",
-    target_os = "vita"
-)))]
-pub(crate) fn accessat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    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),
-            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,
-    _access: Access,
-    _flags: AtFlags,
-) -> io::Result<()> {
-    Ok(())
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "redox", target_os = "vita")))]
-pub(crate) fn utimensat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    times: &Timestamps,
-    flags: AtFlags,
-) -> io::Result<()> {
-    // Old 32-bit version: libc has `utimensat` but it is not y2038 safe by
-    // default. But there may be a `__utimensat16` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_utimensat) = __utimensat64.get() {
-            let libc_times: [LibcTimespec; 2] = [
-                times.last_access.clone().into(),
-                times.last_modification.clone().into(),
-            ];
-
-            unsafe {
-                return ret(libc_utimensat(
-                    borrowed_fd(dirfd),
-                    c_str(path),
-                    libc_times.as_ptr(),
-                    bitflags_bits!(flags),
-                ));
-            }
-        }
-
-        utimensat_old(dirfd, path, times, flags)
-    }
-
-    // Main version: libc is y2038 safe and has `utimensat`. Or, the platform
-    // is not y2038 safe and there's nothing practical we can do.
-    #[cfg(not(any(apple, fix_y2038)))]
-    unsafe {
-        use crate::utils::as_ptr;
-
-        ret(c::utimensat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            as_ptr(times).cast(),
-            bitflags_bits!(flags),
-        ))
-    }
-
-    // Apple version: `utimensat` was introduced in macOS 10.13.
-    #[cfg(apple)]
-    unsafe {
-        use crate::utils::as_ptr;
-
-        // ABI details
-        weak! {
-            fn utimensat(
-                c::c_int,
-                *const c::c_char,
-                *const c::timespec,
-                c::c_int
-            ) -> c::c_int
-        }
-        extern "C" {
-            fn setattrlist(
-                path: *const c::c_char,
-                attr_list: *const Attrlist,
-                attr_buf: *const c::c_void,
-                attr_buf_size: c::size_t,
-                options: c::c_ulong,
-            ) -> c::c_int;
-        }
-        const FSOPT_NOFOLLOW: c::c_ulong = 0x0000_0001;
-
-        // If we have `utimensat`, use it.
-        if let Some(have_utimensat) = utimensat.get() {
-            return ret(have_utimensat(
-                borrowed_fd(dirfd),
-                c_str(path),
-                as_ptr(times).cast(),
-                bitflags_bits!(flags),
-            ));
-        }
-
-        // `setattrlistat` was introduced in 10.13 along with `utimensat`, so
-        // if we don't have `utimensat`, we don't have `setattrlistat` either.
-        // Emulate it using `fork`, and `fchdir` and [`setattrlist`].
-        //
-        // [`setattrlist`]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/setattrlist.2.html
-        match c::fork() {
-            -1 => Err(io::Errno::IO),
-            0 => {
-                if c::fchdir(borrowed_fd(dirfd)) != 0 {
-                    let code = match libc_errno::errno().0 {
-                        c::EACCES => 2,
-                        c::ENOTDIR => 3,
-                        _ => 1,
-                    };
-                    c::_exit(code);
-                }
-
-                let mut flags_arg = 0;
-                if flags.contains(AtFlags::SYMLINK_NOFOLLOW) {
-                    flags_arg |= FSOPT_NOFOLLOW;
-                }
-
-                let (attrbuf_size, times, attrs) = times_to_attrlist(times);
-
-                if setattrlist(
-                    c_str(path),
-                    &attrs,
-                    as_ptr(&times).cast(),
-                    attrbuf_size,
-                    flags_arg,
-                ) != 0
-                {
-                    // Translate expected `errno` codes into ad-hoc integer
-                    // values suitable for exit statuses.
-                    let code = match libc_errno::errno().0 {
-                        c::EACCES => 2,
-                        c::ENOTDIR => 3,
-                        c::EPERM => 4,
-                        c::EROFS => 5,
-                        c::ELOOP => 6,
-                        c::ENOENT => 7,
-                        c::ENAMETOOLONG => 8,
-                        c::EINVAL => 9,
-                        c::ESRCH => 10,
-                        c::ENOTSUP => 11,
-                        _ => 1,
-                    };
-                    c::_exit(code);
-                }
-
-                c::_exit(0);
-            }
-            child_pid => {
-                let mut wstatus = 0;
-                let _ = ret_c_int(c::waitpid(child_pid, &mut wstatus, 0))?;
-                if c::WIFEXITED(wstatus) {
-                    // Translate our ad-hoc exit statuses back to `errno`
-                    // codes.
-                    match c::WEXITSTATUS(wstatus) {
-                        0 => Ok(()),
-                        2 => Err(io::Errno::ACCESS),
-                        3 => Err(io::Errno::NOTDIR),
-                        4 => Err(io::Errno::PERM),
-                        5 => Err(io::Errno::ROFS),
-                        6 => Err(io::Errno::LOOP),
-                        7 => Err(io::Errno::NOENT),
-                        8 => Err(io::Errno::NAMETOOLONG),
-                        9 => Err(io::Errno::INVAL),
-                        10 => Err(io::Errno::SRCH),
-                        11 => Err(io::Errno::NOTSUP),
-                        _ => Err(io::Errno::IO),
-                    }
-                } else {
-                    Err(io::Errno::IO)
-                }
-            }
-        }
-    }
-}
-
-#[cfg(fix_y2038)]
-fn utimensat_old(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    times: &Timestamps,
-    flags: AtFlags,
-) -> io::Result<()> {
-    let old_times = [
-        c::timespec {
-            tv_sec: times
-                .last_access
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: times
-                .last_access
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-        },
-        c::timespec {
-            tv_sec: times
-                .last_modification
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: times
-                .last_modification
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-        },
-    ];
-    unsafe {
-        ret(c::utimensat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            old_times.as_ptr(),
-            bitflags_bits!(flags),
-        ))
-    }
-}
-
-#[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 = "espidf",
-    target_os = "redox",
-    target_os = "wasi"
-)))]
-pub(crate) fn chmodat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    mode: Mode,
-    flags: AtFlags,
-) -> io::Result<()> {
-    unsafe {
-        ret(c::fchmodat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            mode.bits() as c::mode_t,
-            bitflags_bits!(flags),
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-pub(crate) fn chmodat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    mode: Mode,
-    flags: AtFlags,
-) -> io::Result<()> {
-    // Linux's `fchmodat` does not have a flags argument.
-    //
-    // Use `c::syscall` rather than `c::fchmodat` because some libc
-    // 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);
-    }
-    if !flags.is_empty() {
-        return Err(io::Errno::INVAL);
-    }
-    unsafe {
-        ret(fchmodat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            mode.bits() as c::mode_t,
-        ))
-    }
-}
-
-#[cfg(apple)]
-pub(crate) fn fclonefileat(
-    srcfd: BorrowedFd<'_>,
-    dst_dirfd: BorrowedFd<'_>,
-    dst: &CStr,
-    flags: CloneFlags,
-) -> io::Result<()> {
-    syscall! {
-        fn fclonefileat(
-            srcfd: BorrowedFd<'_>,
-            dst_dirfd: BorrowedFd<'_>,
-            dst: *const c::c_char,
-            flags: c::c_int
-        ) via SYS_fclonefileat -> c::c_int
-    }
-
-    unsafe {
-        ret(fclonefileat(
-            srcfd,
-            dst_dirfd,
-            c_str(dst),
-            bitflags_bits!(flags),
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "redox", target_os = "wasi")))]
-pub(crate) fn chownat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    owner: Option<Uid>,
-    group: Option<Gid>,
-    flags: AtFlags,
-) -> io::Result<()> {
-    unsafe {
-        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
-        ret(c::fchownat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            ow,
-            gr,
-            bitflags_bits!(flags),
-        ))
-    }
-}
-
-#[cfg(not(any(
-    apple,
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-pub(crate) fn mknodat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    file_type: FileType,
-    mode: Mode,
-    dev: Dev,
-) -> io::Result<()> {
-    unsafe {
-        ret(c::mknodat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            (mode.bits() | file_type.as_raw_mode()) as c::mode_t,
-            dev.try_into().map_err(|_e| io::Errno::PERM)?,
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-pub(crate) fn copy_file_range(
-    fd_in: BorrowedFd<'_>,
-    off_in: Option<&mut u64>,
-    fd_out: BorrowedFd<'_>,
-    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
-    }
-
-    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;
-        &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;
-        &mut off_out_val
-    } else {
-        null_mut()
-    };
-    let copied = unsafe {
-        ret_usize(copy_file_range(
-            borrowed_fd(fd_in),
-            off_in_ptr,
-            borrowed_fd(fd_out),
-            off_out_ptr,
-            len,
-            0, // no flags are defined yet
-        ))?
-    };
-    if let Some(off_in) = off_in {
-        *off_in = off_in_val as u64;
-    }
-    if let Some(off_out) = off_out {
-        *off_out = off_out_val as u64;
-    }
-    Ok(copied)
-}
-
-#[cfg(not(any(
-    apple,
-    netbsdlike,
-    solarish,
-    target_os = "dragonfly",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "redox",
-    target_os = "vita",
-)))]
-pub(crate) fn fadvise(fd: BorrowedFd<'_>, offset: u64, len: u64, advice: Advice) -> io::Result<()> {
-    let offset = offset as i64;
-    let len = len as i64;
-
-    // FreeBSD returns `EINVAL` on invalid offsets; emulate the POSIX behavior.
-    #[cfg(target_os = "freebsd")]
-    let offset = if (offset as i64) < 0 {
-        i64::MAX
-    } else {
-        offset
-    };
-
-    // FreeBSD returns `EINVAL` on overflow; emulate the POSIX behavior.
-    #[cfg(target_os = "freebsd")]
-    let len = if len > 0 && offset.checked_add(len).is_none() {
-        i64::MAX - offset
-    } else {
-        len
-    };
-
-    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 {
-        Ok(())
-    } else {
-        Err(io::Errno(err))
-    }
-}
-
-pub(crate) fn fcntl_getfl(fd: BorrowedFd<'_>) -> io::Result<OFlags> {
-    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(linux_kernel, target_os = "freebsd", target_os = "fuchsia"))]
-pub(crate) fn fcntl_get_seals(fd: BorrowedFd<'_>) -> io::Result<SealFlags> {
-    let flags = unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GET_SEALS))? };
-    Ok(SealFlags::from_bits_retain(bitcast!(flags)))
-}
-
-#[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())) }
-}
-
-#[cfg(not(any(
-    target_os = "emscripten",
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-pub(crate) fn fcntl_lock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::Result<()> {
-    use c::{flock, F_RDLCK, F_SETLK, F_SETLKW, F_UNLCK, F_WRLCK, SEEK_SET};
-
-    let (cmd, l_type) = match operation {
-        FlockOperation::LockShared => (F_SETLKW, F_RDLCK),
-        FlockOperation::LockExclusive => (F_SETLKW, F_WRLCK),
-        FlockOperation::Unlock => (F_SETLKW, F_UNLCK),
-        FlockOperation::NonBlockingLockShared => (F_SETLK, F_RDLCK),
-        FlockOperation::NonBlockingLockExclusive => (F_SETLK, F_WRLCK),
-        FlockOperation::NonBlockingUnlock => (F_SETLK, F_UNLCK),
-    };
-
-    unsafe {
-        let mut lock: flock = core::mem::zeroed();
-        lock.l_type = l_type as _;
-
-        // When `l_len` is zero, this locks all the bytes from
-        // `l_whence`/`l_start` to the end of the file, even as the
-        // file grows dynamically.
-        lock.l_whence = SEEK_SET as _;
-        lock.l_start = 0;
-        lock.l_len = 0;
-
-        ret(c::fcntl(borrowed_fd(fd), cmd, &lock))
-    }
-}
-
-pub(crate) fn seek(fd: BorrowedFd<'_>, pos: SeekFrom) -> io::Result<u64> {
-    let (whence, offset) = match pos {
-        SeekFrom::Start(pos) => {
-            let pos: u64 = pos;
-            // Silently cast; we'll get `EINVAL` if the value is negative.
-            (c::SEEK_SET, pos as i64)
-        }
-        SeekFrom::End(offset) => (c::SEEK_END, offset),
-        SeekFrom::Current(offset) => (c::SEEK_CUR, offset),
-        #[cfg(any(apple, freebsdlike, linux_kernel, solarish))]
-        SeekFrom::Data(offset) => (c::SEEK_DATA, offset),
-        #[cfg(any(apple, freebsdlike, linux_kernel, solarish))]
-        SeekFrom::Hole(offset) => (c::SEEK_HOLE, offset),
-    };
-
-    // ESP-IDF and Vita don't support 64-bit offsets.
-    #[cfg(any(target_os = "espidf", target_os = "vita"))]
-    let offset: i32 = offset.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-
-    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(c::lseek(borrowed_fd(fd), 0, c::SEEK_CUR))? };
-    Ok(offset as u64)
-}
-
-#[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), bitflags_bits!(mode))) }
-}
-
-#[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`.
-    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(not(target_os = "wasi"))]
-pub(crate) fn chown(path: &CStr, owner: Option<Uid>, group: Option<Gid>) -> io::Result<()> {
-    unsafe {
-        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
-        ret(c::chown(c_str(path), ow, gr))
-    }
-}
-
-#[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::ugid::translate_fchown_args(owner, group);
-        ret(fchown(borrowed_fd(fd), ow, gr))
-    }
-}
-
-#[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::ugid::translate_fchown_args(owner, group);
-        ret(c::fchown(borrowed_fd(fd), ow, gr))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "solaris",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-pub(crate) fn flock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::Result<()> {
-    unsafe { ret(c::flock(borrowed_fd(fd), operation as c::c_int)) }
-}
-
-#[cfg(linux_kernel)]
-pub(crate) fn syncfs(fd: BorrowedFd<'_>) -> io::Result<()> {
-    // Some versions of Android libc lack a `syncfs` function.
-    #[cfg(target_os = "android")]
-    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"))]
-    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 = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-pub(crate) fn sync() {
-    unsafe { c::sync() }
-}
-
-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(all(
-        linux_kernel,
-        any(
-            target_pointer_width = "32",
-            target_arch = "mips64",
-            target_arch = "mips64r6"
-        )
-    ))]
-    {
-        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),
-        }
-    }
-
-    // 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",
-            target_arch = "mips64r6"
-        )
-    )))]
-    unsafe {
-        let mut stat = MaybeUninit::<Stat>::uninit();
-        ret(c::fstat(borrowed_fd(fd), stat.as_mut_ptr()))?;
-        Ok(stat.assume_init())
-    }
-}
-
-#[cfg(all(
-    linux_kernel,
-    any(
-        target_pointer_width = "32",
-        target_arch = "mips64",
-        target_arch = "mips64r6"
-    )
-))]
-fn fstat_old(fd: BorrowedFd<'_>) -> io::Result<Stat> {
-    unsafe {
-        let mut result = MaybeUninit::<c::stat64>::uninit();
-        ret(c::fstat(borrowed_fd(fd), result.as_mut_ptr()))?;
-        stat64_to_stat(result.assume_init())
-    }
-}
-
-#[cfg(not(any(
-    solarish,
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-pub(crate) fn fstatfs(fd: BorrowedFd<'_>) -> io::Result<StatFs> {
-    let mut statfs = MaybeUninit::<StatFs>::uninit();
-    unsafe {
-        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::<c::statvfs>::uninit();
-    unsafe {
-        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: c::statvfs) -> StatVfs {
-    StatVfs {
-        f_bsize: from.f_bsize as u64,
-        f_frsize: from.f_frsize as u64,
-        f_blocks: from.f_blocks as u64,
-        f_bfree: from.f_bfree as u64,
-        f_bavail: from.f_bavail as u64,
-        f_files: from.f_files as u64,
-        f_ffree: from.f_ffree as u64,
-        f_favail: from.f_ffree as u64,
-        #[cfg(not(target_os = "aix"))]
-        f_fsid: from.f_fsid as u64,
-        #[cfg(target_os = "aix")]
-        f_fsid: ((from.f_fsid.val[0] as u64) << 32) | from.f_fsid.val[1],
-        f_flag: StatVfsMountFlags::from_bits_retain(from.f_flag as u64),
-        f_namemax: from.f_namemax as u64,
-    }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-pub(crate) fn futimens(fd: BorrowedFd<'_>, times: &Timestamps) -> io::Result<()> {
-    // Old 32-bit version: libc has `futimens` but it is not y2038 safe by
-    // default. But there may be a `__futimens64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_futimens) = __futimens64.get() {
-            let libc_times: [LibcTimespec; 2] = [
-                times.last_access.clone().into(),
-                times.last_modification.clone().into(),
-            ];
-
-            unsafe {
-                return ret(libc_futimens(borrowed_fd(fd), libc_times.as_ptr()));
-            }
-        }
-
-        futimens_old(fd, times)
-    }
-
-    // Main version: libc is y2038 safe and has `futimens`. Or, the platform
-    // is not y2038 safe and there's nothing practical we can do.
-    #[cfg(not(any(apple, fix_y2038)))]
-    unsafe {
-        use crate::utils::as_ptr;
-
-        ret(c::futimens(borrowed_fd(fd), as_ptr(times).cast()))
-    }
-
-    // Apple version: `futimens` was introduced in macOS 10.13.
-    #[cfg(apple)]
-    unsafe {
-        use crate::utils::as_ptr;
-
-        // ABI details.
-        weak! {
-            fn futimens(c::c_int, *const c::timespec) -> c::c_int
-        }
-        extern "C" {
-            fn fsetattrlist(
-                fd: c::c_int,
-                attr_list: *const Attrlist,
-                attr_buf: *const c::c_void,
-                attr_buf_size: c::size_t,
-                options: c::c_ulong,
-            ) -> c::c_int;
-        }
-
-        // If we have `futimens`, use it.
-        if let Some(have_futimens) = futimens.get() {
-            return ret(have_futimens(borrowed_fd(fd), as_ptr(times).cast()));
-        }
-
-        // Otherwise use `fsetattrlist`.
-        let (attrbuf_size, times, attrs) = times_to_attrlist(times);
-
-        ret(fsetattrlist(
-            borrowed_fd(fd),
-            &attrs,
-            as_ptr(&times).cast(),
-            attrbuf_size,
-            0,
-        ))
-    }
-}
-
-#[cfg(fix_y2038)]
-fn futimens_old(fd: BorrowedFd<'_>, times: &Timestamps) -> io::Result<()> {
-    let old_times = [
-        c::timespec {
-            tv_sec: times
-                .last_access
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: times
-                .last_access
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-        },
-        c::timespec {
-            tv_sec: times
-                .last_modification
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: times
-                .last_modification
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-        },
-    ];
-
-    unsafe { ret(c::futimens(borrowed_fd(fd), old_times.as_ptr())) }
-}
-
-#[cfg(not(any(
-    apple,
-    netbsdlike,
-    solarish,
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "espidf",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-)))]
-pub(crate) fn fallocate(
-    fd: BorrowedFd<'_>,
-    mode: FallocateFlags,
-    offset: u64,
-    len: u64,
-) -> io::Result<()> {
-    // Silently cast; we'll get `EINVAL` if the value is negative.
-    let offset = offset as i64;
-    let len = len as i64;
-
-    #[cfg(any(linux_kernel, target_os = "fuchsia"))]
-    unsafe {
-        ret(c::fallocate(
-            borrowed_fd(fd),
-            bitflags_bits!(mode),
-            offset,
-            len,
-        ))
-    }
-
-    #[cfg(not(any(linux_kernel, target_os = "fuchsia")))]
-    {
-        assert!(mode.is_empty());
-        let err = unsafe { c::posix_fallocate(borrowed_fd(fd), offset, len) };
-
-        // `posix_fallocate` returns its error status rather than using
-        // `errno`.
-        if err == 0 {
-            Ok(())
-        } else {
-            Err(io::Errno(err))
-        }
-    }
-}
-
-#[cfg(apple)]
-pub(crate) fn fallocate(
-    fd: BorrowedFd<'_>,
-    mode: FallocateFlags,
-    offset: u64,
-    len: u64,
-) -> io::Result<()> {
-    let offset: i64 = offset.try_into().map_err(|_e| io::Errno::INVAL)?;
-    let len = len as i64;
-
-    assert!(mode.is_empty());
-
-    let new_len = offset.checked_add(len).ok_or(io::Errno::FBIG)?;
-    let mut store = c::fstore_t {
-        fst_flags: c::F_ALLOCATECONTIG,
-        fst_posmode: c::F_PEOFPOSMODE,
-        fst_offset: 0,
-        fst_length: new_len,
-        fst_bytesalloc: 0,
-    };
-    unsafe {
-        if c::fcntl(borrowed_fd(fd), c::F_PREALLOCATE, &store) == -1 {
-            // Unable to allocate contiguous disk space; attempt to allocate
-            // non-contiguously.
-            store.fst_flags = c::F_ALLOCATEALL;
-            let _ = ret_c_int(c::fcntl(borrowed_fd(fd), c::F_PREALLOCATE, &store))?;
-        }
-        ret(c::ftruncate(borrowed_fd(fd), new_len))
-    }
-}
-
-pub(crate) fn fsync(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(c::fsync(borrowed_fd(fd))) }
-}
-
-#[cfg(not(any(
-    apple,
-    target_os = "dragonfly",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "redox",
-    target_os = "vita",
-)))]
-pub(crate) fn fdatasync(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(c::fdatasync(borrowed_fd(fd))) }
-}
-
-pub(crate) fn ftruncate(fd: BorrowedFd<'_>, length: u64) -> io::Result<()> {
-    let length = length.try_into().map_err(|_overflow_err| io::Errno::FBIG)?;
-    unsafe { ret(c::ftruncate(borrowed_fd(fd), length)) }
-}
-
-#[cfg(any(linux_kernel, target_os = "freebsd"))]
-pub(crate) fn memfd_create(name: &CStr, flags: MemfdFlags) -> io::Result<OwnedFd> {
-    #[cfg(target_os = "freebsd")]
-    weakcall! {
-        fn memfd_create(
-            name: *const c::c_char,
-            flags: c::c_uint
-        ) -> c::c_int
-    }
-
-    #[cfg(linux_kernel)]
-    weak_or_syscall! {
-        fn memfd_create(
-            name: *const c::c_char,
-            flags: c::c_uint
-        ) via SYS_memfd_create -> c::c_int
-    }
-
-    unsafe { ret_owned_fd(memfd_create(c_str(name), bitflags_bits!(flags))) }
-}
-
-#[cfg(linux_kernel)]
-pub(crate) fn openat2(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    oflags: OFlags,
-    mode: Mode,
-    resolve: ResolveFlags,
-) -> io::Result<OwnedFd> {
-    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 {
-        ret_owned_fd(openat2(
-            borrowed_fd(dirfd),
-            c_str(path),
-            &mut open_how,
-            size_of::<open_how>(),
-        ))
-    }
-}
-#[cfg(all(linux_kernel, target_pointer_width = "32"))]
-const SYS_OPENAT2: i32 = 437;
-#[cfg(all(linux_kernel, target_pointer_width = "64"))]
-const SYS_OPENAT2: i64 = 437;
-
-#[cfg(target_os = "linux")]
-pub(crate) fn sendfile(
-    out_fd: BorrowedFd<'_>,
-    in_fd: BorrowedFd<'_>,
-    offset: Option<&mut u64>,
-    count: usize,
-) -> io::Result<usize> {
-    unsafe {
-        ret_usize(c::sendfile64(
-            borrowed_fd(out_fd),
-            borrowed_fd(in_fd),
-            offset.map_or(null_mut(), crate::utils::as_mut_ptr).cast(),
-            count,
-        ))
-    }
-}
-
-/// Convert from a Linux `statx` value to rustix's `Stat`.
-#[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(),
-        st_mode: x.stx_mode.into(),
-        st_nlink: x.stx_nlink.into(),
-        st_uid: x.stx_uid.into(),
-        st_gid: x.stx_gid.into(),
-        st_rdev: crate::fs::makedev(x.stx_rdev_major, x.stx_rdev_minor).into(),
-        st_size: x.stx_size.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_blksize: x.stx_blksize.into(),
-        st_blocks: x.stx_blocks.into(),
-        st_atime: x
-            .stx_atime
-            .tv_sec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_atime_nsec: x.stx_atime.tv_nsec as _,
-        st_mtime: x
-            .stx_mtime
-            .tv_sec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_mtime_nsec: x.stx_mtime.tv_nsec as _,
-        st_ctime: x
-            .stx_ctime
-            .tv_sec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_ctime_nsec: x.stx_ctime.tv_nsec as _,
-        st_ino: x.stx_ino.into(),
-    })
-}
-
-/// Convert from a Linux `statx` value to rustix's `Stat`.
-///
-/// mips64' `struct stat64` in libc has private fields, and `stx_blocks`
-#[cfg(all(linux_kernel, any(target_arch = "mips64", target_arch = "mips64r6")))]
-fn statx_to_stat(x: crate::fs::Statx) -> io::Result<Stat> {
-    let mut result: Stat = unsafe { core::mem::zeroed() };
-
-    result.st_dev = crate::fs::makedev(x.stx_dev_major, x.stx_dev_minor);
-    result.st_mode = x.stx_mode.into();
-    result.st_nlink = x.stx_nlink.into();
-    result.st_uid = x.stx_uid.into();
-    result.st_gid = x.stx_gid.into();
-    result.st_rdev = crate::fs::makedev(x.stx_rdev_major, x.stx_rdev_minor);
-    result.st_size = x.stx_size.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_blksize = x.stx_blksize.into();
-    result.st_blocks = x.stx_blocks.try_into().map_err(|_e| io::Errno::OVERFLOW)?;
-    result.st_atime = x
-        .stx_atime
-        .tv_sec
-        .try_into()
-        .map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_atime_nsec = x.stx_atime.tv_nsec as _;
-    result.st_mtime = x
-        .stx_mtime
-        .tv_sec
-        .try_into()
-        .map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_mtime_nsec = x.stx_mtime.tv_nsec as _;
-    result.st_ctime = x
-        .stx_ctime
-        .tv_sec
-        .try_into()
-        .map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_ctime_nsec = x.stx_ctime.tv_nsec as _;
-    result.st_ino = x.stx_ino.into();
-
-    Ok(result)
-}
-
-/// Convert from a Linux `stat64` value to rustix's `Stat`.
-#[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)?,
-        st_mode: s64.st_mode.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_nlink: s64.st_nlink.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_uid: s64.st_uid.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_gid: s64.st_gid.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_rdev: s64.st_rdev.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_size: s64.st_size.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_blksize: s64.st_blksize.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_blocks: s64.st_blocks.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_atime: s64.st_atime.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_atime_nsec: s64
-            .st_atime_nsec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_mtime: s64.st_mtime.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_mtime_nsec: s64
-            .st_mtime_nsec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_ctime: s64.st_ctime.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_ctime_nsec: s64
-            .st_ctime_nsec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_ino: s64.st_ino.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-    })
-}
-
-/// Convert from a Linux `stat64` value to rustix's `Stat`.
-///
-/// mips64' `struct stat64` in libc has private fields, and `st_blocks` has
-/// type `i64`.
-#[cfg(all(linux_kernel, any(target_arch = "mips64", target_arch = "mips64r6")))]
-fn stat64_to_stat(s64: c::stat64) -> io::Result<Stat> {
-    let mut result: Stat = unsafe { core::mem::zeroed() };
-
-    result.st_dev = s64.st_dev.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_mode = s64.st_mode.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_nlink = s64.st_nlink.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_uid = s64.st_uid.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_gid = s64.st_gid.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_rdev = s64.st_rdev.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_size = s64.st_size.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_blksize = s64.st_blksize.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_blocks = s64.st_blocks.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_atime = s64.st_atime.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_atime_nsec = s64
-        .st_atime_nsec
-        .try_into()
-        .map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_mtime = s64.st_mtime.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_mtime_nsec = s64
-        .st_mtime_nsec
-        .try_into()
-        .map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_ctime = s64.st_ctime.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_ctime_nsec = s64
-        .st_ctime_nsec
-        .try_into()
-        .map_err(|_| io::Errno::OVERFLOW)?;
-    result.st_ino = s64.st_ino.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-
-    Ok(result)
-}
-
-#[cfg(linux_kernel)]
-#[allow(non_upper_case_globals)]
-mod sys {
-    use super::{c, BorrowedFd, Statx};
-
-    weak_or_syscall! {
-        pub(super) fn statx(
-            dirfd_: BorrowedFd<'_>,
-            path: *const c::c_char,
-            flags: c::c_int,
-            mask: c::c_uint,
-            buf: *mut Statx
-        ) via SYS_statx -> c::c_int
-    }
-}
-
-#[cfg(linux_kernel)]
-#[allow(non_upper_case_globals)]
-pub(crate) fn statx(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    flags: AtFlags,
-    mask: StatxFlags,
-) -> io::Result<Statx> {
-    // If a future Linux kernel adds more fields to `struct statx` and users
-    // passing flags unknown to rustix in `StatxFlags`, we could end up
-    // writing outside of the buffer. To prevent this possibility, we mask off
-    // any flags that we don't know about.
-    //
-    // This includes `STATX__RESERVED`, which has a value that we know, but
-    // which could take on arbitrary new meaning in the future. Linux currently
-    // rejects this flag with `EINVAL`, so we do the same.
-    //
-    // This doesn't rely on `STATX_ALL` because [it's deprecated] and already
-    // doesn't represent all the known flags.
-    //
-    // [it's deprecated]: https://patchwork.kernel.org/project/linux-fsdevel/patch/20200505095915.11275-7-mszeredi@redhat.com/
-    #[cfg(not(any(target_os = "android", target_env = "musl")))]
-    const STATX__RESERVED: u32 = c::STATX__RESERVED as u32;
-    #[cfg(any(target_os = "android", target_env = "musl"))]
-    const STATX__RESERVED: u32 = linux_raw_sys::general::STATX__RESERVED;
-    if (mask.bits() & STATX__RESERVED) == STATX__RESERVED {
-        return Err(io::Errno::INVAL);
-    }
-    let mask = mask & StatxFlags::all();
-
-    let mut statx_buf = MaybeUninit::<Statx>::uninit();
-    unsafe {
-        ret(sys::statx(
-            dirfd,
-            c_str(path),
-            bitflags_bits!(flags),
-            mask.bits(),
-            statx_buf.as_mut_ptr(),
-        ))?;
-        Ok(statx_buf.assume_init())
-    }
-}
-
-#[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())),
-            Err(io::Errno::FAULT)
-        )
-    }
-}
-
-#[cfg(apple)]
-pub(crate) unsafe fn fcopyfile(
-    from: BorrowedFd<'_>,
-    to: BorrowedFd<'_>,
-    state: copyfile_state_t,
-    flags: CopyfileFlags,
-) -> io::Result<()> {
-    extern "C" {
-        fn fcopyfile(
-            from: c::c_int,
-            to: c::c_int,
-            state: copyfile_state_t,
-            flags: c::c_uint,
-        ) -> c::c_int;
-    }
-
-    nonnegative_ret(fcopyfile(
-        borrowed_fd(from),
-        borrowed_fd(to),
-        state,
-        bitflags_bits!(flags),
-    ))
-}
-
-#[cfg(apple)]
-pub(crate) fn copyfile_state_alloc() -> io::Result<copyfile_state_t> {
-    extern "C" {
-        fn copyfile_state_alloc() -> copyfile_state_t;
-    }
-
-    let result = unsafe { copyfile_state_alloc() };
-    if result.0.is_null() {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(result)
-    }
-}
-
-#[cfg(apple)]
-pub(crate) unsafe fn copyfile_state_free(state: copyfile_state_t) -> io::Result<()> {
-    extern "C" {
-        fn copyfile_state_free(state: copyfile_state_t) -> c::c_int;
-    }
-
-    nonnegative_ret(copyfile_state_free(state))
-}
-
-#[cfg(apple)]
-const COPYFILE_STATE_COPIED: u32 = 8;
-
-#[cfg(apple)]
-pub(crate) unsafe fn copyfile_state_get_copied(state: copyfile_state_t) -> io::Result<u64> {
-    let mut copied = MaybeUninit::<u64>::uninit();
-    copyfile_state_get(state, COPYFILE_STATE_COPIED, copied.as_mut_ptr().cast())?;
-    Ok(copied.assume_init())
-}
-
-#[cfg(apple)]
-pub(crate) unsafe fn copyfile_state_get(
-    state: copyfile_state_t,
-    flag: u32,
-    dst: *mut c::c_void,
-) -> io::Result<()> {
-    extern "C" {
-        fn copyfile_state_get(state: copyfile_state_t, flag: u32, dst: *mut c::c_void) -> c::c_int;
-    }
-
-    nonnegative_ret(copyfile_state_get(state, flag, dst))
-}
-
-#[cfg(all(apple, feature = "alloc"))]
-pub(crate) fn getpath(fd: BorrowedFd<'_>) -> io::Result<CString> {
-    // The use of `PATH_MAX` is generally not encouraged, but it
-    // is inevitable in this case because macOS defines `fcntl` with
-    // `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 = 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
-    //               must be a buffer of size `MAXPATHLEN` or greater.
-    //
-    // [macOS `fcntl` manual page]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fcntl.2.html
-    unsafe {
-        ret(c::fcntl(borrowed_fd(fd), c::F_GETPATH, buf.as_mut_ptr()))?;
-    }
-
-    let l = buf.iter().position(|&c| c == 0).unwrap();
-    buf.truncate(l);
-    buf.shrink_to_fit();
-
-    Ok(CString::new(buf).unwrap())
-}
-
-#[cfg(apple)]
-pub(crate) fn fcntl_rdadvise(fd: BorrowedFd<'_>, offset: u64, len: u64) -> io::Result<()> {
-    // From the [macOS `fcntl` manual page]:
-    // `F_RDADVISE` - Issue an advisory read async with no copy to user.
-    //
-    // The `F_RDADVISE` command operates on the following structure which holds
-    // information passed from the user to the system:
-    //
-    // ```c
-    // struct radvisory {
-    //      off_t   ra_offset;  /* offset into the file */
-    //      int     ra_count;   /* size of the read     */
-    // };
-    // ```
-    //
-    // [macOS `fcntl` manual page]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fcntl.2.html
-    let ra_offset = match offset.try_into() {
-        Ok(len) => len,
-        // If this conversion fails, the user is providing an offset outside
-        // any possible file extent, so just ignore it.
-        Err(_) => return Ok(()),
-    };
-    let ra_count = match len.try_into() {
-        Ok(len) => len,
-        // If this conversion fails, the user is providing a dubiously large
-        // hint which is unlikely to improve performance.
-        Err(_) => return Ok(()),
-    };
-    unsafe {
-        let radvisory = c::radvisory {
-            ra_offset,
-            ra_count,
-        };
-        ret(c::fcntl(borrowed_fd(fd), c::F_RDADVISE, &radvisory))
-    }
-}
-
-#[cfg(apple)]
-pub(crate) fn fcntl_fullfsync(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_FULLFSYNC)) }
-}
-
-#[cfg(apple)]
-pub(crate) fn fcntl_nocache(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_NOCACHE, value as c::c_int)) }
-}
-
-#[cfg(apple)]
-pub(crate) fn fcntl_global_nocache(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    unsafe {
-        ret(c::fcntl(
-            borrowed_fd(fd),
-            c::F_GLOBAL_NOCACHE,
-            value as c::c_int,
-        ))
-    }
-}
-
-/// Convert `times` from a `futimens`/`utimensat` argument into `setattrlist`
-/// arguments.
-#[cfg(apple)]
-fn times_to_attrlist(times: &Timestamps) -> (c::size_t, [c::timespec; 2], Attrlist) {
-    // ABI details.
-    const ATTR_CMN_MODTIME: u32 = 0x0000_0400;
-    const ATTR_CMN_ACCTIME: u32 = 0x0000_1000;
-    const ATTR_BIT_MAP_COUNT: u16 = 5;
-
-    let mut times = times.clone();
-
-    // If we have any `UTIME_NOW` elements, replace them with the current time.
-    if times.last_access.tv_nsec == c::UTIME_NOW || times.last_modification.tv_nsec == c::UTIME_NOW
-    {
-        let now = {
-            let mut tv = c::timeval {
-                tv_sec: 0,
-                tv_usec: 0,
-            };
-            unsafe {
-                let r = c::gettimeofday(&mut tv, null_mut());
-                assert_eq!(r, 0);
-            }
-            c::timespec {
-                tv_sec: tv.tv_sec,
-                tv_nsec: (tv.tv_usec * 1000) as _,
-            }
-        };
-        if times.last_access.tv_nsec == c::UTIME_NOW {
-            times.last_access = now;
-        }
-        if times.last_modification.tv_nsec == c::UTIME_NOW {
-            times.last_modification = now;
-        }
-    }
-
-    // Pack the return values following the rules for [`getattrlist`].
-    //
-    // [`getattrlist`]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getattrlist.2.html
-    let mut times_size = 0;
-    let mut attrs = Attrlist {
-        bitmapcount: ATTR_BIT_MAP_COUNT,
-        reserved: 0,
-        commonattr: 0,
-        volattr: 0,
-        dirattr: 0,
-        fileattr: 0,
-        forkattr: 0,
-    };
-    let mut return_times = [c::timespec {
-        tv_sec: 0,
-        tv_nsec: 0,
-    }; 2];
-    let mut times_index = 0;
-    if times.last_modification.tv_nsec != c::UTIME_OMIT {
-        attrs.commonattr |= ATTR_CMN_MODTIME;
-        return_times[times_index] = times.last_modification;
-        times_index += 1;
-        times_size += size_of::<c::timespec>();
-    }
-    if times.last_access.tv_nsec != c::UTIME_OMIT {
-        attrs.commonattr |= ATTR_CMN_ACCTIME;
-        return_times[times_index] = times.last_access;
-        times_size += size_of::<c::timespec>();
-    }
-
-    (times_size, return_times, attrs)
-}
-
-/// Support type for `Attrlist`.
-#[cfg(apple)]
-type Attrgroup = u32;
-
-/// Attribute list for use with `setattrlist`.
-#[cfg(apple)]
-#[repr(C)]
-struct Attrlist {
-    bitmapcount: u16,
-    reserved: u16,
-    commonattr: Attrgroup,
-    volattr: Attrgroup,
-    dirattr: Attrgroup,
-    fileattr: Attrgroup,
-    forkattr: Attrgroup,
-}
-
-#[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();
-
-    #[cfg(not(apple))]
-    unsafe {
-        ret_usize(c::getxattr(
-            path.as_ptr(),
-            name.as_ptr(),
-            value_ptr.cast::<c::c_void>(),
-            value.len(),
-        ))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret_usize(c::getxattr(
-            path.as_ptr(),
-            name.as_ptr(),
-            value_ptr.cast::<c::c_void>(),
-            value.len(),
-            0,
-            0,
-        ))
-    }
-}
-
-#[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();
-
-    #[cfg(not(apple))]
-    unsafe {
-        ret_usize(c::lgetxattr(
-            path.as_ptr(),
-            name.as_ptr(),
-            value_ptr.cast::<c::c_void>(),
-            value.len(),
-        ))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret_usize(c::getxattr(
-            path.as_ptr(),
-            name.as_ptr(),
-            value_ptr.cast::<c::c_void>(),
-            value.len(),
-            0,
-            c::XATTR_NOFOLLOW,
-        ))
-    }
-}
-
-#[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();
-
-    #[cfg(not(apple))]
-    unsafe {
-        ret_usize(c::fgetxattr(
-            borrowed_fd(fd),
-            name.as_ptr(),
-            value_ptr.cast::<c::c_void>(),
-            value.len(),
-        ))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret_usize(c::fgetxattr(
-            borrowed_fd(fd),
-            name.as_ptr(),
-            value_ptr.cast::<c::c_void>(),
-            value.len(),
-            0,
-            0,
-        ))
-    }
-}
-
-#[cfg(any(apple, linux_kernel))]
-pub(crate) fn setxattr(
-    path: &CStr,
-    name: &CStr,
-    value: &[u8],
-    flags: XattrFlags,
-) -> io::Result<()> {
-    #[cfg(not(apple))]
-    unsafe {
-        ret(c::setxattr(
-            path.as_ptr(),
-            name.as_ptr(),
-            value.as_ptr().cast::<c::c_void>(),
-            value.len(),
-            flags.bits() as i32,
-        ))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret(c::setxattr(
-            path.as_ptr(),
-            name.as_ptr(),
-            value.as_ptr().cast::<c::c_void>(),
-            value.len(),
-            0,
-            flags.bits() as i32,
-        ))
-    }
-}
-
-#[cfg(any(apple, linux_kernel))]
-pub(crate) fn lsetxattr(
-    path: &CStr,
-    name: &CStr,
-    value: &[u8],
-    flags: XattrFlags,
-) -> io::Result<()> {
-    #[cfg(not(apple))]
-    unsafe {
-        ret(c::lsetxattr(
-            path.as_ptr(),
-            name.as_ptr(),
-            value.as_ptr().cast::<c::c_void>(),
-            value.len(),
-            flags.bits() as i32,
-        ))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret(c::setxattr(
-            path.as_ptr(),
-            name.as_ptr(),
-            value.as_ptr().cast::<c::c_void>(),
-            value.len(),
-            0,
-            flags.bits() as i32 | c::XATTR_NOFOLLOW,
-        ))
-    }
-}
-
-#[cfg(any(apple, linux_kernel))]
-pub(crate) fn fsetxattr(
-    fd: BorrowedFd<'_>,
-    name: &CStr,
-    value: &[u8],
-    flags: XattrFlags,
-) -> io::Result<()> {
-    #[cfg(not(apple))]
-    unsafe {
-        ret(c::fsetxattr(
-            borrowed_fd(fd),
-            name.as_ptr(),
-            value.as_ptr().cast::<c::c_void>(),
-            value.len(),
-            flags.bits() as i32,
-        ))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret(c::fsetxattr(
-            borrowed_fd(fd),
-            name.as_ptr(),
-            value.as_ptr().cast::<c::c_void>(),
-            value.len(),
-            0,
-            flags.bits() as i32,
-        ))
-    }
-}
-
-#[cfg(any(apple, linux_kernel))]
-pub(crate) fn listxattr(path: &CStr, list: &mut [c::c_char]) -> io::Result<usize> {
-    #[cfg(not(apple))]
-    unsafe {
-        ret_usize(c::listxattr(path.as_ptr(), list.as_mut_ptr(), list.len()))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret_usize(c::listxattr(
-            path.as_ptr(),
-            list.as_mut_ptr(),
-            list.len(),
-            0,
-        ))
-    }
-}
-
-#[cfg(any(apple, linux_kernel))]
-pub(crate) fn llistxattr(path: &CStr, list: &mut [c::c_char]) -> io::Result<usize> {
-    #[cfg(not(apple))]
-    unsafe {
-        ret_usize(c::llistxattr(path.as_ptr(), list.as_mut_ptr(), list.len()))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret_usize(c::listxattr(
-            path.as_ptr(),
-            list.as_mut_ptr(),
-            list.len(),
-            c::XATTR_NOFOLLOW,
-        ))
-    }
-}
-
-#[cfg(any(apple, linux_kernel))]
-pub(crate) fn flistxattr(fd: BorrowedFd<'_>, list: &mut [c::c_char]) -> io::Result<usize> {
-    let fd = borrowed_fd(fd);
-
-    #[cfg(not(apple))]
-    unsafe {
-        ret_usize(c::flistxattr(fd, list.as_mut_ptr(), list.len()))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret_usize(c::flistxattr(fd, list.as_mut_ptr(), list.len(), 0))
-    }
-}
-
-#[cfg(any(apple, linux_kernel))]
-pub(crate) fn removexattr(path: &CStr, name: &CStr) -> io::Result<()> {
-    #[cfg(not(apple))]
-    unsafe {
-        ret(c::removexattr(path.as_ptr(), name.as_ptr()))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret(c::removexattr(path.as_ptr(), name.as_ptr(), 0))
-    }
-}
-
-#[cfg(any(apple, linux_kernel))]
-pub(crate) fn lremovexattr(path: &CStr, name: &CStr) -> io::Result<()> {
-    #[cfg(not(apple))]
-    unsafe {
-        ret(c::lremovexattr(path.as_ptr(), name.as_ptr()))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret(c::removexattr(
-            path.as_ptr(),
-            name.as_ptr(),
-            c::XATTR_NOFOLLOW,
-        ))
-    }
-}
-
-#[cfg(any(apple, linux_kernel))]
-pub(crate) fn fremovexattr(fd: BorrowedFd<'_>, name: &CStr) -> io::Result<()> {
-    let fd = borrowed_fd(fd);
-
-    #[cfg(not(apple))]
-    unsafe {
-        ret(c::fremovexattr(fd, name.as_ptr()))
-    }
-
-    #[cfg(apple)]
-    unsafe {
-        ret(c::fremovexattr(fd, name.as_ptr(), 0))
-    }
-}
-
-#[test]
-fn test_sizes() {
-    #[cfg(linux_kernel)]
-    assert_eq_size!(c::loff_t, u64);
-
-    // Assert that `Timestamps` has the expected layout. If we're not fixing
-    // y2038, libc's type should match ours. If we are, it's smaller.
-    #[cfg(not(fix_y2038))]
-    assert_eq_size!([c::timespec; 2], Timestamps);
-    #[cfg(fix_y2038)]
-    assert!(core::mem::size_of::<[c::timespec; 2]>() < core::mem::size_of::<Timestamps>());
-}
diff --git a/vendor/rustix/src/backend/libc/fs/types.rs b/vendor/rustix/src/backend/libc/fs/types.rs
deleted file mode 100644
index 19508c2..0000000
--- a/vendor/rustix/src/backend/libc/fs/types.rs
+++ /dev/null
@@ -1,1164 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-#[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-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;
-
-        /// `W_OK`
-        const WRITE_OK = c::W_OK;
-
-        /// `X_OK`
-        const EXEC_OK = c::X_OK;
-
-        /// `F_OK`
-        const EXISTS = c::F_OK;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "redox")))]
-bitflags! {
-    /// `AT_*` constants for use with [`openat`], [`statat`], and other `*at`
-    /// functions.
-    ///
-    /// [`openat`]: crate::fs::openat
-    /// [`statat`]: crate::fs::statat
-    #[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 = bitcast!(c::AT_REMOVEDIR);
-
-        /// `AT_SYMLINK_FOLLOW`
-        const SYMLINK_FOLLOW = bitcast!(c::AT_SYMLINK_FOLLOW);
-
-        /// `AT_NO_AUTOMOUNT`
-        #[cfg(any(linux_like, target_os = "fuchsia"))]
-        const NO_AUTOMOUNT = bitcast!(c::AT_NO_AUTOMOUNT);
-
-        /// `AT_EMPTY_PATH`
-        #[cfg(any(
-            linux_kernel,
-            target_os = "freebsd",
-            target_os = "fuchsia",
-        ))]
-        const EMPTY_PATH = bitcast!(c::AT_EMPTY_PATH);
-
-        /// `AT_RESOLVE_BENEATH`
-        #[cfg(target_os = "freebsd")]
-        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 = bitcast!(c::AT_STATX_SYNC_AS_STAT);
-
-        /// `AT_STATX_FORCE_SYNC`
-        #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        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 = bitcast!(c::AT_STATX_DONT_SYNC);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `S_I*` constants for use with [`openat`], [`chmodat`], and [`fchmod`].
-    ///
-    /// [`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(any(target_os = "espidf", target_os = "vita")))]
-        const RWXU = c::S_IRWXU as RawMode;
-
-        /// `S_IRUSR`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const RUSR = c::S_IRUSR as RawMode;
-
-        /// `S_IWUSR`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const WUSR = c::S_IWUSR as RawMode;
-
-        /// `S_IXUSR`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const XUSR = c::S_IXUSR as RawMode;
-
-        /// `S_IRWXG`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const RWXG = c::S_IRWXG as RawMode;
-
-        /// `S_IRGRP`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const RGRP = c::S_IRGRP as RawMode;
-
-        /// `S_IWGRP`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const WGRP = c::S_IWGRP as RawMode;
-
-        /// `S_IXGRP`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const XGRP = c::S_IXGRP as RawMode;
-
-        /// `S_IRWXO`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const RWXO = c::S_IRWXO as RawMode;
-
-        /// `S_IROTH`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const ROTH = c::S_IROTH as RawMode;
-
-        /// `S_IWOTH`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const WOTH = c::S_IWOTH as RawMode;
-
-        /// `S_IXOTH`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const XOTH = c::S_IXOTH as RawMode;
-
-        /// `S_ISUID`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const SUID = c::S_ISUID as RawMode;
-
-        /// `S_ISGID`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const SGID = c::S_ISGID as RawMode;
-
-        /// `S_ISVTX`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const SVTX = c::S_ISVTX as RawMode;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(not(target_os = "espidf"))]
-impl Mode {
-    /// Construct a `Mode` from the mode bits of the `st_mode` field of a
-    /// `Mode`.
-    #[inline]
-    pub const fn from_raw_mode(st_mode: RawMode) -> Self {
-        Self::from_bits_truncate(st_mode)
-    }
-
-    /// Construct an `st_mode` value from a `Mode`.
-    #[inline]
-    pub const fn as_raw_mode(self) -> RawMode {
-        self.bits()
-    }
-}
-
-#[cfg(not(target_os = "espidf"))]
-impl From<RawMode> for Mode {
-    /// Support conversions from raw mode values to `Mode`.
-    ///
-    /// ```
-    /// use rustix::fs::{Mode, RawMode};
-    /// assert_eq!(Mode::from(0o700), Mode::RWXU);
-    /// ```
-    #[inline]
-    fn from(st_mode: RawMode) -> Self {
-        Self::from_raw_mode(st_mode)
-    }
-}
-
-#[cfg(not(target_os = "espidf"))]
-impl From<Mode> for RawMode {
-    /// Support conversions from `Mode` to raw mode values.
-    ///
-    /// ```
-    /// use rustix::fs::{Mode, RawMode};
-    /// assert_eq!(RawMode::from(Mode::RWXU), 0o700);
-    /// ```
-    #[inline]
-    fn from(mode: Mode) -> Self {
-        mode.as_raw_mode()
-    }
-}
-
-bitflags! {
-    /// `O_*` constants for use with [`openat`].
-    ///
-    /// [`openat`]: crate::fs::openat
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct OFlags: u32 {
-        /// `O_ACCMODE`
-        const ACCMODE = bitcast!(c::O_ACCMODE);
-
-        /// Similar to `ACCMODE`, but just includes the read/write flags, and
-        /// no other flags.
-        ///
-        /// On some platforms, `PATH` may be included in `ACCMODE`, when
-        /// sometimes we really just want the read/write bits. Caution is
-        /// indicated, as the presence of `PATH` may mean that the read/write
-        /// bits don't have their usual meaning.
-        const RWMODE = bitcast!(c::O_RDONLY | c::O_WRONLY | c::O_RDWR);
-
-        /// `O_APPEND`
-        const APPEND = bitcast!(c::O_APPEND);
-
-        /// `O_CREAT`
-        #[doc(alias = "CREAT")]
-        const CREATE = bitcast!(c::O_CREAT);
-
-        /// `O_DIRECTORY`
-        #[cfg(not(target_os = "espidf"))]
-        const DIRECTORY = bitcast!(c::O_DIRECTORY);
-
-        /// `O_DSYNC`
-        #[cfg(not(any(target_os = "dragonfly", target_os = "espidf", target_os = "l4re", target_os = "redox", target_os = "vita")))]
-        const DSYNC = bitcast!(c::O_DSYNC);
-
-        /// `O_EXCL`
-        const EXCL = bitcast!(c::O_EXCL);
-
-        /// `O_FSYNC`
-        #[cfg(any(
-            bsd,
-            all(target_os = "linux", not(target_env = "musl")),
-        ))]
-        const FSYNC = bitcast!(c::O_FSYNC);
-
-        /// `O_NOFOLLOW`
-        #[cfg(not(target_os = "espidf"))]
-        const NOFOLLOW = bitcast!(c::O_NOFOLLOW);
-
-        /// `O_NONBLOCK`
-        const NONBLOCK = bitcast!(c::O_NONBLOCK);
-
-        /// `O_RDONLY`
-        const RDONLY = bitcast!(c::O_RDONLY);
-
-        /// `O_WRONLY`
-        const WRONLY = bitcast!(c::O_WRONLY);
-
-        /// `O_RDWR`
-        ///
-        /// This is not equal to `RDONLY | WRONLY`. It's a distinct flag.
-        const RDWR = bitcast!(c::O_RDWR);
-
-        /// `O_NOCTTY`
-        #[cfg(not(any(target_os = "espidf", target_os = "l4re", target_os = "redox", target_os = "vita")))]
-        const NOCTTY = bitcast!(c::O_NOCTTY);
-
-        /// `O_RSYNC`
-        #[cfg(any(
-            linux_kernel,
-            netbsdlike,
-            target_os = "emscripten",
-            target_os = "wasi",
-        ))]
-        const RSYNC = bitcast!(c::O_RSYNC);
-
-        /// `O_SYNC`
-        #[cfg(not(any(target_os = "l4re", target_os = "redox")))]
-        const SYNC = bitcast!(c::O_SYNC);
-
-        /// `O_TRUNC`
-        const TRUNC = bitcast!(c::O_TRUNC);
-
-        /// `O_PATH`
-        #[cfg(any(
-            linux_kernel,
-            target_os = "emscripten",
-            target_os = "freebsd",
-            target_os = "fuchsia",
-            target_os = "redox",
-        ))]
-        const PATH = bitcast!(c::O_PATH);
-
-        /// `O_CLOEXEC`
-        const CLOEXEC = bitcast!(c::O_CLOEXEC);
-
-        /// `O_TMPFILE`
-        #[cfg(any(
-            linux_kernel,
-            target_os = "emscripten",
-            target_os = "fuchsia",
-        ))]
-        const TMPFILE = bitcast!(c::O_TMPFILE);
-
-        /// `O_NOATIME`
-        #[cfg(any(
-            linux_kernel,
-            target_os = "fuchsia",
-        ))]
-        const NOATIME = bitcast!(c::O_NOATIME);
-
-        /// `O_DIRECT`
-        #[cfg(any(
-            linux_kernel,
-            target_os = "emscripten",
-            target_os = "freebsd",
-            target_os = "fuchsia",
-            target_os = "netbsd",
-        ))]
-        const DIRECT = bitcast!(c::O_DIRECT);
-
-        /// `O_RESOLVE_BENEATH`
-        #[cfg(target_os = "freebsd")]
-        const RESOLVE_BENEATH = bitcast!(c::O_RESOLVE_BENEATH);
-
-        /// `O_EMPTY_PATH`
-        #[cfg(target_os = "freebsd")]
-        const EMPTY_PATH = bitcast!(c::O_EMPTY_PATH);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(apple)]
-bitflags! {
-    /// `CLONE_*` constants for use with [`fclonefileat`].
-    ///
-    /// [`fclonefileat`]: crate::fs::fclonefileat
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct CloneFlags: u32 {
-        /// `CLONE_NOFOLLOW`
-        const NOFOLLOW = 1;
-
-        /// `CLONE_NOOWNERCOPY`
-        const NOOWNERCOPY = 2;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(apple)]
-mod copyfile {
-    pub(super) const ACL: u32 = 1 << 0;
-    pub(super) const STAT: u32 = 1 << 1;
-    pub(super) const XATTR: u32 = 1 << 2;
-    pub(super) const DATA: u32 = 1 << 3;
-    pub(super) const SECURITY: u32 = STAT | ACL;
-    pub(super) const METADATA: u32 = SECURITY | XATTR;
-    pub(super) const ALL: u32 = METADATA | DATA;
-}
-
-#[cfg(apple)]
-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;
-
-        /// `COPYFILE_STAT`
-        const STAT = copyfile::STAT;
-
-        /// `COPYFILE_XATTR`
-        const XATTR = copyfile::XATTR;
-
-        /// `COPYFILE_DATA`
-        const DATA = copyfile::DATA;
-
-        /// `COPYFILE_SECURITY`
-        const SECURITY = copyfile::SECURITY;
-
-        /// `COPYFILE_METADATA`
-        const METADATA = copyfile::METADATA;
-
-        /// `COPYFILE_ALL`
-        const ALL = copyfile::ALL;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `RESOLVE_*` constants for use with [`openat2`].
-    ///
-    /// [`openat2`]: crate::fs::openat2
-    #[repr(transparent)]
-    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct ResolveFlags: u64 {
-        /// `RESOLVE_NO_XDEV`
-        const NO_XDEV = 0x01;
-
-        /// `RESOLVE_NO_MAGICLINKS`
-        const NO_MAGICLINKS = 0x02;
-
-        /// `RESOLVE_NO_SYMLINKS`
-        const NO_SYMLINKS = 0x04;
-
-        /// `RESOLVE_BENEATH`
-        const BENEATH = 0x08;
-
-        /// `RESOLVE_IN_ROOT`
-        const IN_ROOT = 0x10;
-
-        /// `RESOLVE_CACHED` (since Linux 5.12)
-        const CACHED = 0x20;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[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 = bitcast!(c::RENAME_EXCHANGE);
-
-        /// `RENAME_NOREPLACE`
-        const NOREPLACE = bitcast!(c::RENAME_NOREPLACE);
-
-        /// `RENAME_WHITEOUT`
-        const WHITEOUT = bitcast!(c::RENAME_WHITEOUT);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `S_IF*` constants for use with [`mknodat`] and [`Stat`]'s `st_mode` field.
-///
-/// [`mknodat`]: crate::fs::mknodat
-/// [`Stat`]: crate::fs::Stat
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum FileType {
-    /// `S_IFREG`
-    RegularFile = c::S_IFREG as isize,
-
-    /// `S_IFDIR`
-    Directory = c::S_IFDIR as isize,
-
-    /// `S_IFLNK`
-    Symlink = c::S_IFLNK as isize,
-
-    /// `S_IFIFO`
-    #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFIFO`.
-    #[doc(alias = "IFO")]
-    Fifo = c::S_IFIFO as isize,
-
-    /// `S_IFSOCK`
-    #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFSOCK`.
-    Socket = c::S_IFSOCK as isize,
-
-    /// `S_IFCHR`
-    CharacterDevice = c::S_IFCHR as isize,
-
-    /// `S_IFBLK`
-    BlockDevice = c::S_IFBLK as isize,
-
-    /// An unknown filesystem object.
-    Unknown,
-}
-
-impl FileType {
-    /// Construct a `FileType` from the `S_IFMT` bits of the `st_mode` field of
-    /// a `Stat`.
-    #[inline]
-    pub const fn from_raw_mode(st_mode: RawMode) -> Self {
-        match (st_mode as c::mode_t) & c::S_IFMT {
-            c::S_IFREG => Self::RegularFile,
-            c::S_IFDIR => Self::Directory,
-            c::S_IFLNK => Self::Symlink,
-            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFIFO`.
-            c::S_IFIFO => Self::Fifo,
-            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFSOCK`.
-            c::S_IFSOCK => Self::Socket,
-            c::S_IFCHR => Self::CharacterDevice,
-            c::S_IFBLK => Self::BlockDevice,
-            _ => Self::Unknown,
-        }
-    }
-
-    /// Construct an `st_mode` value from a `FileType`.
-    #[inline]
-    pub const fn as_raw_mode(self) -> RawMode {
-        match self {
-            Self::RegularFile => c::S_IFREG as RawMode,
-            Self::Directory => c::S_IFDIR as RawMode,
-            Self::Symlink => c::S_IFLNK as RawMode,
-            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFIFO`.
-            Self::Fifo => c::S_IFIFO as RawMode,
-            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFSOCK`.
-            Self::Socket => c::S_IFSOCK as RawMode,
-            Self::CharacterDevice => c::S_IFCHR as RawMode,
-            Self::BlockDevice => c::S_IFBLK as RawMode,
-            Self::Unknown => c::S_IFMT as RawMode,
-        }
-    }
-
-    /// Construct a `FileType` from the `d_type` field of a `c::dirent`.
-    #[cfg(not(any(
-        solarish,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "nto",
-        target_os = "redox",
-        target_os = "vita"
-    )))]
-    #[inline]
-    pub(crate) const fn from_dirent_d_type(d_type: u8) -> Self {
-        match d_type {
-            c::DT_REG => Self::RegularFile,
-            c::DT_DIR => Self::Directory,
-            c::DT_LNK => Self::Symlink,
-            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `DT_SOCK`.
-            c::DT_SOCK => Self::Socket,
-            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `DT_FIFO`.
-            c::DT_FIFO => Self::Fifo,
-            c::DT_CHR => Self::CharacterDevice,
-            c::DT_BLK => Self::BlockDevice,
-            // c::DT_UNKNOWN |
-            _ => Self::Unknown,
-        }
-    }
-}
-
-/// `POSIX_FADV_*` constants for use with [`fadvise`].
-///
-/// [`fadvise`]: crate::fs::fadvise
-#[cfg(not(any(
-    apple,
-    netbsdlike,
-    solarish,
-    target_os = "dragonfly",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "redox",
-    target_os = "vita",
-)))]
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(u32)]
-pub enum Advice {
-    /// `POSIX_FADV_NORMAL`
-    Normal = c::POSIX_FADV_NORMAL as c::c_uint,
-
-    /// `POSIX_FADV_SEQUENTIAL`
-    Sequential = c::POSIX_FADV_SEQUENTIAL as c::c_uint,
-
-    /// `POSIX_FADV_RANDOM`
-    Random = c::POSIX_FADV_RANDOM as c::c_uint,
-
-    /// `POSIX_FADV_NOREUSE`
-    NoReuse = c::POSIX_FADV_NOREUSE as c::c_uint,
-
-    /// `POSIX_FADV_WILLNEED`
-    WillNeed = c::POSIX_FADV_WILLNEED as c::c_uint,
-
-    /// `POSIX_FADV_DONTNEED`
-    DontNeed = c::POSIX_FADV_DONTNEED as c::c_uint,
-}
-
-#[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;
-
-        /// `MFD_ALLOW_SEALING`
-        const ALLOW_SEALING = c::MFD_ALLOW_SEALING;
-
-        /// `MFD_HUGETLB` (since Linux 4.14)
-        const HUGETLB = c::MFD_HUGETLB;
-
-        /// `MFD_HUGE_64KB`
-        const HUGE_64KB = c::MFD_HUGE_64KB;
-        /// `MFD_HUGE_512JB`
-        const HUGE_512KB = c::MFD_HUGE_512KB;
-        /// `MFD_HUGE_1MB`
-        const HUGE_1MB = c::MFD_HUGE_1MB;
-        /// `MFD_HUGE_2MB`
-        const HUGE_2MB = c::MFD_HUGE_2MB;
-        /// `MFD_HUGE_8MB`
-        const HUGE_8MB = c::MFD_HUGE_8MB;
-        /// `MFD_HUGE_16MB`
-        const HUGE_16MB = c::MFD_HUGE_16MB;
-        /// `MFD_HUGE_32MB`
-        const HUGE_32MB = c::MFD_HUGE_32MB;
-        /// `MFD_HUGE_256MB`
-        const HUGE_256MB = c::MFD_HUGE_256MB;
-        /// `MFD_HUGE_512MB`
-        const HUGE_512MB = c::MFD_HUGE_512MB;
-        /// `MFD_HUGE_1GB`
-        const HUGE_1GB = c::MFD_HUGE_1GB;
-        /// `MFD_HUGE_2GB`
-        const HUGE_2GB = c::MFD_HUGE_2GB;
-        /// `MFD_HUGE_16GB`
-        const HUGE_16GB = c::MFD_HUGE_16GB;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[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
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct SealFlags: u32 {
-        /// `F_SEAL_SEAL`
-        const SEAL = bitcast!(c::F_SEAL_SEAL);
-        /// `F_SEAL_SHRINK`
-        const SHRINK = bitcast!(c::F_SEAL_SHRINK);
-        /// `F_SEAL_GROW`
-        const GROW = bitcast!(c::F_SEAL_GROW);
-        /// `F_SEAL_WRITE`
-        const WRITE = bitcast!(c::F_SEAL_WRITE);
-        /// `F_SEAL_FUTURE_WRITE` (since Linux 5.1)
-        #[cfg(linux_kernel)]
-        const FUTURE_WRITE = bitcast!(c::F_SEAL_FUTURE_WRITE);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-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;
-
-        /// `STATX_MODE`
-        const MODE = c::STATX_MODE;
-
-        /// `STATX_NLINK`
-        const NLINK = c::STATX_NLINK;
-
-        /// `STATX_UID`
-        const UID = c::STATX_UID;
-
-        /// `STATX_GID`
-        const GID = c::STATX_GID;
-
-        /// `STATX_ATIME`
-        const ATIME = c::STATX_ATIME;
-
-        /// `STATX_MTIME`
-        const MTIME = c::STATX_MTIME;
-
-        /// `STATX_CTIME`
-        const CTIME = c::STATX_CTIME;
-
-        /// `STATX_INO`
-        const INO = c::STATX_INO;
-
-        /// `STATX_SIZE`
-        const SIZE = c::STATX_SIZE;
-
-        /// `STATX_BLOCKS`
-        const BLOCKS = c::STATX_BLOCKS;
-
-        /// `STATX_BASIC_STATS`
-        const BASIC_STATS = c::STATX_BASIC_STATS;
-
-        /// `STATX_BTIME`
-        const BTIME = c::STATX_BTIME;
-
-        /// `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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-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;
-
-        /// `STATX_MODE`
-        const MODE = 0x0002;
-
-        /// `STATX_NLINK`
-        const NLINK = 0x0004;
-
-        /// `STATX_UID`
-        const UID = 0x0008;
-
-        /// `STATX_GID`
-        const GID = 0x0010;
-
-        /// `STATX_ATIME`
-        const ATIME = 0x0020;
-
-        /// `STATX_MTIME`
-        const MTIME = 0x0040;
-
-        /// `STATX_CTIME`
-        const CTIME = 0x0080;
-
-        /// `STATX_INO`
-        const INO = 0x0100;
-
-        /// `STATX_SIZE`
-        const SIZE = 0x0200;
-
-        /// `STATX_BLOCKS`
-        const BLOCKS = 0x0400;
-
-        /// `STATX_BASIC_STATS`
-        const BASIC_STATS = 0x07ff;
-
-        /// `STATX_BTIME`
-        const BTIME = 0x800;
-
-        /// `STATX_MNT_ID` (since Linux 5.8)
-        const MNT_ID = 0x1000;
-
-        /// `STATX_ALL`
-        const ALL = 0xfff;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(not(any(
-    netbsdlike,
-    solarish,
-    target_os = "aix",
-    target_os = "espidf",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita"
-)))]
-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`
-        #[cfg(not(any(
-            bsd,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "hurd",
-            target_os = "wasi",
-        )))]
-        const KEEP_SIZE = bitcast!(c::FALLOC_FL_KEEP_SIZE);
-        /// `FALLOC_FL_PUNCH_HOLE`
-        #[cfg(not(any(
-            bsd,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "hurd",
-            target_os = "wasi",
-        )))]
-        const PUNCH_HOLE = bitcast!(c::FALLOC_FL_PUNCH_HOLE);
-        /// `FALLOC_FL_NO_HIDE_STALE`
-        #[cfg(not(any(
-            bsd,
-            target_os = "aix",
-            target_os = "emscripten",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "hurd",
-            target_os = "l4re",
-            target_os = "linux",
-            target_os = "wasi",
-        )))]
-        const NO_HIDE_STALE = bitcast!(c::FALLOC_FL_NO_HIDE_STALE);
-        /// `FALLOC_FL_COLLAPSE_RANGE`
-        #[cfg(not(any(
-            bsd,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "hurd",
-            target_os = "emscripten",
-            target_os = "wasi",
-        )))]
-        const COLLAPSE_RANGE = bitcast!(c::FALLOC_FL_COLLAPSE_RANGE);
-        /// `FALLOC_FL_ZERO_RANGE`
-        #[cfg(not(any(
-            bsd,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "hurd",
-            target_os = "emscripten",
-            target_os = "wasi",
-        )))]
-        const ZERO_RANGE = bitcast!(c::FALLOC_FL_ZERO_RANGE);
-        /// `FALLOC_FL_INSERT_RANGE`
-        #[cfg(not(any(
-            bsd,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "hurd",
-            target_os = "emscripten",
-            target_os = "wasi",
-        )))]
-        const INSERT_RANGE = bitcast!(c::FALLOC_FL_INSERT_RANGE);
-        /// `FALLOC_FL_UNSHARE_RANGE`
-        #[cfg(not(any(
-            bsd,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "hurd",
-            target_os = "emscripten",
-            target_os = "wasi",
-        )))]
-        const UNSHARE_RANGE = bitcast!(c::FALLOC_FL_UNSHARE_RANGE);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[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(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
-        const MANDLOCK = c::ST_MANDLOCK as u64;
-
-        /// `ST_NOATIME`
-        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
-        const NOATIME = c::ST_NOATIME as u64;
-
-        /// `ST_NODEV`
-        #[cfg(any(
-            linux_kernel,
-            target_os = "aix",
-            target_os = "emscripten",
-            target_os = "fuchsia"
-        ))]
-        const NODEV = c::ST_NODEV as u64;
-
-        /// `ST_NODIRATIME`
-        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
-        const NODIRATIME = c::ST_NODIRATIME as u64;
-
-        /// `ST_NOEXEC`
-        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
-        const NOEXEC = c::ST_NOEXEC as u64;
-
-        /// `ST_NOSUID`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const NOSUID = c::ST_NOSUID as u64;
-
-        /// `ST_RDONLY`
-        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-        const RDONLY = c::ST_RDONLY as u64;
-
-        /// `ST_RELATIME`
-        #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))]
-        const RELATIME = c::ST_RELATIME as u64;
-
-        /// `ST_SYNCHRONOUS`
-        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
-        const SYNCHRONOUS = c::ST_SYNCHRONOUS as u64;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `LOCK_*` constants for use with [`flock`] and [`fcntl_lock`].
-///
-/// [`flock`]: crate::fs::flock
-/// [`fcntl_lock`]: crate::fs::fcntl_lock
-#[cfg(not(any(target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-#[repr(u32)]
-pub enum FlockOperation {
-    /// `LOCK_SH`
-    LockShared = bitcast!(c::LOCK_SH),
-    /// `LOCK_EX`
-    LockExclusive = bitcast!(c::LOCK_EX),
-    /// `LOCK_UN`
-    Unlock = bitcast!(c::LOCK_UN),
-    /// `LOCK_SH | LOCK_NB`
-    NonBlockingLockShared = bitcast!(c::LOCK_SH | c::LOCK_NB),
-    /// `LOCK_EX | LOCK_NB`
-    NonBlockingLockExclusive = bitcast!(c::LOCK_EX | c::LOCK_NB),
-    /// `LOCK_UN | LOCK_NB`
-    NonBlockingUnlock = bitcast!(c::LOCK_UN | c::LOCK_NB),
-}
-
-/// `struct stat` for use with [`statat`] and [`fstat`].
-///
-/// [`statat`]: crate::fs::statat
-/// [`fstat`]: crate::fs::fstat
-#[cfg(not(any(linux_like, target_os = "hurd")))]
-pub type Stat = c::stat;
-
-/// `struct stat` for use with [`statat`] and [`fstat`].
-///
-/// [`statat`]: crate::fs::statat
-/// [`fstat`]: crate::fs::fstat
-#[cfg(any(
-    all(linux_kernel, target_pointer_width = "64"),
-    target_os = "hurd",
-    target_os = "emscripten",
-    target_os = "l4re",
-))]
-pub type Stat = c::stat64;
-
-/// `struct stat` for use with [`statat`] and [`fstat`].
-///
-/// [`statat`]: crate::fs::statat
-/// [`fstat`]: crate::fs::fstat
-// 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(linux_kernel, target_pointer_width = "32"))]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-#[allow(missing_docs)]
-pub struct Stat {
-    pub st_dev: u64,
-    pub st_mode: u32,
-    pub st_nlink: u32,
-    pub st_uid: u32,
-    pub st_gid: u32,
-    pub st_rdev: u64,
-    pub st_size: i64,
-    pub st_blksize: u32,
-    pub st_blocks: u64,
-    pub st_atime: u64,
-    pub st_atime_nsec: u32,
-    pub st_mtime: u64,
-    pub st_mtime_nsec: u32,
-    pub st_ctime: u64,
-    pub st_ctime_nsec: u32,
-    pub st_ino: u64,
-}
-
-/// `struct statfs` for use with [`statfs`] and [`fstatfs`].
-///
-/// [`statfs`]: crate::fs::statfs
-/// [`fstatfs`]: crate::fs::fstatfs
-#[cfg(not(any(
-    linux_like,
-    solarish,
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-#[allow(clippy::module_name_repetitions)]
-pub type StatFs = c::statfs;
-
-/// `struct statfs` for use with [`statfs`] and [`fstatfs`].
-///
-/// [`statfs`]: crate::fs::statfs
-/// [`fstatfs`]: crate::fs::fstatfs
-#[cfg(linux_like)]
-pub type StatFs = c::statfs64;
-
-/// `struct statvfs` for use with [`statvfs`] and [`fstatvfs`].
-///
-/// [`statvfs`]: crate::fs::statvfs
-/// [`fstatvfs`]: crate::fs::fstatvfs
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-#[allow(missing_docs)]
-pub struct StatVfs {
-    pub f_bsize: u64,
-    pub f_frsize: u64,
-    pub f_blocks: u64,
-    pub f_bfree: u64,
-    pub f_bavail: u64,
-    pub f_files: u64,
-    pub f_ffree: u64,
-    pub f_favail: u64,
-    pub f_fsid: u64,
-    pub f_flag: StatVfsMountFlags,
-    pub f_namemax: u64,
-}
-
-/// `struct statx` for use with [`statx`].
-///
-/// [`statx`]: crate::fs::statx
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-// Use the glibc `struct statx`.
-pub type Statx = c::statx;
-
-/// `struct statx_timestamp` for use with [`Statx`].
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-// Use the glibc `struct statx_timestamp`.
-pub type StatxTimestamp = c::statx;
-
-/// `struct statx` for use with [`statx`].
-///
-/// [`statx`]: crate::fs::statx
-// Non-glibc ABIs don't currently declare a `struct statx`, so we declare it
-// ourselves.
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-#[repr(C)]
-#[allow(missing_docs)]
-pub struct Statx {
-    pub stx_mask: u32,
-    pub stx_blksize: u32,
-    pub stx_attributes: u64,
-    pub stx_nlink: u32,
-    pub stx_uid: u32,
-    pub stx_gid: u32,
-    pub stx_mode: u16,
-    __statx_pad1: [u16; 1],
-    pub stx_ino: u64,
-    pub stx_size: u64,
-    pub stx_blocks: u64,
-    pub stx_attributes_mask: u64,
-    pub stx_atime: StatxTimestamp,
-    pub stx_btime: StatxTimestamp,
-    pub stx_ctime: StatxTimestamp,
-    pub stx_mtime: StatxTimestamp,
-    pub stx_rdev_major: u32,
-    pub stx_rdev_minor: u32,
-    pub stx_dev_major: u32,
-    pub stx_dev_minor: u32,
-    pub stx_mnt_id: u64,
-    __statx_pad2: u64,
-    __statx_pad3: [u64; 12],
-}
-
-/// `struct statx_timestamp` for use with [`Statx`].
-// Non-glibc ABIs don't currently declare a `struct statx_timestamp`, so we
-// declare it ourselves.
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-#[repr(C)]
-#[allow(missing_docs)]
-pub struct StatxTimestamp {
-    pub tv_sec: i64,
-    pub tv_nsec: u32,
-    pub __statx_timestamp_pad1: [i32; 1],
-}
-
-/// `mode_t`
-#[cfg(not(all(target_os = "android", target_pointer_width = "32")))]
-pub type RawMode = c::mode_t;
-
-/// `mode_t`
-#[cfg(all(target_os = "android", target_pointer_width = "32"))]
-pub type RawMode = c::c_uint;
-
-/// `dev_t`
-#[cfg(not(all(target_os = "android", target_pointer_width = "32")))]
-pub type Dev = c::dev_t;
-
-/// `dev_t`
-#[cfg(all(target_os = "android", target_pointer_width = "32"))]
-pub type Dev = c::c_ulonglong;
-
-/// `__fsword_t`
-#[cfg(all(
-    target_os = "linux",
-    not(target_env = "musl"),
-    not(target_arch = "s390x"),
-))]
-pub type FsWord = c::__fsword_t;
-
-/// `__fsword_t`
-#[cfg(all(
-    any(target_os = "android", all(target_os = "linux", target_env = "musl")),
-    target_pointer_width = "32",
-))]
-pub type FsWord = u32;
-
-/// `__fsword_t`
-#[cfg(all(
-    any(target_os = "android", all(target_os = "linux", target_env = "musl")),
-    not(target_arch = "s390x"),
-    target_pointer_width = "64",
-))]
-pub type FsWord = u64;
-
-/// `__fsword_t`
-// s390x uses `u32` for `statfs` entries on glibc, even though `__fsword_t` is
-// `u64`.
-#[cfg(all(target_os = "linux", target_arch = "s390x", target_env = "gnu"))]
-pub type FsWord = u32;
-
-/// `__fsword_t`
-// s390x uses `u64` for `statfs` entries on musl.
-#[cfg(all(target_os = "linux", target_arch = "s390x", target_env = "musl"))]
-pub type FsWord = u64;
-
-/// `copyfile_state_t`—State for use with [`fcopyfile`].
-///
-/// [`fcopyfile`]: crate::fs::fcopyfile
-#[cfg(apple)]
-#[allow(non_camel_case_types)]
-#[repr(transparent)]
-#[derive(Copy, Clone)]
-pub struct copyfile_state_t(pub(crate) *mut c::c_void);
diff --git a/vendor/rustix/src/backend/libc/io/errno.rs b/vendor/rustix/src/backend/libc/io/errno.rs
deleted file mode 100644
index 805ea67..0000000
--- a/vendor/rustix/src/backend/libc/io/errno.rs
+++ /dev/null
@@ -1,1052 +0,0 @@
-//! The `rustix` `Errno` type.
-//!
-//! This type holds an OS error code, which conceptually corresponds to an
-//! `errno` value.
-
-use crate::backend::c;
-use libc_errno::errno;
-
-/// `errno`—An error code.
-///
-/// The error type for `rustix` APIs. This is similar to [`std::io::Error`],
-/// but only holds an OS error code, and no extra error value.
-///
-/// # References
-///  - [POSIX]
-///  - [Linux]
-///  - [Winsock]
-///  - [FreeBSD]
-///  - [NetBSD]
-///  - [OpenBSD]
-///  - [DragonFly BSD]
-///  - [illumos]
-///  - [glibc]
-///
-/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/errno.html
-/// [Linux]: https://man7.org/linux/man-pages/man3/errno.3.html
-/// [Winsock]: https://learn.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
-/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?errno
-/// [NetBSD]: https://man.netbsd.org/errno.2
-/// [OpenBSD]: https://man.openbsd.org/errno.2
-/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=errno&section=2
-/// [illumos]: https://illumos.org/man/3C/errno
-/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Error-Codes.html
-/// [`std::io::Error`]: Result
-#[repr(transparent)]
-#[doc(alias = "errno")]
-#[derive(Eq, PartialEq, Hash, Copy, Clone)]
-pub struct Errno(pub(crate) c::c_int);
-
-impl Errno {
-    /// `EACCES`
-    #[doc(alias = "ACCES")]
-    pub const ACCESS: Self = Self(c::EACCES);
-    /// `EADDRINUSE`
-    pub const ADDRINUSE: Self = Self(c::EADDRINUSE);
-    /// `EADDRNOTAVAIL`
-    pub const ADDRNOTAVAIL: Self = Self(c::EADDRNOTAVAIL);
-    /// `EADV`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const ADV: Self = Self(c::EADV);
-    /// `EAFNOSUPPORT`
-    #[cfg(not(target_os = "l4re"))]
-    pub const AFNOSUPPORT: Self = Self(c::EAFNOSUPPORT);
-    /// `EAGAIN`
-    pub const AGAIN: Self = Self(c::EAGAIN);
-    /// `EALREADY`
-    #[cfg(not(target_os = "l4re"))]
-    pub const ALREADY: Self = Self(c::EALREADY);
-    /// `EAUTH`
-    #[cfg(bsd)]
-    pub const AUTH: Self = Self(c::EAUTH);
-    /// `EBADE`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const BADE: Self = Self(c::EBADE);
-    /// `EBADF`
-    pub const BADF: Self = Self(c::EBADF);
-    /// `EBADFD`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const BADFD: Self = Self(c::EBADFD);
-    /// `EBADMSG`
-    #[cfg(not(any(windows, target_os = "l4re")))]
-    pub const BADMSG: Self = Self(c::EBADMSG);
-    /// `EBADR`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const BADR: Self = Self(c::EBADR);
-    /// `EBADRPC`
-    #[cfg(bsd)]
-    pub const BADRPC: Self = Self(c::EBADRPC);
-    /// `EBADRQC`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const BADRQC: Self = Self(c::EBADRQC);
-    /// `EBADSLT`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const BADSLT: Self = Self(c::EBADSLT);
-    /// `EBFONT`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const BFONT: Self = Self(c::EBFONT);
-    /// `EBUSY`
-    #[cfg(not(windows))]
-    pub const BUSY: Self = Self(c::EBUSY);
-    /// `ECANCELED`
-    #[cfg(not(target_os = "l4re"))]
-    pub const CANCELED: Self = Self(c::ECANCELED);
-    /// `ECAPMODE`
-    #[cfg(target_os = "freebsd")]
-    pub const CAPMODE: Self = Self(c::ECAPMODE);
-    /// `ECHILD`
-    #[cfg(not(windows))]
-    pub const CHILD: Self = Self(c::ECHILD);
-    /// `ECHRNG`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const CHRNG: Self = Self(c::ECHRNG);
-    /// `ECOMM`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const COMM: Self = Self(c::ECOMM);
-    /// `ECONNABORTED`
-    pub const CONNABORTED: Self = Self(c::ECONNABORTED);
-    /// `ECONNREFUSED`
-    pub const CONNREFUSED: Self = Self(c::ECONNREFUSED);
-    /// `ECONNRESET`
-    pub const CONNRESET: Self = Self(c::ECONNRESET);
-    /// `EDEADLK`
-    #[cfg(not(windows))]
-    pub const DEADLK: Self = Self(c::EDEADLK);
-    /// `EDEADLOCK`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "android",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const DEADLOCK: Self = Self(c::EDEADLOCK);
-    /// `EDESTADDRREQ`
-    #[cfg(not(target_os = "l4re"))]
-    pub const DESTADDRREQ: Self = Self(c::EDESTADDRREQ);
-    /// `EDISCON`
-    #[cfg(windows)]
-    pub const DISCON: Self = Self(c::EDISCON);
-    /// `EDOM`
-    #[cfg(not(windows))]
-    pub const DOM: Self = Self(c::EDOM);
-    /// `EDOOFUS`
-    #[cfg(freebsdlike)]
-    pub const DOOFUS: Self = Self(c::EDOOFUS);
-    /// `EDOTDOT`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const DOTDOT: Self = Self(c::EDOTDOT);
-    /// `EDQUOT`
-    pub const DQUOT: Self = Self(c::EDQUOT);
-    /// `EEXIST`
-    #[cfg(not(windows))]
-    pub const EXIST: Self = Self(c::EEXIST);
-    /// `EFAULT`
-    pub const FAULT: Self = Self(c::EFAULT);
-    /// `EFBIG`
-    #[cfg(not(windows))]
-    pub const FBIG: Self = Self(c::EFBIG);
-    /// `EFTYPE`
-    #[cfg(any(bsd, target_env = "newlib"))]
-    pub const FTYPE: Self = Self(c::EFTYPE);
-    /// `EHOSTDOWN`
-    #[cfg(not(any(target_os = "l4re", target_os = "wasi")))]
-    pub const HOSTDOWN: Self = Self(c::EHOSTDOWN);
-    /// `EHOSTUNREACH`
-    pub const HOSTUNREACH: Self = Self(c::EHOSTUNREACH);
-    /// `EHWPOISON`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "android",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "redox",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const HWPOISON: Self = Self(c::EHWPOISON);
-    /// `EIDRM`
-    #[cfg(not(any(windows, target_os = "l4re")))]
-    pub const IDRM: Self = Self(c::EIDRM);
-    /// `EILSEQ`
-    #[cfg(not(any(windows, target_os = "l4re")))]
-    pub const ILSEQ: Self = Self(c::EILSEQ);
-    /// `EINPROGRESS`
-    #[cfg(not(target_os = "l4re"))]
-    pub const INPROGRESS: Self = Self(c::EINPROGRESS);
-    /// `EINTR`
-    ///
-    /// For a convenient way to retry system calls that exit with `INTR`, use
-    /// [`retry_on_intr`].
-    ///
-    /// [`retry_on_intr`]: crate::io::retry_on_intr
-    pub const INTR: Self = Self(c::EINTR);
-    /// `EINVAL`
-    pub const INVAL: Self = Self(c::EINVAL);
-    /// `EINVALIDPROCTABLE`
-    #[cfg(windows)]
-    pub const INVALIDPROCTABLE: Self = Self(c::EINVALIDPROCTABLE);
-    /// `EINVALIDPROVIDER`
-    #[cfg(windows)]
-    pub const INVALIDPROVIDER: Self = Self(c::EINVALIDPROVIDER);
-    /// `EIO`
-    #[cfg(not(windows))]
-    pub const IO: Self = Self(c::EIO);
-    /// `EISCONN`
-    #[cfg(not(target_os = "l4re"))]
-    pub const ISCONN: Self = Self(c::EISCONN);
-    /// `EISDIR`
-    #[cfg(not(windows))]
-    pub const ISDIR: Self = Self(c::EISDIR);
-    /// `EISNAM`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const ISNAM: Self = Self(c::EISNAM);
-    /// `EKEYEXPIRED`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const KEYEXPIRED: Self = Self(c::EKEYEXPIRED);
-    /// `EKEYREJECTED`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const KEYREJECTED: Self = Self(c::EKEYREJECTED);
-    /// `EKEYREVOKED`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const KEYREVOKED: Self = Self(c::EKEYREVOKED);
-    /// `EL2HLT`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const L2HLT: Self = Self(c::EL2HLT);
-    /// `EL2NSYNC`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const L2NSYNC: Self = Self(c::EL2NSYNC);
-    /// `EL3HLT`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const L3HLT: Self = Self(c::EL3HLT);
-    /// `EL3RST`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const L3RST: Self = Self(c::EL3RST);
-    /// `ELIBACC`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const LIBACC: Self = Self(c::ELIBACC);
-    /// `ELIBBAD`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const LIBBAD: Self = Self(c::ELIBBAD);
-    /// `ELIBEXEC`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const LIBEXEC: Self = Self(c::ELIBEXEC);
-    /// `ELIBMAX`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const LIBMAX: Self = Self(c::ELIBMAX);
-    /// `ELIBSCN`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const LIBSCN: Self = Self(c::ELIBSCN);
-    /// `ELNRNG`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const LNRNG: Self = Self(c::ELNRNG);
-    /// `ELOOP`
-    pub const LOOP: Self = Self(c::ELOOP);
-    /// `EMEDIUMTYPE`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const MEDIUMTYPE: Self = Self(c::EMEDIUMTYPE);
-    /// `EMFILE`
-    pub const MFILE: Self = Self(c::EMFILE);
-    /// `EMLINK`
-    #[cfg(not(windows))]
-    pub const MLINK: Self = Self(c::EMLINK);
-    /// `EMSGSIZE`
-    #[cfg(not(target_os = "l4re"))]
-    pub const MSGSIZE: Self = Self(c::EMSGSIZE);
-    /// `EMULTIHOP`
-    #[cfg(not(any(windows, target_os = "l4re", target_os = "openbsd")))]
-    pub const MULTIHOP: Self = Self(c::EMULTIHOP);
-    /// `ENAMETOOLONG`
-    pub const NAMETOOLONG: Self = Self(c::ENAMETOOLONG);
-    /// `ENAVAIL`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const NAVAIL: Self = Self(c::ENAVAIL);
-    /// `ENEEDAUTH`
-    #[cfg(bsd)]
-    pub const NEEDAUTH: Self = Self(c::ENEEDAUTH);
-    /// `ENETDOWN`
-    pub const NETDOWN: Self = Self(c::ENETDOWN);
-    /// `ENETRESET`
-    #[cfg(not(target_os = "l4re"))]
-    pub const NETRESET: Self = Self(c::ENETRESET);
-    /// `ENETUNREACH`
-    pub const NETUNREACH: Self = Self(c::ENETUNREACH);
-    /// `ENFILE`
-    #[cfg(not(windows))]
-    pub const NFILE: Self = Self(c::ENFILE);
-    /// `ENOANO`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const NOANO: Self = Self(c::ENOANO);
-    /// `ENOATTR`
-    #[cfg(any(bsd, target_os = "haiku"))]
-    pub const NOATTR: Self = Self(c::ENOATTR);
-    /// `ENOBUFS`
-    #[cfg(not(target_os = "l4re"))]
-    pub const NOBUFS: Self = Self(c::ENOBUFS);
-    /// `ENOCSI`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const NOCSI: Self = Self(c::ENOCSI);
-    /// `ENODATA`
-    #[cfg(not(any(
-        freebsdlike,
-        windows,
-        target_os = "haiku",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const NODATA: Self = Self(c::ENODATA);
-    /// `ENODEV`
-    #[cfg(not(windows))]
-    pub const NODEV: Self = Self(c::ENODEV);
-    /// `ENOENT`
-    #[cfg(not(windows))]
-    pub const NOENT: Self = Self(c::ENOENT);
-    /// `ENOEXEC`
-    #[cfg(not(windows))]
-    pub const NOEXEC: Self = Self(c::ENOEXEC);
-    /// `ENOKEY`
-    #[cfg(not(any(
-        solarish,
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const NOKEY: Self = Self(c::ENOKEY);
-    /// `ENOLCK`
-    #[cfg(not(any(windows, target_os = "l4re")))]
-    pub const NOLCK: Self = Self(c::ENOLCK);
-    /// `ENOLINK`
-    #[cfg(not(any(windows, target_os = "l4re", target_os = "openbsd")))]
-    pub const NOLINK: Self = Self(c::ENOLINK);
-    /// `ENOMEDIUM`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const NOMEDIUM: Self = Self(c::ENOMEDIUM);
-    /// `ENOMEM`
-    #[cfg(not(windows))]
-    pub const NOMEM: Self = Self(c::ENOMEM);
-    /// `ENOMORE`
-    #[cfg(windows)]
-    pub const NOMORE: Self = Self(c::ENOMORE);
-    /// `ENOMSG`
-    #[cfg(not(any(windows, target_os = "l4re")))]
-    pub const NOMSG: Self = Self(c::ENOMSG);
-    /// `ENONET`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const NONET: Self = Self(c::ENONET);
-    /// `ENOPKG`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const NOPKG: Self = Self(c::ENOPKG);
-    /// `ENOPROTOOPT`
-    #[cfg(not(target_os = "l4re"))]
-    pub const NOPROTOOPT: Self = Self(c::ENOPROTOOPT);
-    /// `ENOSPC`
-    #[cfg(not(windows))]
-    pub const NOSPC: Self = Self(c::ENOSPC);
-    /// `ENOSR`
-    #[cfg(not(any(
-        freebsdlike,
-        windows,
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const NOSR: Self = Self(c::ENOSR);
-    /// `ENOSTR`
-    #[cfg(not(any(
-        freebsdlike,
-        windows,
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const NOSTR: Self = Self(c::ENOSTR);
-    /// `ENOSYS`
-    #[cfg(not(windows))]
-    pub const NOSYS: Self = Self(c::ENOSYS);
-    /// `ENOTBLK`
-    #[cfg(not(any(
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const NOTBLK: Self = Self(c::ENOTBLK);
-    /// `ENOTCAPABLE`
-    #[cfg(any(target_os = "freebsd", target_os = "wasi"))]
-    pub const NOTCAPABLE: Self = Self(c::ENOTCAPABLE);
-    /// `ENOTCONN`
-    pub const NOTCONN: Self = Self(c::ENOTCONN);
-    /// `ENOTDIR`
-    #[cfg(not(windows))]
-    pub const NOTDIR: Self = Self(c::ENOTDIR);
-    /// `ENOTEMPTY`
-    pub const NOTEMPTY: Self = Self(c::ENOTEMPTY);
-    /// `ENOTNAM`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const NOTNAM: Self = Self(c::ENOTNAM);
-    /// `ENOTRECOVERABLE`
-    #[cfg(not(any(
-        freebsdlike,
-        netbsdlike,
-        windows,
-        target_os = "haiku",
-        target_os = "l4re"
-    )))]
-    pub const NOTRECOVERABLE: Self = Self(c::ENOTRECOVERABLE);
-    /// `ENOTSOCK`
-    #[cfg(not(target_os = "l4re"))]
-    pub const NOTSOCK: Self = Self(c::ENOTSOCK);
-    /// `ENOTSUP`
-    #[cfg(not(any(windows, target_os = "haiku", target_os = "redox")))]
-    pub const NOTSUP: Self = Self(c::ENOTSUP);
-    /// `ENOTTY`
-    #[cfg(not(windows))]
-    pub const NOTTY: Self = Self(c::ENOTTY);
-    /// `ENOTUNIQ`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const NOTUNIQ: Self = Self(c::ENOTUNIQ);
-    /// `ENXIO`
-    #[cfg(not(windows))]
-    pub const NXIO: Self = Self(c::ENXIO);
-    /// `EOPNOTSUPP`
-    pub const OPNOTSUPP: Self = Self(c::EOPNOTSUPP);
-    /// `EOVERFLOW`
-    #[cfg(not(any(windows, target_os = "l4re")))]
-    pub const OVERFLOW: Self = Self(c::EOVERFLOW);
-    /// `EOWNERDEAD`
-    #[cfg(not(any(
-        freebsdlike,
-        netbsdlike,
-        windows,
-        target_os = "haiku",
-        target_os = "l4re"
-    )))]
-    pub const OWNERDEAD: Self = Self(c::EOWNERDEAD);
-    /// `EPERM`
-    #[cfg(not(windows))]
-    pub const PERM: Self = Self(c::EPERM);
-    /// `EPFNOSUPPORT`
-    #[cfg(not(any(target_os = "l4re", target_os = "wasi")))]
-    pub const PFNOSUPPORT: Self = Self(c::EPFNOSUPPORT);
-    /// `EPIPE`
-    #[cfg(not(windows))]
-    pub const PIPE: Self = Self(c::EPIPE);
-    /// `EPROCLIM`
-    #[cfg(bsd)]
-    pub const PROCLIM: Self = Self(c::EPROCLIM);
-    /// `EPROCUNAVAIL`
-    #[cfg(bsd)]
-    pub const PROCUNAVAIL: Self = Self(c::EPROCUNAVAIL);
-    /// `EPROGMISMATCH`
-    #[cfg(bsd)]
-    pub const PROGMISMATCH: Self = Self(c::EPROGMISMATCH);
-    /// `EPROGUNAVAIL`
-    #[cfg(bsd)]
-    pub const PROGUNAVAIL: Self = Self(c::EPROGUNAVAIL);
-    /// `EPROTO`
-    #[cfg(not(any(windows, target_os = "l4re")))]
-    pub const PROTO: Self = Self(c::EPROTO);
-    /// `EPROTONOSUPPORT`
-    #[cfg(not(target_os = "l4re"))]
-    pub const PROTONOSUPPORT: Self = Self(c::EPROTONOSUPPORT);
-    /// `EPROTOTYPE`
-    #[cfg(not(target_os = "l4re"))]
-    pub const PROTOTYPE: Self = Self(c::EPROTOTYPE);
-    /// `EPROVIDERFAILEDINIT`
-    #[cfg(windows)]
-    pub const PROVIDERFAILEDINIT: Self = Self(c::EPROVIDERFAILEDINIT);
-    /// `ERANGE`
-    #[cfg(not(windows))]
-    pub const RANGE: Self = Self(c::ERANGE);
-    /// `EREFUSED`
-    #[cfg(windows)]
-    pub const REFUSED: Self = Self(c::EREFUSED);
-    /// `EREMCHG`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const REMCHG: Self = Self(c::EREMCHG);
-    /// `EREMOTE`
-    #[cfg(not(any(
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const REMOTE: Self = Self(c::EREMOTE);
-    /// `EREMOTEIO`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const REMOTEIO: Self = Self(c::EREMOTEIO);
-    /// `ERESTART`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const RESTART: Self = Self(c::ERESTART);
-    /// `ERFKILL`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "android",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "redox",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const RFKILL: Self = Self(c::ERFKILL);
-    /// `EROFS`
-    #[cfg(not(windows))]
-    pub const ROFS: Self = Self(c::EROFS);
-    /// `ERPCMISMATCH`
-    #[cfg(bsd)]
-    pub const RPCMISMATCH: Self = Self(c::ERPCMISMATCH);
-    /// `ESHUTDOWN`
-    #[cfg(not(any(
-        target_os = "espidf",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const SHUTDOWN: Self = Self(c::ESHUTDOWN);
-    /// `ESOCKTNOSUPPORT`
-    #[cfg(not(any(
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const SOCKTNOSUPPORT: Self = Self(c::ESOCKTNOSUPPORT);
-    /// `ESPIPE`
-    #[cfg(not(windows))]
-    pub const SPIPE: Self = Self(c::ESPIPE);
-    /// `ESRCH`
-    #[cfg(not(windows))]
-    pub const SRCH: Self = Self(c::ESRCH);
-    /// `ESRMNT`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const SRMNT: Self = Self(c::ESRMNT);
-    /// `ESTALE`
-    pub const STALE: Self = Self(c::ESTALE);
-    /// `ESTRPIPE`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const STRPIPE: Self = Self(c::ESTRPIPE);
-    /// `ETIME`
-    #[cfg(not(any(
-        freebsdlike,
-        windows,
-        target_os = "l4re",
-        target_os = "openbsd",
-        target_os = "wasi"
-    )))]
-    pub const TIME: Self = Self(c::ETIME);
-    /// `ETIMEDOUT`
-    pub const TIMEDOUT: Self = Self(c::ETIMEDOUT);
-    /// `E2BIG`
-    #[cfg(not(windows))]
-    #[doc(alias = "2BIG")]
-    pub const TOOBIG: Self = Self(c::E2BIG);
-    /// `ETOOMANYREFS`
-    #[cfg(not(any(target_os = "haiku", target_os = "l4re", target_os = "wasi")))]
-    pub const TOOMANYREFS: Self = Self(c::ETOOMANYREFS);
-    /// `ETXTBSY`
-    #[cfg(not(windows))]
-    pub const TXTBSY: Self = Self(c::ETXTBSY);
-    /// `EUCLEAN`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "nto",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const UCLEAN: Self = Self(c::EUCLEAN);
-    /// `EUNATCH`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const UNATCH: Self = Self(c::EUNATCH);
-    /// `EUSERS`
-    #[cfg(not(any(
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi"
-    )))]
-    pub const USERS: Self = Self(c::EUSERS);
-    /// `EWOULDBLOCK`
-    pub const WOULDBLOCK: Self = Self(c::EWOULDBLOCK);
-    /// `EXDEV`
-    #[cfg(not(windows))]
-    pub const XDEV: Self = Self(c::EXDEV);
-    /// `EXFULL`
-    #[cfg(not(any(
-        bsd,
-        windows,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "l4re",
-        target_os = "vita",
-        target_os = "wasi",
-    )))]
-    pub const XFULL: Self = Self(c::EXFULL);
-}
-
-impl Errno {
-    /// Extract an `Errno` value from a `std::io::Error`.
-    ///
-    /// This isn't a `From` conversion because it's expected to be relatively
-    /// uncommon.
-    #[cfg(feature = "std")]
-    #[inline]
-    pub fn from_io_error(io_err: &std::io::Error) -> Option<Self> {
-        io_err
-            .raw_os_error()
-            .and_then(|raw| if raw != 0 { Some(Self(raw)) } else { None })
-    }
-
-    /// Extract the raw OS error number from this error.
-    #[inline]
-    pub const fn raw_os_error(self) -> i32 {
-        self.0
-    }
-
-    /// Construct an `Errno` from a raw OS error number.
-    #[inline]
-    pub const fn from_raw_os_error(raw: i32) -> Self {
-        Self(raw)
-    }
-
-    pub(crate) fn last_os_error() -> Self {
-        Self(errno().0)
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/io/mod.rs b/vendor/rustix/src/backend/libc/io/mod.rs
deleted file mode 100644
index 4873885..0000000
--- a/vendor/rustix/src/backend/libc/io/mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-pub(crate) mod errno;
-#[cfg(not(windows))]
-pub(crate) mod types;
-
-#[cfg_attr(windows, path = "windows_syscalls.rs")]
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/io/syscalls.rs b/vendor/rustix/src/backend/libc/io/syscalls.rs
deleted file mode 100644
index e28e6be..0000000
--- a/vendor/rustix/src/backend/libc/io/syscalls.rs
+++ /dev/null
@@ -1,340 +0,0 @@
-//! libc syscalls supporting `rustix::io`.
-
-use crate::backend::c;
-#[cfg(not(target_os = "wasi"))]
-use crate::backend::conv::ret_discarded_fd;
-use crate::backend::conv::{borrowed_fd, ret, ret_c_int, ret_owned_fd, ret_usize};
-use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
-#[cfg(not(any(
-    target_os = "aix",
-    target_os = "espidf",
-    target_os = "nto",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-use crate::io::DupFlags;
-#[cfg(linux_kernel)]
-use crate::io::ReadWriteFlags;
-use crate::io::{self, FdFlags};
-use crate::ioctl::{IoctlOutput, RawOpcode};
-use core::cmp::min;
-#[cfg(all(feature = "fs", feature = "net"))]
-use libc_errno::errno;
-#[cfg(not(target_os = "espidf"))]
-use {
-    crate::backend::MAX_IOV,
-    crate::io::{IoSlice, IoSliceMut},
-};
-
-pub(crate) unsafe fn read(fd: BorrowedFd<'_>, buf: *mut u8, len: usize) -> io::Result<usize> {
-    ret_usize(c::read(borrowed_fd(fd), buf.cast(), min(len, READ_LIMIT)))
-}
-
-pub(crate) fn write(fd: BorrowedFd<'_>, buf: &[u8]) -> io::Result<usize> {
-    unsafe {
-        ret_usize(c::write(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            min(buf.len(), READ_LIMIT),
-        ))
-    }
-}
-
-pub(crate) unsafe fn pread(
-    fd: BorrowedFd<'_>,
-    buf: *mut u8,
-    len: usize,
-    offset: u64,
-) -> io::Result<usize> {
-    let len = min(len, READ_LIMIT);
-
-    // Silently cast; we'll get `EINVAL` if the value is negative.
-    let offset = offset as i64;
-
-    // ESP-IDF and Vita don't support 64-bit offsets.
-    #[cfg(any(target_os = "espidf", target_os = "vita"))]
-    let offset: i32 = offset.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-
-    ret_usize(c::pread(borrowed_fd(fd), buf.cast(), len, offset))
-}
-
-pub(crate) fn pwrite(fd: BorrowedFd<'_>, buf: &[u8], offset: u64) -> io::Result<usize> {
-    let len = min(buf.len(), READ_LIMIT);
-
-    // Silently cast; we'll get `EINVAL` if the value is negative.
-    let offset = offset as i64;
-
-    // ESP-IDF and Vita don't support 64-bit offsets.
-    #[cfg(any(target_os = "espidf", target_os = "vita"))]
-    let offset: i32 = offset.try_into().map_err(|_| io::Errno::OVERFLOW)?;
-
-    unsafe { ret_usize(c::pwrite(borrowed_fd(fd), buf.as_ptr().cast(), len, offset)) }
-}
-
-#[cfg(not(target_os = "espidf"))]
-pub(crate) fn readv(fd: BorrowedFd<'_>, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-    unsafe {
-        ret_usize(c::readv(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), MAX_IOV) as c::c_int,
-        ))
-    }
-}
-
-#[cfg(not(target_os = "espidf"))]
-pub(crate) fn writev(fd: BorrowedFd<'_>, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-    unsafe {
-        ret_usize(c::writev(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), MAX_IOV) as c::c_int,
-        ))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "vita"
-)))]
-pub(crate) fn preadv(
-    fd: BorrowedFd<'_>,
-    bufs: &mut [IoSliceMut<'_>],
-    offset: u64,
-) -> io::Result<usize> {
-    // Silently cast; we'll get `EINVAL` if the value is negative.
-    let offset = offset as i64;
-    unsafe {
-        ret_usize(c::preadv(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), MAX_IOV) as c::c_int,
-            offset,
-        ))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "vita"
-)))]
-pub(crate) fn pwritev(fd: BorrowedFd<'_>, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
-    // Silently cast; we'll get `EINVAL` if the value is negative.
-    let offset = offset as i64;
-    unsafe {
-        ret_usize(c::pwritev(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), MAX_IOV) as c::c_int,
-            offset,
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-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(c::preadv2(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), MAX_IOV) as c::c_int,
-            offset,
-            bitflags_bits!(flags),
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-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 {
-        ret_usize(c::pwritev2(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), MAX_IOV) as c::c_int,
-            offset,
-            bitflags_bits!(flags),
-        ))
-    }
-}
-
-// These functions are derived from Rust's library/std/src/sys/unix/fd.rs at
-// revision 326ef470a8b379a180d6dc4bbef08990698a737a.
-
-// The maximum read limit on most POSIX-like systems is `SSIZE_MAX`, with the
-// manual page quoting that if the count of bytes to read is greater than
-// `SSIZE_MAX` the result is “unspecified”.
-//
-// On macOS, however, apparently the 64-bit libc is either buggy or
-// intentionally showing odd behavior by rejecting any read with a size larger
-// than or equal to `INT_MAX`. To handle both of these the read size is capped
-// on both platforms.
-#[cfg(target_os = "macos")]
-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;
-
-pub(crate) unsafe fn close(raw_fd: RawFd) {
-    let _ = c::close(raw_fd as c::c_int);
-}
-
-#[inline]
-pub(crate) unsafe fn ioctl(
-    fd: BorrowedFd<'_>,
-    request: RawOpcode,
-    arg: *mut c::c_void,
-) -> io::Result<IoctlOutput> {
-    ret_c_int(c::ioctl(borrowed_fd(fd), request, arg))
-}
-
-#[inline]
-pub(crate) unsafe fn ioctl_readonly(
-    fd: BorrowedFd<'_>,
-    request: RawOpcode,
-    arg: *mut c::c_void,
-) -> io::Result<IoctlOutput> {
-    ioctl(fd, request, arg)
-}
-
-#[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)> {
-    use core::mem::MaybeUninit;
-
-    let (mut read, mut write) = crate::fs::fd::_is_file_read_write(fd)?;
-    let mut not_socket = false;
-    if read {
-        // Do a `recv` with `PEEK` and `DONTWAIT` for 1 byte. A 0 indicates
-        // the read side is shut down; an `EWOULDBLOCK` indicates the read
-        // side is still open.
-        match unsafe {
-            c::recv(
-                borrowed_fd(fd),
-                MaybeUninit::<[u8; 1]>::uninit()
-                    .as_mut_ptr()
-                    .cast::<c::c_void>(),
-                1,
-                c::MSG_PEEK | c::MSG_DONTWAIT,
-            )
-        } {
-            0 => read = false,
-            -1 => {
-                #[allow(unreachable_patterns)] // `EAGAIN` may equal `EWOULDBLOCK`
-                match errno().0 {
-                    c::EAGAIN | c::EWOULDBLOCK => (),
-                    c::ENOTSOCK => not_socket = true,
-                    err => return Err(io::Errno(err)),
-                }
-            }
-            _ => (),
-        }
-    }
-    if write && !not_socket {
-        // Do a `send` with `DONTWAIT` for 0 bytes. An `EPIPE` indicates
-        // the write side is shut down.
-        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::EPIPE => write = false,
-                err => return Err(io::Errno(err)),
-            }
-        }
-    }
-    Ok((read, write))
-}
-
-#[cfg(target_os = "wasi")]
-#[cfg(all(feature = "fs", feature = "net"))]
-pub(crate) fn is_read_write(_fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> {
-    todo!("Implement is_read_write for WASI in terms of fd_fdstat_get");
-}
-
-pub(crate) fn fcntl_getfd(fd: BorrowedFd<'_>) -> io::Result<FdFlags> {
-    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<()> {
-    unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_SETFD, flags.bits())) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) fn fcntl_dupfd_cloexec(fd: BorrowedFd<'_>, min: RawFd) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::fcntl(borrowed_fd(fd), c::F_DUPFD_CLOEXEC, min)) }
-}
-
-#[cfg(target_os = "espidf")]
-pub(crate) fn fcntl_dupfd(fd: BorrowedFd<'_>, min: RawFd) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::fcntl(borrowed_fd(fd), c::F_DUPFD, min)) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn dup(fd: BorrowedFd<'_>) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::dup(borrowed_fd(fd))) }
-}
-
-#[allow(clippy::needless_pass_by_ref_mut)]
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn dup2(fd: BorrowedFd<'_>, new: &mut OwnedFd) -> io::Result<()> {
-    unsafe { ret_discarded_fd(c::dup2(borrowed_fd(fd), borrowed_fd(new.as_fd()))) }
-}
-
-#[allow(clippy::needless_pass_by_ref_mut)]
-#[cfg(not(any(
-    apple,
-    target_os = "aix",
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-pub(crate) fn dup3(fd: BorrowedFd<'_>, new: &mut OwnedFd, flags: DupFlags) -> io::Result<()> {
-    unsafe {
-        ret_discarded_fd(c::dup3(
-            borrowed_fd(fd),
-            borrowed_fd(new.as_fd()),
-            bitflags_bits!(flags),
-        ))
-    }
-}
-
-#[cfg(any(
-    apple,
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "redox",
-))]
-pub(crate) fn dup3(fd: BorrowedFd<'_>, new: &mut OwnedFd, _flags: DupFlags) -> io::Result<()> {
-    // Android 5.0 has `dup3`, but libc doesn't have bindings. Emulate it
-    // using `dup2`. We don't need to worry about the difference between
-    // `dup2` and `dup3` when the file descriptors are equal because we
-    // have an `&mut OwnedFd` which means `fd` doesn't alias it.
-    dup2(fd, new)
-}
diff --git a/vendor/rustix/src/backend/libc/io/types.rs b/vendor/rustix/src/backend/libc/io/types.rs
deleted file mode 100644
index 510206f..0000000
--- a/vendor/rustix/src/backend/libc/io/types.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-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: u32 {
-        /// `FD_CLOEXEC`
-        const CLOEXEC = bitcast!(c::FD_CLOEXEC);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `RWF_*` constants for use with [`preadv2`] and [`pwritev2`].
-    ///
-    /// [`preadv2`]: crate::io::preadv2
-    /// [`pwritev2`]: crate::io::pwritev
-    #[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;
-        /// `RWF_HIPRI` (since Linux 4.6)
-        const HIPRI = linux_raw_sys::general::RWF_HIPRI;
-        /// `RWF_SYNC` (since Linux 4.7)
-        const SYNC = linux_raw_sys::general::RWF_SYNC;
-        /// `RWF_NOWAIT` (since Linux 4.14)
-        const NOWAIT = linux_raw_sys::general::RWF_NOWAIT;
-        /// `RWF_APPEND` (since Linux 4.16)
-        const APPEND = linux_raw_sys::general::RWF_APPEND;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-bitflags! {
-    /// `O_*` constants for use with [`dup2`].
-    ///
-    /// [`dup2`]: crate::io::dup2
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct DupFlags: u32 {
-        /// `O_CLOEXEC`
-        #[cfg(not(any(
-            apple,
-            target_os = "aix",
-            target_os = "android",
-            target_os = "redox",
-        )))] // Android 5.0 has dup3, but libc doesn't have bindings
-        const CLOEXEC = bitcast!(c::O_CLOEXEC);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/io/windows_syscalls.rs b/vendor/rustix/src/backend/libc/io/windows_syscalls.rs
deleted file mode 100644
index 049221d..0000000
--- a/vendor/rustix/src/backend/libc/io/windows_syscalls.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Windows system calls in the `io` module.
-
-use crate::backend::c;
-use crate::backend::conv::{borrowed_fd, ret_c_int};
-use crate::backend::fd::LibcFd;
-use crate::fd::{BorrowedFd, RawFd};
-use crate::io;
-use crate::ioctl::{IoctlOutput, RawOpcode};
-
-pub(crate) unsafe fn close(raw_fd: RawFd) {
-    let _ = c::close(raw_fd as LibcFd);
-}
-
-#[inline]
-pub(crate) unsafe fn ioctl(
-    fd: BorrowedFd<'_>,
-    request: RawOpcode,
-    arg: *mut c::c_void,
-) -> io::Result<IoctlOutput> {
-    ret_c_int(c::ioctl(borrowed_fd(fd), request, arg.cast()))
-}
-
-#[inline]
-pub(crate) unsafe fn ioctl_readonly(
-    fd: BorrowedFd<'_>,
-    request: RawOpcode,
-    arg: *mut c::c_void,
-) -> io::Result<IoctlOutput> {
-    ioctl(fd, request, arg)
-}
diff --git a/vendor/rustix/src/backend/libc/io_uring/mod.rs b/vendor/rustix/src/backend/libc/io_uring/mod.rs
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/libc/io_uring/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/io_uring/syscalls.rs b/vendor/rustix/src/backend/libc/io_uring/syscalls.rs
deleted file mode 100644
index 8e81824..0000000
--- a/vendor/rustix/src/backend/libc/io_uring/syscalls.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-//! libc syscalls supporting `rustix::io_uring`.
-
-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};
-
-#[inline]
-pub(crate) fn io_uring_setup(entries: u32, params: &mut io_uring_params) -> io::Result<OwnedFd> {
-    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]
-pub(crate) unsafe fn io_uring_register(
-    fd: BorrowedFd<'_>,
-    opcode: IoringRegisterOp,
-    arg: *const c::c_void,
-    nr_args: u32,
-) -> io::Result<u32> {
-    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,
-    ))
-}
-
-#[inline]
-pub(crate) unsafe fn io_uring_enter(
-    fd: BorrowedFd<'_>,
-    to_submit: u32,
-    min_complete: u32,
-    flags: IoringEnterFlags,
-    arg: *const c::c_void,
-    size: usize,
-) -> io::Result<u32> {
-    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/mod.rs b/vendor/rustix/src/backend/libc/mm/mod.rs
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/libc/mm/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/libc/mm/syscalls.rs b/vendor/rustix/src/backend/libc/mm/syscalls.rs
deleted file mode 100644
index 33bc9ca..0000000
--- a/vendor/rustix/src/backend/libc/mm/syscalls.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-//! libc syscalls supporting `rustix::mm`.
-
-#[cfg(not(target_os = "redox"))]
-use super::types::Advice;
-#[cfg(any(linux_kernel, freebsdlike, netbsdlike))]
-use super::types::MlockAllFlags;
-#[cfg(any(target_os = "emscripten", target_os = "linux"))]
-use super::types::MremapFlags;
-use super::types::{MapFlags, MprotectFlags, MsyncFlags, ProtFlags};
-#[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(linux_kernel)]
-use crate::fd::OwnedFd;
-use crate::io;
-
-#[cfg(not(target_os = "redox"))]
-pub(crate) fn madvise(addr: *mut c::c_void, len: usize, advice: Advice) -> io::Result<()> {
-    // On Linux platforms, `MADV_DONTNEED` has the same value as
-    // `POSIX_MADV_DONTNEED` but different behavior. We remap it to a different
-    // value, and check for it here.
-    #[cfg(target_os = "linux")]
-    if let Advice::LinuxDontNeed = advice {
-        return unsafe { ret(c::madvise(addr, len, c::MADV_DONTNEED)) };
-    }
-
-    #[cfg(not(target_os = "android"))]
-    {
-        let err = unsafe { c::posix_madvise(addr, len, advice as c::c_int) };
-
-        // `posix_madvise` returns its error status rather than using `errno`.
-        if err == 0 {
-            Ok(())
-        } else {
-            Err(io::Errno(err))
-        }
-    }
-
-    #[cfg(target_os = "android")]
-    {
-        if let Advice::DontNeed = advice {
-            // Do nothing. Linux's `MADV_DONTNEED` isn't the same as
-            // `POSIX_MADV_DONTNEED`, so just discard `MADV_DONTNEED`.
-            Ok(())
-        } else {
-            unsafe { ret(c::madvise(addr, len, advice as c::c_int)) }
-        }
-    }
-}
-
-pub(crate) unsafe fn msync(addr: *mut c::c_void, len: usize, flags: MsyncFlags) -> io::Result<()> {
-    let err = c::msync(addr, len, bitflags_bits!(flags));
-
-    // `msync` returns its error status rather than using `errno`.
-    if err == 0 {
-        Ok(())
-    } else {
-        Err(io::Errno(err))
-    }
-}
-
-/// # Safety
-///
-/// `mmap` is primarily unsafe due to the `addr` parameter, as anything working
-/// with memory pointed to by raw pointers is unsafe.
-pub(crate) unsafe fn mmap(
-    ptr: *mut c::c_void,
-    len: usize,
-    prot: ProtFlags,
-    flags: MapFlags,
-    fd: BorrowedFd<'_>,
-    offset: u64,
-) -> io::Result<*mut c::c_void> {
-    let res = c::mmap(
-        ptr,
-        len,
-        bitflags_bits!(prot),
-        bitflags_bits!(flags),
-        borrowed_fd(fd),
-        offset as i64,
-    );
-    if res == c::MAP_FAILED {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(res)
-    }
-}
-
-/// # Safety
-///
-/// `mmap` is primarily unsafe due to the `addr` parameter, as anything working
-/// with memory pointed to by raw pointers is unsafe.
-pub(crate) unsafe fn mmap_anonymous(
-    ptr: *mut c::c_void,
-    len: usize,
-    prot: ProtFlags,
-    flags: MapFlags,
-) -> io::Result<*mut c::c_void> {
-    let res = c::mmap(
-        ptr,
-        len,
-        bitflags_bits!(prot),
-        bitflags_bits!(flags | MapFlags::from_bits_retain(bitcast!(c::MAP_ANONYMOUS))),
-        no_fd(),
-        0,
-    );
-    if res == c::MAP_FAILED {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(res)
-    }
-}
-
-pub(crate) unsafe fn mprotect(
-    ptr: *mut c::c_void,
-    len: usize,
-    flags: MprotectFlags,
-) -> io::Result<()> {
-    ret(c::mprotect(ptr, len, bitflags_bits!(flags)))
-}
-
-pub(crate) unsafe fn munmap(ptr: *mut c::c_void, len: usize) -> io::Result<()> {
-    ret(c::munmap(ptr, len))
-}
-
-/// # Safety
-///
-/// `mremap` is primarily unsafe due to the `old_address` parameter, as
-/// anything working with memory pointed to by raw pointers is unsafe.
-#[cfg(any(target_os = "emscripten", target_os = "linux"))]
-pub(crate) unsafe fn mremap(
-    old_address: *mut c::c_void,
-    old_size: usize,
-    new_size: usize,
-    flags: MremapFlags,
-) -> io::Result<*mut c::c_void> {
-    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 {
-        Ok(res)
-    }
-}
-
-/// # Safety
-///
-/// `mremap_fixed` is primarily unsafe due to the `old_address` and
-/// `new_address` parameters, as anything working with memory pointed to by raw
-/// pointers is unsafe.
-#[cfg(any(target_os = "emscripten", target_os = "linux"))]
-pub(crate) unsafe fn mremap_fixed(
-    old_address: *mut c::c_void,
-    old_size: usize,
-    new_size: usize,
-    flags: MremapFlags,
-    new_address: *mut c::c_void,
-) -> io::Result<*mut c::c_void> {
-    let res = c::mremap(
-        old_address,
-        old_size,
-        new_size,
-        bitflags_bits!(flags | MremapFlags::from_bits_retain(bitcast!(c::MAP_FIXED))),
-        new_address,
-    );
-    if res == c::MAP_FAILED {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(res)
-    }
-}
-
-/// # Safety
-///
-/// `mlock` operates on raw pointers and may round out to the nearest page
-/// boundaries.
-#[inline]
-pub(crate) unsafe fn mlock(addr: *mut c::c_void, length: usize) -> io::Result<()> {
-    ret(c::mlock(addr, length))
-}
-
-/// # Safety
-///
-/// `mlock_with` operates on raw pointers and may round out to the nearest page
-/// boundaries.
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) unsafe fn mlock_with(
-    addr: *mut c::c_void,
-    length: usize,
-    flags: MlockFlags,
-) -> io::Result<()> {
-    weak_or_syscall! {
-        fn mlock2(
-            addr: *const c::c_void,
-            len: c::size_t,
-            flags: c::c_int
-        ) via SYS_mlock2 -> c::c_int
-    }
-
-    ret(mlock2(addr, length, bitflags_bits!(flags)))
-}
-
-/// # Safety
-///
-/// `munlock` operates on raw pointers and may round out to the nearest page
-/// boundaries.
-#[inline]
-pub(crate) unsafe fn munlock(addr: *mut c::c_void, length: usize) -> io::Result<()> {
-    ret(c::munlock(addr, length))
-}
-
-#[cfg(linux_kernel)]
-pub(crate) unsafe fn userfaultfd(flags: UserfaultfdFlags) -> io::Result<OwnedFd> {
-    syscall! {
-        fn userfaultfd(
-            flags: c::c_int
-        ) via SYS_userfaultfd -> c::c_int
-    }
-    ret_owned_fd(userfaultfd(bitflags_bits!(flags)))
-}
-
-/// Locks all pages mapped into the address space of the calling process.
-///
-/// This includes the pages of the code, data, and stack segment, as well as
-/// shared libraries, user space kernel data, shared memory, and memory-mapped
-/// files. All mapped pages are guaranteed to be resident in RAM when the call
-/// returns successfully; the pages are guaranteed to stay in RAM until later
-/// unlocked.
-#[inline]
-#[cfg(any(linux_kernel, freebsdlike, netbsdlike))]
-pub(crate) fn mlockall(flags: MlockAllFlags) -> io::Result<()> {
-    unsafe { ret(c::mlockall(bitflags_bits!(flags))) }
-}
-
-/// Unlocks all pages mapped into the address space of the calling process.
-#[inline]
-#[cfg(any(linux_kernel, freebsdlike, netbsdlike))]
-pub(crate) fn munlockall() -> io::Result<()> {
-    unsafe { ret(c::munlockall()) }
-}
diff --git a/vendor/rustix/src/backend/libc/mm/types.rs b/vendor/rustix/src/backend/libc/mm/types.rs
deleted file mode 100644
index a4aa3e2..0000000
--- a/vendor/rustix/src/backend/libc/mm/types.rs
+++ /dev/null
@@ -1,477 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `PROT_*` flags for use with [`mmap`].
-    ///
-    /// For `PROT_NONE`, use `ProtFlags::empty()`.
-    ///
-    /// [`mmap`]: crate::mm::mmap
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct ProtFlags: u32 {
-        /// `PROT_READ`
-        const READ = bitcast!(c::PROT_READ);
-        /// `PROT_WRITE`
-        const WRITE = bitcast!(c::PROT_WRITE);
-        /// `PROT_EXEC`
-        const EXEC = bitcast!(c::PROT_EXEC);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `PROT_*` flags for use with [`mprotect`].
-    ///
-    /// For `PROT_NONE`, use `MprotectFlags::empty()`.
-    ///
-    /// [`mprotect`]: crate::mm::mprotect
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MprotectFlags: u32 {
-        /// `PROT_READ`
-        const READ = bitcast!(c::PROT_READ);
-        /// `PROT_WRITE`
-        const WRITE = bitcast!(c::PROT_WRITE);
-        /// `PROT_EXEC`
-        const EXEC = bitcast!(c::PROT_EXEC);
-        /// `PROT_GROWSUP`
-        #[cfg(linux_kernel)]
-        const GROWSUP = bitcast!(c::PROT_GROWSUP);
-        /// `PROT_GROWSDOWN`
-        #[cfg(linux_kernel)]
-        const GROWSDOWN = bitcast!(c::PROT_GROWSDOWN);
-        /// `PROT_SEM`
-        #[cfg(linux_kernel)]
-        const SEM = linux_raw_sys::general::PROT_SEM;
-        /// `PROT_BTI`
-        #[cfg(all(linux_kernel, target_arch = "aarch64"))]
-        const BTI = linux_raw_sys::general::PROT_BTI;
-        /// `PROT_MTE`
-        #[cfg(all(linux_kernel, target_arch = "aarch64"))]
-        const MTE = linux_raw_sys::general::PROT_MTE;
-        /// `PROT_SAO`
-        #[cfg(all(linux_kernel, any(target_arch = "powerpc", target_arch = "powerpc64")))]
-        const SAO = linux_raw_sys::general::PROT_SAO;
-        /// `PROT_ADI`
-        #[cfg(all(linux_kernel, any(target_arch = "sparc", target_arch = "sparc64")))]
-        const ADI = linux_raw_sys::general::PROT_ADI;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MAP_*` flags for use with [`mmap`].
-    ///
-    /// For `MAP_ANONYMOUS` (aka `MAP_ANON`), see [`mmap_anonymous`].
-    ///
-    /// [`mmap`]: crate::mm::mmap
-    /// [`mmap_anonymous`]: crates::mm::mmap_anonymous
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MapFlags: u32 {
-        /// `MAP_SHARED`
-        const SHARED = bitcast!(c::MAP_SHARED);
-        /// `MAP_SHARED_VALIDATE`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "android",
-            target_os = "emscripten",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const SHARED_VALIDATE = bitcast!(c::MAP_SHARED_VALIDATE);
-        /// `MAP_PRIVATE`
-        const PRIVATE = bitcast!(c::MAP_PRIVATE);
-        /// `MAP_DENYWRITE`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const DENYWRITE = bitcast!(c::MAP_DENYWRITE);
-        /// `MAP_FIXED`
-        const FIXED = bitcast!(c::MAP_FIXED);
-        /// `MAP_FIXED_NOREPLACE`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "android",
-            target_os = "emscripten",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const FIXED_NOREPLACE = bitcast!(c::MAP_FIXED_NOREPLACE);
-        /// `MAP_GROWSDOWN`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const GROWSDOWN = bitcast!(c::MAP_GROWSDOWN);
-        /// `MAP_HUGETLB`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const HUGETLB = bitcast!(c::MAP_HUGETLB);
-        /// `MAP_HUGE_2MB`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "android",
-            target_os = "emscripten",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const HUGE_2MB = bitcast!(c::MAP_HUGE_2MB);
-        /// `MAP_HUGE_1GB`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "android",
-            target_os = "emscripten",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const HUGE_1GB = bitcast!(c::MAP_HUGE_1GB);
-        /// `MAP_LOCKED`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const LOCKED = bitcast!(c::MAP_LOCKED);
-        /// `MAP_NOCORE`
-        #[cfg(freebsdlike)]
-        const NOCORE = bitcast!(c::MAP_NOCORE);
-        /// `MAP_NORESERVE`
-        #[cfg(not(any(
-            freebsdlike,
-            target_os = "aix",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const NORESERVE = bitcast!(c::MAP_NORESERVE);
-        /// `MAP_NOSYNC`
-        #[cfg(freebsdlike)]
-        const NOSYNC = bitcast!(c::MAP_NOSYNC);
-        /// `MAP_POPULATE`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-        )))]
-        const POPULATE = bitcast!(c::MAP_POPULATE);
-        /// `MAP_STACK`
-        #[cfg(not(any(
-            apple,
-            solarish,
-            target_os = "aix",
-            target_os = "dragonfly",
-            target_os = "haiku",
-            target_os = "netbsd",
-            target_os = "redox",
-        )))]
-        const STACK = bitcast!(c::MAP_STACK);
-        /// `MAP_PREFAULT_READ`
-        #[cfg(target_os = "freebsd")]
-        const PREFAULT_READ = bitcast!(c::MAP_PREFAULT_READ);
-        /// `MAP_SYNC`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            target_os = "aix",
-            target_os = "android",
-            target_os = "emscripten",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "redox",
-            all(
-                linux_kernel,
-                any(target_arch = "mips", target_arch = "mips32r6", target_arch = "mips64", target_arch = "mips64r6"),
-            )
-        )))]
-        const SYNC = bitcast!(c::MAP_SYNC);
-        /// `MAP_UNINITIALIZED`
-        #[cfg(any())]
-        const UNINITIALIZED = bitcast!(c::MAP_UNINITIALIZED);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(any(target_os = "emscripten", target_os = "linux"))]
-bitflags! {
-    /// `MREMAP_*` flags for use with [`mremap`].
-    ///
-    /// For `MREMAP_FIXED`, see [`mremap_fixed`].
-    ///
-    /// [`mremap`]: crate::mm::mremap
-    /// [`mremap_fixed`]: crate::mm::mremap_fixed
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MremapFlags: u32 {
-        /// `MREMAP_MAYMOVE`
-        const MAYMOVE = bitcast!(c::MREMAP_MAYMOVE);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MS_*` flags for use with [`msync`].
-    ///
-    /// [`msync`]: crate::mm::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 = bitcast!(c::MS_SYNC);
-        /// `MS_ASYNC`—Specifies that an update be scheduled, but the call
-        /// returns immediately.
-        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 = bitcast!(c::MS_INVALIDATE);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `MLOCK_*` flags for use with [`mlock_with`].
-    ///
-    /// [`mlock_with`]: crate::mm::mlock_with
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MlockFlags: u32 {
-        /// `MLOCK_ONFAULT`
-        const ONFAULT = bitcast!(c::MLOCK_ONFAULT);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `POSIX_MADV_*` constants for use with [`madvise`].
-///
-/// [`madvise`]: crate::mm::madvise
-#[cfg(not(target_os = "redox"))]
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(u32)]
-#[non_exhaustive]
-pub enum Advice {
-    /// `POSIX_MADV_NORMAL`
-    #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    Normal = bitcast!(c::POSIX_MADV_NORMAL),
-
-    /// `POSIX_MADV_NORMAL`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    Normal = bitcast!(c::MADV_NORMAL),
-
-    /// `POSIX_MADV_SEQUENTIAL`
-    #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    Sequential = bitcast!(c::POSIX_MADV_SEQUENTIAL),
-
-    /// `POSIX_MADV_SEQUENTIAL`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    Sequential = bitcast!(c::MADV_SEQUENTIAL),
-
-    /// `POSIX_MADV_RANDOM`
-    #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    Random = bitcast!(c::POSIX_MADV_RANDOM),
-
-    /// `POSIX_MADV_RANDOM`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    Random = bitcast!(c::MADV_RANDOM),
-
-    /// `POSIX_MADV_WILLNEED`
-    #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    WillNeed = bitcast!(c::POSIX_MADV_WILLNEED),
-
-    /// `POSIX_MADV_WILLNEED`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    WillNeed = bitcast!(c::MADV_WILLNEED),
-
-    /// `POSIX_MADV_DONTNEED`
-    #[cfg(not(any(target_os = "android", target_os = "emscripten", target_os = "haiku")))]
-    DontNeed = bitcast!(c::POSIX_MADV_DONTNEED),
-
-    /// `POSIX_MADV_DONTNEED`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    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 = bitcast!(i32::MAX),
-
-    /// `MADV_DONTNEED`
-    #[cfg(target_os = "android")]
-    LinuxDontNeed = bitcast!(c::MADV_DONTNEED),
-    /// `MADV_FREE`
-    #[cfg(linux_kernel)]
-    LinuxFree = bitcast!(c::MADV_FREE),
-    /// `MADV_REMOVE`
-    #[cfg(linux_kernel)]
-    LinuxRemove = bitcast!(c::MADV_REMOVE),
-    /// `MADV_DONTFORK`
-    #[cfg(linux_kernel)]
-    LinuxDontFork = bitcast!(c::MADV_DONTFORK),
-    /// `MADV_DOFORK`
-    #[cfg(linux_kernel)]
-    LinuxDoFork = bitcast!(c::MADV_DOFORK),
-    /// `MADV_HWPOISON`
-    #[cfg(linux_kernel)]
-    LinuxHwPoison = bitcast!(c::MADV_HWPOISON),
-    /// `MADV_SOFT_OFFLINE`
-    #[cfg(all(
-        linux_kernel,
-        not(any(
-            target_arch = "mips",
-            target_arch = "mips32r6",
-            target_arch = "mips64",
-            target_arch = "mips64r6"
-        ))
-    ))]
-    LinuxSoftOffline = bitcast!(c::MADV_SOFT_OFFLINE),
-    /// `MADV_MERGEABLE`
-    #[cfg(linux_kernel)]
-    LinuxMergeable = bitcast!(c::MADV_MERGEABLE),
-    /// `MADV_UNMERGEABLE`
-    #[cfg(linux_kernel)]
-    LinuxUnmergeable = bitcast!(c::MADV_UNMERGEABLE),
-    /// `MADV_HUGEPAGE`
-    #[cfg(linux_kernel)]
-    LinuxHugepage = bitcast!(c::MADV_HUGEPAGE),
-    /// `MADV_NOHUGEPAGE`
-    #[cfg(linux_kernel)]
-    LinuxNoHugepage = bitcast!(c::MADV_NOHUGEPAGE),
-    /// `MADV_DONTDUMP` (since Linux 3.4)
-    #[cfg(linux_kernel)]
-    LinuxDontDump = bitcast!(c::MADV_DONTDUMP),
-    /// `MADV_DODUMP` (since Linux 3.4)
-    #[cfg(linux_kernel)]
-    LinuxDoDump = bitcast!(c::MADV_DODUMP),
-    /// `MADV_WIPEONFORK` (since Linux 4.14)
-    #[cfg(linux_kernel)]
-    LinuxWipeOnFork = bitcast!(c::MADV_WIPEONFORK),
-    /// `MADV_KEEPONFORK` (since Linux 4.14)
-    #[cfg(linux_kernel)]
-    LinuxKeepOnFork = bitcast!(c::MADV_KEEPONFORK),
-    /// `MADV_COLD` (since Linux 5.4)
-    #[cfg(linux_kernel)]
-    LinuxCold = bitcast!(c::MADV_COLD),
-    /// `MADV_PAGEOUT` (since Linux 5.4)
-    #[cfg(linux_kernel)]
-    LinuxPageOut = bitcast!(c::MADV_PAGEOUT),
-    /// `MADV_POPULATE_READ` (since Linux 5.14)
-    #[cfg(linux_kernel)]
-    LinuxPopulateRead = bitcast!(c::MADV_POPULATE_READ),
-    /// `MADV_POPULATE_WRITE` (since Linux 5.14)
-    #[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")]
-#[allow(non_upper_case_globals)]
-impl Advice {
-    /// `POSIX_MADV_DONTNEED`
-    pub const DontNeed: Self = Self::Normal;
-}
-
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `O_*` flags for use with [`userfaultfd`].
-    ///
-    /// [`userfaultfd`]: crate::mm::userfaultfd
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct UserfaultfdFlags: u32 {
-        /// `O_CLOEXEC`
-        const CLOEXEC = bitcast!(c::O_CLOEXEC);
-        /// `O_NONBLOCK`
-        const NONBLOCK = bitcast!(c::O_NONBLOCK);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(any(linux_kernel, freebsdlike, netbsdlike))]
-bitflags! {
-    /// `MCL_*` flags for use with [`mlockall`].
-    ///
-    /// [`mlockall`]: crate::mm::mlockall
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MlockAllFlags: u32 {
-        /// Used together with `MCL_CURRENT`, `MCL_FUTURE`, or both. Mark all
-        /// current (with `MCL_CURRENT`) or future (with `MCL_FUTURE`) mappings
-        /// to lock pages when they are faulted in. When used with
-        /// `MCL_CURRENT`, all present pages are locked, but `mlockall` will
-        /// not fault in non-present pages. When used with `MCL_FUTURE`, all
-        /// future mappings will be marked to lock pages when they are faulted
-        /// in, but they will not be populated by the lock when the mapping is
-        /// created. `MCL_ONFAULT` must be used with either `MCL_CURRENT` or
-        /// `MCL_FUTURE` or both.
-        #[cfg(linux_kernel)]
-        const ONFAULT = bitcast!(libc::MCL_ONFAULT);
-        /// Lock all pages which will become mapped into the address space of
-        /// the process in the future. These could be, for instance, new pages
-        /// required by a growing heap and stack as well as new memory-mapped
-        /// files or shared memory regions.
-        const FUTURE = bitcast!(libc::MCL_FUTURE);
-        /// Lock all pages which are currently mapped into the address space of
-        /// the process.
-        const CURRENT = bitcast!(libc::MCL_CURRENT);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/mod.rs b/vendor/rustix/src/backend/libc/mod.rs
deleted file mode 100644
index 9ecb09f..0000000
--- a/vendor/rustix/src/backend/libc/mod.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-//! The libc backend.
-//!
-//! On most platforms, this uses the `libc` crate to make system calls. On
-//! Windows, this uses the Winsock API in `windows-sys`, which can be adapted
-//! to have a very `libc`-like interface.
-
-// Every FFI call requires an unsafe block, and there are a lot of FFI
-// calls. For now, set this to allow for the libc backend.
-#![allow(clippy::undocumented_unsafe_blocks)]
-// Lots of libc types vary between platforms, so we often need a `.into()` on
-// one platform where it's redundant on another.
-#![allow(clippy::useless_conversion)]
-
-mod conv;
-
-#[cfg(windows)]
-pub(crate) mod fd {
-    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 Winsock 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 Winsock 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 Winsock 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 Winsock 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 Winsock 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 Winsock 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 Winsock API.
-    ///
-    /// [`AsFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsFd.html
-    pub trait AsFd {
-        /// An `as_fd` function for Winsock, 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))]
-pub(crate) mod fd {
-    pub use crate::maybe_polyfill::os::fd::{
-        AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd,
-    };
-    #[allow(unused_imports)]
-    pub(crate) use RawFd as LibcFd;
-}
-
-// On Windows we emulate selected libc-compatible interfaces. On non-Windows,
-// we just use libc here, since this is the libc backend.
-#[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(linux_kernel)]
-#[cfg(feature = "io_uring")]
-pub(crate) mod io_uring;
-#[cfg(not(any(windows, target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-#[cfg(feature = "mm")]
-pub(crate) mod mm;
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) mod mount;
-#[cfg(linux_kernel)]
-#[cfg(all(feature = "fs", not(feature = "mount")))]
-pub(crate) mod mount; // for deprecated mount functions in "fs"
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-#[cfg(feature = "net")]
-pub(crate) mod net;
-#[cfg(not(any(windows, target_os = "espidf")))]
-#[cfg(any(
-    feature = "param",
-    feature = "runtime",
-    feature = "time",
-    target_arch = "x86",
-))]
-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(any(windows, target_os = "vita")))]
-#[cfg(feature = "termios")]
-pub(crate) mod termios;
-#[cfg(not(windows))]
-#[cfg(feature = "thread")]
-pub(crate) mod thread;
-#[cfg(not(any(windows, target_os = "espidf")))]
-#[cfg(feature = "time")]
-pub(crate) mod time;
-
-/// If the host libc is glibc, return `true` if it is less than version 2.25.
-///
-/// To restate and clarify, this function returning true does not mean the libc
-/// is glibc just that if it is glibc, it is less than version 2.25.
-///
-/// For now, this function is only available on Linux, but if it ends up being
-/// used beyond that, this could be changed to e.g. `#[cfg(unix)]`.
-#[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.
-    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(not(any(
-    windows,
-    target_os = "android",
-    target_os = "espidf",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[cfg(feature = "shm")]
-pub(crate) mod shm;
-#[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 = "espidf",
-    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/mount/mod.rs b/vendor/rustix/src/backend/libc/mount/mod.rs
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/libc/mount/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/libc/mount/syscalls.rs b/vendor/rustix/src/backend/libc/mount/syscalls.rs
deleted file mode 100644
index 7245114..0000000
--- a/vendor/rustix/src/backend/libc/mount/syscalls.rs
+++ /dev/null
@@ -1,272 +0,0 @@
-use crate::backend::c;
-use crate::backend::conv::ret;
-#[cfg(feature = "mount")]
-use crate::backend::conv::{borrowed_fd, c_str, ret_owned_fd};
-#[cfg(feature = "mount")]
-use crate::fd::{BorrowedFd, OwnedFd};
-use crate::ffi::CStr;
-use crate::io;
-use core::ptr::null;
-
-#[cfg(linux_kernel)]
-pub(crate) fn mount(
-    source: Option<&CStr>,
-    target: &CStr,
-    file_system_type: Option<&CStr>,
-    flags: super::types::MountFlagsArg,
-    data: Option<&CStr>,
-) -> io::Result<()> {
-    unsafe {
-        ret(c::mount(
-            source.map_or_else(null, CStr::as_ptr),
-            target.as_ptr(),
-            file_system_type.map_or_else(null, CStr::as_ptr),
-            flags.0,
-            data.map_or_else(null, CStr::as_ptr).cast(),
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-pub(crate) fn unmount(target: &CStr, flags: super::types::UnmountFlags) -> io::Result<()> {
-    unsafe { ret(c::umount2(target.as_ptr(), bitflags_bits!(flags))) }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsopen(fs_name: &CStr, flags: super::types::FsOpenFlags) -> io::Result<OwnedFd> {
-    syscall! {
-        fn fsopen(
-            fs_name: *const c::c_char,
-            flags: c::c_uint
-        ) via SYS_fsopen -> c::c_int
-    }
-    unsafe { ret_owned_fd(fsopen(c_str(fs_name), flags.bits())) }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsmount(
-    fs_fd: BorrowedFd<'_>,
-    flags: super::types::FsMountFlags,
-    attr_flags: super::types::MountAttrFlags,
-) -> io::Result<OwnedFd> {
-    syscall! {
-        fn fsmount(
-            fs_fd: c::c_int,
-            flags: c::c_uint,
-            attr_flags: c::c_uint
-        ) via SYS_fsmount -> c::c_int
-    }
-    unsafe { ret_owned_fd(fsmount(borrowed_fd(fs_fd), flags.bits(), attr_flags.bits())) }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn move_mount(
-    from_dfd: BorrowedFd<'_>,
-    from_pathname: &CStr,
-    to_dfd: BorrowedFd<'_>,
-    to_pathname: &CStr,
-    flags: super::types::MoveMountFlags,
-) -> io::Result<()> {
-    syscall! {
-        fn move_mount(
-            from_dfd: c::c_int,
-            from_pathname: *const c::c_char,
-            to_dfd: c::c_int,
-            to_pathname: *const c::c_char,
-            flags: c::c_uint
-        ) via SYS_move_mount -> c::c_int
-    }
-    unsafe {
-        ret(move_mount(
-            borrowed_fd(from_dfd),
-            c_str(from_pathname),
-            borrowed_fd(to_dfd),
-            c_str(to_pathname),
-            flags.bits(),
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn open_tree(
-    dfd: BorrowedFd<'_>,
-    filename: &CStr,
-    flags: super::types::OpenTreeFlags,
-) -> io::Result<OwnedFd> {
-    syscall! {
-        fn open_tree(
-            dfd: c::c_int,
-            filename: *const c::c_char,
-            flags: c::c_uint
-        ) via SYS_open_tree -> c::c_int
-    }
-
-    unsafe { ret_owned_fd(open_tree(borrowed_fd(dfd), c_str(filename), flags.bits())) }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fspick(
-    dfd: BorrowedFd<'_>,
-    path: &CStr,
-    flags: super::types::FsPickFlags,
-) -> io::Result<OwnedFd> {
-    syscall! {
-        fn fspick(
-            dfd: c::c_int,
-            path: *const c::c_char,
-            flags: c::c_uint
-        ) via SYS_fspick -> c::c_int
-    }
-
-    unsafe { ret_owned_fd(fspick(borrowed_fd(dfd), c_str(path), flags.bits())) }
-}
-
-#[cfg(feature = "mount")]
-#[cfg(linux_kernel)]
-syscall! {
-    fn fsconfig(
-        fs_fd: c::c_int,
-        cmd: c::c_uint,
-        key: *const c::c_char,
-        val: *const c::c_char,
-        aux: c::c_int
-    ) via SYS_fsconfig -> c::c_int
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsconfig_set_flag(fs_fd: BorrowedFd<'_>, key: &CStr) -> io::Result<()> {
-    unsafe {
-        ret(fsconfig(
-            borrowed_fd(fs_fd),
-            super::types::FsConfigCmd::SetFlag as _,
-            c_str(key),
-            null(),
-            0,
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsconfig_set_string(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    value: &CStr,
-) -> io::Result<()> {
-    unsafe {
-        ret(fsconfig(
-            borrowed_fd(fs_fd),
-            super::types::FsConfigCmd::SetString as _,
-            c_str(key),
-            c_str(value),
-            0,
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsconfig_set_binary(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    value: &[u8],
-) -> io::Result<()> {
-    unsafe {
-        ret(fsconfig(
-            borrowed_fd(fs_fd),
-            super::types::FsConfigCmd::SetBinary as _,
-            c_str(key),
-            value.as_ptr().cast(),
-            value.len().try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsconfig_set_fd(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    fd: BorrowedFd<'_>,
-) -> io::Result<()> {
-    unsafe {
-        ret(fsconfig(
-            borrowed_fd(fs_fd),
-            super::types::FsConfigCmd::SetFd as _,
-            c_str(key),
-            null(),
-            borrowed_fd(fd),
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsconfig_set_path(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    path: &CStr,
-    fd: BorrowedFd<'_>,
-) -> io::Result<()> {
-    unsafe {
-        ret(fsconfig(
-            borrowed_fd(fs_fd),
-            super::types::FsConfigCmd::SetPath as _,
-            c_str(key),
-            c_str(path),
-            borrowed_fd(fd),
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsconfig_set_path_empty(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    fd: BorrowedFd<'_>,
-) -> io::Result<()> {
-    unsafe {
-        ret(fsconfig(
-            borrowed_fd(fs_fd),
-            super::types::FsConfigCmd::SetPathEmpty as _,
-            c_str(key),
-            c_str(cstr!("")),
-            borrowed_fd(fd),
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsconfig_create(fs_fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe {
-        ret(fsconfig(
-            borrowed_fd(fs_fd),
-            super::types::FsConfigCmd::Create as _,
-            null(),
-            null(),
-            0,
-        ))
-    }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(feature = "mount")]
-pub(crate) fn fsconfig_reconfigure(fs_fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe {
-        ret(fsconfig(
-            borrowed_fd(fs_fd),
-            super::types::FsConfigCmd::Reconfigure as _,
-            null(),
-            null(),
-            0,
-        ))
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/mount/types.rs b/vendor/rustix/src/backend/libc/mount/types.rs
deleted file mode 100644
index 1023686..0000000
--- a/vendor/rustix/src/backend/libc/mount/types.rs
+++ /dev/null
@@ -1,340 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `MS_*` constants for use with [`mount`].
-    ///
-    /// [`mount`]: crate::mount::mount
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MountFlags: c::c_ulong {
-        /// `MS_BIND`
-        const BIND = c::MS_BIND;
-
-        /// `MS_DIRSYNC`
-        const DIRSYNC = c::MS_DIRSYNC;
-
-        /// `MS_LAZYTIME`
-        const LAZYTIME = c::MS_LAZYTIME;
-
-        /// `MS_MANDLOCK`
-        #[doc(alias = "MANDLOCK")]
-        const PERMIT_MANDATORY_FILE_LOCKING = c::MS_MANDLOCK;
-
-        /// `MS_NOATIME`
-        const NOATIME = c::MS_NOATIME;
-
-        /// `MS_NODEV`
-        const NODEV = c::MS_NODEV;
-
-        /// `MS_NODIRATIME`
-        const NODIRATIME = c::MS_NODIRATIME;
-
-        /// `MS_NOEXEC`
-        const NOEXEC = c::MS_NOEXEC;
-
-        /// `MS_NOSUID`
-        const NOSUID = c::MS_NOSUID;
-
-        /// `MS_RDONLY`
-        const RDONLY = c::MS_RDONLY;
-
-        /// `MS_REC`
-        const REC = c::MS_REC;
-
-        /// `MS_RELATIME`
-        const RELATIME = c::MS_RELATIME;
-
-        /// `MS_SILENT`
-        const SILENT = c::MS_SILENT;
-
-        /// `MS_STRICTATIME`
-        const STRICTATIME = c::MS_STRICTATIME;
-
-        /// `MS_SYNCHRONOUS`
-        const SYNCHRONOUS = c::MS_SYNCHRONOUS;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `MNT_*` constants for use with [`unmount`].
-    ///
-    /// [`unmount`]: crate::mount::unmount
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct UnmountFlags: u32 {
-        /// `MNT_FORCE`
-        const FORCE = bitcast!(c::MNT_FORCE);
-        /// `MNT_DETACH`
-        const DETACH = bitcast!(c::MNT_DETACH);
-        /// `MNT_EXPIRE`
-        const EXPIRE = bitcast!(c::MNT_EXPIRE);
-        /// `UMOUNT_NOFOLLOW`
-        const NOFOLLOW = bitcast!(c::UMOUNT_NOFOLLOW);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `FSOPEN_*` constants for use with [`fsopen`].
-    ///
-    /// [`fsopen`]: crate::mount::fsopen
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct FsOpenFlags: c::c_uint {
-        /// `FSOPEN_CLOEXEC`
-        const FSOPEN_CLOEXEC = 0x0000_0001;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `FSMOUNT_*` constants for use with [`fsmount`].
-    ///
-    /// [`fsmount`]: crate::mount::fsmount
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct FsMountFlags: c::c_uint {
-        /// `FSMOUNT_CLOEXEC`
-        const FSMOUNT_CLOEXEC = 0x0000_0001;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `FSCONFIG_*` constants for use with the `fsconfig` syscall.
-#[cfg(feature = "mount")]
-#[cfg(linux_kernel)]
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(u32)]
-pub(crate) enum FsConfigCmd {
-    /// `FSCONFIG_SET_FLAG`
-    SetFlag = 0,
-
-    /// `FSCONFIG_SET_STRING`
-    SetString = 1,
-
-    /// `FSCONFIG_SET_BINARY`
-    SetBinary = 2,
-
-    /// `FSCONFIG_SET_PATH`
-    SetPath = 3,
-
-    /// `FSCONFIG_SET_PATH_EMPTY`
-    SetPathEmpty = 4,
-
-    /// `FSCONFIG_SET_FD`
-    SetFd = 5,
-
-    /// `FSCONFIG_CMD_CREATE`
-    Create = 6,
-
-    /// `FSCONFIG_CMD_RECONFIGURE`
-    Reconfigure = 7,
-}
-
-#[cfg(feature = "mount")]
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `MOUNT_ATTR_*` constants for use with [`fsmount`].
-    ///
-    /// [`fsmount`]: crate::mount::fsmount
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MountAttrFlags: c::c_uint {
-        /// `MOUNT_ATTR_RDONLY`
-        const MOUNT_ATTR_RDONLY = 0x0000_0001;
-
-        /// `MOUNT_ATTR_NOSUID`
-        const MOUNT_ATTR_NOSUID = 0x0000_0002;
-
-        /// `MOUNT_ATTR_NODEV`
-        const MOUNT_ATTR_NODEV = 0x0000_0004;
-
-        /// `MOUNT_ATTR_NOEXEC`
-        const MOUNT_ATTR_NOEXEC = 0x0000_0008;
-
-        /// `MOUNT_ATTR__ATIME`
-        const MOUNT_ATTR__ATIME = 0x0000_0070;
-
-        /// `MOUNT_ATTR_RELATIME`
-        const MOUNT_ATTR_RELATIME = 0x0000_0000;
-
-        /// `MOUNT_ATTR_NOATIME`
-        const MOUNT_ATTR_NOATIME = 0x0000_0010;
-
-        /// `MOUNT_ATTR_STRICTATIME`
-        const MOUNT_ATTR_STRICTATIME = 0x0000_0020;
-
-        /// `MOUNT_ATTR_NODIRATIME`
-        const MOUNT_ATTR_NODIRATIME = 0x0000_0080;
-
-        /// `MOUNT_ATTR_NOUSER`
-        const MOUNT_ATTR_IDMAP = 0x0010_0000;
-
-        /// `MOUNT_ATTR__ATIME_FLAGS`
-        const MOUNT_ATTR_NOSYMFOLLOW = 0x0020_0000;
-
-        /// `MOUNT_ATTR__ATIME_FLAGS`
-        const MOUNT_ATTR_SIZE_VER0 = 32;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `MOVE_MOUNT_*` constants for use with [`move_mount`].
-    ///
-    /// [`move_mount`]: crate::mount::move_mount
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MoveMountFlags: c::c_uint {
-        /// `MOVE_MOUNT_F_EMPTY_PATH`
-        const MOVE_MOUNT_F_SYMLINKS = 0x0000_0001;
-
-        /// `MOVE_MOUNT_F_AUTOMOUNTS`
-        const MOVE_MOUNT_F_AUTOMOUNTS = 0x0000_0002;
-
-        /// `MOVE_MOUNT_F_EMPTY_PATH`
-        const MOVE_MOUNT_F_EMPTY_PATH = 0x0000_0004;
-
-        /// `MOVE_MOUNT_T_SYMLINKS`
-        const MOVE_MOUNT_T_SYMLINKS = 0x0000_0010;
-
-        /// `MOVE_MOUNT_T_AUTOMOUNTS`
-        const MOVE_MOUNT_T_AUTOMOUNTS = 0x0000_0020;
-
-        /// `MOVE_MOUNT_T_EMPTY_PATH`
-        const MOVE_MOUNT_T_EMPTY_PATH = 0x0000_0040;
-
-        /// `MOVE_MOUNT__MASK`
-        const MOVE_MOUNT_SET_GROUP = 0x0000_0100;
-
-        // TODO: add when Linux 6.5 is released
-        // /// `MOVE_MOUNT_BENEATH`
-        // const MOVE_MOUNT_BENEATH = 0x0000_0200;
-
-        /// `MOVE_MOUNT__MASK`
-        const MOVE_MOUNT__MASK = 0x0000_0377;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `OPENTREE_*` constants for use with [`open_tree`].
-    ///
-    /// [`open_tree`]: crate::mount::open_tree
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct OpenTreeFlags: c::c_uint {
-        /// `OPENTREE_CLONE`
-        const OPEN_TREE_CLONE = 1;
-
-        /// `OPENTREE_CLOEXEC`
-        const OPEN_TREE_CLOEXEC = c::O_CLOEXEC as c::c_uint;
-
-        /// `AT_EMPTY_PATH`
-        const AT_EMPTY_PATH = c::AT_EMPTY_PATH as c::c_uint;
-
-        /// `AT_NO_AUTOMOUNT`
-        const AT_NO_AUTOMOUNT = c::AT_NO_AUTOMOUNT as c::c_uint;
-
-        /// `AT_RECURSIVE`
-        const AT_RECURSIVE = c::AT_RECURSIVE as c::c_uint;
-
-        /// `AT_SYMLINK_NOFOLLOW`
-        const AT_SYMLINK_NOFOLLOW = c::AT_SYMLINK_NOFOLLOW as c::c_uint;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `FSPICK_*` constants for use with [`fspick`].
-    ///
-    /// [`fspick`]: crate::mount::fspick
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct FsPickFlags: c::c_uint {
-        /// `FSPICK_CLOEXEC`
-        const FSPICK_CLOEXEC = 0x0000_0001;
-
-        /// `FSPICK_SYMLINK_NOFOLLOW`
-        const FSPICK_SYMLINK_NOFOLLOW = 0x0000_0002;
-
-        /// `FSPICK_NO_AUTOMOUNT`
-        const FSPICK_NO_AUTOMOUNT = 0x0000_0004;
-
-        /// `FSPICK_EMPTY_PATH`
-        const FSPICK_EMPTY_PATH = 0x0000_0008;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(linux_kernel)]
-bitflags! {
-    /// `MS_*` constants for use with [`mount_change`].
-    ///
-    /// [`mount_change`]: crate::mount::mount_change
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MountPropagationFlags: c::c_ulong {
-        /// `MS_SILENT`
-        const SILENT = c::MS_SILENT;
-        /// `MS_SHARED`
-        const SHARED = c::MS_SHARED;
-        /// `MS_PRIVATE`
-        const PRIVATE = c::MS_PRIVATE;
-        /// `MS_SLAVE`
-        const SLAVE = c::MS_SLAVE;
-        /// `MS_UNBINDABLE`
-        const UNBINDABLE = c::MS_UNBINDABLE;
-        /// `MS_REC`
-        const REC = c::MS_REC;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(linux_kernel)]
-pub(crate) struct MountFlagsArg(pub(crate) c::c_ulong);
diff --git a/vendor/rustix/src/backend/libc/net/addr.rs b/vendor/rustix/src/backend/libc/net/addr.rs
deleted file mode 100644
index 719a549..0000000
--- a/vendor/rustix/src/backend/libc/net/addr.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-//! Socket address utilities.
-
-use crate::backend::c;
-#[cfg(unix)]
-use {
-    crate::ffi::CStr,
-    crate::io,
-    crate::path,
-    core::cmp::Ordering,
-    core::fmt,
-    core::hash::{Hash, Hasher},
-    core::slice,
-};
-
-/// `struct sockaddr_un`
-#[cfg(unix)]
-#[derive(Clone)]
-#[doc(alias = "sockaddr_un")]
-pub struct SocketAddrUnix {
-    pub(crate) unix: c::sockaddr_un,
-    #[cfg(not(any(bsd, target_os = "haiku")))]
-    len: c::socklen_t,
-}
-
-#[cfg(unix)]
-impl SocketAddrUnix {
-    /// Construct a new Unix-domain address from a filesystem path.
-    #[inline]
-    pub fn new<P: path::Arg>(path: P) -> io::Result<Self> {
-        path.into_with_c_str(Self::_new)
-    }
-
-    #[inline]
-    fn _new(path: &CStr) -> io::Result<Self> {
-        let mut unix = Self::init();
-        let bytes = path.to_bytes_with_nul();
-        if bytes.len() > unix.sun_path.len() {
-            return Err(io::Errno::NAMETOOLONG);
-        }
-        for (i, b) in bytes.iter().enumerate() {
-            unix.sun_path[i] = *b as c::c_char;
-        }
-
-        #[cfg(any(bsd, target_os = "haiku"))]
-        {
-            unix.sun_len = (offsetof_sun_path() + bytes.len()).try_into().unwrap();
-        }
-
-        Ok(Self {
-            unix,
-            #[cfg(not(any(bsd, target_os = "haiku")))]
-            len: (offsetof_sun_path() + bytes.len()).try_into().unwrap(),
-        })
-    }
-
-    /// Construct a new abstract Unix-domain address from a byte slice.
-    #[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] = 0;
-        for (i, b) in name.iter().enumerate() {
-            unix.sun_path[1 + i] = *b as c::c_char;
-        }
-        let len = offsetof_sun_path() + 1 + name.len();
-        let len = len.try_into().unwrap();
-        Ok(Self {
-            unix,
-            #[cfg(not(any(bsd, target_os = "haiku")))]
-            len,
-        })
-    }
-
-    fn init() -> c::sockaddr_un {
-        c::sockaddr_un {
-            #[cfg(any(bsd, target_os = "aix", target_os = "haiku", target_os = "nto"))]
-            sun_len: 0,
-            #[cfg(target_os = "vita")]
-            ss_len: 0,
-            sun_family: c::AF_UNIX as _,
-            #[cfg(any(bsd, target_os = "nto"))]
-            sun_path: [0; 104],
-            #[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "nto")))]
-            sun_path: [0; 108],
-            #[cfg(target_os = "haiku")]
-            sun_path: [0; 126],
-            #[cfg(target_os = "aix")]
-            sun_path: [0; 1023],
-        }
-    }
-
-    /// For a filesystem path address, return the path.
-    #[inline]
-    pub fn path(&self) -> Option<&CStr> {
-        let len = self.len();
-        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.
-            unsafe {
-                Some(CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(
-                    bytes.as_ptr().cast(),
-                    bytes.len(),
-                )))
-            }
-        } else {
-            None
-        }
-    }
-
-    /// For an abstract address, return the identifier.
-    #[cfg(linux_kernel)]
-    #[inline]
-    pub fn abstract_name(&self) -> Option<&[u8]> {
-        let len = self.len();
-        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]`.
-            unsafe { Some(slice::from_raw_parts(bytes.as_ptr().cast(), bytes.len())) }
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    pub(crate) fn addr_len(&self) -> c::socklen_t {
-        #[cfg(not(any(bsd, target_os = "haiku")))]
-        {
-            self.len
-        }
-        #[cfg(any(bsd, target_os = "haiku"))]
-        {
-            c::socklen_t::from(self.unix.sun_len)
-        }
-    }
-
-    #[inline]
-    pub(crate) fn len(&self) -> usize {
-        self.addr_len() as usize
-    }
-}
-
-#[cfg(unix)]
-impl PartialEq for SocketAddrUnix {
-    #[inline]
-    fn eq(&self, other: &Self) -> bool {
-        let self_len = self.len() - offsetof_sun_path();
-        let other_len = other.len() - offsetof_sun_path();
-        self.unix.sun_path[..self_len].eq(&other.unix.sun_path[..other_len])
-    }
-}
-
-#[cfg(unix)]
-impl Eq for SocketAddrUnix {}
-
-#[cfg(unix)]
-impl PartialOrd for SocketAddrUnix {
-    #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-#[cfg(unix)]
-impl Ord for SocketAddrUnix {
-    #[inline]
-    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])
-    }
-}
-
-#[cfg(unix)]
-impl Hash for SocketAddrUnix {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        let self_len = self.len() - offsetof_sun_path();
-        self.unix.sun_path[..self_len].hash(state)
-    }
-}
-
-#[cfg(unix)]
-impl fmt::Debug for SocketAddrUnix {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(path) = self.path() {
-            path.fmt(fmt)
-        } else {
-            #[cfg(linux_kernel)]
-            if let Some(name) = self.abstract_name() {
-                return name.fmt(fmt);
-            }
-
-            "(unnamed)".fmt(fmt)
-        }
-    }
-}
-
-/// `struct sockaddr_storage` as a raw struct.
-pub type SocketAddrStorage = c::sockaddr_storage;
-
-/// Return the offset of the `sun_path` field of `sockaddr_un`.
-#[cfg(not(windows))]
-#[inline]
-pub(crate) fn offsetof_sun_path() -> usize {
-    let z = c::sockaddr_un {
-        #[cfg(any(bsd, target_os = "aix", target_os = "haiku", target_os = "nto"))]
-        sun_len: 0_u8,
-        #[cfg(target_os = "vita")]
-        ss_len: 0,
-        #[cfg(any(
-            bsd,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita"
-        ))]
-        sun_family: 0_u8,
-        #[cfg(not(any(
-            bsd,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita"
-        )))]
-        sun_family: 0_u16,
-        #[cfg(any(bsd, target_os = "nto"))]
-        sun_path: [0; 104],
-        #[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "nto")))]
-        sun_path: [0; 108],
-        #[cfg(target_os = "haiku")]
-        sun_path: [0; 126],
-        #[cfg(target_os = "aix")]
-        sun_path: [0; 1023],
-    };
-    (crate::utils::as_ptr(&z.sun_path) as usize) - (crate::utils::as_ptr(&z) as usize)
-}
diff --git a/vendor/rustix/src/backend/libc/net/ext.rs b/vendor/rustix/src/backend/libc/net/ext.rs
deleted file mode 100644
index 2e11c05..0000000
--- a/vendor/rustix/src/backend/libc/net/ext.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-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
-/// can transmute in and out of it.
-#[cfg(windows)]
-#[repr(C)]
-struct sockaddr_in6 {
-    sin6_family: u16,
-    sin6_port: u16,
-    sin6_flowinfo: u32,
-    sin6_addr: c::in6_addr,
-    sin6_scope_id: u32,
-}
-
-#[cfg(not(windows))]
-#[inline]
-pub(crate) const fn in_addr_s_addr(addr: c::in_addr) -> u32 {
-    addr.s_addr
-}
-
-#[cfg(windows)]
-#[inline]
-pub(crate) const 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(windows)]
-#[inline]
-pub(crate) const 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(windows)]
-#[inline]
-pub(crate) const 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(windows)]
-#[inline]
-pub(crate) const 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(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) };
-    addr.sin6_scope_id
-}
-
-#[cfg(not(windows))]
-#[inline]
-pub(crate) const fn sockaddr_in6_new(
-    #[cfg(any(
-        bsd,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "nto",
-        target_os = "vita"
-    ))]
-    sin6_len: u8,
-    sin6_family: c::sa_family_t,
-    sin6_port: u16,
-    sin6_flowinfo: u32,
-    sin6_addr: c::in6_addr,
-    sin6_scope_id: u32,
-) -> c::sockaddr_in6 {
-    c::sockaddr_in6 {
-        #[cfg(any(
-            bsd,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita"
-        ))]
-        sin6_len,
-        sin6_family,
-        sin6_port,
-        sin6_flowinfo,
-        sin6_addr,
-        sin6_scope_id,
-        #[cfg(solarish)]
-        __sin6_src_id: 0,
-        #[cfg(target_os = "vita")]
-        sin6_vport: 0,
-    }
-}
-
-#[cfg(windows)]
-#[inline]
-pub(crate) const 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
deleted file mode 100644
index d7ab68d..0000000
--- a/vendor/rustix/src/backend/libc/net/mod.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-pub(crate) mod addr;
-pub(crate) mod ext;
-#[cfg(not(any(
-    windows,
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-pub(crate) mod msghdr;
-pub(crate) mod read_sockaddr;
-pub(crate) mod send_recv;
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) mod sockopt;
-pub(crate) mod syscalls;
-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
deleted file mode 100644
index dd9b156..0000000
--- a/vendor/rustix/src/backend/libc/net/msghdr.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-//! 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 = zero_msghdr();
-        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 = zero_msghdr();
-        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 = encode_sockaddr_v4(addr);
-
-    f({
-        let mut h = zero_msghdr();
-        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 = encode_sockaddr_v6(addr);
-
-    f({
-        let mut h = zero_msghdr();
-        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 = zero_msghdr();
-        h.msg_name = as_ptr(&addr.unix) 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
-    })
-}
-
-/// Create a zero-initialized message header struct value.
-#[cfg(all(unix, not(target_os = "redox")))]
-pub(crate) fn zero_msghdr() -> c::msghdr {
-    // SAFETY: We can't initialize all the fields by value because on some
-    // platforms the `msghdr` struct in the libc crate contains private padding
-    // fields. But it is still a C type that's meant to be zero-initializable.
-    unsafe { zeroed() }
-}
diff --git a/vendor/rustix/src/backend/libc/net/read_sockaddr.rs b/vendor/rustix/src/backend/libc/net/read_sockaddr.rs
deleted file mode 100644
index 6da7a50..0000000
--- a/vendor/rustix/src/backend/libc/net/read_sockaddr.rs
+++ /dev/null
@@ -1,306 +0,0 @@
-//! 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};
-use core::mem::size_of;
-
-// This must match the header of `sockaddr`.
-#[repr(C)]
-struct sockaddr_header {
-    #[cfg(any(
-        bsd,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "nto",
-        target_os = "vita"
-    ))]
-    sa_len: u8,
-    #[cfg(any(
-        bsd,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "nto",
-        target_os = "vita"
-    ))]
-    ss_family: u8,
-    #[cfg(not(any(
-        bsd,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "nto",
-        target_os = "vita"
-    )))]
-    ss_family: u16,
-}
-
-/// Read the `ss_family` field from a socket address returned from the OS.
-///
-/// # Safety
-///
-/// `storage` must point to a valid socket address returned from the OS.
-#[inline]
-unsafe fn read_ss_family(storage: *const c::sockaddr_storage) -> u16 {
-    // Assert that we know the layout of `sockaddr`.
-    let _ = c::sockaddr {
-        #[cfg(any(
-            bsd,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita"
-        ))]
-        sa_len: 0_u8,
-        #[cfg(any(
-            bsd,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita"
-        ))]
-        sa_family: 0_u8,
-        #[cfg(not(any(
-            bsd,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita"
-        )))]
-        sa_family: 0_u16,
-        #[cfg(not(target_os = "haiku"))]
-        sa_data: [0; 14],
-        #[cfg(target_os = "haiku")]
-        sa_data: [0; 30],
-    };
-
-    (*storage.cast::<sockaddr_header>()).ss_family.into()
-}
-
-/// Set the `ss_family` field of a socket address to `AF_UNSPEC`, so that we
-/// can test for `AF_UNSPEC` to test whether it was stored to.
-pub(crate) unsafe fn initialize_family_to_unspec(storage: *mut c::sockaddr_storage) {
-    (*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,
-) -> io::Result<SocketAddrAny> {
-    #[cfg(unix)]
-    let offsetof_sun_path = super::addr::offsetof_sun_path();
-
-    if len < size_of::<c::sa_family_t>() {
-        return Err(io::Errno::INVAL);
-    }
-    match read_ss_family(storage).into() {
-        c::AF_INET => {
-            if len < size_of::<c::sockaddr_in>() {
-                return Err(io::Errno::INVAL);
-            }
-            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),
-            )))
-        }
-        c::AF_INET6 => {
-            if len < size_of::<c::sockaddr_in6>() {
-                return Err(io::Errno::INVAL);
-            }
-            let decode = &*storage.cast::<c::sockaddr_in6>();
-            #[cfg(not(windows))]
-            let s6_addr = decode.sin6_addr.s6_addr;
-            #[cfg(windows)]
-            let s6_addr = decode.sin6_addr.u.Byte;
-            #[cfg(not(windows))]
-            let sin6_scope_id = decode.sin6_scope_id;
-            #[cfg(windows)]
-            let sin6_scope_id = decode.Anonymous.sin6_scope_id;
-            Ok(SocketAddrAny::V6(SocketAddrV6::new(
-                Ipv6Addr::from(s6_addr),
-                u16::from_be(decode.sin6_port),
-                u32::from_be(decode.sin6_flowinfo),
-                sin6_scope_id,
-            )))
-        }
-        #[cfg(unix)]
-        c::AF_UNIX => {
-            if len < offsetof_sun_path {
-                return Err(io::Errno::INVAL);
-            }
-            if len == offsetof_sun_path {
-                SocketAddrUnix::new(&[][..]).map(SocketAddrAny::Unix)
-            } else {
-                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!(any(solarish, target_os = "freebsd")) {
-                    // FreeBSD and illumos sometimes set 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)
-                        .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] != 0 {
-                        return Err(io::Errno::INVAL);
-                    }
-                    debug_assert_eq!(
-                        CStr::from_ptr(decode.sun_path.as_ptr()).to_bytes().len(),
-                        provided_len
-                    );
-                    &decode.sun_path[..provided_len]
-                };
-
-                SocketAddrUnix::new(core::mem::transmute::<&[c::c_char], &[u8]>(path_bytes))
-                    .map(SocketAddrAny::Unix)
-            }
-        }
-        _ => Err(io::Errno::INVAL),
-    }
-}
-
-/// Read an optional socket address returned from the OS.
-///
-/// # Safety
-///
-/// `storage` must point to a valid socket address returned from the OS.
-pub(crate) unsafe fn maybe_read_sockaddr_os(
-    storage: *const c::sockaddr_storage,
-    len: usize,
-) -> Option<SocketAddrAny> {
-    if len == 0 {
-        return None;
-    }
-
-    assert!(len >= size_of::<c::sa_family_t>());
-    let family = read_ss_family(storage).into();
-    if family == c::AF_UNSPEC {
-        None
-    } else {
-        Some(inner_read_sockaddr_os(family, storage, len))
-    }
-}
-
-/// Read a socket address returned from the OS.
-///
-/// # Safety
-///
-/// `storage` must point to a valid socket address returned from the OS.
-pub(crate) unsafe fn read_sockaddr_os(
-    storage: *const c::sockaddr_storage,
-    len: usize,
-) -> SocketAddrAny {
-    assert!(len >= size_of::<c::sa_family_t>());
-    let family = read_ss_family(storage).into();
-    inner_read_sockaddr_os(family, storage, len)
-}
-
-unsafe fn inner_read_sockaddr_os(
-    family: c::c_int,
-    storage: *const c::sockaddr_storage,
-    len: usize,
-) -> SocketAddrAny {
-    #[cfg(unix)]
-    let offsetof_sun_path = super::addr::offsetof_sun_path();
-
-    assert!(len >= size_of::<c::sa_family_t>());
-    match family {
-        c::AF_INET => {
-            assert!(len >= size_of::<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),
-            ))
-        }
-        c::AF_INET6 => {
-            assert!(len >= size_of::<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),
-                u32::from_be(decode.sin6_flowinfo),
-                sockaddr_in6_sin6_scope_id(decode),
-            ))
-        }
-        #[cfg(unix)]
-        c::AF_UNIX => {
-            assert!(len >= offsetof_sun_path);
-            if len == offsetof_sun_path {
-                SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap())
-            } else {
-                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 and illumos sometimes set the length to longer than
-                // the length of the NUL-terminated string. Find the NUL and
-                // truncate the string accordingly.
-                #[cfg(any(solarish, target_os = "freebsd"))]
-                let path_bytes = &path_bytes[..path_bytes.iter().position(|b| *b == 0).unwrap()];
-
-                SocketAddrAny::Unix(
-                    SocketAddrUnix::new(core::mem::transmute::<&[c::c_char], &[u8]>(path_bytes))
-                        .unwrap(),
-                )
-            }
-        }
-        other => unimplemented!("{:?}", other),
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/net/send_recv.rs b/vendor/rustix/src/backend/libc/net/send_recv.rs
deleted file mode 100644
index 5dc60dd..0000000
--- a/vendor/rustix/src/backend/libc/net/send_recv.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `MSG_*` flags for use with [`send`], [`send_to`], and related
-    /// functions.
-    ///
-    /// [`send`]: crate::net::send
-    /// [`sendto`]: crate::net::sendto
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct SendFlags: u32 {
-        /// `MSG_CONFIRM`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            windows,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "nto",
-            target_os = "haiku",
-            target_os = "vita",
-        )))]
-        const CONFIRM = bitcast!(c::MSG_CONFIRM);
-        /// `MSG_DONTROUTE`
-        const DONTROUTE = bitcast!(c::MSG_DONTROUTE);
-        /// `MSG_DONTWAIT`
-        #[cfg(not(windows))]
-        const DONTWAIT = bitcast!(c::MSG_DONTWAIT);
-        /// `MSG_EOR`
-        #[cfg(not(windows))]
-        const EOT = bitcast!(c::MSG_EOR);
-        /// `MSG_MORE`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            windows,
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita",
-        )))]
-        const MORE = bitcast!(c::MSG_MORE);
-        #[cfg(not(any(apple, windows, target_os = "vita")))]
-        /// `MSG_NOSIGNAL`
-        const NOSIGNAL = bitcast!(c::MSG_NOSIGNAL);
-        /// `MSG_OOB`
-        const OOB = bitcast!(c::MSG_OOB);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MSG_*` flags for use with [`recv`], [`recvfrom`], and related
-    /// functions.
-    ///
-    /// [`recv`]: crate::net::recv
-    /// [`recvfrom`]: crate::net::recvfrom
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct RecvFlags: u32 {
-        #[cfg(not(any(
-            apple,
-            solarish,
-            windows,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita",
-        )))]
-        /// `MSG_CMSG_CLOEXEC`
-        const CMSG_CLOEXEC = bitcast!(c::MSG_CMSG_CLOEXEC);
-        /// `MSG_DONTWAIT`
-        #[cfg(not(windows))]
-        const DONTWAIT = bitcast!(c::MSG_DONTWAIT);
-        /// `MSG_ERRQUEUE`
-        #[cfg(not(any(
-            bsd,
-            solarish,
-            windows,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita",
-        )))]
-        const ERRQUEUE = bitcast!(c::MSG_ERRQUEUE);
-        /// `MSG_OOB`
-        const OOB = bitcast!(c::MSG_OOB);
-        /// `MSG_PEEK`
-        const PEEK = bitcast!(c::MSG_PEEK);
-        /// `MSG_TRUNC`
-        const TRUNC = bitcast!(c::MSG_TRUNC);
-        /// `MSG_WAITALL`
-        const WAITALL = bitcast!(c::MSG_WAITALL);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/net/sockopt.rs b/vendor/rustix/src/backend/libc/net/sockopt.rs
deleted file mode 100644
index cff2ca2..0000000
--- a/vendor/rustix/src/backend/libc/net/sockopt.rs
+++ /dev/null
@@ -1,1065 +0,0 @@
-//! libc syscalls supporting `rustix::net::sockopt`.
-
-use super::ext::{in6_addr_new, in_addr_new};
-use crate::backend::c;
-use crate::backend::conv::{borrowed_fd, ret};
-use crate::fd::BorrowedFd;
-#[cfg(feature = "alloc")]
-#[cfg(any(
-    linux_like,
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos"
-))]
-use crate::ffi::CStr;
-use crate::io;
-use crate::net::sockopt::Timeout;
-#[cfg(not(any(
-    apple,
-    windows,
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "nto",
-    target_os = "vita",
-)))]
-use crate::net::AddressFamily;
-#[cfg(any(
-    linux_kernel,
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_env = "newlib"
-))]
-use crate::net::Protocol;
-#[cfg(any(
-    linux_kernel,
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_env = "newlib"
-))]
-use crate::net::RawProtocol;
-use crate::net::{Ipv4Addr, Ipv6Addr, SocketType};
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-use crate::net::{SocketAddrAny, SocketAddrStorage, SocketAddrV4};
-#[cfg(linux_kernel)]
-use crate::net::{SocketAddrV6, UCred};
-use crate::utils::as_mut_ptr;
-#[cfg(feature = "alloc")]
-#[cfg(any(
-    linux_like,
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos"
-))]
-use alloc::borrow::ToOwned;
-#[cfg(feature = "alloc")]
-#[cfg(any(
-    linux_like,
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos"
-))]
-use alloc::string::String;
-#[cfg(apple)]
-use c::TCP_KEEPALIVE as TCP_KEEPIDLE;
-#[cfg(not(any(apple, target_os = "openbsd", target_os = "haiku", target_os = "nto")))]
-use c::TCP_KEEPIDLE;
-use core::mem::{size_of, MaybeUninit};
-use core::time::Duration;
-#[cfg(windows)]
-use windows_sys::Win32::Foundation::BOOL;
-
-#[inline]
-fn getsockopt<T: Copy>(fd: BorrowedFd<'_>, level: i32, optname: i32) -> io::Result<T> {
-    let mut optlen = core::mem::size_of::<T>().try_into().unwrap();
-    debug_assert!(
-        optlen as usize >= core::mem::size_of::<c::c_int>(),
-        "Socket APIs don't ever use `bool` directly"
-    );
-
-    let mut value = MaybeUninit::<T>::zeroed();
-    getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
-
-    // On Windows at least, `getsockopt` has been observed writing 1
-    // byte on at least (`IPPROTO_TCP`, `TCP_NODELAY`), even though
-    // Windows' documentation says that should write a 4-byte `BOOL`.
-    // So, we initialize the memory to zeros above, and just assert
-    // that `getsockopt` doesn't write too many bytes here.
-    assert!(
-        optlen as usize <= size_of::<T>(),
-        "unexpected getsockopt size"
-    );
-
-    unsafe { Ok(value.assume_init()) }
-}
-
-#[inline]
-fn getsockopt_raw<T>(
-    fd: BorrowedFd<'_>,
-    level: i32,
-    optname: i32,
-    value: &mut MaybeUninit<T>,
-    optlen: &mut c::socklen_t,
-) -> io::Result<()> {
-    unsafe {
-        ret(c::getsockopt(
-            borrowed_fd(fd),
-            level,
-            optname,
-            as_mut_ptr(value).cast(),
-            optlen,
-        ))
-    }
-}
-
-#[inline]
-fn setsockopt<T: Copy>(fd: BorrowedFd<'_>, level: i32, optname: i32, value: T) -> io::Result<()> {
-    let optlen = core::mem::size_of::<T>().try_into().unwrap();
-    debug_assert!(
-        optlen as usize >= core::mem::size_of::<c::c_int>(),
-        "Socket APIs don't ever use `bool` directly"
-    );
-    setsockopt_raw(fd, level, optname, &value, optlen)
-}
-
-#[inline]
-fn setsockopt_raw<T>(
-    fd: BorrowedFd<'_>,
-    level: i32,
-    optname: i32,
-    ptr: *const T,
-    optlen: c::socklen_t,
-) -> io::Result<()> {
-    unsafe {
-        ret(c::setsockopt(
-            borrowed_fd(fd),
-            level,
-            optname,
-            ptr.cast(),
-            optlen,
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn get_socket_type(fd: BorrowedFd<'_>) -> io::Result<SocketType> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_TYPE)
-}
-
-#[inline]
-pub(crate) fn set_socket_reuseaddr(fd: BorrowedFd<'_>, reuseaddr: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_REUSEADDR, from_bool(reuseaddr))
-}
-
-#[inline]
-pub(crate) fn get_socket_reuseaddr(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_REUSEADDR).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_broadcast(fd: BorrowedFd<'_>, broadcast: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_BROADCAST, from_bool(broadcast))
-}
-
-#[inline]
-pub(crate) fn get_socket_broadcast(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_BROADCAST).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_linger(fd: BorrowedFd<'_>, linger: Option<Duration>) -> io::Result<()> {
-    // Convert `linger` to seconds, rounding up.
-    let l_linger = if let Some(linger) = linger {
-        duration_to_secs(linger)?
-    } else {
-        0
-    };
-    let linger = c::linger {
-        l_onoff: linger.is_some().into(),
-        l_linger,
-    };
-    setsockopt(fd, c::SOL_SOCKET, c::SO_LINGER, linger)
-}
-
-#[inline]
-pub(crate) fn get_socket_linger(fd: BorrowedFd<'_>) -> io::Result<Option<Duration>> {
-    let linger: c::linger = getsockopt(fd, c::SOL_SOCKET, c::SO_LINGER)?;
-    Ok((linger.l_onoff != 0).then(|| Duration::from_secs(linger.l_linger as u64)))
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn set_socket_passcred(fd: BorrowedFd<'_>, passcred: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_PASSCRED, from_bool(passcred))
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn get_socket_passcred(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_PASSCRED).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_timeout(
-    fd: BorrowedFd<'_>,
-    id: Timeout,
-    timeout: Option<Duration>,
-) -> io::Result<()> {
-    let optname = match id {
-        Timeout::Recv => c::SO_RCVTIMEO,
-        Timeout::Send => c::SO_SNDTIMEO,
-    };
-
-    #[cfg(not(windows))]
-    let timeout = match timeout {
-        Some(timeout) => {
-            if timeout == Duration::ZERO {
-                return Err(io::Errno::INVAL);
-            }
-
-            // Rust's musl libc bindings deprecated `time_t` while they
-            // transition to 64-bit `time_t`. What we want here is just
-            // “whatever type `timeval`'s `tv_sec` is”, so we're ok using
-            // the deprecated type.
-            #[allow(deprecated)]
-            let tv_sec = timeout.as_secs().try_into().unwrap_or(c::time_t::MAX);
-
-            // `subsec_micros` rounds down, so we use `subsec_nanos` and
-            // manually round up.
-            let mut timeout = c::timeval {
-                tv_sec,
-                tv_usec: ((timeout.subsec_nanos() + 999) / 1000) as _,
-            };
-            if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
-                timeout.tv_usec = 1;
-            }
-            timeout
-        }
-        None => c::timeval {
-            tv_sec: 0,
-            tv_usec: 0,
-        },
-    };
-
-    #[cfg(windows)]
-    let timeout: u32 = match timeout {
-        Some(timeout) => {
-            if timeout == Duration::ZERO {
-                return Err(io::Errno::INVAL);
-            }
-
-            // `as_millis` rounds down, so we use `as_nanos` and
-            // manually round up.
-            let mut timeout: u32 = ((timeout.as_nanos() + 999_999) / 1_000_000)
-                .try_into()
-                .map_err(|_convert_err| io::Errno::INVAL)?;
-            if timeout == 0 {
-                timeout = 1;
-            }
-            timeout
-        }
-        None => 0,
-    };
-
-    setsockopt(fd, c::SOL_SOCKET, optname, timeout)
-}
-
-#[inline]
-pub(crate) fn get_socket_timeout(fd: BorrowedFd<'_>, id: Timeout) -> io::Result<Option<Duration>> {
-    let optname = match id {
-        Timeout::Recv => c::SO_RCVTIMEO,
-        Timeout::Send => c::SO_SNDTIMEO,
-    };
-
-    #[cfg(not(windows))]
-    {
-        let timeout: c::timeval = getsockopt(fd, c::SOL_SOCKET, optname)?;
-        if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
-            Ok(None)
-        } else {
-            Ok(Some(
-                Duration::from_secs(timeout.tv_sec as u64)
-                    + Duration::from_micros(timeout.tv_usec as u64),
-            ))
-        }
-    }
-
-    #[cfg(windows)]
-    {
-        let timeout: u32 = getsockopt(fd, c::SOL_SOCKET, optname)?;
-        if timeout == 0 {
-            Ok(None)
-        } else {
-            Ok(Some(Duration::from_millis(timeout as u64)))
-        }
-    }
-}
-
-#[cfg(any(apple, freebsdlike, target_os = "netbsd"))]
-#[inline]
-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, freebsdlike, target_os = "netbsd"))]
-#[inline]
-pub(crate) fn set_socket_nosigpipe(fd: BorrowedFd<'_>, val: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_NOSIGPIPE, from_bool(val))
-}
-
-#[inline]
-pub(crate) fn get_socket_error(fd: BorrowedFd<'_>) -> io::Result<Result<(), io::Errno>> {
-    let err: c::c_int = getsockopt(fd, c::SOL_SOCKET, c::SO_ERROR)?;
-    Ok(if err == 0 {
-        Ok(())
-    } else {
-        Err(io::Errno::from_raw_os_error(err))
-    })
-}
-
-#[inline]
-pub(crate) fn set_socket_keepalive(fd: BorrowedFd<'_>, keepalive: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_KEEPALIVE, from_bool(keepalive))
-}
-
-#[inline]
-pub(crate) fn get_socket_keepalive(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_KEEPALIVE).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_recv_buffer_size(fd: BorrowedFd<'_>, size: usize) -> io::Result<()> {
-    let size: c::c_int = size.try_into().map_err(|_| io::Errno::INVAL)?;
-    setsockopt(fd, c::SOL_SOCKET, c::SO_RCVBUF, size)
-}
-
-#[inline]
-pub(crate) fn get_socket_recv_buffer_size(fd: BorrowedFd<'_>) -> io::Result<usize> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_RCVBUF).map(|size: u32| size as usize)
-}
-
-#[inline]
-pub(crate) fn set_socket_send_buffer_size(fd: BorrowedFd<'_>, size: usize) -> io::Result<()> {
-    let size: c::c_int = size.try_into().map_err(|_| io::Errno::INVAL)?;
-    setsockopt(fd, c::SOL_SOCKET, c::SO_SNDBUF, size)
-}
-
-#[inline]
-pub(crate) fn get_socket_send_buffer_size(fd: BorrowedFd<'_>) -> io::Result<usize> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_SNDBUF).map(|size: u32| size as usize)
-}
-
-#[inline]
-#[cfg(not(any(
-    apple,
-    windows,
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "netbsd",
-    target_os = "nto",
-    target_os = "vita",
-)))]
-pub(crate) fn get_socket_domain(fd: BorrowedFd<'_>) -> io::Result<AddressFamily> {
-    let domain: c::c_int = getsockopt(fd, c::SOL_SOCKET, c::SO_DOMAIN)?;
-    Ok(AddressFamily(
-        domain.try_into().map_err(|_| io::Errno::OPNOTSUPP)?,
-    ))
-}
-
-#[inline]
-#[cfg(not(apple))] // Apple platforms declare the constant, but do not actually implement it.
-pub(crate) fn get_socket_acceptconn(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_ACCEPTCONN).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_oobinline(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_OOBINLINE, from_bool(value))
-}
-
-#[inline]
-pub(crate) fn get_socket_oobinline(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_OOBINLINE).map(to_bool)
-}
-
-#[cfg(not(any(solarish, windows)))]
-#[inline]
-pub(crate) fn set_socket_reuseport(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_REUSEPORT, from_bool(value))
-}
-
-#[cfg(not(any(solarish, windows)))]
-#[inline]
-pub(crate) fn get_socket_reuseport(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_REUSEPORT).map(to_bool)
-}
-
-#[cfg(target_os = "freebsd")]
-#[inline]
-pub(crate) fn set_socket_reuseport_lb(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_REUSEPORT_LB, from_bool(value))
-}
-
-#[cfg(target_os = "freebsd")]
-#[inline]
-pub(crate) fn get_socket_reuseport_lb(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_REUSEPORT_LB).map(to_bool)
-}
-
-#[cfg(any(
-    linux_kernel,
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_env = "newlib"
-))]
-#[inline]
-pub(crate) fn get_socket_protocol(fd: BorrowedFd<'_>) -> io::Result<Option<Protocol>> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_PROTOCOL)
-        .map(|raw| RawProtocol::new(raw).map(Protocol::from_raw))
-}
-
-#[cfg(target_os = "linux")]
-#[inline]
-pub(crate) fn get_socket_cookie(fd: BorrowedFd<'_>) -> io::Result<u64> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_COOKIE)
-}
-
-#[cfg(target_os = "linux")]
-#[inline]
-pub(crate) fn get_socket_incoming_cpu(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_INCOMING_CPU)
-}
-
-#[cfg(target_os = "linux")]
-#[inline]
-pub(crate) fn set_socket_incoming_cpu(fd: BorrowedFd<'_>, value: u32) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_INCOMING_CPU, value)
-}
-
-#[inline]
-pub(crate) fn set_ip_ttl(fd: BorrowedFd<'_>, ttl: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_TTL, ttl)
-}
-
-#[inline]
-pub(crate) fn get_ip_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_TTL)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_v6only(fd: BorrowedFd<'_>, only_v6: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_V6ONLY, from_bool(only_v6))
-}
-
-#[inline]
-pub(crate) fn get_ipv6_v6only(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_V6ONLY).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_ip_multicast_loop(fd: BorrowedFd<'_>, multicast_loop: bool) -> io::Result<()> {
-    setsockopt(
-        fd,
-        c::IPPROTO_IP,
-        c::IP_MULTICAST_LOOP,
-        from_bool(multicast_loop),
-    )
-}
-
-#[inline]
-pub(crate) fn get_ip_multicast_loop(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_MULTICAST_LOOP).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_ip_multicast_ttl(fd: BorrowedFd<'_>, multicast_ttl: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_MULTICAST_TTL, multicast_ttl)
-}
-
-#[inline]
-pub(crate) fn get_ip_multicast_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_MULTICAST_TTL)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_multicast_loop(fd: BorrowedFd<'_>, multicast_loop: bool) -> io::Result<()> {
-    setsockopt(
-        fd,
-        c::IPPROTO_IPV6,
-        c::IPV6_MULTICAST_LOOP,
-        from_bool(multicast_loop),
-    )
-}
-
-#[inline]
-pub(crate) fn get_ipv6_multicast_loop(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_multicast_hops(fd: BorrowedFd<'_>, multicast_hops: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IPV6_MULTICAST_HOPS, multicast_hops)
-}
-
-#[inline]
-pub(crate) fn get_ipv6_multicast_hops(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_IP, c::IPV6_MULTICAST_HOPS)
-}
-
-#[inline]
-pub(crate) fn set_ip_add_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-) -> io::Result<()> {
-    let mreq = to_ip_mreq(multiaddr, interface);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_ADD_MEMBERSHIP, mreq)
-}
-
-#[cfg(any(
-    apple,
-    freebsdlike,
-    linux_like,
-    target_os = "fuchsia",
-    target_os = "openbsd"
-))]
-#[inline]
-pub(crate) fn set_ip_add_membership_with_ifindex(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    address: &Ipv4Addr,
-    ifindex: i32,
-) -> io::Result<()> {
-    let mreqn = to_ip_mreqn(multiaddr, address, ifindex);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_ADD_MEMBERSHIP, mreqn)
-}
-
-#[cfg(any(apple, freebsdlike, linux_like, solarish, target_os = "aix"))]
-#[inline]
-pub(crate) fn set_ip_add_source_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-    sourceaddr: &Ipv4Addr,
-) -> io::Result<()> {
-    let mreq_source = to_imr_source(multiaddr, interface, sourceaddr);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_ADD_SOURCE_MEMBERSHIP, mreq_source)
-}
-
-#[cfg(any(apple, freebsdlike, linux_like, solarish, target_os = "aix"))]
-#[inline]
-pub(crate) fn set_ip_drop_source_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-    sourceaddr: &Ipv4Addr,
-) -> io::Result<()> {
-    let mreq_source = to_imr_source(multiaddr, interface, sourceaddr);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_DROP_SOURCE_MEMBERSHIP, mreq_source)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_add_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv6Addr,
-    interface: u32,
-) -> io::Result<()> {
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "nto"
-    )))]
-    use c::IPV6_ADD_MEMBERSHIP;
-    #[cfg(any(
-        bsd,
-        solarish,
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "nto"
-    ))]
-    use c::IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP;
-
-    let mreq = to_ipv6mr(multiaddr, interface);
-    setsockopt(fd, c::IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, mreq)
-}
-
-#[inline]
-pub(crate) fn set_ip_drop_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-) -> io::Result<()> {
-    let mreq = to_ip_mreq(multiaddr, interface);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_DROP_MEMBERSHIP, mreq)
-}
-
-#[cfg(any(
-    apple,
-    freebsdlike,
-    linux_like,
-    target_os = "fuchsia",
-    target_os = "openbsd"
-))]
-#[inline]
-pub(crate) fn set_ip_drop_membership_with_ifindex(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    address: &Ipv4Addr,
-    ifindex: i32,
-) -> io::Result<()> {
-    let mreqn = to_ip_mreqn(multiaddr, address, ifindex);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_DROP_MEMBERSHIP, mreqn)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_drop_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv6Addr,
-    interface: u32,
-) -> io::Result<()> {
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "nto"
-    )))]
-    use c::IPV6_DROP_MEMBERSHIP;
-    #[cfg(any(
-        bsd,
-        solarish,
-        target_os = "haiku",
-        target_os = "l4re",
-        target_os = "nto"
-    ))]
-    use c::IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP;
-
-    let mreq = to_ipv6mr(multiaddr, interface);
-    setsockopt(fd, c::IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, mreq)
-}
-
-#[inline]
-pub(crate) fn get_ipv6_unicast_hops(fd: BorrowedFd<'_>) -> io::Result<u8> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS).map(|hops: c::c_int| hops as u8)
-}
-
-#[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,
-        None => -1,
-    };
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS, hops)
-}
-
-#[cfg(any(
-    bsd,
-    linux_like,
-    target_os = "aix",
-    target_os = "fuchsia",
-    target_os = "haiku",
-    target_os = "nto",
-    target_env = "newlib"
-))]
-#[inline]
-pub(crate) fn set_ip_tos(fd: BorrowedFd<'_>, value: u8) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_TOS, i32::from(value))
-}
-
-#[cfg(any(
-    bsd,
-    linux_like,
-    target_os = "aix",
-    target_os = "fuchsia",
-    target_os = "haiku",
-    target_os = "nto",
-    target_env = "newlib"
-))]
-#[inline]
-pub(crate) fn get_ip_tos(fd: BorrowedFd<'_>) -> io::Result<u8> {
-    let value: i32 = getsockopt(fd, c::IPPROTO_IP, c::IP_TOS)?;
-    Ok(value as u8)
-}
-
-#[cfg(any(apple, linux_like, target_os = "freebsd", target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn set_ip_recvtos(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_RECVTOS, from_bool(value))
-}
-
-#[cfg(any(apple, linux_like, target_os = "freebsd", target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn get_ip_recvtos(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_RECVTOS).map(to_bool)
-}
-
-#[cfg(any(
-    bsd,
-    linux_like,
-    target_os = "aix",
-    target_os = "fuchsia",
-    target_os = "nto"
-))]
-#[inline]
-pub(crate) fn set_ipv6_recvtclass(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_RECVTCLASS, from_bool(value))
-}
-
-#[cfg(any(
-    bsd,
-    linux_like,
-    target_os = "aix",
-    target_os = "fuchsia",
-    target_os = "nto"
-))]
-#[inline]
-pub(crate) fn get_ipv6_recvtclass(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_RECVTCLASS).map(to_bool)
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn set_ip_freebind(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_FREEBIND, from_bool(value))
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn get_ip_freebind(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_FREEBIND).map(to_bool)
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn set_ipv6_freebind(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_FREEBIND, from_bool(value))
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn get_ipv6_freebind(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_FREEBIND).map(to_bool)
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn get_ip_original_dst(fd: BorrowedFd<'_>) -> io::Result<SocketAddrV4> {
-    let level = c::IPPROTO_IP;
-    let optname = c::SO_ORIGINAL_DST;
-    let mut value = MaybeUninit::<SocketAddrStorage>::uninit();
-    let mut optlen = core::mem::size_of_val(&value).try_into().unwrap();
-
-    getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
-
-    let any = unsafe { SocketAddrAny::read(value.as_ptr(), optlen as usize)? };
-    match any {
-        SocketAddrAny::V4(v4) => Ok(v4),
-        _ => unreachable!(),
-    }
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn get_ipv6_original_dst(fd: BorrowedFd<'_>) -> io::Result<SocketAddrV6> {
-    let level = c::IPPROTO_IPV6;
-    let optname = c::IP6T_SO_ORIGINAL_DST;
-    let mut value = MaybeUninit::<SocketAddrStorage>::uninit();
-    let mut optlen = core::mem::size_of_val(&value).try_into().unwrap();
-
-    getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
-
-    let any = unsafe { SocketAddrAny::read(value.as_ptr(), optlen as usize)? };
-    match any {
-        SocketAddrAny::V6(v6) => Ok(v6),
-        _ => unreachable!(),
-    }
-}
-
-#[cfg(not(any(
-    solarish,
-    windows,
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "vita"
-)))]
-#[inline]
-pub(crate) fn set_ipv6_tclass(fd: BorrowedFd<'_>, value: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_TCLASS, value)
-}
-
-#[cfg(not(any(
-    solarish,
-    windows,
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "vita"
-)))]
-#[inline]
-pub(crate) fn get_ipv6_tclass(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_TCLASS)
-}
-
-#[inline]
-pub(crate) fn set_tcp_nodelay(fd: BorrowedFd<'_>, nodelay: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_NODELAY, from_bool(nodelay))
-}
-
-#[inline]
-pub(crate) fn get_tcp_nodelay(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_NODELAY).map(to_bool)
-}
-
-#[inline]
-#[cfg(not(any(target_os = "openbsd", target_os = "haiku", target_os = "nto")))]
-pub(crate) fn set_tcp_keepcnt(fd: BorrowedFd<'_>, count: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPCNT, count)
-}
-
-#[inline]
-#[cfg(not(any(target_os = "openbsd", target_os = "haiku", target_os = "nto")))]
-pub(crate) fn get_tcp_keepcnt(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPCNT)
-}
-
-#[inline]
-#[cfg(not(any(target_os = "openbsd", target_os = "haiku", target_os = "nto")))]
-pub(crate) fn set_tcp_keepidle(fd: BorrowedFd<'_>, duration: Duration) -> io::Result<()> {
-    let secs: c::c_uint = duration_to_secs(duration)?;
-    setsockopt(fd, c::IPPROTO_TCP, TCP_KEEPIDLE, secs)
-}
-
-#[inline]
-#[cfg(not(any(target_os = "openbsd", target_os = "haiku", target_os = "nto")))]
-pub(crate) fn get_tcp_keepidle(fd: BorrowedFd<'_>) -> io::Result<Duration> {
-    let secs: c::c_uint = getsockopt(fd, c::IPPROTO_TCP, TCP_KEEPIDLE)?;
-    Ok(Duration::from_secs(secs as u64))
-}
-
-#[inline]
-#[cfg(not(any(target_os = "openbsd", target_os = "haiku", target_os = "nto")))]
-pub(crate) fn set_tcp_keepintvl(fd: BorrowedFd<'_>, duration: Duration) -> io::Result<()> {
-    let secs: c::c_uint = duration_to_secs(duration)?;
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPINTVL, secs)
-}
-
-#[inline]
-#[cfg(not(any(target_os = "openbsd", target_os = "haiku", target_os = "nto")))]
-pub(crate) fn get_tcp_keepintvl(fd: BorrowedFd<'_>) -> io::Result<Duration> {
-    let secs: c::c_uint = getsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPINTVL)?;
-    Ok(Duration::from_secs(secs as u64))
-}
-
-#[inline]
-#[cfg(any(linux_like, target_os = "fuchsia"))]
-pub(crate) fn set_tcp_user_timeout(fd: BorrowedFd<'_>, value: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_USER_TIMEOUT, value)
-}
-
-#[inline]
-#[cfg(any(linux_like, target_os = "fuchsia"))]
-pub(crate) fn get_tcp_user_timeout(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_USER_TIMEOUT)
-}
-
-#[cfg(any(linux_like, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn set_tcp_quickack(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_QUICKACK, from_bool(value))
-}
-
-#[cfg(any(linux_like, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn get_tcp_quickack(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_QUICKACK).map(to_bool)
-}
-
-#[cfg(any(
-    linux_like,
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos"
-))]
-#[inline]
-pub(crate) fn set_tcp_congestion(fd: BorrowedFd<'_>, value: &str) -> io::Result<()> {
-    let level = c::IPPROTO_TCP;
-    let optname = c::TCP_CONGESTION;
-    let optlen = value.len().try_into().unwrap();
-    setsockopt_raw(fd, level, optname, value.as_ptr(), optlen)
-}
-
-#[cfg(feature = "alloc")]
-#[cfg(any(
-    linux_like,
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos"
-))]
-#[inline]
-pub(crate) fn get_tcp_congestion(fd: BorrowedFd<'_>) -> io::Result<String> {
-    let level = c::IPPROTO_TCP;
-    let optname = c::TCP_CONGESTION;
-    const OPTLEN: c::socklen_t = 16;
-    let mut value = MaybeUninit::<[MaybeUninit<u8>; OPTLEN as usize]>::uninit();
-    let mut optlen = OPTLEN;
-    getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
-    unsafe {
-        let value = value.assume_init();
-        let slice: &[u8] = core::mem::transmute(&value[..optlen as usize]);
-        assert!(slice.iter().any(|b| *b == b'\0'));
-        Ok(
-            core::str::from_utf8(CStr::from_ptr(slice.as_ptr().cast()).to_bytes())
-                .unwrap()
-                .to_owned(),
-        )
-    }
-}
-
-#[cfg(any(linux_like, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn set_tcp_thin_linear_timeouts(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(
-        fd,
-        c::IPPROTO_TCP,
-        c::TCP_THIN_LINEAR_TIMEOUTS,
-        from_bool(value),
-    )
-}
-
-#[cfg(any(linux_like, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn get_tcp_thin_linear_timeouts(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_THIN_LINEAR_TIMEOUTS).map(to_bool)
-}
-
-#[cfg(any(linux_like, solarish, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn set_tcp_cork(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_CORK, from_bool(value))
-}
-
-#[cfg(any(linux_like, solarish, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn get_tcp_cork(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_CORK).map(to_bool)
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn get_socket_peercred(fd: BorrowedFd<'_>) -> io::Result<UCred> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_PEERCRED)
-}
-
-#[inline]
-fn to_ip_mreq(multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> c::ip_mreq {
-    c::ip_mreq {
-        imr_multiaddr: to_imr_addr(multiaddr),
-        imr_interface: to_imr_addr(interface),
-    }
-}
-
-#[cfg(any(
-    apple,
-    freebsdlike,
-    linux_like,
-    target_os = "fuchsia",
-    target_os = "openbsd"
-))]
-#[inline]
-fn to_ip_mreqn(multiaddr: &Ipv4Addr, address: &Ipv4Addr, ifindex: i32) -> c::ip_mreqn {
-    c::ip_mreqn {
-        imr_multiaddr: to_imr_addr(multiaddr),
-        imr_address: to_imr_addr(address),
-        imr_ifindex: ifindex,
-    }
-}
-
-#[cfg(any(apple, freebsdlike, linux_like, solarish, target_os = "aix"))]
-#[inline]
-fn to_imr_source(
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-    sourceaddr: &Ipv4Addr,
-) -> c::ip_mreq_source {
-    c::ip_mreq_source {
-        imr_multiaddr: to_imr_addr(multiaddr),
-        imr_interface: to_imr_addr(interface),
-        imr_sourceaddr: to_imr_addr(sourceaddr),
-    }
-}
-
-#[inline]
-fn to_imr_addr(addr: &Ipv4Addr) -> c::in_addr {
-    in_addr_new(u32::from_ne_bytes(addr.octets()))
-}
-
-#[inline]
-fn to_ipv6mr(multiaddr: &Ipv6Addr, interface: u32) -> c::ipv6_mreq {
-    c::ipv6_mreq {
-        ipv6mr_multiaddr: to_ipv6mr_multiaddr(multiaddr),
-        ipv6mr_interface: to_ipv6mr_interface(interface),
-    }
-}
-
-#[inline]
-fn to_ipv6mr_multiaddr(multiaddr: &Ipv6Addr) -> c::in6_addr {
-    in6_addr_new(multiaddr.octets())
-}
-
-#[cfg(target_os = "android")]
-#[inline]
-fn to_ipv6mr_interface(interface: u32) -> c::c_int {
-    interface as c::c_int
-}
-
-#[cfg(not(target_os = "android"))]
-#[inline]
-fn to_ipv6mr_interface(interface: u32) -> c::c_uint {
-    interface as c::c_uint
-}
-
-// `getsockopt` and `setsockopt` represent boolean values as integers.
-#[cfg(not(windows))]
-type RawSocketBool = c::c_int;
-#[cfg(windows)]
-type RawSocketBool = BOOL;
-
-// Wrap `RawSocketBool` in a newtype to discourage misuse.
-#[repr(transparent)]
-#[derive(Copy, Clone)]
-struct SocketBool(RawSocketBool);
-
-// Convert from a `bool` to a `SocketBool`.
-#[inline]
-fn from_bool(value: bool) -> SocketBool {
-    SocketBool(value.into())
-}
-
-// Convert from a `SocketBool` to a `bool`.
-#[inline]
-fn to_bool(value: SocketBool) -> bool {
-    value.0 != 0
-}
-
-/// Convert to seconds, rounding up if necessary.
-#[inline]
-fn duration_to_secs<T: TryFrom<u64>>(duration: Duration) -> io::Result<T> {
-    let mut secs = duration.as_secs();
-    if duration.subsec_nanos() != 0 {
-        secs = secs.checked_add(1).ok_or(io::Errno::INVAL)?;
-    }
-    T::try_from(secs).map_err(|_e| io::Errno::INVAL)
-}
diff --git a/vendor/rustix/src/backend/libc/net/syscalls.rs b/vendor/rustix/src/backend/libc/net/syscalls.rs
deleted file mode 100644
index 48dbf1f..0000000
--- a/vendor/rustix/src/backend/libc/net/syscalls.rs
+++ /dev/null
@@ -1,568 +0,0 @@
-//! libc syscalls supporting `rustix::net`.
-
-#[cfg(unix)]
-use super::addr::SocketAddrUnix;
-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::mem::{size_of, MaybeUninit};
-#[cfg(not(any(
-    windows,
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    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 {
-    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) unsafe fn recv(
-    fd: BorrowedFd<'_>,
-    buf: *mut u8,
-    len: usize,
-    flags: RecvFlags,
-) -> io::Result<usize> {
-    ret_send_recv(c::recv(
-        borrowed_fd(fd),
-        buf.cast(),
-        send_recv_len(len),
-        bitflags_bits!(flags),
-    ))
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn send(fd: BorrowedFd<'_>, buf: &[u8], flags: SendFlags) -> io::Result<usize> {
-    unsafe {
-        ret_send_recv(c::send(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            send_recv_len(buf.len()),
-            bitflags_bits!(flags),
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) unsafe fn recvfrom(
-    fd: BorrowedFd<'_>,
-    buf: *mut u8,
-    buf_len: usize,
-    flags: RecvFlags,
-) -> io::Result<(usize, Option<SocketAddrAny>)> {
-    let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
-    let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
-
-    // `recvfrom` does not write to the storage if the socket is
-    // connection-oriented sockets, so we initialize the family field to
-    // `AF_UNSPEC` so that we can detect this case.
-    initialize_family_to_unspec(storage.as_mut_ptr());
-
-    ret_send_recv(c::recvfrom(
-        borrowed_fd(fd),
-        buf.cast(),
-        send_recv_len(buf_len),
-        bitflags_bits!(flags),
-        storage.as_mut_ptr().cast(),
-        &mut len,
-    ))
-    .map(|nread| {
-        (
-            nread,
-            maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()),
-        )
-    })
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn sendto_v4(
-    fd: BorrowedFd<'_>,
-    buf: &[u8],
-    flags: SendFlags,
-    addr: &SocketAddrV4,
-) -> io::Result<usize> {
-    unsafe {
-        ret_send_recv(c::sendto(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            send_recv_len(buf.len()),
-            bitflags_bits!(flags),
-            as_ptr(&encode_sockaddr_v4(addr)).cast::<c::sockaddr>(),
-            size_of::<c::sockaddr_in>() as c::socklen_t,
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn sendto_v6(
-    fd: BorrowedFd<'_>,
-    buf: &[u8],
-    flags: SendFlags,
-    addr: &SocketAddrV6,
-) -> io::Result<usize> {
-    unsafe {
-        ret_send_recv(c::sendto(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            send_recv_len(buf.len()),
-            bitflags_bits!(flags),
-            as_ptr(&encode_sockaddr_v6(addr)).cast::<c::sockaddr>(),
-            size_of::<c::sockaddr_in6>() as c::socklen_t,
-        ))
-    }
-}
-
-#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
-pub(crate) fn sendto_unix(
-    fd: BorrowedFd<'_>,
-    buf: &[u8],
-    flags: SendFlags,
-    addr: &SocketAddrUnix,
-) -> io::Result<usize> {
-    unsafe {
-        ret_send_recv(c::sendto(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            send_recv_len(buf.len()),
-            bitflags_bits!(flags),
-            as_ptr(&addr.unix).cast(),
-            addr.addr_len(),
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn socket(
-    domain: AddressFamily,
-    type_: SocketType,
-    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,
-            raw_protocol as c::c_int,
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn socket_with(
-    domain: AddressFamily,
-    type_: SocketType,
-    flags: SocketFlags,
-    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 | flags.bits()) as c::c_int,
-            raw_protocol as c::c_int,
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn bind_v4(sockfd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> {
-    unsafe {
-        ret(c::bind(
-            borrowed_fd(sockfd),
-            as_ptr(&encode_sockaddr_v4(addr)).cast(),
-            size_of::<c::sockaddr_in>() as c::socklen_t,
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn bind_v6(sockfd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> {
-    unsafe {
-        ret(c::bind(
-            borrowed_fd(sockfd),
-            as_ptr(&encode_sockaddr_v6(addr)).cast(),
-            size_of::<c::sockaddr_in6>() as c::socklen_t,
-        ))
-    }
-}
-
-#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
-pub(crate) fn bind_unix(sockfd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> {
-    unsafe {
-        ret(c::bind(
-            borrowed_fd(sockfd),
-            as_ptr(&addr.unix).cast(),
-            addr.addr_len(),
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn connect_v4(sockfd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> {
-    unsafe {
-        ret(c::connect(
-            borrowed_fd(sockfd),
-            as_ptr(&encode_sockaddr_v4(addr)).cast(),
-            size_of::<c::sockaddr_in>() as c::socklen_t,
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn connect_v6(sockfd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> {
-    unsafe {
-        ret(c::connect(
-            borrowed_fd(sockfd),
-            as_ptr(&encode_sockaddr_v6(addr)).cast(),
-            size_of::<c::sockaddr_in6>() as c::socklen_t,
-        ))
-    }
-}
-
-#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
-pub(crate) fn connect_unix(sockfd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> {
-    unsafe {
-        ret(c::connect(
-            borrowed_fd(sockfd),
-            as_ptr(&addr.unix).cast(),
-            addr.addr_len(),
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn connect_unspec(sockfd: BorrowedFd<'_>) -> io::Result<()> {
-    debug_assert_eq!(c::AF_UNSPEC, 0);
-    let addr = MaybeUninit::<c::sockaddr_storage>::zeroed();
-    unsafe {
-        ret(c::connect(
-            borrowed_fd(sockfd),
-            as_ptr(&addr).cast(),
-            size_of::<c::sockaddr_storage>() as c::socklen_t,
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn listen(sockfd: BorrowedFd<'_>, backlog: c::c_int) -> io::Result<()> {
-    unsafe { ret(c::listen(borrowed_fd(sockfd), backlog)) }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn accept(sockfd: BorrowedFd<'_>) -> io::Result<OwnedFd> {
-    unsafe {
-        let owned_fd = ret_owned_fd(c::accept(borrowed_fd(sockfd), null_mut(), null_mut()))?;
-        Ok(owned_fd)
-    }
-}
-
-#[cfg(not(any(
-    windows,
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    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 = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    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 = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    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 = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    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(any(target_os = "espidf", target_os = "redox", target_os = "vita"))
-))]
-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,
-    target_os = "aix",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "redox",
-    target_os = "nto",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-pub(crate) fn accept_with(sockfd: BorrowedFd<'_>, flags: SocketFlags) -> io::Result<OwnedFd> {
-    unsafe {
-        let owned_fd = ret_owned_fd(c::accept4(
-            borrowed_fd(sockfd),
-            null_mut(),
-            null_mut(),
-            flags.bits() as c::c_int,
-        ))?;
-        Ok(owned_fd)
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn acceptfrom(sockfd: BorrowedFd<'_>) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
-    unsafe {
-        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
-        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
-        let owned_fd = ret_owned_fd(c::accept(
-            borrowed_fd(sockfd),
-            storage.as_mut_ptr().cast(),
-            &mut len,
-        ))?;
-        Ok((
-            owned_fd,
-            maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()),
-        ))
-    }
-}
-
-#[cfg(not(any(
-    apple,
-    windows,
-    target_os = "aix",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "nto",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-pub(crate) fn acceptfrom_with(
-    sockfd: BorrowedFd<'_>,
-    flags: SocketFlags,
-) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
-    unsafe {
-        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
-        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
-        let owned_fd = ret_owned_fd(c::accept4(
-            borrowed_fd(sockfd),
-            storage.as_mut_ptr().cast(),
-            &mut len,
-            flags.bits() as c::c_int,
-        ))?;
-        Ok((
-            owned_fd,
-            maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()),
-        ))
-    }
-}
-
-/// Darwin lacks `accept4`, but does have `accept`. We define
-/// `SocketFlags` to have no flags, so we can discard it here.
-#[cfg(any(
-    apple,
-    windows,
-    target_os = "aix",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "nto",
-    target_os = "vita",
-))]
-pub(crate) fn accept_with(sockfd: BorrowedFd<'_>, _flags: SocketFlags) -> io::Result<OwnedFd> {
-    accept(sockfd)
-}
-
-/// Darwin lacks `accept4`, but does have `accept`. We define
-/// `SocketFlags` to have no flags, so we can discard it here.
-#[cfg(any(
-    apple,
-    windows,
-    target_os = "aix",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "nto",
-    target_os = "vita",
-))]
-pub(crate) fn acceptfrom_with(
-    sockfd: BorrowedFd<'_>,
-    _flags: SocketFlags,
-) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
-    acceptfrom(sockfd)
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn shutdown(sockfd: BorrowedFd<'_>, how: Shutdown) -> io::Result<()> {
-    unsafe { ret(c::shutdown(borrowed_fd(sockfd), how as c::c_int)) }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn getsockname(sockfd: BorrowedFd<'_>) -> io::Result<SocketAddrAny> {
-    unsafe {
-        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
-        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
-        ret(c::getsockname(
-            borrowed_fd(sockfd),
-            storage.as_mut_ptr().cast(),
-            &mut len,
-        ))?;
-        Ok(read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn getpeername(sockfd: BorrowedFd<'_>) -> io::Result<Option<SocketAddrAny>> {
-    unsafe {
-        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
-        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
-        ret(c::getpeername(
-            borrowed_fd(sockfd),
-            storage.as_mut_ptr().cast(),
-            &mut len,
-        ))?;
-        Ok(maybe_read_sockaddr_os(
-            storage.as_ptr(),
-            len.try_into().unwrap(),
-        ))
-    }
-}
-
-#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
-pub(crate) fn socketpair(
-    domain: AddressFamily,
-    type_: SocketType,
-    flags: SocketFlags,
-    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 | flags.bits()) as c::c_int,
-            raw_protocol as c::c_int,
-            fds.as_mut_ptr().cast::<c::c_int>(),
-        ))?;
-
-        let [fd0, fd1] = fds.assume_init();
-        Ok((fd0, fd1))
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/net/write_sockaddr.rs b/vendor/rustix/src/backend/libc/net/write_sockaddr.rs
deleted file mode 100644
index 2eee98c..0000000
--- a/vendor/rustix/src/backend/libc/net/write_sockaddr.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-//! 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::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;
-
-pub(crate) unsafe fn write_sockaddr(
-    addr: &SocketAddrAny,
-    storage: *mut SocketAddrStorage,
-) -> usize {
-    match addr {
-        SocketAddrAny::V4(v4) => write_sockaddr_v4(v4, storage),
-        SocketAddrAny::V6(v6) => write_sockaddr_v6(v6, storage),
-        #[cfg(unix)]
-        SocketAddrAny::Unix(unix) => write_sockaddr_unix(unix, storage),
-    }
-}
-
-pub(crate) fn encode_sockaddr_v4(v4: &SocketAddrV4) -> c::sockaddr_in {
-    c::sockaddr_in {
-        #[cfg(any(
-            bsd,
-            target_os = "aix",
-            target_os = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "vita",
-        ))]
-        sin_len: size_of::<c::sockaddr_in>() as _,
-        sin_family: c::AF_INET as _,
-        sin_port: u16::to_be(v4.port()),
-        sin_addr: in_addr_new(u32::from_ne_bytes(v4.ip().octets())),
-        #[cfg(not(any(target_os = "haiku", target_os = "vita")))]
-        sin_zero: [0; 8_usize],
-        #[cfg(target_os = "haiku")]
-        sin_zero: [0; 24_usize],
-        #[cfg(target_os = "vita")]
-        sin_zero: [0; 6_usize],
-        #[cfg(target_os = "vita")]
-        sin_vport: 0,
-    }
-}
-
-unsafe fn write_sockaddr_v4(v4: &SocketAddrV4, storage: *mut SocketAddrStorage) -> usize {
-    let encoded = encode_sockaddr_v4(v4);
-    core::ptr::write(storage.cast(), encoded);
-    size_of::<c::sockaddr_in>()
-}
-
-pub(crate) fn encode_sockaddr_v6(v6: &SocketAddrV6) -> c::sockaddr_in6 {
-    #[cfg(any(
-        bsd,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "nto",
-        target_os = "vita"
-    ))]
-    {
-        sockaddr_in6_new(
-            size_of::<c::sockaddr_in6>() as _,
-            c::AF_INET6 as _,
-            u16::to_be(v6.port()),
-            u32::to_be(v6.flowinfo()),
-            in6_addr_new(v6.ip().octets()),
-            v6.scope_id(),
-        )
-    }
-    #[cfg(not(any(
-        bsd,
-        target_os = "aix",
-        target_os = "espidf",
-        target_os = "haiku",
-        target_os = "nto",
-        target_os = "vita"
-    )))]
-    {
-        sockaddr_in6_new(
-            c::AF_INET6 as _,
-            u16::to_be(v6.port()),
-            u32::to_be(v6.flowinfo()),
-            in6_addr_new(v6.ip().octets()),
-            v6.scope_id(),
-        )
-    }
-}
-
-unsafe fn write_sockaddr_v6(v6: &SocketAddrV6, storage: *mut SocketAddrStorage) -> usize {
-    let encoded = encode_sockaddr_v6(v6);
-    core::ptr::write(storage.cast(), encoded);
-    size_of::<c::sockaddr_in6>()
-}
-
-#[cfg(unix)]
-unsafe fn write_sockaddr_unix(unix: &SocketAddrUnix, storage: *mut SocketAddrStorage) -> usize {
-    core::ptr::write(storage.cast(), unix.unix);
-    unix.len()
-}
diff --git a/vendor/rustix/src/backend/libc/param/auxv.rs b/vendor/rustix/src/backend/libc/param/auxv.rs
deleted file mode 100644
index 880a1d4..0000000
--- a/vendor/rustix/src/backend/libc/param/auxv.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use crate::backend::c;
-#[cfg(any(
-    all(target_os = "android", target_pointer_width = "64"),
-    target_os = "linux",
-))]
-use crate::ffi::CStr;
-
-// `getauxval` wasn't supported in glibc until 2.16.
-#[cfg(any(
-    all(target_os = "android", target_pointer_width = "64"),
-    target_os = "linux",
-))]
-weak!(fn getauxval(c::c_ulong) -> *mut c::c_void);
-
-#[inline]
-pub(crate) fn page_size() -> usize {
-    unsafe { c::sysconf(c::_SC_PAGESIZE) as usize }
-}
-
-#[cfg(not(any(target_os = "vita", target_os = "wasi")))]
-#[inline]
-pub(crate) fn clock_ticks_per_second() -> u64 {
-    unsafe { c::sysconf(c::_SC_CLK_TCK) as u64 }
-}
-
-#[cfg(any(
-    all(target_os = "android", target_pointer_width = "64"),
-    target_os = "linux",
-))]
-#[inline]
-pub(crate) fn linux_hwcap() -> (usize, usize) {
-    if let Some(libc_getauxval) = getauxval.get() {
-        unsafe {
-            let hwcap = libc_getauxval(c::AT_HWCAP) as usize;
-            let hwcap2 = libc_getauxval(c::AT_HWCAP2) as usize;
-            (hwcap, hwcap2)
-        }
-    } else {
-        (0, 0)
-    }
-}
-
-#[cfg(any(
-    all(target_os = "android", target_pointer_width = "64"),
-    target_os = "linux",
-))]
-#[inline]
-pub(crate) fn linux_execfn() -> &'static CStr {
-    if let Some(libc_getauxval) = getauxval.get() {
-        unsafe { CStr::from_ptr(libc_getauxval(c::AT_EXECFN).cast()) }
-    } else {
-        cstr!("")
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/param/mod.rs b/vendor/rustix/src/backend/libc/param/mod.rs
deleted file mode 100644
index 2cb2fe7..0000000
--- a/vendor/rustix/src/backend/libc/param/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod auxv;
diff --git a/vendor/rustix/src/backend/libc/pid/mod.rs b/vendor/rustix/src/backend/libc/pid/mod.rs
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/libc/pid/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/pid/syscalls.rs b/vendor/rustix/src/backend/libc/pid/syscalls.rs
deleted file mode 100644
index d0ed4bc..0000000
--- a/vendor/rustix/src/backend/libc/pid/syscalls.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! 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
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/libc/pipe/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-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
deleted file mode 100644
index cff932d..0000000
--- a/vendor/rustix/src/backend/libc/pipe/syscalls.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-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 = "espidf",
-    target_os = "haiku",
-    target_os = "nto",
-    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::option_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 = "espidf",
-    target_os = "haiku",
-    target_os = "nto",
-    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 = option_as_mut_ptr(off_in).cast();
-    let off_out = option_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
deleted file mode 100644
index 78fc2fc..0000000
--- a/vendor/rustix/src/backend/libc/pipe/types.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-#[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::pipe::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 = "espidf",
-            target_os = "haiku",
-            target_os = "nto",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "vita",
-        )))]
-        const DIRECT = bitcast!(c::O_DIRECT);
-        /// `O_NONBLOCK`
-        const NONBLOCK = bitcast!(c::O_NONBLOCK);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// A buffer type for use 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.
-///
-/// [`vmsplice`]: crate::pipe::vmsplice
-#[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() {
-    assert_eq_size!(PipeFlags, c::c_int);
-
-    #[cfg(linux_kernel)]
-    assert_eq_size!(SpliceFlags, c::c_int);
-}
diff --git a/vendor/rustix/src/backend/libc/prctl/mod.rs b/vendor/rustix/src/backend/libc/prctl/mod.rs
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/libc/prctl/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/prctl/syscalls.rs b/vendor/rustix/src/backend/libc/prctl/syscalls.rs
deleted file mode 100644
index 451cecc..0000000
--- a/vendor/rustix/src/backend/libc/prctl/syscalls.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index 4cf06b9..0000000
--- a/vendor/rustix/src/backend/libc/process/cpu_set.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-//! Rust implementation of the `CPU_*` macro API.
-
-#![allow(non_snake_case)]
-
-use super::types::{RawCpuSet, CPU_SETSIZE};
-use crate::backend::c;
-
-#[inline]
-pub(crate) fn CPU_SET(cpu: usize, cpuset: &mut RawCpuSet) {
-    assert!(
-        cpu < CPU_SETSIZE,
-        "cpu out of bounds: the cpu max is {} but the cpu is {}",
-        CPU_SETSIZE,
-        cpu
-    );
-    unsafe { c::CPU_SET(cpu, cpuset) }
-}
-
-#[inline]
-pub(crate) fn CPU_ZERO(cpuset: &mut RawCpuSet) {
-    unsafe { c::CPU_ZERO(cpuset) }
-}
-
-#[inline]
-pub(crate) fn CPU_CLR(cpu: usize, cpuset: &mut RawCpuSet) {
-    assert!(
-        cpu < CPU_SETSIZE,
-        "cpu out of bounds: the cpu max is {} but the cpu is {}",
-        CPU_SETSIZE,
-        cpu
-    );
-    unsafe { c::CPU_CLR(cpu, cpuset) }
-}
-
-#[inline]
-pub(crate) fn CPU_ISSET(cpu: usize, cpuset: &RawCpuSet) -> bool {
-    assert!(
-        cpu < CPU_SETSIZE,
-        "cpu out of bounds: the cpu max is {} but the cpu is {}",
-        CPU_SETSIZE,
-        cpu
-    );
-    unsafe { c::CPU_ISSET(cpu, cpuset) }
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn CPU_COUNT(cpuset: &RawCpuSet) -> u32 {
-    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
deleted file mode 100644
index 39803b5..0000000
--- a/vendor/rustix/src/backend/libc/process/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-#[cfg(any(freebsdlike, linux_kernel, target_os = "fuchsia"))]
-pub(crate) mod cpu_set;
-#[cfg(not(windows))]
-pub(crate) mod syscalls;
-pub(crate) mod types;
-#[cfg(not(any(target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-pub(crate) mod wait;
diff --git a/vendor/rustix/src/backend/libc/process/syscalls.rs b/vendor/rustix/src/backend/libc/process/syscalls.rs
deleted file mode 100644
index 46fd182..0000000
--- a/vendor/rustix/src/backend/libc/process/syscalls.rs
+++ /dev/null
@@ -1,713 +0,0 @@
-//! libc syscalls supporting `rustix::process`.
-
-#[cfg(any(freebsdlike, linux_kernel, target_os = "fuchsia"))]
-use super::types::RawCpuSet;
-use crate::backend::c;
-#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))]
-use crate::backend::conv::borrowed_fd;
-#[cfg(feature = "fs")]
-use crate::backend::conv::c_str;
-#[cfg(all(feature = "alloc", feature = "fs", not(target_os = "wasi")))]
-use crate::backend::conv::ret_discarded_char_ptr;
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-use crate::backend::conv::ret_infallible;
-#[cfg(not(target_os = "wasi"))]
-use crate::backend::conv::ret_pid_t;
-#[cfg(linux_kernel)]
-use crate::backend::conv::ret_u32;
-#[cfg(all(feature = "alloc", not(target_os = "wasi")))]
-use crate::backend::conv::ret_usize;
-use crate::backend::conv::{ret, ret_c_int};
-#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))]
-use crate::fd::BorrowedFd;
-#[cfg(target_os = "linux")]
-use crate::fd::{AsRawFd, OwnedFd, RawFd};
-#[cfg(feature = "fs")]
-use crate::ffi::CStr;
-#[cfg(feature = "fs")]
-use crate::fs::Mode;
-use crate::io;
-#[cfg(all(feature = "alloc", not(target_os = "wasi")))]
-use crate::process::Gid;
-#[cfg(not(target_os = "wasi"))]
-use crate::process::Pid;
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-use crate::process::Signal;
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-use crate::process::Uid;
-#[cfg(linux_kernel)]
-use crate::process::{Cpuid, MembarrierCommand, MembarrierQuery};
-#[cfg(not(any(target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-use crate::process::{RawPid, WaitOptions, WaitStatus};
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-use crate::process::{Resource, Rlimit};
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "openbsd",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-use crate::process::{WaitId, WaitidOptions, WaitidStatus};
-use core::mem::MaybeUninit;
-#[cfg(target_os = "linux")]
-use {
-    super::super::conv::ret_owned_fd, crate::process::PidfdFlags, crate::process::PidfdGetfdFlags,
-};
-
-#[cfg(any(linux_kernel, target_os = "dragonfly"))]
-#[inline]
-pub(crate) fn sched_getcpu() -> usize {
-    let r = unsafe { libc::sched_getcpu() };
-    debug_assert!(r >= 0);
-    r as usize
-}
-
-#[cfg(feature = "fs")]
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn chdir(path: &CStr) -> io::Result<()> {
-    unsafe { ret(c::chdir(c_str(path))) }
-}
-
-#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
-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(all(feature = "alloc", feature = "fs"))]
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn getcwd(buf: &mut [MaybeUninit<u8>]) -> io::Result<()> {
-    unsafe { ret_discarded_char_ptr(c::getcwd(buf.as_mut_ptr().cast(), buf.len())) }
-}
-
-// 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`.
-    //
-    // [the documentation]: https://man7.org/linux/man-pages/man2/membarrier.2.html#NOTES
-    const MEMBARRIER_CMD_QUERY: u32 = 0;
-    unsafe {
-        match ret_u32(membarrier_all(MEMBARRIER_CMD_QUERY as i32, 0)) {
-            Ok(query) => MembarrierQuery::from_bits_retain(query),
-            Err(_) => MembarrierQuery::empty(),
-        }
-    }
-}
-
-#[cfg(linux_kernel)]
-pub(crate) fn membarrier(cmd: MembarrierCommand) -> io::Result<()> {
-    unsafe { ret(membarrier_all(cmd as i32, 0)) }
-}
-
-#[cfg(linux_kernel)]
-pub(crate) fn membarrier_cpu(cmd: MembarrierCommand, cpu: Cpuid) -> io::Result<()> {
-    const MEMBARRIER_CMD_FLAG_CPU: u32 = 1;
-
-    syscall! {
-        fn membarrier_cpu(
-            cmd: c::c_int,
-            flags: c::c_uint,
-            cpu_id: c::c_int
-        ) via SYS_membarrier -> c::c_int
-    }
-
-    unsafe {
-        ret(membarrier_cpu(
-            cmd as i32,
-            MEMBARRIER_CMD_FLAG_CPU,
-            bitcast!(cpu.as_raw()),
-        ))
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getppid() -> Option<Pid> {
-    unsafe {
-        let pid: i32 = c::getppid();
-        Pid::from_raw(pid)
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn getpgid(pid: Option<Pid>) -> io::Result<Pid> {
-    unsafe {
-        let pgid = ret_pid_t(c::getpgid(Pid::as_raw(pid) as _))?;
-        Ok(Pid::from_raw_unchecked(pgid))
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn setpgid(pid: Option<Pid>, pgid: Option<Pid>) -> io::Result<()> {
-    unsafe { ret(c::setpgid(Pid::as_raw(pid) as _, Pid::as_raw(pgid) as _)) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getpgrp() -> Pid {
-    unsafe {
-        let pgid = c::getpgrp();
-        Pid::from_raw_unchecked(pgid)
-    }
-}
-
-#[cfg(any(freebsdlike, linux_kernel, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn sched_getaffinity(pid: Option<Pid>, cpuset: &mut RawCpuSet) -> io::Result<()> {
-    unsafe {
-        ret(c::sched_getaffinity(
-            Pid::as_raw(pid) as _,
-            core::mem::size_of::<RawCpuSet>(),
-            cpuset,
-        ))
-    }
-}
-
-#[cfg(any(freebsdlike, linux_kernel, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn sched_setaffinity(pid: Option<Pid>, cpuset: &RawCpuSet) -> io::Result<()> {
-    unsafe {
-        ret(c::sched_setaffinity(
-            Pid::as_raw(pid) as _,
-            core::mem::size_of::<RawCpuSet>(),
-            cpuset,
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn sched_yield() {
-    unsafe {
-        let _ = c::sched_yield();
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[cfg(feature = "fs")]
-#[inline]
-pub(crate) fn umask(mask: Mode) -> Mode {
-    unsafe { Mode::from_bits_retain(c::umask(mask.bits() as c::mode_t).into()) }
-}
-
-#[cfg(not(any(target_os = "fuchsia", target_os = "vita", target_os = "wasi")))]
-#[inline]
-pub(crate) fn nice(inc: i32) -> io::Result<i32> {
-    libc_errno::set_errno(libc_errno::Errno(0));
-    let r = unsafe { c::nice(inc) };
-    if libc_errno::errno().0 != 0 {
-        ret_c_int(r)
-    } else {
-        Ok(r)
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-pub(crate) fn getpriority_user(uid: Uid) -> io::Result<i32> {
-    libc_errno::set_errno(libc_errno::Errno(0));
-    let r = unsafe { c::getpriority(c::PRIO_USER, uid.as_raw() as _) };
-    if libc_errno::errno().0 != 0 {
-        ret_c_int(r)
-    } else {
-        Ok(r)
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-pub(crate) fn getpriority_pgrp(pgid: Option<Pid>) -> io::Result<i32> {
-    libc_errno::set_errno(libc_errno::Errno(0));
-    let r = unsafe { c::getpriority(c::PRIO_PGRP, Pid::as_raw(pgid) as _) };
-    if libc_errno::errno().0 != 0 {
-        ret_c_int(r)
-    } else {
-        Ok(r)
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-pub(crate) fn getpriority_process(pid: Option<Pid>) -> io::Result<i32> {
-    libc_errno::set_errno(libc_errno::Errno(0));
-    let r = unsafe { c::getpriority(c::PRIO_PROCESS, Pid::as_raw(pid) as _) };
-    if libc_errno::errno().0 != 0 {
-        ret_c_int(r)
-    } else {
-        Ok(r)
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "vita",
-    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 = "espidf",
-    target_os = "fuchsia",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-pub(crate) fn setpriority_pgrp(pgid: Option<Pid>, priority: i32) -> io::Result<()> {
-    unsafe {
-        ret(c::setpriority(
-            c::PRIO_PGRP,
-            Pid::as_raw(pgid) as _,
-            priority,
-        ))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-pub(crate) fn setpriority_process(pid: Option<Pid>, priority: i32) -> io::Result<()> {
-    unsafe {
-        ret(c::setpriority(
-            c::PRIO_PROCESS,
-            Pid::as_raw(pid) as _,
-            priority,
-        ))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-pub(crate) fn getrlimit(limit: Resource) -> Rlimit {
-    let mut result = MaybeUninit::<c::rlimit>::uninit();
-    unsafe {
-        ret_infallible(c::getrlimit(limit as _, result.as_mut_ptr()));
-        rlimit_from_libc(result.assume_init())
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-pub(crate) fn setrlimit(limit: Resource, new: Rlimit) -> io::Result<()> {
-    let lim = rlimit_to_libc(new)?;
-    unsafe { ret(c::setrlimit(limit as _, &lim)) }
-}
-
-#[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::<c::rlimit>::uninit();
-    unsafe {
-        ret(c::prlimit(
-            Pid::as_raw(pid),
-            limit as _,
-            &lim,
-            result.as_mut_ptr(),
-        ))?;
-        Ok(rlimit_from_libc(result.assume_init()))
-    }
-}
-
-/// Convert a Rust [`Rlimit`] to a C `c::rlimit`.
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-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 == c::RLIM_INFINITY {
-        None
-    } else {
-        Some(lim.rlim_max.try_into().unwrap())
-    };
-    Rlimit { current, maximum }
-}
-
-/// Convert a C `c::rlimit` to a Rust `Rlimit`.
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-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 => c::RLIM_INFINITY as _,
-    };
-    let rlim_max = match maximum {
-        Some(r) => r.try_into().map_err(|_e| io::Errno::INVAL)?,
-        None => c::RLIM_INFINITY as _,
-    };
-    Ok(c::rlimit { rlim_cur, rlim_max })
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-#[inline]
-pub(crate) fn wait(waitopts: WaitOptions) -> io::Result<Option<(Pid, WaitStatus)>> {
-    _waitpid(!0, waitopts)
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-#[inline]
-pub(crate) fn waitpid(
-    pid: Option<Pid>,
-    waitopts: WaitOptions,
-) -> io::Result<Option<(Pid, WaitStatus)>> {
-    _waitpid(Pid::as_raw(pid), waitopts)
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-#[inline]
-pub(crate) fn waitpgid(pgid: Pid, waitopts: WaitOptions) -> io::Result<Option<(Pid, WaitStatus)>> {
-    _waitpid(-pgid.as_raw_nonzero().get(), waitopts)
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "vita", target_os = "wasi")))]
-#[inline]
-pub(crate) fn _waitpid(
-    pid: RawPid,
-    waitopts: WaitOptions,
-) -> io::Result<Option<(Pid, WaitStatus)>> {
-    unsafe {
-        let mut status: c::c_int = 0;
-        let pid = ret_c_int(c::waitpid(pid as _, &mut status, waitopts.bits() as _))?;
-        Ok(Pid::from_raw(pid).map(|pid| (pid, WaitStatus::new(status as _))))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "openbsd",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-pub(crate) fn waitid(id: WaitId<'_>, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // Get the id to wait on.
-    match id {
-        WaitId::All => _waitid_all(options),
-        WaitId::Pid(pid) => _waitid_pid(pid, options),
-        WaitId::Pgid(pgid) => _waitid_pgid(pgid, options),
-        #[cfg(target_os = "linux")]
-        WaitId::PidFd(fd) => _waitid_pidfd(fd, options),
-        #[cfg(not(target_os = "linux"))]
-        WaitId::__EatLifetime(_) => unreachable!(),
-    }
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "openbsd",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-fn _waitid_all(options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // `waitid` can return successfully without initializing the struct (no
-    // children found when using `WNOHANG`)
-    let mut status = MaybeUninit::<c::siginfo_t>::zeroed();
-    unsafe {
-        ret(c::waitid(
-            c::P_ALL,
-            0,
-            status.as_mut_ptr(),
-            options.bits() as _,
-        ))?
-    };
-
-    Ok(unsafe { cvt_waitid_status(status) })
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "openbsd",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-fn _waitid_pid(pid: Pid, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // `waitid` can return successfully without initializing the struct (no
-    // children found when using `WNOHANG`)
-    let mut status = MaybeUninit::<c::siginfo_t>::zeroed();
-    unsafe {
-        ret(c::waitid(
-            c::P_PID,
-            Pid::as_raw(Some(pid)) as _,
-            status.as_mut_ptr(),
-            options.bits() as _,
-        ))?
-    };
-
-    Ok(unsafe { cvt_waitid_status(status) })
-}
-
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "openbsd",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-fn _waitid_pgid(pgid: Option<Pid>, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // `waitid` can return successfully without initializing the struct (no
-    // children found when using `WNOHANG`)
-    let mut status = MaybeUninit::<c::siginfo_t>::zeroed();
-    unsafe {
-        ret(c::waitid(
-            c::P_PGID,
-            Pid::as_raw(pgid) as _,
-            status.as_mut_ptr(),
-            options.bits() as _,
-        ))?
-    };
-
-    Ok(unsafe { cvt_waitid_status(status) })
-}
-
-#[cfg(target_os = "linux")]
-#[inline]
-fn _waitid_pidfd(fd: BorrowedFd<'_>, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // `waitid` can return successfully without initializing the struct (no
-    // children found when using `WNOHANG`)
-    let mut status = MaybeUninit::<c::siginfo_t>::zeroed();
-    unsafe {
-        ret(c::waitid(
-            c::P_PIDFD,
-            fd.as_raw_fd() as _,
-            status.as_mut_ptr(),
-            options.bits() as _,
-        ))?
-    };
-
-    Ok(unsafe { cvt_waitid_status(status) })
-}
-
-/// Convert a `siginfo_t` to a `WaitidStatus`.
-///
-/// # Safety
-///
-/// The caller must ensure that `status` is initialized and that `waitid`
-/// returned successfully.
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[inline]
-unsafe fn cvt_waitid_status(status: MaybeUninit<c::siginfo_t>) -> Option<WaitidStatus> {
-    let status = status.assume_init();
-    // `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
-    // `si_signo`. We have zero-initialized the whole struct, and all kernels
-    // should set `SIGCHLD` here.
-    if status.si_signo == 0 {
-        None
-    } else {
-        Some(WaitidStatus(status))
-    }
-}
-
-#[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 _))?;
-        Ok(Pid::from_raw_unchecked(pid))
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn setsid() -> io::Result<Pid> {
-    unsafe {
-        let pid = ret_c_int(c::setsid())?;
-        Ok(Pid::from_raw_unchecked(pid))
-    }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-#[inline]
-pub(crate) fn kill_process(pid: Pid, sig: Signal) -> io::Result<()> {
-    unsafe { ret(c::kill(pid.as_raw_nonzero().get(), sig as i32)) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-#[inline]
-pub(crate) fn kill_process_group(pid: Pid, sig: Signal) -> io::Result<()> {
-    unsafe {
-        ret(c::kill(
-            pid.as_raw_nonzero().get().wrapping_neg(),
-            sig as i32,
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-#[inline]
-pub(crate) fn kill_current_process_group(sig: Signal) -> io::Result<()> {
-    unsafe { ret(c::kill(0, sig as i32)) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) fn test_kill_process(pid: Pid) -> io::Result<()> {
-    unsafe { ret(c::kill(pid.as_raw_nonzero().get(), 0)) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-#[inline]
-pub(crate) fn test_kill_process_group(pid: Pid) -> io::Result<()> {
-    unsafe { ret(c::kill(pid.as_raw_nonzero().get().wrapping_neg(), 0)) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-#[inline]
-pub(crate) fn test_kill_current_process_group() -> io::Result<()> {
-    unsafe { ret(c::kill(0, 0)) }
-}
-
-#[cfg(freebsdlike)]
-#[inline]
-pub(crate) unsafe fn procctl(
-    idtype: c::idtype_t,
-    id: c::id_t,
-    option: c::c_int,
-    data: *mut c::c_void,
-) -> io::Result<()> {
-    ret(c::procctl(idtype, id, option, data))
-}
-
-#[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 {
-        ret_owned_fd(pidfd_open(
-            pid.as_raw_nonzero().get(),
-            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),
-        ))
-    }
-}
-
-#[cfg(all(feature = "alloc", not(target_os = "wasi")))]
-pub(crate) fn getgroups(buf: &mut [Gid]) -> io::Result<usize> {
-    let len = buf.len().try_into().map_err(|_| io::Errno::NOMEM)?;
-
-    unsafe { ret_usize(c::getgroups(len, buf.as_mut_ptr().cast()) as isize) }
-}
diff --git a/vendor/rustix/src/backend/libc/process/types.rs b/vendor/rustix/src/backend/libc/process/types.rs
deleted file mode 100644
index f914128..0000000
--- a/vendor/rustix/src/backend/libc/process/types.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-#[cfg(not(any(target_os = "espidf", target_os = "vita")))]
-use crate::backend::c;
-
-/// A command for use with [`membarrier`] and [`membarrier_cpu`].
-///
-/// For `MEMBARRIER_CMD_QUERY`, see [`membarrier_query`].
-///
-/// [`membarrier`]: crate::process::membarrier
-/// [`membarrier_cpu`]: crate::process::membarrier_cpu
-/// [`membarrier_query`]: crate::process::membarrier_query
-#[cfg(linux_kernel)]
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
-#[repr(u32)]
-pub enum MembarrierCommand {
-    /// `MEMBARRIER_CMD_GLOBAL`
-    #[doc(alias = "Shared")]
-    #[doc(alias = "MEMBARRIER_CMD_SHARED")]
-    Global = c::MEMBARRIER_CMD_GLOBAL as u32,
-    /// `MEMBARRIER_CMD_GLOBAL_EXPEDITED`
-    GlobalExpedited = c::MEMBARRIER_CMD_GLOBAL_EXPEDITED as u32,
-    /// `MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED`
-    RegisterGlobalExpedited = c::MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED as u32,
-    /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED`
-    PrivateExpedited = c::MEMBARRIER_CMD_PRIVATE_EXPEDITED as u32,
-    /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED`
-    RegisterPrivateExpedited = c::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED as u32,
-    /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE`
-    PrivateExpeditedSyncCore = c::MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE as u32,
-    /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE`
-    RegisterPrivateExpeditedSyncCore =
-        c::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE as u32,
-    /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)
-    PrivateExpeditedRseq = c::MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ as u32,
-    /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)
-    RegisterPrivateExpeditedRseq = c::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ as u32,
-}
-
-/// A resource value for use with [`getrlimit`], [`setrlimit`], and
-/// [`prlimit`].
-///
-/// [`getrlimit`]: crate::process::getrlimit
-/// [`setrlimit`]: crate::process::setrlimit
-/// [`prlimit`]: crate::process::prlimit
-#[cfg(not(any(
-    target_os = "espidf",
-    target_os = "fuchsia",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi"
-)))]
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(not(target_os = "l4re"), repr(u32))]
-#[cfg_attr(target_os = "l4re", repr(u64))]
-pub enum Resource {
-    /// `RLIMIT_CPU`
-    Cpu = bitcast!(c::RLIMIT_CPU),
-    /// `RLIMIT_FSIZE`
-    Fsize = bitcast!(c::RLIMIT_FSIZE),
-    /// `RLIMIT_DATA`
-    Data = bitcast!(c::RLIMIT_DATA),
-    /// `RLIMIT_STACK`
-    Stack = bitcast!(c::RLIMIT_STACK),
-    /// `RLIMIT_CORE`
-    #[cfg(not(target_os = "haiku"))]
-    Core = bitcast!(c::RLIMIT_CORE),
-    /// `RLIMIT_RSS`
-    // "nto" has `RLIMIT_RSS`, but it has the same value as `RLIMIT_AS`.
-    #[cfg(not(any(apple, solarish, target_os = "nto", target_os = "haiku")))]
-    Rss = bitcast!(c::RLIMIT_RSS),
-    /// `RLIMIT_NPROC`
-    #[cfg(not(any(solarish, target_os = "haiku")))]
-    Nproc = bitcast!(c::RLIMIT_NPROC),
-    /// `RLIMIT_NOFILE`
-    Nofile = bitcast!(c::RLIMIT_NOFILE),
-    /// `RLIMIT_MEMLOCK`
-    #[cfg(not(any(solarish, target_os = "aix", target_os = "haiku")))]
-    Memlock = bitcast!(c::RLIMIT_MEMLOCK),
-    /// `RLIMIT_AS`
-    #[cfg(not(target_os = "openbsd"))]
-    As = bitcast!(c::RLIMIT_AS),
-    /// `RLIMIT_LOCKS`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "nto"
-    )))]
-    Locks = bitcast!(c::RLIMIT_LOCKS),
-    /// `RLIMIT_SIGPENDING`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "nto"
-    )))]
-    Sigpending = bitcast!(c::RLIMIT_SIGPENDING),
-    /// `RLIMIT_MSGQUEUE`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "nto"
-    )))]
-    Msgqueue = bitcast!(c::RLIMIT_MSGQUEUE),
-    /// `RLIMIT_NICE`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "nto"
-    )))]
-    Nice = bitcast!(c::RLIMIT_NICE),
-    /// `RLIMIT_RTPRIO`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "nto"
-    )))]
-    Rtprio = bitcast!(c::RLIMIT_RTPRIO),
-    /// `RLIMIT_RTTIME`
-    #[cfg(not(any(
-        bsd,
-        solarish,
-        target_os = "aix",
-        target_os = "android",
-        target_os = "emscripten",
-        target_os = "haiku",
-        target_os = "hurd",
-        target_os = "nto",
-    )))]
-    Rttime = bitcast!(c::RLIMIT_RTTIME),
-}
-
-#[cfg(apple)]
-#[allow(non_upper_case_globals)]
-impl Resource {
-    /// `RLIMIT_RSS`
-    pub const Rss: Self = Self::As;
-}
-
-/// A CPU identifier as a raw integer.
-#[cfg(linux_kernel)]
-pub type RawCpuid = u32;
-#[cfg(freebsdlike)]
-pub type RawId = c::id_t;
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-pub(crate) type RawCpuSet = c::cpu_set_t;
-#[cfg(freebsdlike)]
-pub(crate) type RawCpuSet = c::cpuset_t;
-
-#[cfg(any(freebsdlike, linux_kernel, target_os = "fuchsia"))]
-#[inline]
-pub(crate) fn raw_cpu_set_new() -> RawCpuSet {
-    let mut set = unsafe { core::mem::zeroed() };
-    super::cpu_set::CPU_ZERO(&mut set);
-    set
-}
-
-#[cfg(any(freebsdlike, linux_kernel, target_os = "fuchsia"))]
-pub(crate) const CPU_SETSIZE: usize = c::CPU_SETSIZE as usize;
diff --git a/vendor/rustix/src/backend/libc/process/wait.rs b/vendor/rustix/src/backend/libc/process/wait.rs
deleted file mode 100644
index 9a932cf..0000000
--- a/vendor/rustix/src/backend/libc/process/wait.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use crate::backend::c;
-
-pub(crate) use c::{
-    WCONTINUED, WEXITSTATUS, WIFCONTINUED, WIFEXITED, WIFSIGNALED, WIFSTOPPED, WNOHANG, WSTOPSIG,
-    WTERMSIG, WUNTRACED,
-};
-
-#[cfg(not(any(target_os = "openbsd", target_os = "redox", target_os = "wasi")))]
-pub(crate) use c::{WEXITED, WNOWAIT, WSTOPPED};
diff --git a/vendor/rustix/src/backend/libc/pty/mod.rs b/vendor/rustix/src/backend/libc/pty/mod.rs
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/libc/pty/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/pty/syscalls.rs b/vendor/rustix/src/backend/libc/pty/syscalls.rs
deleted file mode 100644
index 2395efd..0000000
--- a/vendor/rustix/src/backend/libc/pty/syscalls.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-//! libc syscalls supporting `rustix::pty`.
-
-use crate::backend::c;
-use crate::backend::conv::{borrowed_fd, ret};
-use crate::fd::BorrowedFd;
-use crate::io;
-#[cfg(all(
-    feature = "alloc",
-    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))]
-use crate::{backend::conv::ret_owned_fd, fd::OwnedFd, pty::OpenptFlags};
-
-#[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(all(
-    feature = "alloc",
-    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(linux_like, target_os = "fuchsia"))]
-        let r = unsafe { c::ptsname_r(borrowed_fd(fd), buffer.as_mut_ptr().cast(), buffer.len()) };
-
-        // FreeBSD 12 doesn't have `ptsname_r`.
-        #[cfg(target_os = "freebsd")]
-        let r = unsafe {
-            weak! {
-                fn ptsname_r(
-                     c::c_int,
-                     *mut c::c_char,
-                     c::size_t
-                ) -> c::c_int
-            }
-            if let Some(func) = ptsname_r.get() {
-                func(borrowed_fd(fd), buffer.as_mut_ptr().cast(), buffer.len())
-            } else {
-                libc::ENOSYS
-            }
-        };
-
-        // 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 _, &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));
-        }
-
-        // Use `Vec` reallocation strategy to grow capacity exponentially.
-        buffer.reserve(1);
-        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))) }
-}
diff --git a/vendor/rustix/src/backend/libc/rand/mod.rs b/vendor/rustix/src/backend/libc/rand/mod.rs
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/libc/rand/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/libc/rand/syscalls.rs b/vendor/rustix/src/backend/libc/rand/syscalls.rs
deleted file mode 100644
index 3a3929e..0000000
--- a/vendor/rustix/src/backend/libc/rand/syscalls.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-//! libc syscalls supporting `rustix::rand`.
-
-#[cfg(linux_kernel)]
-use {crate::backend::c, crate::backend::conv::ret_usize, crate::io, crate::rand::GetRandomFlags};
-
-#[cfg(linux_kernel)]
-pub(crate) unsafe fn getrandom(
-    buf: *mut u8,
-    cap: usize,
-    flags: GetRandomFlags,
-) -> io::Result<usize> {
-    // `getrandom` wasn't supported in glibc until 2.25.
-    weak_or_syscall! {
-        fn getrandom(buf: *mut c::c_void, buflen: c::size_t, flags: c::c_uint) via SYS_getrandom -> c::ssize_t
-    }
-
-    ret_usize(getrandom(buf.cast(), cap, flags.bits()))
-}
diff --git a/vendor/rustix/src/backend/libc/rand/types.rs b/vendor/rustix/src/backend/libc/rand/types.rs
deleted file mode 100644
index 46690b5..0000000
--- a/vendor/rustix/src/backend/libc/rand/types.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-#[cfg(linux_kernel)]
-use crate::backend::c;
-#[cfg(linux_kernel)]
-use bitflags::bitflags;
-
-#[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;
-        /// `GRND_NONBLOCK`
-        const NONBLOCK = c::GRND_NONBLOCK;
-        /// `GRND_INSECURE`
-        const INSECURE = c::GRND_INSECURE;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/shm/mod.rs b/vendor/rustix/src/backend/libc/shm/mod.rs
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/libc/shm/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/libc/shm/syscalls.rs b/vendor/rustix/src/backend/libc/shm/syscalls.rs
deleted file mode 100644
index b0d907f..0000000
--- a/vendor/rustix/src/backend/libc/shm/syscalls.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use crate::ffi::CStr;
-
-use crate::backend::c;
-use crate::backend::conv::{c_str, ret, ret_owned_fd};
-use crate::fd::OwnedFd;
-use crate::fs::Mode;
-use crate::io;
-use crate::shm::ShmOFlags;
-
-pub(crate) fn shm_open(name: &CStr, oflags: ShmOFlags, mode: Mode) -> io::Result<OwnedFd> {
-    // On this platforms, `mode_t` is `u16` and can't be passed directly to a
-    // variadic function.
-    #[cfg(apple)]
-    let mode: c::c_uint = mode.bits().into();
-
-    // Otherwise, cast to `mode_t` as that's what `open` is documented to take.
-    #[cfg(not(apple))]
-    let mode: c::mode_t = mode.bits() as _;
-
-    unsafe { ret_owned_fd(c::shm_open(c_str(name), bitflags_bits!(oflags), mode)) }
-}
-
-pub(crate) fn shm_unlink(name: &CStr) -> io::Result<()> {
-    unsafe { ret(c::shm_unlink(c_str(name))) }
-}
diff --git a/vendor/rustix/src/backend/libc/shm/types.rs b/vendor/rustix/src/backend/libc/shm/types.rs
deleted file mode 100644
index 6575ef5..0000000
--- a/vendor/rustix/src/backend/libc/shm/types.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `O_*` constants for use with [`shm_open`].
-    ///
-    /// [`shm_open`]: crate:shm::shm_open
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct ShmOFlags: u32 {
-        /// `O_CREAT`
-        #[doc(alias = "CREAT")]
-        const CREATE = bitcast!(c::O_CREAT);
-
-        /// `O_EXCL`
-        const EXCL = bitcast!(c::O_EXCL);
-
-        /// `O_RDONLY`
-        const RDONLY = bitcast!(c::O_RDONLY);
-
-        /// `O_RDWR`
-        const RDWR = bitcast!(c::O_RDWR);
-
-        /// `O_TRUNC`
-        const TRUNC = bitcast!(c::O_TRUNC);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/system/mod.rs b/vendor/rustix/src/backend/libc/system/mod.rs
deleted file mode 100644
index bff7fd5..0000000
--- a/vendor/rustix/src/backend/libc/system/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-#[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
deleted file mode 100644
index 05d674b..0000000
--- a/vendor/rustix/src/backend/libc/system/syscalls.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//! 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(target_os = "linux")]
-use crate::system::RebootCommand;
-#[cfg(linux_kernel)]
-use crate::system::Sysinfo;
-use core::mem::MaybeUninit;
-#[cfg(not(any(
-    target_os = "emscripten",
-    target_os = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    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 {
-        let r = c::uname(uname.as_mut_ptr());
-
-        // On POSIX, `uname` is documented to return non-negative on success
-        // instead of the usual 0, though some specific systems do document
-        // that they always use zero allowing us to skip this check.
-        #[cfg(not(any(apple, freebsdlike, linux_like, target_os = "netbsd")))]
-        let r = core::cmp::min(r, 0);
-
-        ret_infallible(r);
-        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 = "espidf",
-    target_os = "redox",
-    target_os = "vita",
-    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(target_os = "linux")]
-pub(crate) fn reboot(cmd: RebootCommand) -> io::Result<()> {
-    unsafe { ret(c::reboot(cmd as i32)) }
-}
diff --git a/vendor/rustix/src/backend/libc/system/types.rs b/vendor/rustix/src/backend/libc/system/types.rs
deleted file mode 100644
index 731e89b..0000000
--- a/vendor/rustix/src/backend/libc/system/types.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/libc/termios/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/termios/syscalls.rs b/vendor/rustix/src/backend/libc/termios/syscalls.rs
deleted file mode 100644
index a833aea..0000000
--- a/vendor/rustix/src/backend/libc/termios/syscalls.rs
+++ /dev/null
@@ -1,403 +0,0 @@
-//! libc syscalls supporting `rustix::termios`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend::syscalls` module documentation for details.
-
-use crate::backend::c;
-#[cfg(not(target_os = "wasi"))]
-use crate::backend::conv::ret_pid_t;
-use crate::backend::conv::{borrowed_fd, ret};
-use crate::fd::BorrowedFd;
-#[cfg(all(feature = "alloc", feature = "procfs"))]
-#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
-use crate::ffi::CStr;
-#[cfg(any(
-    not(target_os = "espidf"),
-    all(
-        feature = "procfs",
-        not(any(target_os = "fuchsia", target_os = "wasi"))
-    )
-))]
-use core::mem::MaybeUninit;
-#[cfg(not(target_os = "wasi"))]
-use {crate::io, crate::pid::Pid};
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-use {
-    crate::termios::{Action, OptionalActions, QueueSelector, Termios, Winsize},
-    crate::utils::as_mut_ptr,
-};
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) fn tcgetattr(fd: BorrowedFd<'_>) -> io::Result<Termios> {
-    // If we have `TCGETS2`, use it, so that we fill in the `c_ispeed` and
-    // `c_ospeed` fields.
-    #[cfg(linux_kernel)]
-    {
-        use crate::termios::{ControlModes, InputModes, LocalModes, OutputModes, SpecialCodes};
-        use crate::utils::default_array;
-
-        let termios2 = unsafe {
-            let mut termios2 = MaybeUninit::<c::termios2>::uninit();
-
-            // QEMU's `TCGETS2` doesn't currently set `input_speed` or
-            // `output_speed` on PowerPC, so zero out the fields ourselves.
-            #[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
-            {
-                termios2.write(core::mem::zeroed());
-            }
-
-            ret(c::ioctl(
-                borrowed_fd(fd),
-                c::TCGETS2 as _,
-                termios2.as_mut_ptr(),
-            ))?;
-
-            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(default_array()),
-            input_speed: termios2.c_ispeed,
-            output_speed: termios2.c_ospeed,
-        };
-
-        // QEMU's `TCGETS2` doesn't currently set `input_speed` or
-        // `output_speed` on PowerPC, so set them manually if we can.
-        #[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
-        {
-            use crate::termios::speed;
-
-            if result.output_speed == 0 && (termios2.c_cflag & c::CBAUD) != c::BOTHER {
-                if let Some(output_speed) = speed::decode(termios2.c_cflag & c::CBAUD) {
-                    result.output_speed = output_speed;
-                }
-            }
-            if result.input_speed == 0
-                && ((termios2.c_cflag & c::CIBAUD) >> c::IBSHIFT) != c::BOTHER
-            {
-                // For input speeds, `B0` is special-cased to mean the input
-                // speed is the same as the output speed.
-                if ((termios2.c_cflag & c::CIBAUD) >> c::IBSHIFT) == c::B0 {
-                    result.input_speed = result.output_speed;
-                } else if let Some(input_speed) =
-                    speed::decode((termios2.c_cflag & c::CIBAUD) >> c::IBSHIFT)
-                {
-                    result.input_speed = input_speed;
-                }
-            }
-        }
-
-        result.special_codes.0[..termios2.c_cc.len()].copy_from_slice(&termios2.c_cc);
-
-        Ok(result)
-    }
-
-    #[cfg(not(linux_kernel))]
-    unsafe {
-        let mut result = MaybeUninit::<Termios>::uninit();
-
-        // `result` is a `Termios` which starts with the same layout as
-        // `libc::termios`, so we can cast the pointer.
-        ret(c::tcgetattr(borrowed_fd(fd), result.as_mut_ptr().cast()))?;
-
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn tcgetpgrp(fd: BorrowedFd<'_>) -> io::Result<Pid> {
-    unsafe {
-        let pid = ret_pid_t(c::tcgetpgrp(borrowed_fd(fd)))?;
-
-        // This doesn't appear to be documented, but on Linux, it appears
-        // `tcsetpgrp` can succceed and set the pid to 0 if we pass it a
-        // pseudo-terminal device fd. For now, translate it into `OPNOTSUPP`.
-        #[cfg(linux_kernel)]
-        if pid == 0 {
-            return Err(io::Errno::OPNOTSUPP);
-        }
-
-        Ok(Pid::from_raw_unchecked(pid))
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn tcsetpgrp(fd: BorrowedFd<'_>, pid: Pid) -> io::Result<()> {
-    unsafe { ret(c::tcsetpgrp(borrowed_fd(fd), pid.as_raw_nonzero().get())) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) fn tcsetattr(
-    fd: BorrowedFd<'_>,
-    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)]
-    {
-        use crate::termios::speed;
-        use crate::utils::default_array;
-        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 = 0x8024_5409;
-        #[cfg(any(target_arch = "sparc", target_arch = "sparc64"))]
-        const TCSETS2: u32 = 0x802c_540d;
-
-        // 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 = "mips32r6",
-                target_arch = "mips64",
-                target_arch = "mips64r6"
-            )) {
-                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: default_array(),
-            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]);
-
-        unsafe { ret(c::ioctl(borrowed_fd(fd), request as _, &termios2)) }
-    }
-
-    #[cfg(not(linux_kernel))]
-    unsafe {
-        ret(c::tcsetattr(
-            borrowed_fd(fd),
-            optional_actions as _,
-            crate::utils::as_ptr(termios).cast(),
-        ))
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn tcsendbreak(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(c::tcsendbreak(borrowed_fd(fd), 0)) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) fn tcdrain(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(c::tcdrain(borrowed_fd(fd))) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) fn tcflush(fd: BorrowedFd<'_>, queue_selector: QueueSelector) -> io::Result<()> {
-    unsafe { ret(c::tcflush(borrowed_fd(fd), queue_selector as _)) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) fn tcflow(fd: BorrowedFd<'_>, action: Action) -> io::Result<()> {
-    unsafe { ret(c::tcflow(borrowed_fd(fd), action as _)) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn tcgetsid(fd: BorrowedFd<'_>) -> io::Result<Pid> {
-    unsafe {
-        let pid = ret_pid_t(c::tcgetsid(borrowed_fd(fd)))?;
-        Ok(Pid::from_raw_unchecked(pid))
-    }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) fn tcsetwinsize(fd: BorrowedFd<'_>, winsize: Winsize) -> io::Result<()> {
-    unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCSWINSZ, &winsize)) }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
-pub(crate) fn tcgetwinsize(fd: BorrowedFd<'_>) -> io::Result<Winsize> {
-    unsafe {
-        let mut buf = MaybeUninit::<Winsize>::uninit();
-        ret(c::ioctl(
-            borrowed_fd(fd),
-            c::TIOCGWINSZ.into(),
-            buf.as_mut_ptr(),
-        ))?;
-        Ok(buf.assume_init())
-    }
-}
-
-#[cfg(not(any(target_os = "espidf", target_os = "nto", target_os = "wasi")))]
-#[inline]
-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(any(target_os = "espidf", target_os = "wasi")))]
-#[inline]
-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(any(target_os = "espidf", target_os = "wasi")))]
-#[inline]
-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(any(target_os = "espidf", target_os = "nto", target_os = "wasi")))]
-#[inline]
-pub(crate) fn cfmakeraw(termios: &mut Termios) {
-    unsafe { c::cfmakeraw(as_mut_ptr(termios).cast()) }
-}
-
-pub(crate) fn isatty(fd: BorrowedFd<'_>) -> bool {
-    // Use the return value of `isatty` alone. We don't check `errno` because
-    // we return `bool` rather than `io::Result<bool>`, because we assume
-    // `BorrowedFd` protects us from `EBADF`, and any other reasonably
-    // anticipated `errno` value would end up interpreted as “assume it's not a
-    // terminal” anyway.
-    unsafe { c::isatty(borrowed_fd(fd)) != 0 }
-}
-
-#[cfg(all(feature = "alloc", feature = "procfs"))]
-#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
-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()) {
-            0 => Ok(CStr::from_ptr(buf.as_ptr().cast()).to_bytes().len()),
-            err => Err(io::Errno::from_raw_os_error(err)),
-        }
-    }
-}
diff --git a/vendor/rustix/src/backend/libc/thread/futex.rs b/vendor/rustix/src/backend/libc/thread/futex.rs
deleted file mode 100644
index 44d96f0..0000000
--- a/vendor/rustix/src/backend/libc/thread/futex.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-use crate::backend::c;
-
-bitflags::bitflags! {
-    /// `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 = bitcast!(c::FUTEX_PRIVATE_FLAG);
-        /// `FUTEX_CLOCK_REALTIME`
-        const CLOCK_REALTIME = bitcast!(c::FUTEX_CLOCK_REALTIME);
-    }
-}
-
-/// `FUTEX_*` operations for use with [`futex`].
-///
-/// [`futex`]: crate::thread::futex
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(u32)]
-pub enum FutexOperation {
-    /// `FUTEX_WAIT`
-    Wait = bitcast!(c::FUTEX_WAIT),
-    /// `FUTEX_WAKE`
-    Wake = bitcast!(c::FUTEX_WAKE),
-    /// `FUTEX_FD`
-    Fd = bitcast!(c::FUTEX_FD),
-    /// `FUTEX_REQUEUE`
-    Requeue = bitcast!(c::FUTEX_REQUEUE),
-    /// `FUTEX_CMP_REQUEUE`
-    CmpRequeue = bitcast!(c::FUTEX_CMP_REQUEUE),
-    /// `FUTEX_WAKE_OP`
-    WakeOp = bitcast!(c::FUTEX_WAKE_OP),
-    /// `FUTEX_LOCK_PI`
-    LockPi = bitcast!(c::FUTEX_LOCK_PI),
-    /// `FUTEX_UNLOCK_PI`
-    UnlockPi = bitcast!(c::FUTEX_UNLOCK_PI),
-    /// `FUTEX_TRYLOCK_PI`
-    TrylockPi = bitcast!(c::FUTEX_TRYLOCK_PI),
-    /// `FUTEX_WAIT_BITSET`
-    WaitBitset = bitcast!(c::FUTEX_WAIT_BITSET),
-}
diff --git a/vendor/rustix/src/backend/libc/thread/mod.rs b/vendor/rustix/src/backend/libc/thread/mod.rs
deleted file mode 100644
index 4f8c87c..0000000
--- a/vendor/rustix/src/backend/libc/thread/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-#[cfg(linux_kernel)]
-pub(crate) mod futex;
-#[cfg(not(windows))]
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/thread/syscalls.rs b/vendor/rustix/src/backend/libc/thread/syscalls.rs
deleted file mode 100644
index 33750f4..0000000
--- a/vendor/rustix/src/backend/libc/thread/syscalls.rs
+++ /dev/null
@@ -1,523 +0,0 @@
-//! libc syscalls supporting `rustix::thread`.
-
-use crate::backend::c;
-use crate::backend::conv::ret;
-use crate::io;
-#[cfg(not(target_os = "redox"))]
-use crate::thread::{NanosleepRelativeResult, Timespec};
-#[cfg(all(target_env = "gnu", fix_y2038))]
-use crate::timespec::LibcTimespec;
-use core::mem::MaybeUninit;
-#[cfg(linux_kernel)]
-use {
-    crate::backend::conv::{borrowed_fd, ret_c_int, ret_usize},
-    crate::fd::BorrowedFd,
-    crate::pid::Pid,
-    crate::thread::{FutexFlags, FutexOperation},
-    crate::utils::as_mut_ptr,
-};
-#[cfg(not(any(
-    apple,
-    freebsdlike,
-    target_os = "emscripten",
-    target_os = "espidf",
-    target_os = "haiku",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-use {crate::thread::ClockId, core::ptr::null_mut};
-
-#[cfg(all(target_env = "gnu", fix_y2038))]
-weak!(fn __clock_nanosleep_time64(c::clockid_t, c::c_int, *const LibcTimespec, *mut LibcTimespec) -> c::c_int);
-#[cfg(all(target_env = "gnu", fix_y2038))]
-weak!(fn __nanosleep64(*const LibcTimespec, *mut LibcTimespec) -> c::c_int);
-
-#[cfg(not(any(
-    apple,
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "espidf",
-    target_os = "freebsd", // FreeBSD 12 has clock_nanosleep, but libc targets FreeBSD 11.
-    target_os = "haiku",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-#[inline]
-pub(crate) fn clock_nanosleep_relative(id: ClockId, request: &Timespec) -> NanosleepRelativeResult {
-    // Old 32-bit version: libc has `clock_nanosleep` but it is not y2038 safe
-    // by default. But there may be a `__clock_nanosleep_time64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_clock_nanosleep) = __clock_nanosleep_time64.get() {
-            let flags = 0;
-            let mut remain = MaybeUninit::<LibcTimespec>::uninit();
-
-            unsafe {
-                return match libc_clock_nanosleep(
-                    id as c::clockid_t,
-                    flags,
-                    &request.clone().into(),
-                    remain.as_mut_ptr(),
-                ) {
-                    0 => NanosleepRelativeResult::Ok,
-                    err if err == io::Errno::INTR.0 => {
-                        NanosleepRelativeResult::Interrupted(remain.assume_init().into())
-                    }
-                    err => NanosleepRelativeResult::Err(io::Errno(err)),
-                };
-            }
-        }
-
-        clock_nanosleep_relative_old(id, request)
-    }
-
-    // Main version: libc is y2038 safe and has `clock_nanosleep`.
-    #[cfg(not(fix_y2038))]
-    unsafe {
-        let flags = 0;
-        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 => {
-                NanosleepRelativeResult::Interrupted(remain.assume_init())
-            }
-            err => NanosleepRelativeResult::Err(io::Errno(err)),
-        }
-    }
-}
-
-#[cfg(all(
-    fix_y2038,
-    not(any(
-        apple,
-        target_os = "emscripten",
-        target_os = "haiku",
-        target_os = "vita"
-    ))
-))]
-fn clock_nanosleep_relative_old(id: ClockId, request: &Timespec) -> NanosleepRelativeResult {
-    let tv_sec = match request.tv_sec.try_into() {
-        Ok(tv_sec) => tv_sec,
-        Err(_) => return NanosleepRelativeResult::Err(io::Errno::OVERFLOW),
-    };
-    let tv_nsec = match request.tv_nsec.try_into() {
-        Ok(tv_nsec) => tv_nsec,
-        Err(_) => return NanosleepRelativeResult::Err(io::Errno::INVAL),
-    };
-    let old_request = c::timespec { tv_sec, tv_nsec };
-    let mut old_remain = MaybeUninit::<c::timespec>::uninit();
-    let flags = 0;
-
-    unsafe {
-        match c::clock_nanosleep(
-            id as c::clockid_t,
-            flags,
-            &old_request,
-            old_remain.as_mut_ptr(),
-        ) {
-            0 => NanosleepRelativeResult::Ok,
-            err if err == io::Errno::INTR.0 => {
-                let old_remain = old_remain.assume_init();
-                let remain = Timespec {
-                    tv_sec: old_remain.tv_sec.into(),
-                    tv_nsec: old_remain.tv_nsec.into(),
-                };
-                NanosleepRelativeResult::Interrupted(remain)
-            }
-            err => NanosleepRelativeResult::Err(io::Errno(err)),
-        }
-    }
-}
-
-#[cfg(not(any(
-    apple,
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "espidf",
-    target_os = "freebsd", // FreeBSD 12 has clock_nanosleep, but libc targets FreeBSD 11.
-    target_os = "haiku",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "vita",
-    target_os = "wasi",
-)))]
-#[inline]
-pub(crate) fn clock_nanosleep_absolute(id: ClockId, request: &Timespec) -> io::Result<()> {
-    // Old 32-bit version: libc has `clock_nanosleep` but it is not y2038 safe
-    // by default. But there may be a `__clock_nanosleep_time64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_clock_nanosleep) = __clock_nanosleep_time64.get() {
-            let flags = c::TIMER_ABSTIME;
-            unsafe {
-                return match {
-                    libc_clock_nanosleep(
-                        id as c::clockid_t,
-                        flags,
-                        &request.clone().into(),
-                        null_mut(),
-                    )
-                } {
-                    0 => Ok(()),
-                    err => Err(io::Errno(err)),
-                };
-            }
-        }
-
-        clock_nanosleep_absolute_old(id, request)
-    }
-
-    // Main version: libc is y2038 safe and has `clock_nanosleep`.
-    #[cfg(not(fix_y2038))]
-    {
-        let flags = c::TIMER_ABSTIME;
-
-        match unsafe { c::clock_nanosleep(id as c::clockid_t, flags as _, request, null_mut()) } {
-            0 => Ok(()),
-            err => Err(io::Errno(err)),
-        }
-    }
-}
-
-#[cfg(all(
-    fix_y2038,
-    not(any(
-        apple,
-        target_os = "emscripten",
-        target_os = "haiku",
-        target_os = "vita"
-    ))
-))]
-fn clock_nanosleep_absolute_old(id: ClockId, request: &Timespec) -> io::Result<()> {
-    let flags = c::TIMER_ABSTIME;
-
-    let old_request = c::timespec {
-        tv_sec: request.tv_sec.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        tv_nsec: request.tv_nsec.try_into().map_err(|_| io::Errno::INVAL)?,
-    };
-    match unsafe { c::clock_nanosleep(id as c::clockid_t, flags, &old_request, null_mut()) } {
-        0 => Ok(()),
-        err => Err(io::Errno(err)),
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-#[inline]
-pub(crate) fn nanosleep(request: &Timespec) -> NanosleepRelativeResult {
-    // Old 32-bit version: libc has `nanosleep` but it is not y2038 safe by
-    // default. But there may be a `__nanosleep64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_nanosleep) = __nanosleep64.get() {
-            let mut remain = MaybeUninit::<LibcTimespec>::uninit();
-            unsafe {
-                return match ret(libc_nanosleep(&request.clone().into(), remain.as_mut_ptr())) {
-                    Ok(()) => NanosleepRelativeResult::Ok,
-                    Err(io::Errno::INTR) => {
-                        NanosleepRelativeResult::Interrupted(remain.assume_init().into())
-                    }
-                    Err(err) => NanosleepRelativeResult::Err(err),
-                };
-            }
-        }
-
-        nanosleep_old(request)
-    }
-
-    // Main version: libc is y2038 safe and has `nanosleep`.
-    #[cfg(not(fix_y2038))]
-    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()),
-            Err(err) => NanosleepRelativeResult::Err(err),
-        }
-    }
-}
-
-#[cfg(fix_y2038)]
-fn nanosleep_old(request: &Timespec) -> NanosleepRelativeResult {
-    let tv_sec = match request.tv_sec.try_into() {
-        Ok(tv_sec) => tv_sec,
-        Err(_) => return NanosleepRelativeResult::Err(io::Errno::OVERFLOW),
-    };
-    let tv_nsec = match request.tv_nsec.try_into() {
-        Ok(tv_nsec) => tv_nsec,
-        Err(_) => return NanosleepRelativeResult::Err(io::Errno::INVAL),
-    };
-    let old_request = c::timespec { tv_sec, tv_nsec };
-    let mut old_remain = MaybeUninit::<c::timespec>::uninit();
-
-    unsafe {
-        match ret(c::nanosleep(&old_request, old_remain.as_mut_ptr())) {
-            Ok(()) => NanosleepRelativeResult::Ok,
-            Err(io::Errno::INTR) => {
-                let old_remain = old_remain.assume_init();
-                let remain = Timespec {
-                    tv_sec: old_remain.tv_sec.into(),
-                    tv_nsec: old_remain.tv_nsec.into(),
-                };
-                NanosleepRelativeResult::Interrupted(remain)
-            }
-            Err(err) => NanosleepRelativeResult::Err(err),
-        }
-    }
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-#[must_use]
-pub(crate) fn gettid() -> Pid {
-    // `gettid` wasn't supported in glibc until 2.30, and musl until 1.2.2,
-    // so use `syscall`.
-    // <https://sourceware.org/bugzilla/show_bug.cgi?id=6399#c62>
-    weak_or_syscall! {
-        fn gettid() via SYS_gettid -> c::pid_t
-    }
-
-    unsafe {
-        let tid = gettid();
-        Pid::from_raw_unchecked(tid)
-    }
-}
-
-#[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,
-    // so use `syscall`.
-    weak_or_syscall! {
-        fn setns(fd: c::c_int, nstype: c::c_int) via SYS_setns -> c::c_int
-    }
-
-    unsafe { ret_c_int(setns(borrowed_fd(fd), nstype)) }
-}
-
-#[cfg(linux_kernel)]
-#[inline]
-pub(crate) fn unshare(flags: crate::thread::UnshareFlags) -> io::Result<()> {
-    unsafe { ret(c::unshare(flags.bits() as i32)) }
-}
-
-#[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<()> {
-    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(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<()> {
-    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(linux_kernel)]
-#[inline]
-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(linux_kernel)]
-#[inline]
-pub(crate) fn setresuid_thread(
-    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;
-
-    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(linux_kernel)]
-#[inline]
-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(linux_kernel)]
-#[inline]
-pub(crate) fn setresgid_thread(
-    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;
-
-    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())) }
-}
-
-// TODO: This could be de-multiplexed.
-#[cfg(linux_kernel)]
-pub(crate) unsafe fn futex(
-    uaddr: *mut u32,
-    op: FutexOperation,
-    flags: FutexFlags,
-    val: u32,
-    utime: *const Timespec,
-    uaddr2: *mut u32,
-    val3: u32,
-) -> io::Result<usize> {
-    #[cfg(all(
-        target_pointer_width = "32",
-        not(any(target_arch = "aarch64", target_arch = "x86_64"))
-    ))]
-    {
-        // TODO: Upstream this to the libc crate.
-        #[allow(non_upper_case_globals)]
-        const SYS_futex_time64: i32 = linux_raw_sys::general::__NR_futex_time64 as i32;
-
-        syscall! {
-            fn futex_time64(
-                uaddr: *mut u32,
-                futex_op: c::c_int,
-                val: u32,
-                timeout: *const Timespec,
-                uaddr2: *mut u32,
-                val3: u32
-            ) via SYS_futex_time64 -> c::ssize_t
-        }
-
-        ret_usize(futex_time64(
-            uaddr,
-            op as i32 | flags.bits() as i32,
-            val,
-            utime,
-            uaddr2,
-            val3,
-        ))
-        .or_else(|err| {
-            // See the comments in `rustix_clock_gettime_via_syscall` about
-            // emulation.
-            if err == io::Errno::NOSYS {
-                futex_old(uaddr, op, flags, val, utime, uaddr2, val3)
-            } else {
-                Err(err)
-            }
-        })
-    }
-
-    #[cfg(any(
-        target_pointer_width = "64",
-        target_arch = "aarch64",
-        target_arch = "x86_64"
-    ))]
-    {
-        syscall! {
-            fn futex(
-                uaddr: *mut u32,
-                futex_op: c::c_int,
-                val: u32,
-                timeout: *const linux_raw_sys::general::__kernel_timespec,
-                uaddr2: *mut u32,
-                val3: u32
-            ) via SYS_futex -> c::c_long
-        }
-
-        ret_usize(futex(
-            uaddr,
-            op as i32 | flags.bits() as i32,
-            val,
-            utime.cast(),
-            uaddr2,
-            val3,
-        ) as isize)
-    }
-}
-
-#[cfg(linux_kernel)]
-#[cfg(all(
-    target_pointer_width = "32",
-    not(any(target_arch = "aarch64", target_arch = "x86_64"))
-))]
-unsafe fn futex_old(
-    uaddr: *mut u32,
-    op: FutexOperation,
-    flags: FutexFlags,
-    val: u32,
-    utime: *const Timespec,
-    uaddr2: *mut u32,
-    val3: u32,
-) -> io::Result<usize> {
-    syscall! {
-        fn futex(
-            uaddr: *mut u32,
-            futex_op: c::c_int,
-            val: u32,
-            timeout: *const linux_raw_sys::general::__kernel_old_timespec,
-            uaddr2: *mut u32,
-            val3: u32
-        ) via SYS_futex -> c::c_long
-    }
-
-    let old_utime = linux_raw_sys::general::__kernel_old_timespec {
-        tv_sec: (*utime).tv_sec.try_into().map_err(|_| io::Errno::INVAL)?,
-        tv_nsec: (*utime).tv_nsec.try_into().map_err(|_| io::Errno::INVAL)?,
-    };
-    ret_usize(futex(
-        uaddr,
-        op as i32 | flags.bits() as i32,
-        val,
-        &old_utime,
-        uaddr2,
-        val3,
-    ) as isize)
-}
diff --git a/vendor/rustix/src/backend/libc/time/mod.rs b/vendor/rustix/src/backend/libc/time/mod.rs
deleted file mode 100644
index bff7fd5..0000000
--- a/vendor/rustix/src/backend/libc/time/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-#[cfg(not(windows))]
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/libc/time/syscalls.rs b/vendor/rustix/src/backend/libc/time/syscalls.rs
deleted file mode 100644
index 6b1c9fd..0000000
--- a/vendor/rustix/src/backend/libc/time/syscalls.rs
+++ /dev/null
@@ -1,452 +0,0 @@
-//! libc syscalls supporting `rustix::time`.
-
-use crate::backend::c;
-use crate::backend::conv::ret;
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(feature = "time")]
-#[cfg(any(all(target_env = "gnu", fix_y2038), not(fix_y2038)))]
-use crate::backend::time::types::LibcItimerspec;
-#[cfg(not(target_os = "wasi"))]
-use crate::clockid::{ClockId, DynamicClockId};
-use crate::io;
-#[cfg(all(target_env = "gnu", fix_y2038))]
-use crate::timespec::LibcTimespec;
-use crate::timespec::Timespec;
-use core::mem::MaybeUninit;
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(feature = "time")]
-use {
-    crate::backend::conv::{borrowed_fd, ret_owned_fd},
-    crate::fd::{BorrowedFd, OwnedFd},
-    crate::time::{Itimerspec, TimerfdClockId, TimerfdFlags, TimerfdTimerFlags},
-};
-
-#[cfg(all(target_env = "gnu", fix_y2038))]
-weak!(fn __clock_gettime64(c::clockid_t, *mut LibcTimespec) -> c::c_int);
-#[cfg(all(target_env = "gnu", fix_y2038))]
-weak!(fn __clock_settime64(c::clockid_t, *const LibcTimespec) -> c::c_int);
-#[cfg(all(target_env = "gnu", fix_y2038))]
-weak!(fn __clock_getres64(c::clockid_t, *mut LibcTimespec) -> c::c_int);
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(all(target_env = "gnu", fix_y2038))]
-#[cfg(feature = "time")]
-weak!(fn __timerfd_gettime64(c::c_int, *mut LibcItimerspec) -> c::c_int);
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(all(target_env = "gnu", fix_y2038))]
-#[cfg(feature = "time")]
-weak!(fn __timerfd_settime64(c::c_int, c::c_int, *const LibcItimerspec, *mut LibcItimerspec) -> c::c_int);
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-#[inline]
-#[must_use]
-pub(crate) fn clock_getres(id: ClockId) -> Timespec {
-    // Old 32-bit version: libc has `clock_getres` but it is not y2038 safe by
-    // default. But there may be a `__clock_getres64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_clock_getres) = __clock_getres64.get() {
-            let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
-            unsafe {
-                ret(libc_clock_getres(id as c::clockid_t, timespec.as_mut_ptr())).unwrap();
-                return timespec.assume_init().into();
-            }
-        }
-
-        clock_getres_old(id)
-    }
-
-    // Main version: libc is y2038 safe and has `clock_getres`.
-    #[cfg(not(fix_y2038))]
-    unsafe {
-        let mut timespec = MaybeUninit::<Timespec>::uninit();
-        let _ = c::clock_getres(id as c::clockid_t, timespec.as_mut_ptr());
-        timespec.assume_init()
-    }
-}
-
-#[cfg(fix_y2038)]
-#[must_use]
-fn clock_getres_old(id: ClockId) -> Timespec {
-    let mut old_timespec = MaybeUninit::<c::timespec>::uninit();
-
-    let old_timespec = unsafe {
-        ret(c::clock_getres(
-            id as c::clockid_t,
-            old_timespec.as_mut_ptr(),
-        ))
-        .unwrap();
-        old_timespec.assume_init()
-    };
-
-    Timespec {
-        tv_sec: old_timespec.tv_sec.into(),
-        tv_nsec: old_timespec.tv_nsec.into(),
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn clock_gettime(id: ClockId) -> Timespec {
-    // Old 32-bit version: libc has `clock_gettime` but it is not y2038 safe by
-    // default. But there may be a `__clock_gettime64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_clock_gettime) = __clock_gettime64.get() {
-            let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
-            unsafe {
-                ret(libc_clock_gettime(
-                    id as c::clockid_t,
-                    timespec.as_mut_ptr(),
-                ))
-                .unwrap();
-                return timespec.assume_init().into();
-            }
-        }
-
-        clock_gettime_old(id)
-    }
-
-    // Use `.unwrap()` here because `clock_getres` can fail if the clock itself
-    // overflows a number of seconds, but if that happens, the monotonic clocks
-    // can't maintain their invariants, or the realtime clocks aren't properly
-    // configured.
-    #[cfg(not(fix_y2038))]
-    unsafe {
-        let mut timespec = MaybeUninit::<Timespec>::uninit();
-        ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr())).unwrap();
-        timespec.assume_init()
-    }
-}
-
-#[cfg(fix_y2038)]
-#[must_use]
-fn clock_gettime_old(id: ClockId) -> Timespec {
-    let mut old_timespec = MaybeUninit::<c::timespec>::uninit();
-
-    let old_timespec = unsafe {
-        ret(c::clock_gettime(
-            id as c::clockid_t,
-            old_timespec.as_mut_ptr(),
-        ))
-        .unwrap();
-        old_timespec.assume_init()
-    };
-
-    Timespec {
-        tv_sec: old_timespec.tv_sec.into(),
-        tv_nsec: old_timespec.tv_nsec.into(),
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn clock_gettime_dynamic(id: DynamicClockId<'_>) -> io::Result<Timespec> {
-    let id: c::clockid_t = match id {
-        DynamicClockId::Known(id) => id as c::clockid_t,
-
-        #[cfg(linux_kernel)]
-        DynamicClockId::Dynamic(fd) => {
-            use crate::fd::AsRawFd;
-            const CLOCKFD: i32 = 3;
-            (!fd.as_raw_fd() << 3) | CLOCKFD
-        }
-
-        #[cfg(not(linux_kernel))]
-        DynamicClockId::Dynamic(_fd) => {
-            // Dynamic clocks are not supported on this platform.
-            return Err(io::Errno::INVAL);
-        }
-
-        #[cfg(linux_kernel)]
-        DynamicClockId::RealtimeAlarm => c::CLOCK_REALTIME_ALARM,
-
-        #[cfg(linux_kernel)]
-        DynamicClockId::Tai => c::CLOCK_TAI,
-
-        #[cfg(any(
-            freebsdlike,
-            linux_kernel,
-            target_os = "fuchsia",
-            target_os = "openbsd"
-        ))]
-        DynamicClockId::Boottime => c::CLOCK_BOOTTIME,
-
-        #[cfg(any(linux_kernel, target_os = "fuchsia"))]
-        DynamicClockId::BoottimeAlarm => c::CLOCK_BOOTTIME_ALARM,
-    };
-
-    // Old 32-bit version: libc has `clock_gettime` but it is not y2038
-    // safe by default. But there may be a `__clock_gettime64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_clock_gettime) = __clock_gettime64.get() {
-            let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
-            unsafe {
-                ret(libc_clock_gettime(
-                    id as c::clockid_t,
-                    timespec.as_mut_ptr(),
-                ))?;
-
-                return Ok(timespec.assume_init().into());
-            }
-        }
-
-        clock_gettime_dynamic_old(id)
-    }
-
-    // Main version: libc is y2038 safe and has `clock_gettime`.
-    #[cfg(not(fix_y2038))]
-    unsafe {
-        let mut timespec = MaybeUninit::<Timespec>::uninit();
-
-        ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr()))?;
-
-        Ok(timespec.assume_init())
-    }
-}
-
-#[cfg(fix_y2038)]
-#[inline]
-fn clock_gettime_dynamic_old(id: c::clockid_t) -> io::Result<Timespec> {
-    let mut old_timespec = MaybeUninit::<c::timespec>::uninit();
-
-    let old_timespec = unsafe {
-        ret(c::clock_gettime(
-            id as c::clockid_t,
-            old_timespec.as_mut_ptr(),
-        ))?;
-
-        old_timespec.assume_init()
-    };
-
-    Ok(Timespec {
-        tv_sec: old_timespec.tv_sec.into(),
-        tv_nsec: old_timespec.tv_nsec.into(),
-    })
-}
-
-#[cfg(not(any(
-    target_os = "redox",
-    target_os = "wasi",
-    all(apple, not(target_os = "macos"))
-)))]
-#[inline]
-pub(crate) fn clock_settime(id: ClockId, timespec: Timespec) -> io::Result<()> {
-    // Old 32-bit version: libc has `clock_gettime` but it is not y2038 safe by
-    // default. But there may be a `__clock_settime64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_clock_settime) = __clock_settime64.get() {
-            unsafe {
-                let mut new_timespec = core::mem::zeroed::<LibcTimespec>();
-                new_timespec.tv_sec = timespec.tv_sec;
-                new_timespec.tv_nsec = timespec.tv_nsec as _;
-                return ret(libc_clock_settime(id as c::clockid_t, &new_timespec));
-            }
-        }
-
-        clock_settime_old(id, timespec)
-    }
-
-    // Main version: libc is y2038 safe and has `clock_settime`.
-    #[cfg(not(fix_y2038))]
-    unsafe {
-        ret(c::clock_settime(id as c::clockid_t, &timespec))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "redox",
-    target_os = "wasi",
-    all(apple, not(target_os = "macos"))
-)))]
-#[cfg(fix_y2038)]
-fn clock_settime_old(id: ClockId, timespec: Timespec) -> io::Result<()> {
-    let old_timespec = c::timespec {
-        tv_sec: timespec
-            .tv_sec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        tv_nsec: timespec.tv_nsec as _,
-    };
-
-    unsafe { ret(c::clock_settime(id as c::clockid_t, &old_timespec)) }
-}
-
-#[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, bitflags_bits!(flags))) }
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(feature = "time")]
-pub(crate) fn timerfd_settime(
-    fd: BorrowedFd<'_>,
-    flags: TimerfdTimerFlags,
-    new_value: &Itimerspec,
-) -> io::Result<Itimerspec> {
-    // Old 32-bit version: libc has `timerfd_settime` but it is not y2038 safe
-    // by default. But there may be a `__timerfd_settime64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_timerfd_settime) = __timerfd_settime64.get() {
-            let mut result = MaybeUninit::<LibcItimerspec>::uninit();
-            unsafe {
-                ret(libc_timerfd_settime(
-                    borrowed_fd(fd),
-                    bitflags_bits!(flags),
-                    &new_value.clone().into(),
-                    result.as_mut_ptr(),
-                ))?;
-                return Ok(result.assume_init().into());
-            }
-        }
-
-        timerfd_settime_old(fd, flags, new_value)
-    }
-
-    #[cfg(not(fix_y2038))]
-    unsafe {
-        let mut result = MaybeUninit::<LibcItimerspec>::uninit();
-        ret(c::timerfd_settime(
-            borrowed_fd(fd),
-            bitflags_bits!(flags),
-            new_value,
-            result.as_mut_ptr(),
-        ))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(fix_y2038)]
-#[cfg(feature = "time")]
-fn timerfd_settime_old(
-    fd: BorrowedFd<'_>,
-    flags: TimerfdTimerFlags,
-    new_value: &Itimerspec,
-) -> io::Result<Itimerspec> {
-    let mut old_result = MaybeUninit::<c::itimerspec>::uninit();
-
-    // Convert `new_value` to the old `itimerspec` format.
-    let old_new_value = c::itimerspec {
-        it_interval: c::timespec {
-            tv_sec: new_value
-                .it_interval
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: new_value
-                .it_interval
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::INVAL)?,
-        },
-        it_value: c::timespec {
-            tv_sec: new_value
-                .it_value
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: new_value
-                .it_value
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::INVAL)?,
-        },
-    };
-
-    let old_result = unsafe {
-        ret(c::timerfd_settime(
-            borrowed_fd(fd),
-            bitflags_bits!(flags),
-            &old_new_value,
-            old_result.as_mut_ptr(),
-        ))?;
-        old_result.assume_init()
-    };
-
-    Ok(Itimerspec {
-        it_interval: Timespec {
-            tv_sec: old_result
-                .it_interval
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: old_result.it_interval.tv_nsec as _,
-        },
-        it_value: Timespec {
-            tv_sec: old_result
-                .it_interval
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: old_result.it_interval.tv_nsec as _,
-        },
-    })
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(feature = "time")]
-pub(crate) fn timerfd_gettime(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> {
-    // Old 32-bit version: libc has `timerfd_gettime` but it is not y2038 safe
-    // by default. But there may be a `__timerfd_gettime64` we can use.
-    #[cfg(fix_y2038)]
-    {
-        #[cfg(target_env = "gnu")]
-        if let Some(libc_timerfd_gettime) = __timerfd_gettime64.get() {
-            let mut result = MaybeUninit::<LibcItimerspec>::uninit();
-            unsafe {
-                ret(libc_timerfd_gettime(borrowed_fd(fd), result.as_mut_ptr()))?;
-                return Ok(result.assume_init().into());
-            }
-        }
-
-        timerfd_gettime_old(fd)
-    }
-
-    #[cfg(not(fix_y2038))]
-    unsafe {
-        let mut result = MaybeUninit::<LibcItimerspec>::uninit();
-        ret(c::timerfd_gettime(borrowed_fd(fd), result.as_mut_ptr()))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(fix_y2038)]
-#[cfg(feature = "time")]
-fn timerfd_gettime_old(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> {
-    let mut old_result = MaybeUninit::<c::itimerspec>::uninit();
-
-    let old_result = unsafe {
-        ret(c::timerfd_gettime(borrowed_fd(fd), old_result.as_mut_ptr()))?;
-        old_result.assume_init()
-    };
-
-    Ok(Itimerspec {
-        it_interval: Timespec {
-            tv_sec: old_result
-                .it_interval
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: old_result.it_interval.tv_nsec as _,
-        },
-        it_value: Timespec {
-            tv_sec: old_result
-                .it_interval
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: old_result.it_interval.tv_nsec as _,
-        },
-    })
-}
diff --git a/vendor/rustix/src/backend/libc/time/types.rs b/vendor/rustix/src/backend/libc/time/types.rs
deleted file mode 100644
index 5254c6b..0000000
--- a/vendor/rustix/src/backend/libc/time/types.rs
+++ /dev/null
@@ -1,177 +0,0 @@
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-use crate::backend::c;
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(fix_y2038)]
-use crate::timespec::LibcTimespec;
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(fix_y2038)]
-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(linux_kernel, target_os = "fuchsia"))]
-#[cfg(not(fix_y2038))]
-pub type Itimerspec = c::itimerspec;
-
-/// `struct itimerspec` for use with [`timerfd_gettime`] and
-/// [`timerfd_settime`].
-///
-/// [`timerfd_gettime`]: crate::time::timerfd_gettime
-/// [`timerfd_settime`]: crate::time::timerfd_settime
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(fix_y2038)]
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct Itimerspec {
-    /// The interval of an interval timer.
-    pub it_interval: Timespec,
-    /// Time remaining in the current interval.
-    pub it_value: Timespec,
-}
-
-/// On most platforms, `LibcItimerspec` is just `Itimerspec`.
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(not(fix_y2038))]
-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(linux_kernel, target_os = "fuchsia"))]
-#[cfg(fix_y2038)]
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub(crate) struct LibcItimerspec {
-    pub it_interval: LibcTimespec,
-    pub it_value: LibcTimespec,
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(fix_y2038)]
-impl From<LibcItimerspec> for Itimerspec {
-    #[inline]
-    fn from(t: LibcItimerspec) -> Self {
-        Self {
-            it_interval: t.it_interval.into(),
-            it_value: t.it_value.into(),
-        }
-    }
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[cfg(fix_y2038)]
-impl From<Itimerspec> for LibcItimerspec {
-    #[inline]
-    fn from(t: Itimerspec) -> Self {
-        Self {
-            it_interval: t.it_interval.into(),
-            it_value: t.it_value.into(),
-        }
-    }
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-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: u32 {
-        /// `TFD_NONBLOCK`
-        #[doc(alias = "TFD_NONBLOCK")]
-        const NONBLOCK = bitcast!(c::TFD_NONBLOCK);
-
-        /// `TFD_CLOEXEC`
-        #[doc(alias = "TFD_CLOEXEC")]
-        const CLOEXEC = bitcast!(c::TFD_CLOEXEC);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-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: u32 {
-        /// `TFD_TIMER_ABSTIME`
-        #[doc(alias = "TFD_TIMER_ABSTIME")]
-        const ABSTIME = bitcast!(c::TFD_TIMER_ABSTIME);
-
-        /// `TFD_TIMER_CANCEL_ON_SET`
-        #[cfg(linux_kernel)]
-        #[doc(alias = "TFD_TIMER_CANCEL_ON_SET")]
-        const CANCEL_ON_SET = bitcast!(c::TFD_TIMER_CANCEL_ON_SET);
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `CLOCK_*` constants for use with [`timerfd_create`].
-///
-/// [`timerfd_create`]: crate::time::timerfd_create
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-#[repr(u32)]
-#[non_exhaustive]
-pub enum TimerfdClockId {
-    /// `CLOCK_REALTIME`—A clock that tells the “real” time.
-    ///
-    /// This is a clock that tells the amount of time elapsed since the 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.
-    #[doc(alias = "CLOCK_REALTIME")]
-    Realtime = bitcast!(c::CLOCK_REALTIME),
-
-    /// `CLOCK_MONOTONIC`—A clock that tells an abstract time.
-    ///
-    /// Unlike `Realtime`, this clock is not based on a fixed known epoch, so
-    /// individual times aren't meaningful. However, since it isn't settable,
-    /// it is reliable for measuring durations.
-    ///
-    /// This clock does not advance while the system is suspended; see
-    /// `Boottime` for a clock that does.
-    #[doc(alias = "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.
-    #[doc(alias = "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.
-    #[doc(alias = "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.
-    #[doc(alias = "CLOCK_BOOTTIME_ALARM")]
-    BoottimeAlarm = bitcast!(c::CLOCK_BOOTTIME_ALARM),
-}
-
-#[cfg(any(linux_kernel, target_os = "fuchsia"))]
-#[test]
-fn test_types() {
-    assert_eq_size!(TimerfdFlags, c::c_int);
-    assert_eq_size!(TimerfdTimerFlags, c::c_int);
-}
diff --git a/vendor/rustix/src/backend/libc/ugid/mod.rs b/vendor/rustix/src/backend/libc/ugid/mod.rs
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/libc/ugid/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/libc/ugid/syscalls.rs b/vendor/rustix/src/backend/libc/ugid/syscalls.rs
deleted file mode 100644
index 0d3f622..0000000
--- a/vendor/rustix/src/backend/libc/ugid/syscalls.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-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
deleted file mode 100644
index ee2704a..0000000
--- a/vendor/rustix/src/backend/libc/winsock_c.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//! Adapt the Winsock API to resemble a POSIX-style libc API.
-
-#![allow(unused_imports)]
-#![allow(non_camel_case_types)]
-#![allow(dead_code)]
-
-use windows_sys::Win32::Networking::WinSock;
-
-// Define the basic C types. With Rust 1.64, we can use these from `core::ffi`.
-pub(crate) type c_schar = i8;
-pub(crate) type c_uchar = u8;
-pub(crate) type c_short = i16;
-pub(crate) type c_ushort = u16;
-pub(crate) type c_int = i32;
-pub(crate) type c_uint = u32;
-pub(crate) type c_longlong = i64;
-pub(crate) type c_ulonglong = u64;
-pub(crate) type ssize_t = isize;
-pub(crate) type c_char = i8;
-pub(crate) type c_long = i32;
-pub(crate) type c_ulong = u32;
-pub(crate) use core::ffi::c_void;
-
-// windows-sys declares these constants as u16. For better compatibility
-// with Unix-family APIs, redeclare them as u32.
-pub(crate) const AF_INET: i32 = WinSock::AF_INET as _;
-pub(crate) const AF_INET6: i32 = WinSock::AF_INET6 as _;
-pub(crate) const AF_UNSPEC: i32 = WinSock::AF_UNSPEC as _;
-
-// Include the contents of `WinSock`, renaming as needed to match POSIX.
-//
-// Use `WSA_E_CANCELLED` for `ECANCELED` instead of `WSAECANCELLED`, because
-// `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, 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,
-    WSAEFAULT as EFAULT, WSAEHOSTDOWN as EHOSTDOWN, WSAEHOSTUNREACH as EHOSTUNREACH,
-    WSAEINPROGRESS as EINPROGRESS, WSAEINTR as EINTR, WSAEINVAL as EINVAL,
-    WSAEINVALIDPROCTABLE as EINVALIDPROCTABLE, WSAEINVALIDPROVIDER as EINVALIDPROVIDER,
-    WSAEISCONN as EISCONN, WSAELOOP as ELOOP, WSAEMFILE as EMFILE, WSAEMSGSIZE as EMSGSIZE,
-    WSAENAMETOOLONG as ENAMETOOLONG, WSAENETDOWN as ENETDOWN, WSAENETRESET as ENETRESET,
-    WSAENETUNREACH as ENETUNREACH, WSAENOBUFS as ENOBUFS, WSAENOMORE as ENOMORE,
-    WSAENOPROTOOPT as ENOPROTOOPT, WSAENOTCONN as ENOTCONN, WSAENOTEMPTY as ENOTEMPTY,
-    WSAENOTSOCK as ENOTSOCK, WSAEOPNOTSUPP as EOPNOTSUPP, WSAEPFNOSUPPORT as EPFNOSUPPORT,
-    WSAEPROCLIM as EPROCLIM, WSAEPROTONOSUPPORT as EPROTONOSUPPORT, WSAEPROTOTYPE as EPROTOTYPE,
-    WSAEPROVIDERFAILEDINIT as EPROVIDERFAILEDINIT, WSAEREFUSED as EREFUSED, WSAEREMOTE as EREMOTE,
-    WSAESHUTDOWN as ESHUTDOWN, WSAESOCKTNOSUPPORT as ESOCKTNOSUPPORT, WSAESTALE as ESTALE,
-    WSAETIMEDOUT as ETIMEDOUT, WSAETOOMANYREFS as ETOOMANYREFS, WSAEUSERS as EUSERS,
-    WSAEWOULDBLOCK as EWOULDBLOCK, WSAEWOULDBLOCK as EAGAIN, WSAPOLLFD as pollfd,
-    WSA_E_CANCELLED as ECANCELED, *,
-};
diff --git a/vendor/rustix/src/backend/linux_raw/arch/aarch64.rs b/vendor/rustix/src/backend/linux_raw/arch/aarch64.rs
deleted file mode 100644
index d4cf247..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/aarch64.rs
+++ /dev/null
@@ -1,268 +0,0 @@
-//! aarch64 Linux system calls.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
-};
-use core::arch::asm;
-
-#[cfg(target_pointer_width = "32")]
-compile_error!("arm64-ilp32 is not supported yet");
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber<'_>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        lateout("x0") r0,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        in("x0") a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        in("x2") a2.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        in("x2") a2.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        in("x2") a2.to_asm(),
-        in("x3") a3.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        in("x2") a2.to_asm(),
-        in("x3") a3.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        in("x2") a2.to_asm(),
-        in("x3") a3.to_asm(),
-        in("x4") a4.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        in("x2") a2.to_asm(),
-        in("x3") a3.to_asm(),
-        in("x4") a4.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        in("x2") a2.to_asm(),
-        in("x3") a3.to_asm(),
-        in("x4") a4.to_asm(),
-        in("x5") a5.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("x8") nr.to_asm(),
-        inlateout("x0") a0.to_asm() => r0,
-        in("x1") a1.to_asm(),
-        in("x2") a2.to_asm(),
-        in("x3") a3.to_asm(),
-        in("x4") a4.to_asm(),
-        in("x5") a5.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/arm.rs b/vendor/rustix/src/backend/linux_raw/arch/arm.rs
deleted file mode 100644
index 77c1f82..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/arm.rs
+++ /dev/null
@@ -1,265 +0,0 @@
-//! arm Linux system calls.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
-};
-use core::arch::asm;
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber<'_>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        lateout("r0") r0,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        in("r0") a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        in("r4") a4.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        in("r4") a4.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        in("r4") a4.to_asm(),
-        in("r5") a5.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "svc 0",
-        in("r7") nr.to_asm(),
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        in("r4") a4.to_asm(),
-        in("r5") a5.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/mips.rs b/vendor/rustix/src/backend/linux_raw/arch/mips.rs
deleted file mode 100644
index 37932e0..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/mips.rs
+++ /dev/null
@@ -1,543 +0,0 @@
-//! mipsel Linux system calls.
-//!
-//! On mipsel, Linux indicates success or failure using `$a3` rather
-//! than by returning a negative error code as most other architectures do.
-//!
-//! Mips-family platforms have a special calling convention for `__NR_pipe`,
-//! however we use `__NR_pipe2` instead to avoid having to implement it.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, A6, R0,
-};
-use core::arch::asm;
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "syscall",
-        in("$2" /*$v0*/) nr.to_asm(),
-        in("$4" /*$a0*/) a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "sw {}, 20($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        in(reg) a5.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "sw {}, 20($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        in(reg) a5.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall7_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-    a6: ArgReg<'_, A6>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "sw {}, 20($sp)",
-        "sw {}, 24($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        in(reg) a5.to_asm(),
-        in(reg) a6.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/mips32r6.rs b/vendor/rustix/src/backend/linux_raw/arch/mips32r6.rs
deleted file mode 100644
index c2d9244..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/mips32r6.rs
+++ /dev/null
@@ -1,543 +0,0 @@
-//! mipsisa32r6el Linux system calls.
-//!
-//! On mipsisa32r6el, Linux indicates success or failure using `$a3` rather
-//! than by returning a negative error code as most other architectures do.
-//!
-//! Mips-family platforms have a special calling convention for `__NR_pipe`,
-//! however we use `__NR_pipe2` instead to avoid having to implement it.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, A6, R0,
-};
-use core::arch::asm;
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "syscall",
-        in("$2" /*$v0*/) nr.to_asm(),
-        in("$4" /*$a0*/) a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "sw {}, 20($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        in(reg) a5.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "sw {}, 20($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        in(reg) a5.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall7_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-    a6: ArgReg<'_, A6>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        ".set noat",
-        "subu $sp, 32",
-        "sw {}, 16($sp)",
-        "sw {}, 20($sp)",
-        "sw {}, 24($sp)",
-        "syscall",
-        "addu $sp, 32",
-        ".set at",
-        in(reg) a4.to_asm(),
-        in(reg) a5.to_asm(),
-        in(reg) a6.to_asm(),
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$t0*/) _,
-        lateout("$9" /*$t1*/) _,
-        lateout("$10" /*$t2*/) _,
-        lateout("$11" /*$t3*/) _,
-        lateout("$12" /*$t4*/) _,
-        lateout("$13" /*$t5*/) _,
-        lateout("$14" /*$t6*/) _,
-        lateout("$15" /*$t7*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/mips64.rs b/vendor/rustix/src/backend/linux_raw/arch/mips64.rs
deleted file mode 100644
index 244daf3..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/mips64.rs
+++ /dev/null
@@ -1,466 +0,0 @@
-//! mips64el Linux system calls.
-//!
-//! On mips64el, Linux indicates success or failure using `$a3` (`$7`) rather
-//! than by returning a negative error code as most other architectures do.
-//!
-//! Mips-family platforms have a special calling convention for `__NR_pipe`,
-//! however we use `__NR_pipe2` instead to avoid having to implement it.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
-};
-use core::arch::asm;
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "syscall",
-        in("$2" /*$v0*/) nr.to_asm(),
-        in("$4" /*$a0*/) a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        inlateout("$8" /*$a4*/) a4.to_asm() => _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        inlateout("$8" /*$a4*/) a4.to_asm() => _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        inlateout("$8" /*$a4*/) a4.to_asm() => _,
-        inlateout("$9" /*$a5*/) a5.to_asm() => _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        inlateout("$8" /*$a4*/) a4.to_asm() => _,
-        inlateout("$9" /*$a5*/) a5.to_asm() => _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/mips64r6.rs b/vendor/rustix/src/backend/linux_raw/arch/mips64r6.rs
deleted file mode 100644
index 8c06d9e..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/mips64r6.rs
+++ /dev/null
@@ -1,470 +0,0 @@
-//! mipsisa64r6el Linux system calls.
-//!
-//! On mipsisa64r6el, Linux indicates success or failure using `$a3` (`$7`)
-//! rather than by returning a negative error code as most other architectures
-//! do.
-//!
-//! Mips-family platforms have a special calling convention for `__NR_pipe`,
-//! however we use `__NR_pipe2` instead to avoid having to implement it.
-//!
-//! Note that MIPS R6 inline assembly currently doesn't differ from MIPS,
-//! because no explicit call of R6-only or R2-only instructions exist here.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
-};
-use core::arch::asm;
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "syscall",
-        in("$2" /*$v0*/) nr.to_asm(),
-        in("$4" /*$a0*/) a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        lateout("$7" /*$a3*/) err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        lateout("$8" /*$a4*/) _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        inlateout("$8" /*$a4*/) a4.to_asm() => _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        inlateout("$8" /*$a4*/) a4.to_asm() => _,
-        lateout("$9" /*$a5*/) _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        inlateout("$8" /*$a4*/) a4.to_asm() => _,
-        inlateout("$9" /*$a5*/) a5.to_asm() => _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let x0;
-    let err: usize;
-    asm!(
-        "syscall",
-        inlateout("$2" /*$v0*/) nr.to_asm() => x0,
-        in("$4" /*$a0*/) a0.to_asm(),
-        in("$5" /*$a1*/) a1.to_asm(),
-        in("$6" /*$a2*/) a2.to_asm(),
-        inlateout("$7" /*$a3*/) a3.to_asm() => err,
-        inlateout("$8" /*$a4*/) a4.to_asm() => _,
-        inlateout("$9" /*$a5*/) a5.to_asm() => _,
-        lateout("$10" /*$a6*/) _,
-        lateout("$11" /*$a7*/) _,
-        lateout("$12" /*$t0*/) _,
-        lateout("$13" /*$t1*/) _,
-        lateout("$14" /*$t2*/) _,
-        lateout("$15" /*$t3*/) _,
-        lateout("$24" /*$t8*/) _,
-        lateout("$25" /*$t9*/) _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(if err != 0 {
-        (x0 as usize).wrapping_neg() as *mut _
-    } else {
-        x0
-    })
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/mod.rs b/vendor/rustix/src/backend/linux_raw/arch/mod.rs
deleted file mode 100644
index ac9e25f..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/mod.rs
+++ /dev/null
@@ -1,317 +0,0 @@
-//! Architecture-specific syscall code.
-//!
-//! This module also has a `choose` submodule which chooses a scheme and is
-//! what most of the `rustix` syscalls use.
-//!
-//! Compilers should really have intrinsics for making system calls. They're
-//! much like regular calls, with custom calling conventions, and calling
-//! conventions are otherwise the compiler's job. But for now, use inline asm.
-//!
-//! The calling conventions for Linux syscalls are [documented here].
-//!
-//! [documented here]: https://man7.org/linux/man-pages/man2/syscall.2.html
-//!
-//! # Safety
-//!
-//! This contains the inline `asm` statements performing the syscall
-//! instructions.
-
-#![allow(unsafe_code)]
-#![cfg_attr(not(feature = "all-apis"), allow(unused_imports))]
-// We'll use as many arguments as syscalls need.
-#![allow(clippy::too_many_arguments)]
-
-// These functions always use the machine's syscall instruction, even when it
-// isn't the fastest option available.
-#[cfg_attr(target_arch = "aarch64", path = "aarch64.rs")]
-#[cfg_attr(all(target_arch = "arm", not(thumb_mode)), path = "arm.rs")]
-#[cfg_attr(all(target_arch = "arm", thumb_mode), path = "thumb.rs")]
-#[cfg_attr(target_arch = "mips", path = "mips.rs")]
-#[cfg_attr(target_arch = "mips32r6", path = "mips32r6.rs")]
-#[cfg_attr(target_arch = "mips64", path = "mips64.rs")]
-#[cfg_attr(target_arch = "mips64r6", path = "mips64r6.rs")]
-#[cfg_attr(target_arch = "powerpc64", path = "powerpc64.rs")]
-#[cfg_attr(target_arch = "riscv64", path = "riscv64.rs")]
-#[cfg_attr(target_arch = "x86", path = "x86.rs")]
-#[cfg_attr(target_arch = "x86_64", path = "x86_64.rs")]
-pub(in crate::backend) mod asm;
-
-// On most architectures, the architecture syscall instruction is fast, so use
-// it directly.
-#[cfg(any(
-    target_arch = "arm",
-    target_arch = "aarch64",
-    target_arch = "mips",
-    target_arch = "mips32r6",
-    target_arch = "mips64",
-    target_arch = "mips64r6",
-    target_arch = "powerpc64",
-    target_arch = "riscv64",
-    target_arch = "x86_64",
-))]
-pub(in crate::backend) use self::asm as choose;
-
-// On 32-bit x86, use vDSO wrappers for all syscalls. We could use the
-// architecture syscall instruction (`int 0x80`), but the vDSO kernel_vsyscall
-// mechanism is much faster.
-#[cfg(target_arch = "x86")]
-pub(in crate::backend) use super::vdso_wrappers::x86_via_vdso as choose;
-
-// This would be the code for always using `int 0x80` on 32-bit x86.
-//#[cfg(target_arch = "x86")]
-//pub(in crate::backend) use self::asm as choose;
-
-// Macros for invoking system calls.
-//
-// These factor out:
-//  - Calling `nr` on the syscall number to convert it into `SyscallNumber`.
-//  - Calling `.into()` on each of the arguments to convert them into `ArgReg`.
-//  - Qualifying the `syscall*` and `__NR_*` identifiers.
-//  - Counting the number of arguments.
-macro_rules! syscall {
-    ($nr:ident) => {
-        $crate::backend::arch::choose::syscall0($crate::backend::reg::nr(
-            linux_raw_sys::general::$nr,
-        ))
-    };
-
-    ($nr:ident, $a0:expr) => {
-        $crate::backend::arch::choose::syscall1(
-            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
-            $a0.into(),
-        )
-    };
-
-    ($nr:ident, $a0:expr, $a1:expr) => {
-        $crate::backend::arch::choose::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::choose::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::choose::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::choose::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::choose::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::choose::syscall7(
-            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
-            $a0.into(),
-            $a1.into(),
-            $a2.into(),
-            $a3.into(),
-            $a4.into(),
-            $a5.into(),
-            $a6.into(),
-        )
-    };
-}
-
-// 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(
-            linux_raw_sys::general::$nr,
-        ))
-    };
-
-    ($nr:ident, $a0:expr) => {
-        $crate::backend::arch::choose::syscall1_readonly(
-            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
-            $a0.into(),
-        )
-    };
-
-    ($nr:ident, $a0:expr, $a1:expr) => {
-        $crate::backend::arch::choose::syscall2_readonly(
-            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
-            $a0.into(),
-            $a1.into(),
-        )
-    };
-
-    ($nr:ident, $a0:expr, $a1:expr, $a2:expr) => {
-        $crate::backend::arch::choose::syscall3_readonly(
-            $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::choose::syscall4_readonly(
-            $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::choose::syscall5_readonly(
-            $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::choose::syscall6_readonly(
-            $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::choose::syscall7_readonly(
-            $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 indicates that the syscall does not return.
-#[cfg(feature = "runtime")]
-macro_rules! syscall_noreturn {
-    ($nr:ident, $a0:expr) => {
-        $crate::backend::arch::choose::syscall1_noreturn(
-            $crate::backend::reg::nr(linux_raw_sys::general::$nr),
-            $a0.into(),
-        )
-    };
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/powerpc64.rs b/vendor/rustix/src/backend/linux_raw/arch/powerpc64.rs
deleted file mode 100644
index 14866c2..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/powerpc64.rs
+++ /dev/null
@@ -1,413 +0,0 @@
-//! powerpc64le Linux system calls.
-//!
-//! On powerpc64le, Linux indicates success or failure using `cr0.SO` rather
-//! than by returning a negative error code as most other architectures do. In
-//! theory we could immediately translate this into a `Result`, and it'd save a
-//! few branches. And in theory we could have specialized sequences for use
-//! with syscalls that are known to never fail. However, those would require
-//! more extensive changes in rustix's platform-independent code. For now, we
-//! check the flag and negate the error value to make PowerPC64 look like other
-//! architectures.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
-};
-use core::arch::asm;
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber<'_>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        lateout("r3") r0,
-        lateout("r4") _,
-        lateout("r5") _,
-        lateout("r6") _,
-        lateout("r7") _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        lateout("r4") _,
-        lateout("r5") _,
-        lateout("r6") _,
-        lateout("r7") _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        lateout("r4") _,
-        lateout("r5") _,
-        lateout("r6") _,
-        lateout("r7") _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "sc",
-        in("r0") nr.to_asm(),
-        in("r3") a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        lateout("r5") _,
-        lateout("r6") _,
-        lateout("r7") _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        lateout("r5") _,
-        lateout("r6") _,
-        lateout("r7") _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        inlateout("r5") a2.to_asm() => _,
-        lateout("r6") _,
-        lateout("r7") _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        inlateout("r5") a2.to_asm() => _,
-        lateout("r6") _,
-        lateout("r7") _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        inlateout("r5") a2.to_asm() => _,
-        inlateout("r6") a3.to_asm() => _,
-        lateout("r7") _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        inlateout("r5") a2.to_asm() => _,
-        inlateout("r6") a3.to_asm() => _,
-        lateout("r7") _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        inlateout("r5") a2.to_asm() => _,
-        inlateout("r6") a3.to_asm() => _,
-        inlateout("r7") a4.to_asm() => _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        inlateout("r5") a2.to_asm() => _,
-        inlateout("r6") a3.to_asm() => _,
-        inlateout("r7") a4.to_asm() => _,
-        lateout("r8") _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        inlateout("r5") a2.to_asm() => _,
-        inlateout("r6") a3.to_asm() => _,
-        inlateout("r7") a4.to_asm() => _,
-        inlateout("r8") a5.to_asm() => _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "sc",
-        "bns 0f",
-        "neg 3, 3",
-        "0:",
-        inlateout("r0") nr.to_asm() => _,
-        inlateout("r3") a0.to_asm() => r0,
-        inlateout("r4") a1.to_asm() => _,
-        inlateout("r5") a2.to_asm() => _,
-        inlateout("r6") a3.to_asm() => _,
-        inlateout("r7") a4.to_asm() => _,
-        inlateout("r8") a5.to_asm() => _,
-        lateout("r9") _,
-        lateout("r10") _,
-        lateout("r11") _,
-        lateout("r12") _,
-        lateout("cr0") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/riscv64.rs b/vendor/rustix/src/backend/linux_raw/arch/riscv64.rs
deleted file mode 100644
index 7b8533d..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/riscv64.rs
+++ /dev/null
@@ -1,265 +0,0 @@
-//! riscv64 Linux system calls.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
-};
-use core::arch::asm;
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber<'_>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        lateout("a0") r0,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        in("a0") a0.to_asm(),
-        options(nostack, noreturn)
-    );
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        in("a2") a2.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        in("a2") a2.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        in("a2") a2.to_asm(),
-        in("a3") a3.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        in("a2") a2.to_asm(),
-        in("a3") a3.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        in("a2") a2.to_asm(),
-        in("a3") a3.to_asm(),
-        in("a4") a4.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        in("a2") a2.to_asm(),
-        in("a3") a3.to_asm(),
-        in("a4") a4.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        in("a2") a2.to_asm(),
-        in("a3") a3.to_asm(),
-        in("a4") a4.to_asm(),
-        in("a5") a5.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "ecall",
-        in("a7") nr.to_asm(),
-        inlateout("a0") a0.to_asm() => r0,
-        in("a1") a1.to_asm(),
-        in("a2") a2.to_asm(),
-        in("a3") a3.to_asm(),
-        in("a4") a4.to_asm(),
-        in("a5") a5.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/thumb.rs b/vendor/rustix/src/backend/linux_raw/arch/thumb.rs
deleted file mode 100644
index 73f9c1c..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/thumb.rs
+++ /dev/null
@@ -1,322 +0,0 @@
-//! arm Linux system calls, using thumb-mode.
-//!
-//! In thumb-mode, r7 is the frame pointer and is not permitted to be used in
-//! an inline asm operand, so we have to use a different register and copy it
-//! into r7 inside the inline asm.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
-};
-use core::arch::asm;
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber<'_>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        lateout("r0") r0,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "mov r7, {nr}",
-        "svc 0",
-        nr = in(reg) nr.to_asm(),
-        in("r0") a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        in("r4") a4.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        in("r4") a4.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        in("r4") a4.to_asm(),
-        in("r5") a5.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "mov {tmp}, r7",
-        "mov r7, {nr}",
-        "svc 0",
-        "mov r7, {tmp}",
-        nr = in(reg) nr.to_asm(),
-        tmp = out(reg) _,
-        inlateout("r0") a0.to_asm() => r0,
-        in("r1") a1.to_asm(),
-        in("r2") a2.to_asm(),
-        in("r3") a3.to_asm(),
-        in("r4") a4.to_asm(),
-        in("r5") a5.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/x86.rs b/vendor/rustix/src/backend/linux_raw/arch/x86.rs
deleted file mode 100644
index e789181..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/x86.rs
+++ /dev/null
@@ -1,489 +0,0 @@
-//! 32-bit x86 Linux system calls.
-//!
-//! There are two forms; `indirect_*` which take a callee, which allow calling
-//! through the vDSO when possible, and plain forms, which use the `int 0x80`
-//! instruction.
-//!
-//! Most `rustix` syscalls use the vsyscall mechanism rather than going using
-//! `int 0x80` sequences, as vsyscall is much faster.
-//!
-//! Syscalls made with `int 0x80` preserve the flags register, while syscalls
-//! made using vsyscall do not.
-
-#![allow(dead_code)]
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
-};
-use crate::backend::vdso_wrappers::SyscallType;
-use core::arch::asm;
-
-#[inline]
-pub(in crate::backend) unsafe fn indirect_syscall0(
-    callee: SyscallType,
-    nr: SyscallNumber<'_>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "call {callee}",
-        callee = in(reg) callee,
-        inlateout("eax") nr.to_asm() => r0,
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn indirect_syscall1(
-    callee: SyscallType,
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "call {callee}",
-        callee = in(reg) callee,
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn indirect_syscall1_noreturn(
-    callee: SyscallType,
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> ! {
-    asm!(
-        "call {callee}",
-        callee = in(reg) callee,
-        in("eax") nr.to_asm(),
-        in("ebx") a0.to_asm(),
-        options(noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn indirect_syscall2(
-    callee: SyscallType,
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "call {callee}",
-        callee = in(reg) callee,
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn indirect_syscall3(
-    callee: SyscallType,
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "call {callee}",
-        callee = in(reg) callee,
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn indirect_syscall4(
-    callee: SyscallType,
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> 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.
-    //
-    // 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
-    // satisfy `in(reg)`.
-    asm!(
-        "xchg esi, {a3}",
-        "call edi",
-        "xchg esi, {a3}",
-        a3 = in(reg) a3.to_asm(),
-        in("edi") callee,
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn indirect_syscall5(
-    callee: SyscallType,
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    // Oof. a3 should go in esi, and `asm!` won't let us use that register as
-    // an operand. And we can't request stack slots. And there are no other
-    // registers free. Use eax as a temporary pointer to a slice, since it gets
-    // clobbered as the return value anyway.
-    asm!(
-        "push esi",
-        "push [eax + 0]",
-        "mov esi, [eax + 4]",
-        "mov eax, [eax + 8]",
-        "call [esp]",
-        "pop esi",
-        "pop esi",
-        inout("eax") &[callee as _, a3.to_asm(), nr.to_asm()] => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        in("edi") a4.to_asm(),
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn indirect_syscall6(
-    callee: SyscallType,
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    // Oof again. a3 should go in esi, and a5 should go in ebp, and `asm!`
-    // won't let us use either of those registers as operands. And we can't
-    // request stack slots. And there are no other registers free. Use eax as a
-    // temporary pointer to a slice, since it gets clobbered as the return
-    // value anyway.
-    //
-    // This is another reason that syscalls should be compiler intrinsics
-    // rather than inline asm.
-    asm!(
-        "push ebp",
-        "push esi",
-        "push [eax + 0]",
-        "mov esi, [eax + 4]",
-        "mov ebp, [eax + 8]",
-        "mov eax, [eax + 12]",
-        "call [esp]",
-        "pop esi",
-        "pop esi",
-        "pop ebp",
-        inout("eax") &[callee as _, a3.to_asm(), a5.to_asm(), nr.to_asm()] => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        in("edi") a4.to_asm(),
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber<'_>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "int $$0x80",
-        inlateout("eax") nr.to_asm() => r0,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "int $$0x80",
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "int $$0x80",
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "int $$0x80",
-        in("eax") nr.to_asm(),
-        in("ebx") a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "int $$0x80",
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "int $$0x80",
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "int $$0x80",
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "int $$0x80",
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> 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.
-    asm!(
-        "xchg esi, {a3}",
-        "int $$0x80",
-        "xchg esi, {a3}",
-        a3 = in(reg) a3.to_asm(),
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "xchg esi, {a3}",
-        "int $$0x80",
-        "xchg esi, {a3}",
-        a3 = in(reg) a3.to_asm(),
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    // As in `syscall4`, use xchg to handle a3. a4 should go in edi, and we can
-    // use that register as an operand. Unlike in `indirect_syscall5`, we don't
-    // have a `callee` operand taking up a register, so we have enough
-    // registers and don't need to use a slice.
-    asm!(
-        "xchg esi, {a3}",
-        "int $$0x80",
-        "xchg esi, {a3}",
-        a3 = in(reg) a3.to_asm(),
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        in("edi") a4.to_asm(),
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    // See the comments in `syscall5`.
-    asm!(
-        "xchg esi, {a3}",
-        "int $$0x80",
-        "xchg esi, {a3}",
-        a3 = in(reg) a3.to_asm(),
-        inlateout("eax") nr.to_asm() => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        in("edi") a4.to_asm(),
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    // See the comments in `indirect_syscall6`.
-    asm!(
-        "push ebp",
-        "push esi",
-        "mov esi, [eax + 0]",
-        "mov ebp, [eax + 4]",
-        "mov eax, [eax + 8]",
-        "int $$0x80",
-        "pop esi",
-        "pop ebp",
-        inout("eax") &[a3.to_asm(), a5.to_asm(), nr.to_asm()] => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        in("edi") a4.to_asm(),
-        options(preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    // See the comments in `indirect_syscall6`.
-    asm!(
-        "push ebp",
-        "push esi",
-        "mov esi, [eax + 0]",
-        "mov ebp, [eax + 4]",
-        "mov eax, [eax + 8]",
-        "int $$0x80",
-        "pop esi",
-        "pop ebp",
-        inout("eax") &[a3.to_asm(), a5.to_asm(), nr.to_asm()] => r0,
-        in("ebx") a0.to_asm(),
-        in("ecx") a1.to_asm(),
-        in("edx") a2.to_asm(),
-        in("edi") a4.to_asm(),
-        options(preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/arch/x86_64.rs b/vendor/rustix/src/backend/linux_raw/arch/x86_64.rs
deleted file mode 100644
index 62f35d9..0000000
--- a/vendor/rustix/src/backend/linux_raw/arch/x86_64.rs
+++ /dev/null
@@ -1,293 +0,0 @@
-//! x86-64 Linux system calls.
-
-use crate::backend::reg::{
-    ArgReg, FromAsm, RetReg, SyscallNumber, ToAsm, A0, A1, A2, A3, A4, A5, R0,
-};
-use core::arch::asm;
-
-#[cfg(target_pointer_width = "32")]
-compile_error!("x32 is not yet supported");
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall0_readonly(nr: SyscallNumber<'_>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall1_noreturn(nr: SyscallNumber<'_>, a0: ArgReg<'_, A0>) -> ! {
-    asm!(
-        "syscall",
-        in("rax") nr.to_asm(),
-        in("rdi") a0.to_asm(),
-        options(nostack, noreturn)
-    )
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall2_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        in("rdx") a2.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall3_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        in("rdx") a2.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        in("rdx") a2.to_asm(),
-        in("r10") a3.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall4_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        in("rdx") a2.to_asm(),
-        in("r10") a3.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        in("rdx") a2.to_asm(),
-        in("r10") a3.to_asm(),
-        in("r8") a4.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall5_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        in("rdx") a2.to_asm(),
-        in("r10") a3.to_asm(),
-        in("r8") a4.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        in("rdx") a2.to_asm(),
-        in("r10") a3.to_asm(),
-        in("r8") a4.to_asm(),
-        in("r9") a5.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags)
-    );
-    FromAsm::from_asm(r0)
-}
-
-#[inline]
-pub(in crate::backend) unsafe fn syscall6_readonly(
-    nr: SyscallNumber<'_>,
-    a0: ArgReg<'_, A0>,
-    a1: ArgReg<'_, A1>,
-    a2: ArgReg<'_, A2>,
-    a3: ArgReg<'_, A3>,
-    a4: ArgReg<'_, A4>,
-    a5: ArgReg<'_, A5>,
-) -> RetReg<R0> {
-    let r0;
-    asm!(
-        "syscall",
-        inlateout("rax") nr.to_asm() => r0,
-        in("rdi") a0.to_asm(),
-        in("rsi") a1.to_asm(),
-        in("rdx") a2.to_asm(),
-        in("r10") a3.to_asm(),
-        in("r8") a4.to_asm(),
-        in("r9") a5.to_asm(),
-        lateout("rcx") _,
-        lateout("r11") _,
-        options(nostack, preserves_flags, readonly)
-    );
-    FromAsm::from_asm(r0)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/c.rs b/vendor/rustix/src/backend/linux_raw/c.rs
deleted file mode 100644
index edc9eb8..0000000
--- a/vendor/rustix/src/backend/linux_raw/c.rs
+++ /dev/null
@@ -1,304 +0,0 @@
-//! Adapt the Linux API to resemble a POSIX-style libc API.
-//!
-//! The linux_raw backend doesn't use actual libc; this just defines certain
-//! types that are convenient to have defined.
-
-#![allow(unused_imports)]
-#![allow(non_camel_case_types)]
-
-pub(crate) type size_t = usize;
-pub(crate) use linux_raw_sys::ctypes::*;
-pub(crate) use linux_raw_sys::errno::EINVAL;
-pub(crate) use linux_raw_sys::ioctl::{FIONBIO, FIONREAD};
-// 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::{
-    __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,
-};
-
-#[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(feature = "use-explicitly-provided-auxv"),
-        any(
-            feature = "param",
-            feature = "process",
-            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,
-};
-
-pub(crate) use linux_raw_sys::ioctl::{BLKPBSZGET, BLKSSZGET, FICLONE};
-
-#[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::{
-        linger, msghdr, sockaddr, sockaddr_in, sockaddr_in6, sockaddr_un, socklen_t, AF_DECnet,
-        __kernel_sa_family_t as sa_family_t, __kernel_sockaddr_storage as sockaddr_storage,
-        cmsghdr, in6_addr, in_addr, ip_mreq, ip_mreq_source, ip_mreqn, ipv6_mreq, 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,
-        IP6T_SO_ORIGINAL_DST, IPPROTO_FRAGMENT, IPPROTO_ICMPV6, IPPROTO_MH, IPPROTO_ROUTING,
-        IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_FREEBIND, IPV6_MULTICAST_HOPS,
-        IPV6_MULTICAST_LOOP, IPV6_RECVTCLASS, IPV6_TCLASS, IPV6_UNICAST_HOPS, IPV6_V6ONLY,
-        IP_ADD_MEMBERSHIP, IP_ADD_SOURCE_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_DROP_SOURCE_MEMBERSHIP,
-        IP_FREEBIND, IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_RECVTOS, IP_TOS, 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_ACCEPTCONN, SO_BROADCAST, SO_COOKIE, SO_DOMAIN, SO_ERROR,
-        SO_INCOMING_CPU, SO_KEEPALIVE, SO_LINGER, SO_OOBINLINE, SO_ORIGINAL_DST, SO_PASSCRED,
-        SO_PROTOCOL, SO_RCVBUF, SO_RCVTIMEO_NEW, SO_RCVTIMEO_NEW as SO_RCVTIMEO, SO_RCVTIMEO_OLD,
-        SO_REUSEADDR, SO_REUSEPORT, SO_SNDBUF, SO_SNDTIMEO_NEW, SO_SNDTIMEO_NEW as SO_SNDTIMEO,
-        SO_SNDTIMEO_OLD, SO_TYPE, TCP_CONGESTION, TCP_CORK, TCP_KEEPCNT, TCP_KEEPIDLE,
-        TCP_KEEPINTVL, TCP_NODELAY, TCP_QUICKACK, TCP_THIN_LINEAR_TIMEOUTS, TCP_USER_TIMEOUT,
-    },
-    netlink::*,
-};
-
-// Cast away bindgen's `enum` type to make these consistent with the other
-// `setsockopt`/`getsockopt` level values.
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_IP: u32 = linux_raw_sys::net::IPPROTO_IP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_ICMP: u32 = linux_raw_sys::net::IPPROTO_ICMP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_IGMP: u32 = linux_raw_sys::net::IPPROTO_IGMP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_IPIP: u32 = linux_raw_sys::net::IPPROTO_IPIP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_TCP: u32 = linux_raw_sys::net::IPPROTO_TCP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_EGP: u32 = linux_raw_sys::net::IPPROTO_EGP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_PUP: u32 = linux_raw_sys::net::IPPROTO_PUP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_UDP: u32 = linux_raw_sys::net::IPPROTO_UDP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_IDP: u32 = linux_raw_sys::net::IPPROTO_IDP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_TP: u32 = linux_raw_sys::net::IPPROTO_TP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_DCCP: u32 = linux_raw_sys::net::IPPROTO_DCCP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_IPV6: u32 = linux_raw_sys::net::IPPROTO_IPV6 as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_RSVP: u32 = linux_raw_sys::net::IPPROTO_RSVP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_GRE: u32 = linux_raw_sys::net::IPPROTO_GRE as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_ESP: u32 = linux_raw_sys::net::IPPROTO_ESP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_AH: u32 = linux_raw_sys::net::IPPROTO_AH as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_MTP: u32 = linux_raw_sys::net::IPPROTO_MTP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_BEETPH: u32 = linux_raw_sys::net::IPPROTO_BEETPH as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_ENCAP: u32 = linux_raw_sys::net::IPPROTO_ENCAP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_PIM: u32 = linux_raw_sys::net::IPPROTO_PIM as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_COMP: u32 = linux_raw_sys::net::IPPROTO_COMP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_SCTP: u32 = linux_raw_sys::net::IPPROTO_SCTP as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_UDPLITE: u32 = linux_raw_sys::net::IPPROTO_UDPLITE as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_MPLS: u32 = linux_raw_sys::net::IPPROTO_MPLS as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_ETHERNET: u32 = linux_raw_sys::net::IPPROTO_ETHERNET as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_RAW: u32 = linux_raw_sys::net::IPPROTO_RAW as _;
-#[cfg(feature = "net")]
-pub(crate) const IPPROTO_MPTCP: u32 = linux_raw_sys::net::IPPROTO_MPTCP as _;
-
-#[cfg(any(feature = "process", feature = "runtime"))]
-pub(crate) use linux_raw_sys::general::siginfo_t;
-
-#[cfg(any(feature = "process", feature = "runtime"))]
-pub(crate) const EXIT_SUCCESS: c_int = 0;
-#[cfg(any(feature = "process", feature = "runtime"))]
-pub(crate) const EXIT_FAILURE: c_int = 1;
-#[cfg(feature = "process")]
-pub(crate) const EXIT_SIGNALED_SIGABRT: c_int = 128 + linux_raw_sys::general::SIGABRT as c_int;
-#[cfg(feature = "runtime")]
-pub(crate) const CLONE_CHILD_SETTID: c_int = linux_raw_sys::general::CLONE_CHILD_SETTID as c_int;
-
-#[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_PGID, P_PID, P_PIDFD,
-    },
-    ioctl::TIOCSCTTY,
-};
-
-#[cfg(feature = "pty")]
-pub(crate) use linux_raw_sys::ioctl::TIOCGPTPEER;
-
-#[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, TIOCEXCL, TIOCNXCL},
-};
-
-// 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 = "mips32r6",
-        target_arch = "mips64",
-        target_arch = "mips64r6"
-    )
-))]
-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 = "mips32r6",
-    target_arch = "mips64",
-    target_arch = "mips64r6",
-    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 = "mips32r6",
-    target_arch = "mips64",
-    target_arch = "mips64r6",
-    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 _;
-#[cfg(any(feature = "thread", feature = "time", target_arch = "x86"))]
-pub(crate) const CLOCK_BOOTTIME: c_int = linux_raw_sys::general::CLOCK_BOOTTIME as _;
-#[cfg(any(feature = "thread", feature = "time", target_arch = "x86"))]
-pub(crate) const CLOCK_BOOTTIME_ALARM: c_int = linux_raw_sys::general::CLOCK_BOOTTIME_ALARM as _;
-#[cfg(any(feature = "thread", feature = "time", target_arch = "x86"))]
-pub(crate) const CLOCK_TAI: c_int = linux_raw_sys::general::CLOCK_TAI as _;
-#[cfg(any(feature = "thread", feature = "time", target_arch = "x86"))]
-pub(crate) const CLOCK_REALTIME_ALARM: c_int = linux_raw_sys::general::CLOCK_REALTIME_ALARM as _;
-
-#[cfg(feature = "system")]
-mod reboot_symbols {
-    use super::c_int;
-
-    pub(crate) const LINUX_REBOOT_MAGIC1: c_int = linux_raw_sys::general::LINUX_REBOOT_MAGIC1 as _;
-    pub(crate) const LINUX_REBOOT_MAGIC2: c_int = linux_raw_sys::general::LINUX_REBOOT_MAGIC2 as _;
-
-    pub(crate) const LINUX_REBOOT_CMD_RESTART: c_int =
-        linux_raw_sys::general::LINUX_REBOOT_CMD_RESTART as _;
-    pub(crate) const LINUX_REBOOT_CMD_HALT: c_int =
-        linux_raw_sys::general::LINUX_REBOOT_CMD_HALT as _;
-    pub(crate) const LINUX_REBOOT_CMD_CAD_ON: c_int =
-        linux_raw_sys::general::LINUX_REBOOT_CMD_CAD_ON as _;
-    pub(crate) const LINUX_REBOOT_CMD_CAD_OFF: c_int =
-        linux_raw_sys::general::LINUX_REBOOT_CMD_CAD_OFF as _;
-    pub(crate) const LINUX_REBOOT_CMD_POWER_OFF: c_int =
-        linux_raw_sys::general::LINUX_REBOOT_CMD_POWER_OFF as _;
-    pub(crate) const LINUX_REBOOT_CMD_SW_SUSPEND: c_int =
-        linux_raw_sys::general::LINUX_REBOOT_CMD_SW_SUSPEND as _;
-    pub(crate) const LINUX_REBOOT_CMD_KEXEC: c_int =
-        linux_raw_sys::general::LINUX_REBOOT_CMD_KEXEC as _;
-}
-#[cfg(feature = "system")]
-pub(crate) use reboot_symbols::*;
diff --git a/vendor/rustix/src/backend/linux_raw/conv.rs b/vendor/rustix/src/backend/linux_raw/conv.rs
deleted file mode 100644
index f0de45a..0000000
--- a/vendor/rustix/src/backend/linux_raw/conv.rs
+++ /dev/null
@@ -1,1019 +0,0 @@
-//! Convert values to [`ArgReg`] and from [`RetReg`].
-//!
-//! System call arguments and return values are all communicated with inline
-//! asm and FFI as `*mut Opaque`. To protect these raw pointers from escaping
-//! or being accidentally misused as they travel through the code, we wrap them
-//! in [`ArgReg`] and [`RetReg`] structs. This file provides `From`
-//! implementations and explicit conversion functions for converting values
-//! into and out of these wrapper structs.
-//!
-//! # Safety
-//!
-//! Some of this code is `unsafe` in order to work with raw file descriptors,
-//! and some is `unsafe` to interpret the values in a `RetReg`.
-#![allow(unsafe_code)]
-
-use super::c;
-use super::fd::{AsRawFd, BorrowedFd, FromRawFd, RawFd};
-#[cfg(any(feature = "event", feature = "runtime"))]
-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_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(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;
-use crate::io;
-#[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;
-#[cfg(any(feature = "thread", feature = "time", target_arch = "x86"))]
-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::net::socklen_t;
-
-/// Convert `SYS_*` constants for socketcall.
-#[cfg(target_arch = "x86")]
-#[inline]
-pub(super) fn x86_sys<'a, Num: ArgNumber>(sys: u32) -> ArgReg<'a, Num> {
-    pass_usize(sys as usize)
-}
-
-/// Pass the "low" half of the endian-specific memory encoding of a `u64`, for
-/// 32-bit architectures.
-#[cfg(target_pointer_width = "32")]
-#[inline]
-pub(super) fn lo<'a, Num: ArgNumber>(x: u64) -> ArgReg<'a, Num> {
-    #[cfg(target_endian = "little")]
-    let x = x >> 32;
-    #[cfg(target_endian = "big")]
-    let x = x & 0xffff_ffff;
-
-    pass_usize(x as usize)
-}
-
-/// Pass the "high" half of the endian-specific memory encoding of a `u64`, for
-/// 32-bit architectures.
-#[cfg(target_pointer_width = "32")]
-#[inline]
-pub(super) fn hi<'a, Num: ArgNumber>(x: u64) -> ArgReg<'a, Num> {
-    #[cfg(target_endian = "little")]
-    let x = x & 0xffff_ffff;
-    #[cfg(target_endian = "big")]
-    let x = x >> 32;
-
-    pass_usize(x as usize)
-}
-
-/// Pass a zero, or null, argument.
-#[inline]
-pub(super) fn zero<'a, Num: ArgNumber>() -> ArgReg<'a, Num> {
-    raw_arg(null_mut())
-}
-
-/// Pass the `mem::size_of` of a type.
-#[inline]
-pub(super) fn size_of<'a, T: Sized, Num: ArgNumber>() -> ArgReg<'a, Num> {
-    pass_usize(core::mem::size_of::<T>())
-}
-
-/// Pass an arbitrary `usize` value.
-///
-/// For passing pointers, use `void_star` or other functions which take a raw
-/// pointer instead of casting to `usize`, so that provenance is preserved.
-#[inline]
-pub(super) fn pass_usize<'a, Num: ArgNumber>(t: usize) -> ArgReg<'a, Num> {
-    raw_arg(t as *mut _)
-}
-
-impl<'a, Num: ArgNumber, T> From<*mut T> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(c: *mut T) -> ArgReg<'a, Num> {
-        raw_arg(c.cast())
-    }
-}
-
-impl<'a, Num: ArgNumber, T> From<*const T> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(c: *const T) -> ArgReg<'a, Num> {
-        let mut_ptr = c as *mut T;
-        raw_arg(mut_ptr.cast())
-    }
-}
-
-impl<'a, Num: ArgNumber> From<&'a CStr> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(c: &'a CStr) -> Self {
-        let mut_ptr = c.as_ptr() as *mut u8;
-        raw_arg(mut_ptr.cast())
-    }
-}
-
-impl<'a, Num: ArgNumber> From<Option<&'a CStr>> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(t: Option<&'a CStr>) -> Self {
-        raw_arg(match t {
-            Some(s) => {
-                let mut_ptr = s.as_ptr() as *mut u8;
-                mut_ptr.cast()
-            }
-            None => null_mut(),
-        })
-    }
-}
-
-/// Pass a borrowed file-descriptor argument.
-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.
-        unsafe { raw_fd(fd.as_raw_fd()) }
-    }
-}
-
-/// Pass a raw file-descriptor argument. Most users should use [`ArgReg::from`]
-/// instead, to preserve I/O safety as long as possible.
-///
-/// # Safety
-///
-/// `fd` must be a valid open file descriptor.
-#[inline]
-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);
-
-    // Don't pass the `io_uring_register_files_skip` sentry value this way.
-    #[cfg(feature = "io_uring")]
-    debug_assert_ne!(
-        fd,
-        crate::io_uring::io_uring_register_files_skip().as_raw_fd()
-    );
-
-    // Linux doesn't look at the high bits beyond the `c_int`, so use
-    // zero-extension rather than sign-extension because it's a smaller
-    // instruction.
-    let fd: c::c_int = fd;
-    pass_usize(fd as c::c_uint as usize)
-}
-
-/// Deliberately pass `-1` to a file-descriptor argument, for system calls
-/// like `mmap` where this indicates the argument is omitted.
-#[inline]
-pub(super) fn no_fd<'a, Num: ArgNumber>() -> ArgReg<'a, Num> {
-    pass_usize(!0_usize)
-}
-
-#[inline]
-pub(super) fn slice_just_addr<T: Sized, Num: ArgNumber>(v: &[T]) -> ArgReg<'_, Num> {
-    let mut_ptr = v.as_ptr() as *mut T;
-    raw_arg(mut_ptr.cast())
-}
-
-#[inline]
-pub(super) fn slice_just_addr_mut<T: Sized, Num: ArgNumber>(v: &mut [T]) -> ArgReg<'_, Num> {
-    raw_arg(v.as_mut_ptr().cast())
-}
-
-#[inline]
-pub(super) fn slice<T: Sized, Num0: ArgNumber, Num1: ArgNumber>(
-    v: &[T],
-) -> (ArgReg<'_, Num0>, ArgReg<'_, Num1>) {
-    (slice_just_addr(v), pass_usize(v.len()))
-}
-
-#[inline]
-pub(super) fn slice_mut<T: Sized, Num0: ArgNumber, Num1: ArgNumber>(
-    v: &mut [T],
-) -> (ArgReg<'_, Num0>, ArgReg<'_, Num1>) {
-    (raw_arg(v.as_mut_ptr().cast()), pass_usize(v.len()))
-}
-
-#[inline]
-pub(super) fn by_ref<T: Sized, Num: ArgNumber>(t: &T) -> ArgReg<'_, Num> {
-    let mut_ptr = as_ptr(t) as *mut T;
-    raw_arg(mut_ptr.cast())
-}
-
-#[inline]
-pub(super) fn by_mut<T: Sized, Num: ArgNumber>(t: &mut T) -> ArgReg<'_, Num> {
-    raw_arg(as_mut_ptr(t).cast())
-}
-
-/// Convert an optional mutable reference into a `usize` for passing to a
-/// syscall.
-#[inline]
-pub(super) fn opt_mut<T: Sized, Num: ArgNumber>(t: Option<&mut T>) -> ArgReg<'_, Num> {
-    // This optimizes into the equivalent of `transmute(t)`, and has the
-    // advantage of not requiring `unsafe`.
-    match t {
-        Some(t) => by_mut(t),
-        None => raw_arg(null_mut()),
-    }
-}
-
-/// Convert an optional immutable reference into a `usize` for passing to a
-/// syscall.
-#[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-#[inline]
-pub(super) fn opt_ref<T: Sized, Num: ArgNumber>(t: Option<&T>) -> ArgReg<'_, Num> {
-    // This optimizes into the equivalent of `transmute(t)`, and has the
-    // advantage of not requiring `unsafe`.
-    match t {
-        Some(t) => by_ref(t),
-        None => raw_arg(null_mut()),
-    }
-}
-
-/// Convert a `c_int` into an `ArgReg`.
-///
-/// Be sure to use `raw_fd` to pass `RawFd` values.
-#[inline]
-pub(super) fn c_int<'a, Num: ArgNumber>(i: c::c_int) -> ArgReg<'a, Num> {
-    pass_usize(i as usize)
-}
-
-/// Convert a `c_uint` into an `ArgReg`.
-#[inline]
-pub(super) fn c_uint<'a, Num: ArgNumber>(i: c::c_uint) -> ArgReg<'a, Num> {
-    pass_usize(i as usize)
-}
-
-#[cfg(target_pointer_width = "64")]
-#[inline]
-pub(super) fn loff_t<'a, Num: ArgNumber>(i: __kernel_loff_t) -> ArgReg<'a, Num> {
-    pass_usize(i as usize)
-}
-
-#[cfg(target_pointer_width = "64")]
-#[inline]
-pub(super) fn loff_t_from_u64<'a, Num: ArgNumber>(i: u64) -> ArgReg<'a, Num> {
-    // `loff_t` is signed, but syscalls which expect `loff_t` return `EINVAL`
-    // if it's outside the signed `i64` range, so we can silently cast.
-    pass_usize(i as usize)
-}
-
-#[cfg(any(feature = "thread", feature = "time", target_arch = "x86"))]
-impl<'a, Num: ArgNumber> From<ClockId> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(i: ClockId) -> Self {
-        pass_usize(i as __kernel_clockid_t as usize)
-    }
-}
-
-#[cfg(feature = "time")]
-impl<'a, Num: ArgNumber> From<TimerfdClockId> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(i: TimerfdClockId) -> Self {
-        pass_usize(i as __kernel_clockid_t as usize)
-    }
-}
-
-#[cfg(feature = "net")]
-#[inline]
-pub(super) fn socklen_t<'a, Num: ArgNumber>(i: socklen_t) -> ArgReg<'a, Num> {
-    pass_usize(i as usize)
-}
-
-#[cfg(any(
-    feature = "fs",
-    all(
-        not(feature = "use-libc-auxv"),
-        not(feature = "use-explicitly-provided-auxv"),
-        any(
-            feature = "param",
-            feature = "process",
-            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)
-        }
-    }
-
-    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())
-        }
-    }
-
-    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 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")]
-    #[inline]
-    const fn oflags_bits(oflags: OFlags) -> c::c_uint {
-        oflags.bits()
-    }
-
-    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]
-    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())
-        }
-    }
-}
-
-#[cfg(any(feature = "fs", feature = "mount"))]
-impl<'a, Num: ArgNumber> From<crate::backend::mount::types::MountFlagsArg> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mount::types::MountFlagsArg) -> Self {
-        c_uint(flags.0)
-    }
-}
-
-// When the deprecated "fs" aliases are removed, we can remove the "fs"
-// here too.
-#[cfg(any(feature = "fs", feature = "mount"))]
-impl<'a, Num: ArgNumber> From<crate::backend::mount::types::UnmountFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mount::types::UnmountFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mount")]
-impl<'a, Num: ArgNumber> From<crate::mount::FsConfigCmd> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(cmd: crate::mount::FsConfigCmd) -> Self {
-        c_uint(cmd as c::c_uint)
-    }
-}
-
-#[cfg(feature = "mount")]
-impl<'a, Num: ArgNumber> From<crate::backend::mount::types::FsOpenFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mount::types::FsOpenFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mount")]
-impl<'a, Num: ArgNumber> From<crate::backend::mount::types::FsMountFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mount::types::FsMountFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mount")]
-impl<'a, Num: ArgNumber> From<crate::backend::mount::types::MountAttrFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mount::types::MountAttrFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mount")]
-impl<'a, Num: ArgNumber> From<crate::backend::mount::types::OpenTreeFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mount::types::OpenTreeFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mount")]
-impl<'a, Num: ArgNumber> From<crate::backend::mount::types::FsPickFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mount::types::FsPickFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mount")]
-impl<'a, Num: ArgNumber> From<crate::backend::mount::types::MoveMountFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mount::types::MoveMountFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-impl<'a, Num: ArgNumber> From<crate::io::FdFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::io::FdFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "pipe")]
-impl<'a, Num: ArgNumber> From<crate::pipe::PipeFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::pipe::PipeFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "pipe")]
-impl<'a, Num: ArgNumber> From<crate::pipe::SpliceFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::pipe::SpliceFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-impl<'a, Num: ArgNumber> From<crate::io::DupFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::io::DupFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-impl<'a, Num: ArgNumber> From<crate::io::ReadWriteFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::io::ReadWriteFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "process")]
-impl<'a, Num: ArgNumber> From<crate::process::PidfdFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::process::PidfdFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "pty")]
-impl<'a, Num: ArgNumber> From<crate::pty::OpenptFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::pty::OpenptFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "thread")]
-impl<'a, Num: ArgNumber> From<crate::thread::UnshareFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::thread::UnshareFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "event")]
-impl<'a, Num: ArgNumber> From<crate::event::EventfdFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::event::EventfdFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "event")]
-impl<'a, Num: ArgNumber> From<crate::event::epoll::CreateFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::event::epoll::CreateFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mm")]
-impl<'a, Num: ArgNumber> From<crate::backend::mm::types::ProtFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mm::types::ProtFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mm")]
-impl<'a, Num: ArgNumber> From<crate::backend::mm::types::MsyncFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mm::types::MsyncFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mm")]
-impl<'a, Num: ArgNumber> From<crate::backend::mm::types::MremapFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mm::types::MremapFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mm")]
-impl<'a, Num: ArgNumber> From<crate::backend::mm::types::MlockFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mm::types::MlockFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mm")]
-impl<'a, Num: ArgNumber> From<crate::backend::mm::types::MlockAllFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mm::types::MlockAllFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mm")]
-impl<'a, Num: ArgNumber> From<crate::backend::mm::types::MapFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mm::types::MapFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mm")]
-impl<'a, Num: ArgNumber> From<crate::backend::mm::types::MprotectFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mm::types::MprotectFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "mm")]
-impl<'a, Num: ArgNumber> From<crate::backend::mm::types::UserfaultfdFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::backend::mm::types::UserfaultfdFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "process")]
-impl<'a, Num: ArgNumber> From<crate::backend::process::types::MembarrierCommand>
-    for ArgReg<'a, Num>
-{
-    #[inline]
-    fn from(cmd: crate::backend::process::types::MembarrierCommand) -> Self {
-        c_uint(cmd as u32)
-    }
-}
-
-#[cfg(feature = "process")]
-impl<'a, Num: ArgNumber> From<crate::process::Cpuid> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(cpuid: crate::process::Cpuid) -> Self {
-        c_uint(cpuid.as_raw())
-    }
-}
-
-#[cfg(target_pointer_width = "64")]
-#[inline]
-pub(super) fn dev_t<'a, Num: ArgNumber>(dev: u64) -> ArgReg<'a, Num> {
-    pass_usize(dev as usize)
-}
-
-#[cfg(target_pointer_width = "32")]
-#[inline]
-pub(super) fn dev_t<'a, Num: ArgNumber>(dev: u64) -> io::Result<ArgReg<'a, Num>> {
-    Ok(pass_usize(dev.try_into().map_err(|_err| io::Errno::INVAL)?))
-}
-
-/// 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 {
-        c_uint(resource as c::c_uint)
-    }
-}
-
-#[cfg(any(feature = "process", feature = "runtime", feature = "termios"))]
-impl<'a, Num: ArgNumber> From<Pid> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(pid: Pid) -> Self {
-        pass_usize(pid.as_raw_nonzero().get() as usize)
-    }
-}
-
-#[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 {
-        pass_usize(sig as usize)
-    }
-}
-
-#[cfg(feature = "io_uring")]
-impl<'a, Num: ArgNumber> From<crate::io_uring::IoringEnterFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::io_uring::IoringEnterFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "time")]
-impl<'a, Num: ArgNumber> From<crate::time::TimerfdFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::time::TimerfdFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "time")]
-impl<'a, Num: ArgNumber> From<crate::time::TimerfdTimerFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::time::TimerfdTimerFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "rand")]
-impl<'a, Num: ArgNumber> From<crate::rand::GetRandomFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::rand::GetRandomFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "net")]
-impl<'a, Num: ArgNumber> From<crate::net::RecvFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::net::RecvFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "net")]
-impl<'a, Num: ArgNumber> From<crate::net::SendFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::net::SendFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "net")]
-impl<'a, Num: ArgNumber> From<crate::net::SocketFlags> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::net::SocketFlags) -> Self {
-        c_uint(flags.bits())
-    }
-}
-
-#[cfg(feature = "net")]
-impl<'a, Num: ArgNumber> From<crate::net::AddressFamily> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(family: crate::net::AddressFamily) -> Self {
-        c_uint(family.0.into())
-    }
-}
-
-#[cfg(feature = "net")]
-impl<'a, Num: ArgNumber> From<(crate::net::SocketType, crate::net::SocketFlags)>
-    for ArgReg<'a, Num>
-{
-    #[inline]
-    fn from(pair: (crate::net::SocketType, crate::net::SocketFlags)) -> Self {
-        c_uint(pair.0 .0 | pair.1.bits())
-    }
-}
-
-#[cfg(feature = "thread")]
-impl<'a, Num: ArgNumber> From<(crate::thread::FutexOperation, crate::thread::FutexFlags)>
-    for ArgReg<'a, Num>
-{
-    #[inline]
-    fn from(pair: (crate::thread::FutexOperation, crate::thread::FutexFlags)) -> Self {
-        c_uint(pair.0 as u32 | pair.1.bits())
-    }
-}
-
-#[cfg(feature = "net")]
-impl<'a, Num: ArgNumber> From<crate::net::SocketType> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(type_: crate::net::SocketType) -> Self {
-        c_uint(type_.0)
-    }
-}
-
-#[cfg(feature = "net")]
-impl<'a, Num: ArgNumber> From<Option<crate::net::Protocol>> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(protocol: Option<crate::net::Protocol>) -> Self {
-        c_uint(match protocol {
-            Some(p) => p.0.get(),
-            None => 0,
-        })
-    }
-}
-
-impl<'a, Num: ArgNumber, T> From<&'a mut MaybeUninit<T>> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(t: &'a mut MaybeUninit<T>) -> Self {
-        raw_arg(t.as_mut_ptr().cast())
-    }
-}
-
-impl<'a, Num: ArgNumber, T> From<&'a mut [MaybeUninit<T>]> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(t: &'a mut [MaybeUninit<T>]) -> Self {
-        raw_arg(t.as_mut_ptr().cast())
-    }
-}
-
-#[cfg(any(feature = "process", feature = "thread"))]
-impl<'a, Num: ArgNumber> From<crate::ugid::Uid> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(t: crate::ugid::Uid) -> Self {
-        c_uint(t.as_raw())
-    }
-}
-
-#[cfg(any(feature = "process", feature = "thread"))]
-impl<'a, Num: ArgNumber> From<crate::ugid::Gid> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(t: crate::ugid::Gid) -> Self {
-        c_uint(t.as_raw())
-    }
-}
-
-#[cfg(feature = "runtime")]
-impl<'a, Num: ArgNumber> From<crate::runtime::How> for ArgReg<'a, Num> {
-    #[inline]
-    fn from(flags: crate::runtime::How) -> Self {
-        c_uint(flags as u32)
-    }
-}
-
-/// Convert a `usize` returned from a syscall that effectively returns `()` on
-/// success.
-///
-/// # Safety
-///
-/// The caller must ensure that this is the return value of a syscall which
-/// just returns 0 on success.
-#[inline]
-pub(super) unsafe fn ret(raw: RetReg<R0>) -> io::Result<()> {
-    try_decode_void(raw)
-}
-
-/// Convert a `usize` returned from a syscall that doesn't return on success.
-///
-/// # Safety
-///
-/// The caller must ensure that this is the return value of a syscall which
-/// doesn't return on success.
-#[cfg(any(feature = "event", feature = "runtime"))]
-#[inline]
-pub(super) unsafe fn ret_error(raw: RetReg<R0>) -> io::Errno {
-    try_decode_error(raw)
-}
-
-/// Convert a `usize` returned from a syscall that effectively always returns
-/// `()`.
-///
-/// # Safety
-///
-/// The caller must ensure that this is the return value of a syscall which
-/// always returns `()`.
-#[inline]
-pub(super) unsafe fn ret_infallible(raw: RetReg<R0>) {
-    #[cfg(debug_assertions)]
-    {
-        try_decode_void(raw).unwrap()
-    }
-    #[cfg(not(debug_assertions))]
-    drop(raw);
-}
-
-/// Convert a `usize` returned from a syscall that effectively returns a
-/// `c_int` on success.
-#[inline]
-pub(super) fn ret_c_int(raw: RetReg<R0>) -> io::Result<c::c_int> {
-    try_decode_c_int(raw)
-}
-
-/// Convert a `usize` returned from a syscall that effectively returns a
-/// `c_uint` on success.
-#[inline]
-pub(super) fn ret_c_uint(raw: RetReg<R0>) -> io::Result<c::c_uint> {
-    try_decode_c_uint(raw)
-}
-
-/// Convert a `usize` returned from a syscall that effectively returns a `u64`
-/// on success.
-#[cfg(target_pointer_width = "64")]
-#[inline]
-pub(super) fn ret_u64(raw: RetReg<R0>) -> io::Result<u64> {
-    try_decode_u64(raw)
-}
-
-/// Convert a `usize` returned from a syscall that effectively returns a
-/// `usize` on success.
-#[inline]
-pub(super) fn ret_usize(raw: RetReg<R0>) -> io::Result<usize> {
-    try_decode_usize(raw)
-}
-
-/// Convert a `usize` returned from a syscall that effectively always
-/// returns a `usize`.
-///
-/// # Safety
-///
-/// This function must only be used with return values from infallible
-/// syscalls.
-#[inline]
-pub(super) unsafe fn ret_usize_infallible(raw: RetReg<R0>) -> usize {
-    #[cfg(debug_assertions)]
-    {
-        try_decode_usize(raw).unwrap()
-    }
-    #[cfg(not(debug_assertions))]
-    {
-        decode_usize_infallible(raw)
-    }
-}
-
-/// 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`.
-///
-/// # Safety
-///
-/// This function must only be used with return values from infallible
-/// syscalls.
-#[inline]
-pub(super) unsafe fn ret_c_uint_infallible(raw: RetReg<R0>) -> c::c_uint {
-    #[cfg(debug_assertions)]
-    {
-        try_decode_c_uint(raw).unwrap()
-    }
-    #[cfg(not(debug_assertions))]
-    {
-        decode_c_uint_infallible(raw)
-    }
-}
-
-/// Convert a `usize` returned from a syscall that effectively returns an
-/// `OwnedFd` on success.
-///
-/// # Safety
-///
-/// The caller must ensure that this is the return value of a syscall which
-/// returns an owned file descriptor.
-#[inline]
-pub(super) unsafe fn ret_owned_fd(raw: RetReg<R0>) -> io::Result<OwnedFd> {
-    let raw_fd = try_decode_raw_fd(raw)?;
-    Ok(crate::backend::fd::OwnedFd::from_raw_fd(raw_fd))
-}
-
-/// Convert the return value of `dup2` and `dup3`.
-///
-/// When these functions succeed, they return the same value as their second
-/// argument, so we don't construct a new `OwnedFd`.
-///
-/// # Safety
-///
-/// The caller must ensure that this is the return value of a syscall which
-/// returns a file descriptor.
-#[inline]
-pub(super) unsafe fn ret_discarded_fd(raw: RetReg<R0>) -> io::Result<()> {
-    let _raw_fd = try_decode_raw_fd(raw)?;
-    Ok(())
-}
-
-/// Convert a `usize` returned from a syscall that effectively returns a
-/// `*mut c_void` on success.
-#[inline]
-pub(super) fn ret_void_star(raw: RetReg<R0>) -> io::Result<*mut c::c_void> {
-    try_decode_void_star(raw)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/event/epoll.rs b/vendor/rustix/src/backend/linux_raw/event/epoll.rs
deleted file mode 100644
index 3d5787b..0000000
--- a/vendor/rustix/src/backend/linux_raw/event/epoll.rs
+++ /dev/null
@@ -1,470 +0,0 @@
-//! Linux `epoll` support.
-//!
-//! # Examples
-//!
-//! ```no_run
-//! # #[cfg(feature = "net")]
-//! # fn main() -> std::io::Result<()> {
-//! 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, 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, 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::create(epoll::CreateFlags::CLOEXEC)?;
-//!
-//! // Register the socket with the epoll object.
-//! 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 = epoll::EventData::new_u64(2);
-//! let mut sockets = HashMap::new();
-//!
-//! // Process events.
-//! let mut event_list = epoll::EventVec::with_capacity(4);
-//! loop {
-//!     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::add(
-//!                 &epoll,
-//!                 &conn_sock,
-//!                 next_id,
-//!                 epoll::EventFlags::OUT | epoll::EventFlags::ET,
-//!             )?;
-//!
-//!             // Keep track of the socket.
-//!             sockets.insert(next_id, conn_sock);
-//!             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::delete(&epoll, &target)?;
-//!         }
-//!     }
-//! }
-//! # }
-//! # #[cfg(not(feature = "net"))]
-//! # fn main() {}
-//! ```
-
-#![allow(unsafe_code)]
-
-use crate::backend::c;
-use crate::backend::event::syscalls;
-use crate::fd::{AsFd, AsRawFd, OwnedFd};
-use crate::io;
-#[cfg(feature = "alloc")]
-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 [`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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `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;
-
-        /// `EPOLLOUT`
-        const OUT = linux_raw_sys::general::EPOLLOUT as u32;
-
-        /// `EPOLLPRI`
-        const PRI = linux_raw_sys::general::EPOLLPRI as u32;
-
-        /// `EPOLLERR`
-        const ERR = linux_raw_sys::general::EPOLLERR as u32;
-
-        /// `EPOLLHUP`
-        const HUP = linux_raw_sys::general::EPOLLHUP as u32;
-
-        /// `EPOLLRDNORM`
-        const RDNORM = linux_raw_sys::general::EPOLLRDNORM as u32;
-
-        /// `EPOLLRDBAND`
-        const RDBAND = linux_raw_sys::general::EPOLLRDBAND as u32;
-
-        /// `EPOLLWRNORM`
-        const WRNORM = linux_raw_sys::general::EPOLLWRNORM as u32;
-
-        /// `EPOLLWRBAND`
-        const WRBAND = linux_raw_sys::general::EPOLLWRBAND as u32;
-
-        /// `EPOLLMSG`
-        const MSG = linux_raw_sys::general::EPOLLMSG as u32;
-
-        /// `EPOLLRDHUP`
-        const RDHUP = linux_raw_sys::general::EPOLLRDHUP as u32;
-
-        /// `EPOLLET`
-        const ET = linux_raw_sys::general::EPOLLET as u32;
-
-        /// `EPOLLONESHOT`
-        const ONESHOT = linux_raw_sys::general::EPOLLONESHOT as u32;
-
-        /// `EPOLLWAKEUP`
-        const WAKEUP = linux_raw_sys::general::EPOLLWAKEUP as u32;
-
-        /// `EPOLLEXCLUSIVE`
-        const EXCLUSIVE = linux_raw_sys::general::EPOLLEXCLUSIVE as u32;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `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 create(flags: CreateFlags) -> io::Result<OwnedFd> {
-    syscalls::epoll_create(flags)
-}
-
-/// `epoll_ctl(self, EPOLL_CTL_ADD, data, event)`—Adds an element to an epoll
-/// object.
-///
-/// 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")]
-#[inline]
-pub fn add(
-    epoll: impl AsFd,
-    source: impl AsFd,
-    data: EventData,
-    event_flags: EventFlags,
-) -> io::Result<()> {
-    // SAFETY: We're calling `epoll_ctl` via FFI and we know how it
-    // behaves.
-    unsafe {
-        syscalls::epoll_add(
-            epoll.as_fd(),
-            source.as_fd().as_raw_fd(),
-            &Event {
-                flags: event_flags,
-                data,
-            },
-        )
-    }
-}
-
-/// `epoll_ctl(self, EPOLL_CTL_MOD, target, event)`—Modifies an element in a
-/// given epoll object.
-///
-/// This sets the events of interest with `target` to `events`.
-#[doc(alias = "epoll_ctl")]
-#[inline]
-pub fn modify(
-    epoll: impl AsFd,
-    source: impl AsFd,
-    data: EventData,
-    event_flags: EventFlags,
-) -> io::Result<()> {
-    // SAFETY: We're calling `epoll_ctl` via FFI and we know how it
-    // behaves.
-    unsafe {
-        let raw_fd = source.as_fd().as_raw_fd();
-        syscalls::epoll_mod(
-            epoll.as_fd(),
-            raw_fd,
-            &Event {
-                flags: event_flags,
-                data,
-            },
-        )
-    }
-}
-
-/// `epoll_ctl(self, EPOLL_CTL_DEL, target, NULL)`—Removes an element in a
-/// given epoll object.
-#[doc(alias = "epoll_ctl")]
-#[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 {
-        let raw_fd = source.as_fd().as_raw_fd();
-        syscalls::epoll_del(epoll.as_fd(), raw_fd)
-    }
-}
-
-/// `epoll_wait(self, events, timeout)`—Waits for registered events of
-/// interest.
-///
-/// For each event of interest, an element is written to `events`. On
-/// success, this returns the number of written elements.
-#[cfg(feature = "alloc")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
-#[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 {
-        event_list.events.set_len(0);
-        let nfds = syscalls::epoll_wait(
-            epoll.as_fd(),
-            event_list.events[..].as_mut_ptr().cast(),
-            event_list.events.capacity(),
-            timeout,
-        )?;
-        event_list.events.set_len(nfds);
-    }
-
-    Ok(())
-}
-
-/// An iterator over the `Event`s in an `EventVec`.
-pub struct Iter<'a> {
-    /// 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 = Event;
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next()
-    }
-}
-
-/// A record of an event that occurred.
-#[repr(C)]
-#[cfg_attr(target_arch = "x86_64", repr(packed))]
-#[derive(Copy, Clone, Eq, PartialEq, Hash)]
-pub struct Event {
-    /// Which specific event(s) occurred.
-    pub flags: EventFlags,
-    /// User data.
-    pub data: EventData,
-}
-
-/// Data associated 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.
-#[cfg(feature = "alloc")]
-pub struct EventVec {
-    events: Vec<Event>,
-}
-
-#[cfg(feature = "alloc")]
-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 {
-        Self {
-            events: Vec::with_capacity(capacity),
-        }
-    }
-
-    /// Returns the current `Event` capacity of this `EventVec`.
-    #[inline]
-    pub fn capacity(&self) -> usize {
-        self.events.capacity()
-    }
-
-    /// Reserves enough memory for at least `additional` more `Event`s.
-    #[inline]
-    pub fn reserve(&mut self, additional: usize) {
-        self.events.reserve(additional);
-    }
-
-    /// Reserves enough memory for exactly `additional` more `Event`s.
-    #[inline]
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.events.reserve_exact(additional);
-    }
-
-    /// Clears all the `Events` out of this `EventVec`.
-    #[inline]
-    pub fn clear(&mut self) {
-        self.events.clear();
-    }
-
-    /// Shrinks the capacity of this `EventVec` as much as possible.
-    #[inline]
-    pub fn shrink_to_fit(&mut self) {
-        self.events.shrink_to_fit();
-    }
-
-    /// Returns an iterator over the `Event`s in this `EventVec`.
-    #[inline]
-    pub fn iter(&self) -> Iter<'_> {
-        Iter {
-            iter: self.events.iter().copied(),
-        }
-    }
-
-    /// Returns the number of `Event`s logically contained in this `EventVec`.
-    #[inline]
-    pub fn len(&mut self) -> usize {
-        self.events.len()
-    }
-
-    /// Tests whether this `EventVec` is logically empty.
-    #[inline]
-    pub fn is_empty(&mut self) -> bool {
-        self.events.is_empty()
-    }
-}
-
-#[cfg(feature = "alloc")]
-impl<'a> IntoIterator for &'a EventVec {
-    type IntoIter = Iter<'a>;
-    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
deleted file mode 100644
index 605de25..0000000
--- a/vendor/rustix/src/backend/linux_raw/event/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-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/event/poll_fd.rs b/vendor/rustix/src/backend/linux_raw/event/poll_fd.rs
deleted file mode 100644
index 9de43f2..0000000
--- a/vendor/rustix/src/backend/linux_raw/event/poll_fd.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use crate::fd::{AsFd, BorrowedFd};
-use bitflags::bitflags;
-
-bitflags! {
-    /// `POLL*` flags for use with [`poll`].
-    ///
-    /// [`poll`]: crate::event::poll
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct PollFlags: u16 {
-        /// `POLLIN`
-        const IN = linux_raw_sys::general::POLLIN as u16;
-        /// `POLLPRI`
-        const PRI = linux_raw_sys::general::POLLPRI as u16;
-        /// `POLLOUT`
-        const OUT = linux_raw_sys::general::POLLOUT as u16;
-        /// `POLLRDNORM`
-        const RDNORM = linux_raw_sys::general::POLLRDNORM as u16;
-        /// `POLLWRNORM`
-        const WRNORM = linux_raw_sys::general::POLLWRNORM as u16;
-        /// `POLLRDBAND`
-        const RDBAND = linux_raw_sys::general::POLLRDBAND as u16;
-        /// `POLLWRBAND`
-        const WRBAND = linux_raw_sys::general::POLLWRBAND as u16;
-        /// `POLLERR`
-        const ERR = linux_raw_sys::general::POLLERR as u16;
-        /// `POLLHUP`
-        const HUP = linux_raw_sys::general::POLLHUP as u16;
-        /// `POLLNVAL`
-        const NVAL = linux_raw_sys::general::POLLNVAL as u16;
-        /// `POLLRDHUP`
-        const RDHUP = linux_raw_sys::general::POLLRDHUP as u16;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `struct pollfd`—File descriptor and flags for use with [`poll`].
-///
-/// [`poll`]: crate::event::poll
-#[doc(alias = "pollfd")]
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct PollFd<'fd> {
-    pub(crate) fd: BorrowedFd<'fd>,
-    pub(crate) events: u16,
-    pub(crate) revents: u16,
-}
-
-impl<'fd> PollFd<'fd> {
-    /// Constructs a new `PollFd` holding `fd` and `events`.
-    #[inline]
-    pub fn new<Fd: AsFd>(fd: &'fd Fd, events: PollFlags) -> Self {
-        Self::from_borrowed_fd(fd.as_fd(), events)
-    }
-
-    /// Sets the contained file descriptor to `fd`.
-    #[inline]
-    pub fn set_fd<Fd: AsFd>(&mut self, fd: &'fd Fd) {
-        self.fd = fd.as_fd();
-    }
-
-    /// Clears the ready events.
-    #[inline]
-    pub fn clear_revents(&mut self) {
-        self.revents = 0;
-    }
-
-    /// Constructs a new `PollFd` holding `fd` and `events`.
-    ///
-    /// This is the same as `new`, but can be used to avoid borrowing the
-    /// `BorrowedFd`, which can be tricky in situations where the `BorrowedFd`
-    /// is a temporary.
-    #[inline]
-    pub fn from_borrowed_fd(fd: BorrowedFd<'fd>, events: PollFlags) -> Self {
-        Self {
-            fd,
-            events: events.bits(),
-            revents: 0,
-        }
-    }
-
-    /// Returns the ready events.
-    #[inline]
-    pub fn revents(&self) -> PollFlags {
-        // Use `.unwrap()` here because in theory we know we know all the bits
-        // the OS might set here, but OS's have added extensions in the past.
-        PollFlags::from_bits(self.revents).unwrap()
-    }
-}
-
-impl<'fd> AsFd for PollFd<'fd> {
-    #[inline]
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        self.fd.as_fd()
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/event/syscalls.rs b/vendor/rustix/src/backend/linux_raw/event/syscalls.rs
deleted file mode 100644
index 0ae7753..0000000
--- a/vendor/rustix/src/backend/linux_raw/event/syscalls.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-//! linux_raw syscalls supporting `rustix::event`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use crate::backend::c;
-#[cfg(feature = "alloc")]
-use crate::backend::conv::pass_usize;
-use crate::backend::conv::{
-    by_ref, c_int, c_uint, raw_fd, ret, ret_error, 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()
-    ))
-}
-
-#[cfg(feature = "alloc")]
-#[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)) }
-}
-
-#[inline]
-pub(crate) fn pause() {
-    unsafe {
-        #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-        let error = ret_error(syscall_readonly!(
-            __NR_ppoll,
-            zero(),
-            zero(),
-            zero(),
-            zero()
-        ));
-
-        #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
-        let error = ret_error(syscall_readonly!(__NR_pause));
-
-        debug_assert_eq!(error, io::Errno::INTR);
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/event/types.rs b/vendor/rustix/src/backend/linux_raw/event/types.rs
deleted file mode 100644
index 01611f6..0000000
--- a/vendor/rustix/src/backend/linux_raw/event/types.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `EFD_*` flags for use with [`eventfd`].
-    ///
-    /// [`eventfd`]: crate::event::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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/fs/dir.rs b/vendor/rustix/src/backend/linux_raw/fs/dir.rs
deleted file mode 100644
index dbddd58..0000000
--- a/vendor/rustix/src/backend/linux_raw/fs/dir.rs
+++ /dev/null
@@ -1,315 +0,0 @@
-use crate::fd::{AsFd, BorrowedFd, OwnedFd};
-use crate::ffi::{CStr, CString};
-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;
-use alloc::vec::Vec;
-use core::fmt;
-use core::mem::size_of;
-use linux_raw_sys::general::{linux_dirent64, SEEK_SET};
-
-/// `DIR*`
-pub struct Dir {
-    /// The `OwnedFd` that we read directory entries from.
-    fd: OwnedFd,
-
-    /// Have we seen any errors in this iteration?
-    any_errors: bool,
-
-    /// Should we rewind the stream on the next iteration?
-    rewind: bool,
-
-    /// The buffer for `linux_dirent64` entries.
-    buf: Vec<u8>,
-
-    /// Where we are in the buffer.
-    pos: usize,
-}
-
-impl Dir {
-    /// Take ownership of `fd` and construct a `Dir` that reads entries from
-    /// the given directory file descriptor.
-    #[inline]
-    pub fn new<Fd: Into<OwnedFd>>(fd: Fd) -> io::Result<Self> {
-        Self::_new(fd.into())
-    }
-
-    #[inline]
-    fn _new(fd: OwnedFd) -> io::Result<Self> {
-        Ok(Self {
-            fd,
-            any_errors: false,
-            rewind: false,
-            buf: Vec::new(),
-            pos: 0,
-        })
-    }
-
-    /// Borrow `fd` and construct a `Dir` that reads entries from the given
-    /// directory file descriptor.
-    #[inline]
-    pub fn read_from<Fd: AsFd>(fd: Fd) -> io::Result<Self> {
-        Self::_read_from(fd.as_fd())
-    }
-
-    #[inline]
-    fn _read_from(fd: BorrowedFd<'_>) -> io::Result<Self> {
-        let flags = fcntl_getfl(fd)?;
-        let fd_for_dir = openat(fd, cstr!("."), flags | OFlags::CLOEXEC, Mode::empty())?;
-
-        Ok(Self {
-            fd: fd_for_dir,
-            any_errors: false,
-            rewind: false,
-            buf: Vec::new(),
-            pos: 0,
-        })
-    }
-
-    /// `rewinddir(self)`
-    #[inline]
-    pub fn rewind(&mut self) {
-        self.any_errors = false;
-        self.rewind = true;
-        self.pos = self.buf.len();
-    }
-
-    /// `readdir(self)`, where `None` means the end of the directory.
-    pub fn read(&mut self) -> Option<io::Result<DirEntry>> {
-        // If we've seen errors, don't continue to try to read anyting further.
-        if self.any_errors {
-            return None;
-        }
-
-        // If a rewind was requested, seek to the beginning.
-        if self.rewind {
-            self.rewind = false;
-            match io::retry_on_intr(|| {
-                crate::backend::fs::syscalls::_seek(self.fd.as_fd(), 0, SEEK_SET)
-            }) {
-                Ok(_) => (),
-                Err(err) => {
-                    self.any_errors = true;
-                    return Some(Err(err));
-                }
-            }
-        }
-
-        // Compute linux_dirent64 field offsets.
-        let z = linux_dirent64 {
-            d_ino: 0_u64,
-            d_off: 0_i64,
-            d_type: 0_u8,
-            d_reclen: 0_u16,
-            d_name: Default::default(),
-        };
-        let base = as_ptr(&z) as usize;
-        let offsetof_d_reclen = (as_ptr(&z.d_reclen) as usize) - base;
-        let offsetof_d_name = (as_ptr(&z.d_name) as usize) - base;
-        let offsetof_d_ino = (as_ptr(&z.d_ino) as usize) - base;
-        let offsetof_d_type = (as_ptr(&z.d_type) as usize) - base;
-
-        // Test if we need more entries, and if so, read more.
-        if self.buf.len() - self.pos < size_of::<linux_dirent64>() {
-            match self.read_more()? {
-                Ok(()) => (),
-                Err(err) => return Some(Err(err)),
-            }
-        }
-
-        // We successfully read an entry. Extract the fields.
-        let pos = self.pos;
-
-        // Do an unaligned u16 load.
-        let d_reclen = u16::from_ne_bytes([
-            self.buf[pos + offsetof_d_reclen],
-            self.buf[pos + offsetof_d_reclen + 1],
-        ]);
-        assert!(self.buf.len() - pos >= d_reclen as usize);
-        self.pos += d_reclen as usize;
-
-        // Read the NUL-terminated name from the `d_name` field. Without
-        // `unsafe`, we need to scan for the NUL twice: once to obtain a size
-        // for the slice, and then once within `CStr::from_bytes_with_nul`.
-        let name_start = pos + offsetof_d_name;
-        let name_len = self.buf[name_start..]
-            .iter()
-            .position(|x| *x == b'\0')
-            .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);
-
-        // Do an unaligned u64 load.
-        let d_ino = u64::from_ne_bytes([
-            self.buf[pos + offsetof_d_ino],
-            self.buf[pos + offsetof_d_ino + 1],
-            self.buf[pos + offsetof_d_ino + 2],
-            self.buf[pos + offsetof_d_ino + 3],
-            self.buf[pos + offsetof_d_ino + 4],
-            self.buf[pos + offsetof_d_ino + 5],
-            self.buf[pos + offsetof_d_ino + 6],
-            self.buf[pos + offsetof_d_ino + 7],
-        ]);
-
-        let d_type = self.buf[pos + offsetof_d_type];
-
-        // Check that our types correspond to the `linux_dirent64` types.
-        let _ = linux_dirent64 {
-            d_ino,
-            d_off: 0,
-            d_type,
-            d_reclen,
-            d_name: Default::default(),
-        };
-
-        Some(Ok(DirEntry {
-            d_ino,
-            d_type,
-            name,
-        }))
-    }
-
-    #[must_use]
-    fn read_more(&mut self) -> Option<io::Result<()>> {
-        // The first few times we're called, we allocate a relatively small
-        // buffer, because many directories are small. If we're called more,
-        // use progressively larger allocations, up to a fixed maximum.
-        //
-        // The specific sizes and policy here have not been tuned in detail yet
-        // and may need to be adjusted. In doing so, we should be careful to
-        // avoid unbounded buffer growth. This buffer only exists to share the
-        // cost of a `getdents` call over many entries, so if it gets too big,
-        // cache and heap usage will outweigh the benefit. And ultimately,
-        // directories can contain more entries than we can allocate contiguous
-        // memory for, so we'll always need to cap the size at some point.
-        if self.buf.len() < 1024 * size_of::<linux_dirent64>() {
-            self.buf.reserve(32 * size_of::<linux_dirent64>());
-        }
-        self.buf.resize(self.buf.capacity(), 0);
-        let nread = match io::retry_on_intr(|| {
-            crate::backend::fs::syscalls::getdents(self.fd.as_fd(), &mut self.buf)
-        }) {
-            Ok(nread) => nread,
-            Err(io::Errno::NOENT) => {
-                self.any_errors = true;
-                return None;
-            }
-            Err(err) => {
-                self.any_errors = true;
-                return Some(Err(err));
-            }
-        };
-        self.buf.resize(nread, 0);
-        self.pos = 0;
-        if nread == 0 {
-            None
-        } else {
-            Some(Ok(()))
-        }
-    }
-
-    /// `fstat(self)`
-    #[inline]
-    pub fn stat(&self) -> io::Result<Stat> {
-        fstat(&self.fd)
-    }
-
-    /// `fstatfs(self)`
-    #[inline]
-    pub fn statfs(&self) -> io::Result<StatFs> {
-        fstatfs(&self.fd)
-    }
-
-    /// `fstatvfs(self)`
-    #[inline]
-    pub fn statvfs(&self) -> io::Result<StatVfs> {
-        fstatvfs(&self.fd)
-    }
-
-    /// `fchdir(self)`
-    #[cfg(feature = "process")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "process")))]
-    #[inline]
-    pub fn chdir(&self) -> io::Result<()> {
-        fchdir(&self.fd)
-    }
-}
-
-impl Iterator for Dir {
-    type Item = io::Result<DirEntry>;
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        Self::read(self)
-    }
-}
-
-impl fmt::Debug for Dir {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Dir").field("fd", &self.fd).finish()
-    }
-}
-
-/// `struct dirent`
-#[derive(Debug)]
-pub struct DirEntry {
-    d_ino: u64,
-    d_type: u8,
-    name: CString,
-}
-
-impl DirEntry {
-    /// Returns the file name of this directory entry.
-    #[inline]
-    pub fn file_name(&self) -> &CStr {
-        &self.name
-    }
-
-    /// Returns the type of this directory entry.
-    #[inline]
-    pub fn file_type(&self) -> FileType {
-        FileType::from_dirent_d_type(self.d_type)
-    }
-
-    /// Return the inode number of this directory entry.
-    #[inline]
-    pub fn ino(&self) -> u64 {
-        self.d_ino
-    }
-}
-
-#[test]
-fn dir_iterator_handles_io_errors() {
-    // create a dir, keep the FD, then delete the dir
-    let tmp = tempfile::tempdir().unwrap();
-    let fd = crate::fs::openat(
-        crate::fs::CWD,
-        tmp.path(),
-        crate::fs::OFlags::RDONLY | crate::fs::OFlags::CLOEXEC,
-        crate::fs::Mode::empty(),
-    )
-    .unwrap();
-
-    let file_fd = crate::fs::openat(
-        &fd,
-        tmp.path().join("test.txt"),
-        crate::fs::OFlags::WRONLY | crate::fs::OFlags::CREATE,
-        crate::fs::Mode::RWXU,
-    )
-    .unwrap();
-
-    let mut dir = Dir::read_from(&fd).unwrap();
-
-    // Reach inside the `Dir` and replace its directory with a file, which
-    // will cause the subsequent `getdents64` to fail.
-    crate::io::dup2(&file_fd, &mut dir.fd).unwrap();
-
-    assert!(matches!(dir.next(), Some(Err(_))));
-    assert!(dir.next().is_none());
-}
diff --git a/vendor/rustix/src/backend/linux_raw/fs/inotify.rs b/vendor/rustix/src/backend/linux_raw/fs/inotify.rs
deleted file mode 100644
index 851335b..0000000
--- a/vendor/rustix/src/backend/linux_raw/fs/inotify.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-//! inotify support for working with inotifies
-
-use crate::backend::c;
-use crate::backend::fs::syscalls;
-use crate::fd::{BorrowedFd, OwnedFd};
-use crate::io;
-use bitflags::bitflags;
-
-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;
-        /// `IN_NONBLOCK`
-        const NONBLOCK = linux_raw_sys::general::IN_NONBLOCK;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `IN*` for use with [`inotify_add_watch`].
-    ///
-    /// [`inotify_add_watch`]: crate::fs::inotify::inotify_add_watch
-    #[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;
-        /// `IN_ATTRIB`
-        const ATTRIB = linux_raw_sys::general::IN_ATTRIB;
-        /// `IN_CLOSE_NOWRITE`
-        const CLOSE_NOWRITE = linux_raw_sys::general::IN_CLOSE_NOWRITE;
-        /// `IN_CLOSE_WRITE`
-        const CLOSE_WRITE = linux_raw_sys::general::IN_CLOSE_WRITE;
-        /// `IN_CREATE`
-        const CREATE = linux_raw_sys::general::IN_CREATE;
-        /// `IN_DELETE`
-        const DELETE = linux_raw_sys::general::IN_DELETE;
-        /// `IN_DELETE_SELF`
-        const DELETE_SELF = linux_raw_sys::general::IN_DELETE_SELF;
-        /// `IN_MODIFY`
-        const MODIFY = linux_raw_sys::general::IN_MODIFY;
-        /// `IN_MOVE_SELF`
-        const MOVE_SELF = linux_raw_sys::general::IN_MOVE_SELF;
-        /// `IN_MOVED_FROM`
-        const MOVED_FROM = linux_raw_sys::general::IN_MOVED_FROM;
-        /// `IN_MOVED_TO`
-        const MOVED_TO = linux_raw_sys::general::IN_MOVED_TO;
-        /// `IN_OPEN`
-        const OPEN = linux_raw_sys::general::IN_OPEN;
-
-        /// `IN_CLOSE`
-        const CLOSE = linux_raw_sys::general::IN_CLOSE;
-        /// `IN_MOVE`
-        const MOVE = linux_raw_sys::general::IN_MOVE;
-        /// `IN_ALL_EVENTS`
-        const ALL_EVENTS = linux_raw_sys::general::IN_ALL_EVENTS;
-
-        /// `IN_DONT_FOLLOW`
-        const DONT_FOLLOW = linux_raw_sys::general::IN_DONT_FOLLOW;
-        /// `IN_EXCL_UNLINK`
-        const EXCL_UNLINK = linux_raw_sys::general::IN_EXCL_UNLINK;
-        /// `IN_MASK_ADD`
-        const MASK_ADD = linux_raw_sys::general::IN_MASK_ADD;
-        /// `IN_MASK_CREATE`
-        const MASK_CREATE = linux_raw_sys::general::IN_MASK_CREATE;
-        /// `IN_ONESHOT`
-        const ONESHOT = linux_raw_sys::general::IN_ONESHOT;
-        /// `IN_ONLYDIR`
-        const ONLYDIR = linux_raw_sys::general::IN_ONLYDIR;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `inotify_init1(flags)`—Creates a new inotify object.
-///
-/// 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)
-}
-
-/// `inotify_add_watch(self, path, flags)`—Adds a watch to inotify.
-///
-/// This registers or updates a watch for the filesystem path `path` and
-/// returns a watch descriptor corresponding to this watch.
-///
-/// Note: Due to the existence of hardlinks, providing two 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,
-    flags: WatchFlags,
-) -> io::Result<i32> {
-    path.into_with_c_str(|path| syscalls::inotify_add_watch(inot, path, flags))
-}
-
-/// `inotify_rm_watch(self, wd)`—Removes a watch from this inotify.
-///
-/// 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/makedev.rs b/vendor/rustix/src/backend/linux_raw/fs/makedev.rs
deleted file mode 100644
index 284ba2f..0000000
--- a/vendor/rustix/src/backend/linux_raw/fs/makedev.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use crate::fs::Dev;
-
-#[inline]
-pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
-    ((u64::from(maj) & 0xffff_f000_u64) << 32)
-        | ((u64::from(maj) & 0x0000_0fff_u64) << 8)
-        | ((u64::from(min) & 0xffff_ff00_u64) << 12)
-        | (u64::from(min) & 0x0000_00ff_u64)
-}
-
-#[inline]
-pub(crate) fn major(dev: Dev) -> u32 {
-    (((dev >> 31 >> 1) & 0xffff_f000) | ((dev >> 8) & 0x0000_0fff)) as u32
-}
-
-#[inline]
-pub(crate) fn minor(dev: Dev) -> u32 {
-    (((dev >> 12) & 0xffff_ff00) | (dev & 0x0000_00ff)) as u32
-}
diff --git a/vendor/rustix/src/backend/linux_raw/fs/mod.rs b/vendor/rustix/src/backend/linux_raw/fs/mod.rs
deleted file mode 100644
index 9f53c5d..0000000
--- a/vendor/rustix/src/backend/linux_raw/fs/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#[cfg(feature = "alloc")]
-pub(crate) mod dir;
-pub mod inotify;
-pub(crate) mod makedev;
-pub(crate) mod syscalls;
-pub(crate) mod types;
-
-// TODO: Fix linux-raw-sys to define ioctl codes for sparc.
-#[cfg(any(target_arch = "sparc", target_arch = "sparc64"))]
-pub(crate) const EXT4_IOC_RESIZE_FS: u32 = 0x8008_6610;
-
-#[cfg(not(any(target_arch = "sparc", target_arch = "sparc64")))]
-pub(crate) use linux_raw_sys::ioctl::EXT4_IOC_RESIZE_FS;
diff --git a/vendor/rustix/src/backend/linux_raw/fs/syscalls.rs b/vendor/rustix/src/backend/linux_raw/fs/syscalls.rs
deleted file mode 100644
index 47d01df..0000000
--- a/vendor/rustix/src/backend/linux_raw/fs/syscalls.rs
+++ /dev/null
@@ -1,1670 +0,0 @@
-//! linux_raw syscalls supporting `rustix::fs`.
-//!
-//! # 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::fs::oflags_for_open_how;
-#[cfg(any(
-    not(feature = "linux_4_11"),
-    target_arch = "aarch64",
-    target_arch = "riscv64",
-    target_arch = "mips",
-    target_arch = "mips32r6",
-))]
-use crate::backend::conv::zero;
-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,
-};
-#[cfg(target_pointer_width = "64")]
-use crate::backend::conv::{loff_t, loff_t_from_u64, ret_u64};
-#[cfg(any(
-    target_arch = "aarch64",
-    target_arch = "riscv64",
-    target_arch = "mips64",
-    target_arch = "mips64r6",
-    target_pointer_width = "32",
-))]
-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, Gid, MemfdFlags,
-    Mode, OFlags, RenameFlags, ResolveFlags, SealFlags, SeekFrom, Stat, StatFs, StatVfs,
-    StatVfsMountFlags, StatxFlags, Timestamps, Uid, XattrFlags,
-};
-use crate::io;
-use core::mem::MaybeUninit;
-#[cfg(any(target_arch = "mips64", target_arch = "mips64r6"))]
-use linux_raw_sys::general::stat as linux_stat64;
-use linux_raw_sys::general::{
-    __kernel_fsid_t, open_how, statx, AT_EACCESS, AT_FDCWD, AT_REMOVEDIR, 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,
-};
-#[cfg(target_pointer_width = "32")]
-use {
-    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(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(CWD.as_fd(), path, flags, mode)
-    }
-    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(__NR_open, path, flags, mode))
-    }
-}
-
-#[inline]
-pub(crate) fn openat(
-    dirfd: BorrowedFd<'_>,
-    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);
-
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_openat, dirfd, path, flags, mode)) }
-}
-
-#[inline]
-pub(crate) fn openat2(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    mut flags: OFlags,
-    mode: Mode,
-    resolve: ResolveFlags,
-) -> io::Result<OwnedFd> {
-    // 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);
-    }
-
-    unsafe {
-        ret_owned_fd(syscall_readonly!(
-            __NR_openat2,
-            dirfd,
-            path,
-            by_ref(&open_how {
-                flags: oflags_for_open_how(flags),
-                mode: u64::from(mode.bits()),
-                resolve: resolve.bits(),
-            }),
-            size_of::<open_how, _>()
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn chmod(path: &CStr, mode: Mode) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fchmodat,
-            raw_fd(AT_FDCWD),
-            path,
-            mode
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn chmodat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    mode: Mode,
-    flags: AtFlags,
-) -> io::Result<()> {
-    if flags == AtFlags::SYMLINK_NOFOLLOW {
-        return Err(io::Errno::OPNOTSUPP);
-    }
-    if !flags.is_empty() {
-        return Err(io::Errno::INVAL);
-    }
-    unsafe { ret(syscall_readonly!(__NR_fchmodat, dirfd, path, mode)) }
-}
-
-#[inline]
-pub(crate) fn fchmod(fd: BorrowedFd<'_>, mode: Mode) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_fchmod, fd, mode)) }
-}
-
-#[inline]
-pub(crate) fn chownat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    owner: Option<Uid>,
-    group: Option<Gid>,
-    flags: AtFlags,
-) -> io::Result<()> {
-    unsafe {
-        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
-        ret(syscall_readonly!(
-            __NR_fchownat,
-            dirfd,
-            path,
-            c_uint(ow),
-            c_uint(gr),
-            flags
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn chown(path: &CStr, owner: Option<Uid>, group: Option<Gid>) -> io::Result<()> {
-    // Most architectures have a `chown` syscall.
-    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
-    unsafe {
-        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
-        ret(syscall_readonly!(__NR_chown, path, c_uint(ow), c_uint(gr)))
-    }
-
-    // Aarch64 and RISC-V don't, so use `fchownat`.
-    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-    unsafe {
-        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
-        ret(syscall_readonly!(
-            __NR_fchownat,
-            raw_fd(AT_FDCWD),
-            path,
-            c_uint(ow),
-            c_uint(gr),
-            zero()
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn fchown(fd: BorrowedFd<'_>, owner: Option<Uid>, group: Option<Gid>) -> io::Result<()> {
-    unsafe {
-        let (ow, gr) = crate::ugid::translate_fchown_args(owner, group);
-        ret(syscall_readonly!(__NR_fchown, fd, c_uint(ow), c_uint(gr)))
-    }
-}
-
-#[inline]
-pub(crate) fn mknodat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    file_type: FileType,
-    mode: Mode,
-    dev: u64,
-) -> io::Result<()> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_mknodat,
-            dirfd,
-            path,
-            (mode, file_type),
-            dev_t(dev)?
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_mknodat,
-            dirfd,
-            path,
-            (mode, file_type),
-            dev_t(dev)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn seek(fd: BorrowedFd<'_>, pos: SeekFrom) -> io::Result<u64> {
-    let (whence, offset) = match pos {
-        SeekFrom::Start(pos) => {
-            let pos: u64 = pos;
-            // Silently cast; we'll get `EINVAL` if the value is negative.
-            (SEEK_SET, pos as i64)
-        }
-        SeekFrom::End(offset) => (SEEK_END, offset),
-        SeekFrom::Current(offset) => (SEEK_CUR, offset),
-        SeekFrom::Data(offset) => (SEEK_DATA, offset),
-        SeekFrom::Hole(offset) => (SEEK_HOLE, offset),
-    };
-    _seek(fd, offset, whence)
-}
-
-#[inline]
-pub(crate) fn _seek(fd: BorrowedFd<'_>, offset: i64, whence: c::c_uint) -> io::Result<u64> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        let mut result = MaybeUninit::<u64>::uninit();
-        ret(syscall!(
-            __NR__llseek,
-            fd,
-            // Don't use the hi/lo functions here because Linux's llseek
-            // takes its 64-bit argument differently from everything else.
-            pass_usize((offset >> 32) as usize),
-            pass_usize(offset as usize),
-            &mut result,
-            c_uint(whence)
-        ))?;
-        Ok(result.assume_init())
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_u64(syscall_readonly!(
-            __NR_lseek,
-            fd,
-            loff_t(offset),
-            c_uint(whence)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn tell(fd: BorrowedFd<'_>) -> io::Result<u64> {
-    _seek(fd, 0, SEEK_CUR).map(|x| x as u64)
-}
-
-#[inline]
-pub(crate) fn ftruncate(fd: BorrowedFd<'_>, length: u64) -> io::Result<()> {
-    // <https://github.com/torvalds/linux/blob/fcadab740480e0e0e9fa9bd272acd409884d431a/arch/arm64/kernel/sys32.c#L81-L83>
-    #[cfg(all(
-        target_pointer_width = "32",
-        any(
-            target_arch = "arm",
-            target_arch = "mips",
-            target_arch = "mips32r6",
-            target_arch = "powerpc"
-        ),
-    ))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_ftruncate64,
-            fd,
-            zero(),
-            hi(length),
-            lo(length)
-        ))
-    }
-    #[cfg(all(
-        target_pointer_width = "32",
-        not(any(
-            target_arch = "arm",
-            target_arch = "mips",
-            target_arch = "mips32r6",
-            target_arch = "powerpc"
-        )),
-    ))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_ftruncate64,
-            fd,
-            hi(length),
-            lo(length)
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_ftruncate,
-            fd,
-            loff_t_from_u64(length)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn fallocate(
-    fd: BorrowedFd<'_>,
-    mode: FallocateFlags,
-    offset: u64,
-    len: u64,
-) -> io::Result<()> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fallocate,
-            fd,
-            mode,
-            hi(offset),
-            lo(offset),
-            hi(len),
-            lo(len)
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fallocate,
-            fd,
-            mode,
-            loff_t_from_u64(offset),
-            loff_t_from_u64(len)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn fadvise(fd: BorrowedFd<'_>, pos: u64, len: u64, advice: Advice) -> io::Result<()> {
-    // On ARM, the arguments are reordered so that the len and pos argument
-    // pairs are aligned. And ARM has a custom syscall code for this.
-    #[cfg(target_arch = "arm")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_arm_fadvise64_64,
-            fd,
-            advice,
-            hi(pos),
-            lo(pos),
-            hi(len),
-            lo(len)
-        ))
-    }
-
-    // On powerpc, the arguments are reordered as on ARM.
-    #[cfg(target_arch = "powerpc")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fadvise64_64,
-            fd,
-            advice,
-            hi(pos),
-            lo(pos),
-            hi(len),
-            lo(len)
-        ))
-    }
-
-    // On mips, the arguments are not reordered, and padding is inserted
-    // instead to ensure alignment.
-    #[cfg(any(target_arch = "mips", target_arch = "mips32r6"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fadvise64,
-            fd,
-            zero(),
-            hi(pos),
-            lo(pos),
-            hi(len),
-            lo(len),
-            advice
-        ))
-    }
-
-    // For all other 32-bit architectures, use `fadvise64_64` so that we get a
-    // 64-bit length.
-    #[cfg(all(
-        target_pointer_width = "32",
-        not(any(
-            target_arch = "arm",
-            target_arch = "mips",
-            target_arch = "mips32r6",
-            target_arch = "powerpc"
-        )),
-    ))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fadvise64_64,
-            fd,
-            hi(pos),
-            lo(pos),
-            hi(len),
-            lo(len),
-            advice
-        ))
-    }
-
-    // On 64-bit architectures, use `fadvise64` which is sufficient.
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fadvise64,
-            fd,
-            loff_t_from_u64(pos),
-            loff_t_from_u64(len),
-            advice
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn fsync(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_fsync, fd)) }
-}
-
-#[inline]
-pub(crate) fn fdatasync(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_fdatasync, fd)) }
-}
-
-#[inline]
-pub(crate) fn flock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_flock,
-            fd,
-            c_uint(operation as c::c_uint)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn syncfs(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_syncfs, fd)) }
-}
-
-#[inline]
-pub(crate) fn sync() {
-    unsafe { ret_infallible(syscall_readonly!(__NR_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",
-        target_arch = "mips64r6"
-    ))]
-    {
-        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),
-        }
-    }
-
-    #[cfg(all(
-        target_pointer_width = "64",
-        not(target_arch = "mips64"),
-        not(target_arch = "mips64r6")
-    ))]
-    unsafe {
-        let mut result = MaybeUninit::<Stat>::uninit();
-        ret(syscall!(__NR_fstat, fd, &mut result))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(any(
-    target_pointer_width = "32",
-    target_arch = "mips64",
-    target_arch = "mips64r6",
-))]
-fn fstat_old(fd: BorrowedFd<'_>) -> io::Result<Stat> {
-    let mut result = MaybeUninit::<linux_stat64>::uninit();
-
-    #[cfg(any(target_arch = "mips64", target_arch = "mips64r6"))]
-    unsafe {
-        ret(syscall!(__NR_fstat, fd, &mut result))?;
-        stat_to_stat(result.assume_init())
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall!(__NR_fstat64, fd, &mut result))?;
-        stat_to_stat(result.assume_init())
-    }
-}
-
-#[inline]
-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",
-        target_arch = "mips64r6"
-    ))]
-    {
-        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(path),
-            Err(err) => Err(err),
-        }
-    }
-
-    #[cfg(all(
-        target_pointer_width = "64",
-        not(target_arch = "mips64"),
-        not(target_arch = "mips64r6"),
-    ))]
-    unsafe {
-        let mut result = MaybeUninit::<Stat>::uninit();
-        ret(syscall!(
-            __NR_newfstatat,
-            raw_fd(AT_FDCWD),
-            path,
-            &mut result,
-            c_uint(0)
-        ))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(any(
-    target_pointer_width = "32",
-    target_arch = "mips64",
-    target_arch = "mips64r6"
-))]
-fn stat_old(path: &CStr) -> io::Result<Stat> {
-    let mut result = MaybeUninit::<linux_stat64>::uninit();
-
-    #[cfg(any(target_arch = "mips64", target_arch = "mips64r6"))]
-    unsafe {
-        ret(syscall!(
-            __NR_newfstatat,
-            raw_fd(AT_FDCWD),
-            path,
-            &mut result,
-            c_uint(0)
-        ))?;
-        stat_to_stat(result.assume_init())
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall!(
-            __NR_fstatat64,
-            raw_fd(AT_FDCWD),
-            path,
-            &mut result,
-            c_uint(0)
-        ))?;
-        stat_to_stat(result.assume_init())
-    }
-}
-
-#[inline]
-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",
-        target_arch = "mips64r6"
-    ))]
-    {
-        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),
-        }
-    }
-
-    #[cfg(all(
-        target_pointer_width = "64",
-        not(target_arch = "mips64"),
-        not(target_arch = "mips64r6"),
-    ))]
-    unsafe {
-        let mut result = MaybeUninit::<Stat>::uninit();
-        ret(syscall!(__NR_newfstatat, dirfd, path, &mut result, flags))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(any(
-    target_pointer_width = "32",
-    target_arch = "mips64",
-    target_arch = "mips64r6"
-))]
-fn statat_old(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> {
-    let mut result = MaybeUninit::<linux_stat64>::uninit();
-
-    #[cfg(any(target_arch = "mips64", target_arch = "mips64r6"))]
-    unsafe {
-        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, path, &mut result, flags))?;
-        stat_to_stat(result.assume_init())
-    }
-}
-
-#[inline]
-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 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(path),
-            Err(err) => Err(err),
-        }
-    }
-
-    #[cfg(all(target_pointer_width = "64", not(target_arch = "mips64")))]
-    unsafe {
-        let mut result = MaybeUninit::<Stat>::uninit();
-        ret(syscall!(
-            __NR_newfstatat,
-            raw_fd(AT_FDCWD),
-            path,
-            &mut result,
-            c_uint(AT_SYMLINK_NOFOLLOW)
-        ))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(any(target_pointer_width = "32", target_arch = "mips64"))]
-fn lstat_old(path: &CStr) -> io::Result<Stat> {
-    let mut result = MaybeUninit::<linux_stat64>::uninit();
-
-    #[cfg(any(target_arch = "mips64", target_arch = "mips64r6"))]
-    unsafe {
-        ret(syscall!(
-            __NR_newfstatat,
-            raw_fd(AT_FDCWD),
-            path,
-            &mut result,
-            c_uint(AT_SYMLINK_NOFOLLOW)
-        ))?;
-        stat_to_stat(result.assume_init())
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall!(
-            __NR_fstatat64,
-            raw_fd(AT_FDCWD),
-            path,
-            &mut result,
-            c_uint(AT_SYMLINK_NOFOLLOW)
-        ))?;
-        stat_to_stat(result.assume_init())
-    }
-}
-
-/// Convert from a Linux `statx` value to rustix's `Stat`.
-#[cfg(any(
-    target_pointer_width = "32",
-    target_arch = "mips64",
-    target_arch = "mips64r6"
-))]
-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),
-        st_mode: x.stx_mode.into(),
-        st_nlink: x.stx_nlink.into(),
-        st_uid: x.stx_uid.into(),
-        st_gid: x.stx_gid.into(),
-        st_rdev: crate::fs::makedev(x.stx_rdev_major, x.stx_rdev_minor),
-        st_size: x.stx_size.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_blksize: x.stx_blksize.into(),
-        st_blocks: x.stx_blocks.into(),
-        st_atime: x
-            .stx_atime
-            .tv_sec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_atime_nsec: x.stx_atime.tv_nsec.into(),
-        st_mtime: x
-            .stx_mtime
-            .tv_sec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_mtime_nsec: x.stx_mtime.tv_nsec.into(),
-        st_ctime: x
-            .stx_ctime
-            .tv_sec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_ctime_nsec: x.stx_ctime.tv_nsec.into(),
-        st_ino: x.stx_ino.into(),
-    })
-}
-
-/// Convert from a Linux `stat64` value to rustix's `Stat`.
-#[cfg(target_pointer_width = "32")]
-fn stat_to_stat(s64: linux_raw_sys::general::stat64) -> io::Result<Stat> {
-    Ok(Stat {
-        st_dev: s64.st_dev.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_mode: s64.st_mode.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_nlink: s64.st_nlink.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_uid: s64.st_uid.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_gid: s64.st_gid.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_rdev: s64.st_rdev.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_size: s64.st_size.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_blksize: s64.st_blksize.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_blocks: s64.st_blocks.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_atime: s64.st_atime.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_atime_nsec: s64
-            .st_atime_nsec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_mtime: s64.st_mtime.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_mtime_nsec: s64
-            .st_mtime_nsec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_ctime: s64.st_ctime.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_ctime_nsec: s64
-            .st_ctime_nsec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_ino: s64.st_ino.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-    })
-}
-
-/// Convert from a Linux `stat` value to rustix's `Stat`.
-#[cfg(any(target_arch = "mips64", target_arch = "mips64r6"))]
-fn stat_to_stat(s: linux_raw_sys::general::stat) -> io::Result<Stat> {
-    Ok(Stat {
-        st_dev: s.st_dev.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_mode: s.st_mode.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_nlink: s.st_nlink.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_uid: s.st_uid.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_gid: s.st_gid.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_rdev: s.st_rdev.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_size: s.st_size.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_blksize: s.st_blksize.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_blocks: s.st_blocks.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_atime: s.st_atime.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_atime_nsec: s
-            .st_atime_nsec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_mtime: s.st_mtime.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_mtime_nsec: s
-            .st_mtime_nsec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_ctime: s.st_ctime.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-        st_ctime_nsec: s
-            .st_ctime_nsec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        st_ino: s.st_ino.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-    })
-}
-
-#[inline]
-pub(crate) fn statx(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    flags: AtFlags,
-    mask: StatxFlags,
-) -> io::Result<statx> {
-    // If a future Linux kernel adds more fields to `struct statx` and users
-    // passing flags unknown to rustix in `StatxFlags`, we could end up
-    // writing outside of the buffer. To prevent this possibility, we mask off
-    // any flags that we don't know about.
-    //
-    // This includes `STATX__RESERVED`, which has a value that we know, but
-    // which could take on arbitrary new meaning in the future. Linux currently
-    // rejects this flag with `EINVAL`, so we do the same.
-    //
-    // This doesn't rely on `STATX_ALL` because [it's deprecated] and already
-    // doesn't represent all the known flags.
-    //
-    // [it's deprecated]: https://patchwork.kernel.org/project/linux-fsdevel/patch/20200505095915.11275-7-mszeredi@redhat.com/
-    if (mask.bits() & STATX__RESERVED) == STATX__RESERVED {
-        return Err(io::Errno::INVAL);
-    }
-    let mask = mask & StatxFlags::all();
-
-    unsafe {
-        let mut statx_buf = MaybeUninit::<statx>::uninit();
-        ret(syscall!(
-            __NR_statx,
-            dirfd,
-            path,
-            flags,
-            mask,
-            &mut statx_buf
-        ))?;
-        Ok(statx_buf.assume_init())
-    }
-}
-
-#[cfg(not(feature = "linux_4_11"))]
-#[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. This can use
-        // "readonly" because we don't pass it a buffer to mutate.
-        matches!(
-            ret(syscall_readonly!(
-                __NR_statx,
-                raw_fd(AT_FDCWD),
-                zero(),
-                zero(),
-                zero(),
-                zero()
-            )),
-            Err(io::Errno::FAULT)
-        )
-    }
-}
-
-#[inline]
-pub(crate) fn fstatfs(fd: BorrowedFd<'_>) -> io::Result<StatFs> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        let mut result = MaybeUninit::<StatFs>::uninit();
-        ret(syscall!(
-            __NR_fstatfs64,
-            fd,
-            size_of::<StatFs, _>(),
-            &mut result
-        ))?;
-        Ok(result.assume_init())
-    }
-
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        let mut result = MaybeUninit::<StatFs>::uninit();
-        ret(syscall!(__NR_fstatfs, fd, &mut result))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[inline]
-pub(crate) fn fstatvfs(fd: BorrowedFd<'_>) -> io::Result<StatVfs> {
-    // Linux doesn't have an `fstatvfs` syscall; we have to do `fstatfs` and
-    // translate the fields as best we can.
-    let statfs = fstatfs(fd)?;
-
-    Ok(statfs_to_statvfs(statfs))
-}
-
-#[inline]
-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,
-            path,
-            size_of::<StatFs, _>(),
-            &mut result
-        ))?;
-        Ok(result.assume_init())
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        let mut result = MaybeUninit::<StatFs>::uninit();
-        ret(syscall!(__NR_statfs, path, &mut result))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[inline]
-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(path)?;
-
-    Ok(statfs_to_statvfs(statfs))
-}
-
-fn statfs_to_statvfs(statfs: StatFs) -> StatVfs {
-    let __kernel_fsid_t { val } = statfs.f_fsid;
-    let [f_fsid_val0, f_fsid_val1]: [i32; 2] = val;
-
-    StatVfs {
-        f_bsize: statfs.f_bsize as u64,
-        f_frsize: if statfs.f_frsize != 0 {
-            statfs.f_frsize
-        } else {
-            statfs.f_bsize
-        } as u64,
-        f_blocks: statfs.f_blocks as u64,
-        f_bfree: statfs.f_bfree as u64,
-        f_bavail: statfs.f_bavail as u64,
-        f_files: statfs.f_files as u64,
-        f_ffree: statfs.f_ffree as u64,
-        f_favail: statfs.f_ffree 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,
-    }
-}
-
-#[cfg(feature = "alloc")]
-#[inline]
-pub(crate) fn readlink(path: &CStr, buf: &mut [u8]) -> io::Result<usize> {
-    let (buf_addr_mut, buf_len) = slice_mut(buf);
-    unsafe {
-        ret_usize(syscall!(
-            __NR_readlinkat,
-            raw_fd(AT_FDCWD),
-            path,
-            buf_addr_mut,
-            buf_len
-        ))
-    }
-}
-
-#[inline]
-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!(
-            __NR_readlinkat,
-            dirfd,
-            path,
-            buf_addr_mut,
-            buf_len
-        ))
-    }
-}
-
-#[inline]
-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_retain)
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        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))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(__NR_fcntl, fd, c_uint(F_SETFL), flags))
-    }
-}
-
-#[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_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_retain(seals as u32))
-    }
-}
-
-#[inline]
-pub(crate) fn fcntl_add_seals(fd: BorrowedFd<'_>, seals: SealFlags) -> io::Result<()> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fcntl64,
-            fd,
-            c_uint(F_ADD_SEALS),
-            seals
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fcntl,
-            fd,
-            c_uint(F_ADD_SEALS),
-            seals
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn fcntl_lock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::Result<()> {
-    #[cfg(target_pointer_width = "64")]
-    use linux_raw_sys::general::{flock, F_SETLK, F_SETLKW};
-    #[cfg(target_pointer_width = "32")]
-    use linux_raw_sys::general::{flock64 as flock, F_SETLK64 as F_SETLK, F_SETLKW64 as F_SETLKW};
-    use linux_raw_sys::general::{F_RDLCK, F_UNLCK, F_WRLCK};
-
-    let (cmd, l_type) = match operation {
-        FlockOperation::LockShared => (F_SETLKW, F_RDLCK),
-        FlockOperation::LockExclusive => (F_SETLKW, F_WRLCK),
-        FlockOperation::Unlock => (F_SETLKW, F_UNLCK),
-        FlockOperation::NonBlockingLockShared => (F_SETLK, F_RDLCK),
-        FlockOperation::NonBlockingLockExclusive => (F_SETLK, F_WRLCK),
-        FlockOperation::NonBlockingUnlock => (F_SETLK, F_UNLCK),
-    };
-
-    let lock = flock {
-        l_type: l_type as _,
-
-        // When `l_len` is zero, this locks all the bytes from
-        // `l_whence`/`l_start` to the end of the file, even as the
-        // file grows dynamically.
-        l_whence: SEEK_SET as _,
-        l_start: 0,
-        l_len: 0,
-
-        // Unused.
-        l_pid: 0,
-    };
-
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fcntl64,
-            fd,
-            c_uint(cmd),
-            by_ref(&lock)
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fcntl,
-            fd,
-            c_uint(cmd),
-            by_ref(&lock)
-        ))
-    }
-}
-
-#[inline]
-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),
-            old_path,
-            raw_fd(AT_FDCWD),
-            new_path,
-            c_uint(0)
-        ))
-    }
-    #[cfg(not(target_arch = "riscv64"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_renameat,
-            raw_fd(AT_FDCWD),
-            old_path,
-            raw_fd(AT_FDCWD),
-            new_path
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn renameat(
-    old_dirfd: BorrowedFd<'_>,
-    old_path: &CStr,
-    new_dirfd: BorrowedFd<'_>,
-    new_path: &CStr,
-) -> io::Result<()> {
-    #[cfg(target_arch = "riscv64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_renameat2,
-            old_dirfd,
-            old_path,
-            new_dirfd,
-            new_path,
-            c_uint(0)
-        ))
-    }
-    #[cfg(not(target_arch = "riscv64"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_renameat,
-            old_dirfd,
-            old_path,
-            new_dirfd,
-            new_path
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn renameat2(
-    old_dirfd: BorrowedFd<'_>,
-    old_path: &CStr,
-    new_dirfd: BorrowedFd<'_>,
-    new_path: &CStr,
-    flags: RenameFlags,
-) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_renameat2,
-            old_dirfd,
-            old_path,
-            new_dirfd,
-            new_path,
-            flags
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn unlink(path: &CStr) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_unlinkat,
-            raw_fd(AT_FDCWD),
-            path,
-            c_uint(0)
-        ))
-    }
-}
-
-#[inline]
-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(path: &CStr) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_unlinkat,
-            raw_fd(AT_FDCWD),
-            path,
-            c_uint(AT_REMOVEDIR)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn link(old_path: &CStr, new_path: &CStr) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_linkat,
-            raw_fd(AT_FDCWD),
-            old_path,
-            raw_fd(AT_FDCWD),
-            new_path,
-            c_uint(0)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn linkat(
-    old_dirfd: BorrowedFd<'_>,
-    old_path: &CStr,
-    new_dirfd: BorrowedFd<'_>,
-    new_path: &CStr,
-    flags: AtFlags,
-) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_linkat,
-            old_dirfd,
-            old_path,
-            new_dirfd,
-            new_path,
-            flags
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn symlink(old_path: &CStr, new_path: &CStr) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_symlinkat,
-            old_path,
-            raw_fd(AT_FDCWD),
-            new_path
-        ))
-    }
-}
-
-#[inline]
-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(path: &CStr, mode: Mode) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_mkdirat,
-            raw_fd(AT_FDCWD),
-            path,
-            mode
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn mkdirat(dirfd: BorrowedFd<'_>, path: &CStr, mode: Mode) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_mkdirat, dirfd, path, mode)) }
-}
-
-#[cfg(feature = "alloc")]
-#[inline]
-pub(crate) fn getdents(fd: BorrowedFd<'_>, dirent: &mut [u8]) -> io::Result<usize> {
-    let (dirent_addr_mut, dirent_len) = slice_mut(dirent);
-
-    unsafe { ret_usize(syscall!(__NR_getdents64, fd, dirent_addr_mut, dirent_len)) }
-}
-
-#[inline]
-pub(crate) fn getdents_uninit(
-    fd: BorrowedFd<'_>,
-    dirent: &mut [MaybeUninit<u8>],
-) -> io::Result<usize> {
-    let (dirent_addr_mut, dirent_len) = slice_mut(dirent);
-
-    unsafe { ret_usize(syscall!(__NR_getdents64, fd, dirent_addr_mut, dirent_len)) }
-}
-
-#[inline]
-pub(crate) fn utimensat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    times: &Timestamps,
-    flags: AtFlags,
-) -> io::Result<()> {
-    _utimensat(dirfd, Some(path), times, flags)
-}
-
-#[inline]
-fn _utimensat(
-    dirfd: BorrowedFd<'_>,
-    path: Option<&CStr>,
-    times: &Timestamps,
-    flags: AtFlags,
-) -> io::Result<()> {
-    // `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,
-            path,
-            by_ref(times),
-            flags
-        )) {
-            Err(io::Errno::NOSYS) => _utimensat_old(dirfd, path, times, flags),
-            otherwise => otherwise,
-        }
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_utimensat,
-            dirfd,
-            path,
-            by_ref(times),
-            flags
-        ))
-    }
-}
-
-#[cfg(target_pointer_width = "32")]
-unsafe fn _utimensat_old(
-    dirfd: BorrowedFd<'_>,
-    path: Option<&CStr>,
-    times: &Timestamps,
-    flags: AtFlags,
-) -> io::Result<()> {
-    // See the comments in `rustix_clock_gettime_via_syscall` about
-    // emulation.
-    let old_times = [
-        __kernel_old_timespec {
-            tv_sec: times
-                .last_access
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: times
-                .last_access
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::INVAL)?,
-        },
-        __kernel_old_timespec {
-            tv_sec: times
-                .last_modification
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: times
-                .last_modification
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::INVAL)?,
-        },
-    ];
-    // The length of the array is fixed and not passed into the syscall.
-    let old_times_addr = slice_just_addr(&old_times);
-    ret(syscall_readonly!(
-        __NR_utimensat,
-        dirfd,
-        path,
-        old_times_addr,
-        flags
-    ))
-}
-
-#[inline]
-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,
-    access: Access,
-    flags: AtFlags,
-) -> io::Result<()> {
-    if !flags
-        .difference(AtFlags::EACCESS | AtFlags::SYMLINK_NOFOLLOW)
-        .is_empty()
-    {
-        return Err(io::Errno::INVAL);
-    }
-
-    // Linux's `faccessat` syscall doesn't have a flags argument, so if we have
-    // 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() {
-        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::backend::ugid::syscalls::getuid()
-                == crate::backend::ugid::syscalls::geteuid()
-            && crate::backend::ugid::syscalls::getgid()
-                == crate::backend::ugid::syscalls::getegid())
-    {
-        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>,
-    fd_out: BorrowedFd<'_>,
-    off_out: Option<&mut u64>,
-    len: usize,
-) -> io::Result<usize> {
-    unsafe {
-        ret_usize(syscall!(
-            __NR_copy_file_range,
-            fd_in,
-            opt_mut(off_in),
-            fd_out,
-            opt_mut(off_out),
-            pass_usize(len),
-            c_uint(0)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn memfd_create(name: &CStr, flags: MemfdFlags) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_memfd_create, name, flags)) }
-}
-
-#[inline]
-pub(crate) fn sendfile(
-    out_fd: BorrowedFd<'_>,
-    in_fd: BorrowedFd<'_>,
-    offset: Option<&mut u64>,
-    count: usize,
-) -> io::Result<usize> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret_usize(syscall!(
-            __NR_sendfile64,
-            out_fd,
-            in_fd,
-            opt_mut(offset),
-            pass_usize(count)
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_usize(syscall!(
-            __NR_sendfile,
-            out_fd,
-            in_fd,
-            opt_mut(offset),
-            pass_usize(count)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn inotify_init1(flags: inotify::CreateFlags) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_inotify_init1, flags)) }
-}
-
-#[inline]
-pub(crate) fn inotify_add_watch(
-    infd: BorrowedFd<'_>,
-    path: &CStr,
-    flags: inotify::WatchFlags,
-) -> io::Result<i32> {
-    unsafe { ret_c_int(syscall_readonly!(__NR_inotify_add_watch, infd, path, flags)) }
-}
-
-#[inline]
-pub(crate) fn inotify_rm_watch(infd: BorrowedFd<'_>, wfd: i32) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_inotify_rm_watch, infd, c_int(wfd))) }
-}
-
-#[inline]
-pub(crate) fn getxattr(path: &CStr, name: &CStr, value: &mut [u8]) -> io::Result<usize> {
-    let (value_addr_mut, value_len) = slice_mut(value);
-    unsafe {
-        ret_usize(syscall!(
-            __NR_getxattr,
-            path,
-            name,
-            value_addr_mut,
-            value_len
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn lgetxattr(path: &CStr, name: &CStr, value: &mut [u8]) -> io::Result<usize> {
-    let (value_addr_mut, value_len) = slice_mut(value);
-    unsafe {
-        ret_usize(syscall!(
-            __NR_lgetxattr,
-            path,
-            name,
-            value_addr_mut,
-            value_len
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn fgetxattr(fd: BorrowedFd<'_>, name: &CStr, value: &mut [u8]) -> io::Result<usize> {
-    let (value_addr_mut, value_len) = slice_mut(value);
-    unsafe {
-        ret_usize(syscall!(
-            __NR_fgetxattr,
-            fd,
-            name,
-            value_addr_mut,
-            value_len
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn setxattr(
-    path: &CStr,
-    name: &CStr,
-    value: &[u8],
-    flags: XattrFlags,
-) -> io::Result<()> {
-    let (value_addr, value_len) = slice(value);
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_setxattr,
-            path,
-            name,
-            value_addr,
-            value_len,
-            flags
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn lsetxattr(
-    path: &CStr,
-    name: &CStr,
-    value: &[u8],
-    flags: XattrFlags,
-) -> io::Result<()> {
-    let (value_addr, value_len) = slice(value);
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_lsetxattr,
-            path,
-            name,
-            value_addr,
-            value_len,
-            flags
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn fsetxattr(
-    fd: BorrowedFd<'_>,
-    name: &CStr,
-    value: &[u8],
-    flags: XattrFlags,
-) -> io::Result<()> {
-    let (value_addr, value_len) = slice(value);
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fsetxattr,
-            fd,
-            name,
-            value_addr,
-            value_len,
-            flags
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn listxattr(path: &CStr, list: &mut [c::c_char]) -> io::Result<usize> {
-    let (list_addr_mut, list_len) = slice_mut(list);
-    unsafe { ret_usize(syscall!(__NR_listxattr, path, list_addr_mut, list_len)) }
-}
-
-#[inline]
-pub(crate) fn llistxattr(path: &CStr, list: &mut [c::c_char]) -> io::Result<usize> {
-    let (list_addr_mut, list_len) = slice_mut(list);
-    unsafe { ret_usize(syscall!(__NR_llistxattr, path, list_addr_mut, list_len)) }
-}
-
-#[inline]
-pub(crate) fn flistxattr(fd: BorrowedFd<'_>, list: &mut [c::c_char]) -> io::Result<usize> {
-    let (list_addr_mut, list_len) = slice_mut(list);
-    unsafe { ret_usize(syscall!(__NR_flistxattr, fd, list_addr_mut, list_len)) }
-}
-
-#[inline]
-pub(crate) fn removexattr(path: &CStr, name: &CStr) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_removexattr, path, name)) }
-}
-
-#[inline]
-pub(crate) fn lremovexattr(path: &CStr, name: &CStr) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_lremovexattr, path, name)) }
-}
-
-#[inline]
-pub(crate) fn fremovexattr(fd: BorrowedFd<'_>, name: &CStr) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_fremovexattr, fd, name)) }
-}
-
-#[test]
-fn test_sizes() {
-    assert_eq_size!(linux_raw_sys::general::__kernel_loff_t, u64);
-
-    // Assert that `Timestamps` has the expected layout.
-    assert_eq_size!([linux_raw_sys::general::__kernel_timespec; 2], Timestamps);
-}
diff --git a/vendor/rustix/src/backend/linux_raw/fs/types.rs b/vendor/rustix/src/backend/linux_raw/fs/types.rs
deleted file mode 100644
index 39823c4..0000000
--- a/vendor/rustix/src/backend/linux_raw/fs/types.rs
+++ /dev/null
@@ -1,739 +0,0 @@
-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;
-
-        /// `W_OK`
-        const WRITE_OK = linux_raw_sys::general::W_OK;
-
-        /// `X_OK`
-        const EXEC_OK = linux_raw_sys::general::X_OK;
-
-        /// `F_OK`
-        const EXISTS = linux_raw_sys::general::F_OK;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `AT_*` constants for use with [`openat`], [`statat`], and other `*at`
-    /// functions.
-    ///
-    /// [`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_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_STATX_SYNC_AS_STAT`
-        const STATX_SYNC_AS_STAT = linux_raw_sys::general::AT_STATX_SYNC_AS_STAT;
-
-        /// `AT_STATX_FORCE_SYNC`
-        const STATX_FORCE_SYNC = linux_raw_sys::general::AT_STATX_FORCE_SYNC;
-
-        /// `AT_STATX_DONT_SYNC`
-        const STATX_DONT_SYNC = linux_raw_sys::general::AT_STATX_DONT_SYNC;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `S_I*` constants for use with [`openat`], [`chmodat`], and [`fchmod`].
-    ///
-    /// [`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;
-
-        /// `S_IRUSR`
-        const RUSR = linux_raw_sys::general::S_IRUSR;
-
-        /// `S_IWUSR`
-        const WUSR = linux_raw_sys::general::S_IWUSR;
-
-        /// `S_IXUSR`
-        const XUSR = linux_raw_sys::general::S_IXUSR;
-
-        /// `S_IRWXG`
-        const RWXG = linux_raw_sys::general::S_IRWXG;
-
-        /// `S_IRGRP`
-        const RGRP = linux_raw_sys::general::S_IRGRP;
-
-        /// `S_IWGRP`
-        const WGRP = linux_raw_sys::general::S_IWGRP;
-
-        /// `S_IXGRP`
-        const XGRP = linux_raw_sys::general::S_IXGRP;
-
-        /// `S_IRWXO`
-        const RWXO = linux_raw_sys::general::S_IRWXO;
-
-        /// `S_IROTH`
-        const ROTH = linux_raw_sys::general::S_IROTH;
-
-        /// `S_IWOTH`
-        const WOTH = linux_raw_sys::general::S_IWOTH;
-
-        /// `S_IXOTH`
-        const XOTH = linux_raw_sys::general::S_IXOTH;
-
-        /// `S_ISUID`
-        const SUID = linux_raw_sys::general::S_ISUID;
-
-        /// `S_ISGID`
-        const SGID = linux_raw_sys::general::S_ISGID;
-
-        /// `S_ISVTX`
-        const SVTX = linux_raw_sys::general::S_ISVTX;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-impl Mode {
-    /// Construct a `Mode` from the mode bits of the `st_mode` field of a
-    /// `Mode`.
-    #[inline]
-    pub const fn from_raw_mode(st_mode: RawMode) -> Self {
-        Self::from_bits_truncate(st_mode)
-    }
-
-    /// Construct an `st_mode` value from a `Mode`.
-    #[inline]
-    pub const fn as_raw_mode(self) -> RawMode {
-        self.bits()
-    }
-}
-
-impl From<RawMode> for Mode {
-    /// Support conversions from raw mode values to `Mode`.
-    ///
-    /// ```
-    /// use rustix::fs::{Mode, RawMode};
-    /// assert_eq!(Mode::from(0o700), Mode::RWXU);
-    /// ```
-    #[inline]
-    fn from(st_mode: RawMode) -> Self {
-        Self::from_raw_mode(st_mode)
-    }
-}
-
-impl From<Mode> for RawMode {
-    /// Support conversions from `Mode` to raw mode values.
-    ///
-    /// ```
-    /// use rustix::fs::{Mode, RawMode};
-    /// assert_eq!(RawMode::from(Mode::RWXU), 0o700);
-    /// ```
-    #[inline]
-    fn from(mode: Mode) -> Self {
-        mode.as_raw_mode()
-    }
-}
-
-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;
-
-        /// Similar to `ACCMODE`, but just includes the read/write flags, and
-        /// no other flags.
-        ///
-        /// On some platforms, `PATH` may be included in `ACCMODE`, when
-        /// sometimes we really just want the read/write bits. Caution is
-        /// indicated, as the presence of `PATH` may mean that the read/write
-        /// bits don't have their usual meaning.
-        const RWMODE = linux_raw_sys::general::O_RDONLY |
-                       linux_raw_sys::general::O_WRONLY |
-                       linux_raw_sys::general::O_RDWR;
-
-        /// `O_APPEND`
-        const APPEND = linux_raw_sys::general::O_APPEND;
-
-        /// `O_CREAT`
-        #[doc(alias = "CREAT")]
-        const CREATE = linux_raw_sys::general::O_CREAT;
-
-        /// `O_DIRECTORY`
-        const DIRECTORY = linux_raw_sys::general::O_DIRECTORY;
-
-        /// `O_DSYNC`.
-        const DSYNC = linux_raw_sys::general::O_SYNC;
-
-        /// `O_EXCL`
-        const EXCL = linux_raw_sys::general::O_EXCL;
-
-        /// `O_FSYNC`.
-        const FSYNC = linux_raw_sys::general::O_SYNC;
-
-        /// `O_NOFOLLOW`
-        const NOFOLLOW = linux_raw_sys::general::O_NOFOLLOW;
-
-        /// `O_NONBLOCK`
-        const NONBLOCK = linux_raw_sys::general::O_NONBLOCK;
-
-        /// `O_RDONLY`
-        const RDONLY = linux_raw_sys::general::O_RDONLY;
-
-        /// `O_WRONLY`
-        const WRONLY = linux_raw_sys::general::O_WRONLY;
-
-        /// `O_RDWR`
-        ///
-        /// This is not equal to `RDONLY | WRONLY`. It's a distinct flag.
-        const RDWR = linux_raw_sys::general::O_RDWR;
-
-        /// `O_NOCTTY`
-        const NOCTTY = linux_raw_sys::general::O_NOCTTY;
-
-        /// `O_RSYNC`.
-        const RSYNC = linux_raw_sys::general::O_SYNC;
-
-        /// `O_SYNC`
-        const SYNC = linux_raw_sys::general::O_SYNC;
-
-        /// `O_TRUNC`
-        const TRUNC = linux_raw_sys::general::O_TRUNC;
-
-        /// `O_PATH`
-        const PATH = linux_raw_sys::general::O_PATH;
-
-        /// `O_CLOEXEC`
-        const CLOEXEC = linux_raw_sys::general::O_CLOEXEC;
-
-        /// `O_TMPFILE`
-        const TMPFILE = linux_raw_sys::general::O_TMPFILE;
-
-        /// `O_NOATIME`
-        const NOATIME = linux_raw_sys::general::O_NOATIME;
-
-        /// `O_DIRECT`
-        const DIRECT = linux_raw_sys::general::O_DIRECT;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `RESOLVE_*` constants for use with [`openat2`].
-    ///
-    /// [`openat2`]: crate::fs::openat2
-    #[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;
-
-        /// `RESOLVE_NO_MAGICLINKS`
-        const NO_MAGICLINKS = linux_raw_sys::general::RESOLVE_NO_MAGICLINKS as u64;
-
-        /// `RESOLVE_NO_SYMLINKS`
-        const NO_SYMLINKS = linux_raw_sys::general::RESOLVE_NO_SYMLINKS as u64;
-
-        /// `RESOLVE_BENEATH`
-        const BENEATH = linux_raw_sys::general::RESOLVE_BENEATH as u64;
-
-        /// `RESOLVE_IN_ROOT`
-        const IN_ROOT = linux_raw_sys::general::RESOLVE_IN_ROOT as u64;
-
-        /// `RESOLVE_CACHED` (since Linux 5.12)
-        const CACHED = linux_raw_sys::general::RESOLVE_CACHED as u64;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-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;
-
-        /// `RENAME_NOREPLACE`
-        const NOREPLACE = linux_raw_sys::general::RENAME_NOREPLACE;
-
-        /// `RENAME_WHITEOUT`
-        const WHITEOUT = linux_raw_sys::general::RENAME_WHITEOUT;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `S_IF*` constants for use with [`mknodat`] and [`Stat`]'s `st_mode` field.
-///
-/// [`mknodat`]: crate::fs::mknodat
-/// [`Stat`]: crate::fs::Stat
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum FileType {
-    /// `S_IFREG`
-    RegularFile = linux_raw_sys::general::S_IFREG as isize,
-
-    /// `S_IFDIR`
-    Directory = linux_raw_sys::general::S_IFDIR as isize,
-
-    /// `S_IFLNK`
-    Symlink = linux_raw_sys::general::S_IFLNK as isize,
-
-    /// `S_IFIFO`
-    #[doc(alias = "IFO")]
-    Fifo = linux_raw_sys::general::S_IFIFO as isize,
-
-    /// `S_IFSOCK`
-    Socket = linux_raw_sys::general::S_IFSOCK as isize,
-
-    /// `S_IFCHR`
-    CharacterDevice = linux_raw_sys::general::S_IFCHR as isize,
-
-    /// `S_IFBLK`
-    BlockDevice = linux_raw_sys::general::S_IFBLK as isize,
-
-    /// An unknown filesystem object.
-    Unknown,
-}
-
-impl FileType {
-    /// Construct a `FileType` from the `S_IFMT` bits of the `st_mode` field of
-    /// a `Stat`.
-    #[inline]
-    pub const fn from_raw_mode(st_mode: RawMode) -> Self {
-        match st_mode & linux_raw_sys::general::S_IFMT {
-            linux_raw_sys::general::S_IFREG => Self::RegularFile,
-            linux_raw_sys::general::S_IFDIR => Self::Directory,
-            linux_raw_sys::general::S_IFLNK => Self::Symlink,
-            linux_raw_sys::general::S_IFIFO => Self::Fifo,
-            linux_raw_sys::general::S_IFSOCK => Self::Socket,
-            linux_raw_sys::general::S_IFCHR => Self::CharacterDevice,
-            linux_raw_sys::general::S_IFBLK => Self::BlockDevice,
-            _ => Self::Unknown,
-        }
-    }
-
-    /// Construct an `st_mode` value from a `FileType`.
-    #[inline]
-    pub const fn as_raw_mode(self) -> RawMode {
-        match self {
-            Self::RegularFile => linux_raw_sys::general::S_IFREG,
-            Self::Directory => linux_raw_sys::general::S_IFDIR,
-            Self::Symlink => linux_raw_sys::general::S_IFLNK,
-            Self::Fifo => linux_raw_sys::general::S_IFIFO,
-            Self::Socket => linux_raw_sys::general::S_IFSOCK,
-            Self::CharacterDevice => linux_raw_sys::general::S_IFCHR,
-            Self::BlockDevice => linux_raw_sys::general::S_IFBLK,
-            Self::Unknown => linux_raw_sys::general::S_IFMT,
-        }
-    }
-
-    /// Construct a `FileType` from the `d_type` field of a `c::dirent`.
-    #[inline]
-    pub(crate) const fn from_dirent_d_type(d_type: u8) -> Self {
-        match d_type as u32 {
-            linux_raw_sys::general::DT_REG => Self::RegularFile,
-            linux_raw_sys::general::DT_DIR => Self::Directory,
-            linux_raw_sys::general::DT_LNK => Self::Symlink,
-            linux_raw_sys::general::DT_SOCK => Self::Socket,
-            linux_raw_sys::general::DT_FIFO => Self::Fifo,
-            linux_raw_sys::general::DT_CHR => Self::CharacterDevice,
-            linux_raw_sys::general::DT_BLK => Self::BlockDevice,
-            // linux_raw_sys::general::DT_UNKNOWN |
-            _ => Self::Unknown,
-        }
-    }
-}
-
-/// `POSIX_FADV_*` constants for use with [`fadvise`].
-///
-/// [`fadvise`]: crate::fs::fadvise
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(u32)]
-pub enum Advice {
-    /// `POSIX_FADV_NORMAL`
-    Normal = linux_raw_sys::general::POSIX_FADV_NORMAL,
-
-    /// `POSIX_FADV_SEQUENTIAL`
-    Sequential = linux_raw_sys::general::POSIX_FADV_SEQUENTIAL,
-
-    /// `POSIX_FADV_RANDOM`
-    Random = linux_raw_sys::general::POSIX_FADV_RANDOM,
-
-    /// `POSIX_FADV_NOREUSE`
-    NoReuse = linux_raw_sys::general::POSIX_FADV_NOREUSE,
-
-    /// `POSIX_FADV_WILLNEED`
-    WillNeed = linux_raw_sys::general::POSIX_FADV_WILLNEED,
-
-    /// `POSIX_FADV_DONTNEED`
-    DontNeed = linux_raw_sys::general::POSIX_FADV_DONTNEED,
-}
-
-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;
-
-        /// `MFD_ALLOW_SEALING`
-        const ALLOW_SEALING = linux_raw_sys::general::MFD_ALLOW_SEALING;
-
-        /// `MFD_HUGETLB` (since Linux 4.14)
-        const HUGETLB = linux_raw_sys::general::MFD_HUGETLB;
-
-        /// `MFD_HUGE_64KB`
-        const HUGE_64KB = linux_raw_sys::general::MFD_HUGE_64KB;
-        /// `MFD_HUGE_512JB`
-        const HUGE_512KB = linux_raw_sys::general::MFD_HUGE_512KB;
-        /// `MFD_HUGE_1MB`
-        const HUGE_1MB = linux_raw_sys::general::MFD_HUGE_1MB;
-        /// `MFD_HUGE_2MB`
-        const HUGE_2MB = linux_raw_sys::general::MFD_HUGE_2MB;
-        /// `MFD_HUGE_8MB`
-        const HUGE_8MB = linux_raw_sys::general::MFD_HUGE_8MB;
-        /// `MFD_HUGE_16MB`
-        const HUGE_16MB = linux_raw_sys::general::MFD_HUGE_16MB;
-        /// `MFD_HUGE_32MB`
-        const HUGE_32MB = linux_raw_sys::general::MFD_HUGE_32MB;
-        /// `MFD_HUGE_256MB`
-        const HUGE_256MB = linux_raw_sys::general::MFD_HUGE_256MB;
-        /// `MFD_HUGE_512MB`
-        const HUGE_512MB = linux_raw_sys::general::MFD_HUGE_512MB;
-        /// `MFD_HUGE_1GB`
-        const HUGE_1GB = linux_raw_sys::general::MFD_HUGE_1GB;
-        /// `MFD_HUGE_2GB`
-        const HUGE_2GB = linux_raw_sys::general::MFD_HUGE_2GB;
-        /// `MFD_HUGE_16GB`
-        const HUGE_16GB = linux_raw_sys::general::MFD_HUGE_16GB;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-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
-    #[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;
-        /// `F_SEAL_SHRINK`.
-        const SHRINK = linux_raw_sys::general::F_SEAL_SHRINK;
-        /// `F_SEAL_GROW`.
-        const GROW = linux_raw_sys::general::F_SEAL_GROW;
-        /// `F_SEAL_WRITE`.
-        const WRITE = linux_raw_sys::general::F_SEAL_WRITE;
-        /// `F_SEAL_FUTURE_WRITE` (since Linux 5.1)
-        const FUTURE_WRITE = linux_raw_sys::general::F_SEAL_FUTURE_WRITE;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-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;
-
-        /// `STATX_MODE`
-        const MODE = linux_raw_sys::general::STATX_MODE;
-
-        /// `STATX_NLINK`
-        const NLINK = linux_raw_sys::general::STATX_NLINK;
-
-        /// `STATX_UID`
-        const UID = linux_raw_sys::general::STATX_UID;
-
-        /// `STATX_GID`
-        const GID = linux_raw_sys::general::STATX_GID;
-
-        /// `STATX_ATIME`
-        const ATIME = linux_raw_sys::general::STATX_ATIME;
-
-        /// `STATX_MTIME`
-        const MTIME = linux_raw_sys::general::STATX_MTIME;
-
-        /// `STATX_CTIME`
-        const CTIME = linux_raw_sys::general::STATX_CTIME;
-
-        /// `STATX_INO`
-        const INO = linux_raw_sys::general::STATX_INO;
-
-        /// `STATX_SIZE`
-        const SIZE = linux_raw_sys::general::STATX_SIZE;
-
-        /// `STATX_BLOCKS`
-        const BLOCKS = linux_raw_sys::general::STATX_BLOCKS;
-
-        /// `STATX_BASIC_STATS`
-        const BASIC_STATS = linux_raw_sys::general::STATX_BASIC_STATS;
-
-        /// `STATX_BTIME`
-        const BTIME = linux_raw_sys::general::STATX_BTIME;
-
-        /// `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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-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;
-        /// `FALLOC_FL_PUNCH_HOLE`
-        const PUNCH_HOLE = linux_raw_sys::general::FALLOC_FL_PUNCH_HOLE;
-        /// `FALLOC_FL_NO_HIDE_STALE`
-        const NO_HIDE_STALE = linux_raw_sys::general::FALLOC_FL_NO_HIDE_STALE;
-        /// `FALLOC_FL_COLLAPSE_RANGE`
-        const COLLAPSE_RANGE = linux_raw_sys::general::FALLOC_FL_COLLAPSE_RANGE;
-        /// `FALLOC_FL_ZERO_RANGE`
-        const ZERO_RANGE = linux_raw_sys::general::FALLOC_FL_ZERO_RANGE;
-        /// `FALLOC_FL_INSERT_RANGE`
-        const INSERT_RANGE = linux_raw_sys::general::FALLOC_FL_INSERT_RANGE;
-        /// `FALLOC_FL_UNSHARE_RANGE`
-        const UNSHARE_RANGE = linux_raw_sys::general::FALLOC_FL_UNSHARE_RANGE;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-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;
-
-        /// `ST_NOATIME`
-        const NOATIME = linux_raw_sys::general::MS_NOATIME as u64;
-
-        /// `ST_NODEV`
-        const NODEV = linux_raw_sys::general::MS_NODEV as u64;
-
-        /// `ST_NODIRATIME`
-        const NODIRATIME = linux_raw_sys::general::MS_NODIRATIME as u64;
-
-        /// `ST_NOEXEC`
-        const NOEXEC = linux_raw_sys::general::MS_NOEXEC as u64;
-
-        /// `ST_NOSUID`
-        const NOSUID = linux_raw_sys::general::MS_NOSUID as u64;
-
-        /// `ST_RDONLY`
-        const RDONLY = linux_raw_sys::general::MS_RDONLY as u64;
-
-        /// `ST_RELATIME`
-        const RELATIME = linux_raw_sys::general::MS_RELATIME as u64;
-
-        /// `ST_SYNCHRONOUS`
-        const SYNCHRONOUS = linux_raw_sys::general::MS_SYNCHRONOUS as u64;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `LOCK_*` constants for use with [`flock`] and [`fcntl_lock`].
-///
-/// [`flock`]: crate::fs::flock
-/// [`fcntl_lock`]: crate::fs::fcntl_lock
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-#[repr(u32)]
-pub enum FlockOperation {
-    /// `LOCK_SH`
-    LockShared = linux_raw_sys::general::LOCK_SH,
-    /// `LOCK_EX`
-    LockExclusive = linux_raw_sys::general::LOCK_EX,
-    /// `LOCK_UN`
-    Unlock = linux_raw_sys::general::LOCK_UN,
-    /// `LOCK_SH | LOCK_NB`
-    NonBlockingLockShared = linux_raw_sys::general::LOCK_SH | linux_raw_sys::general::LOCK_NB,
-    /// `LOCK_EX | LOCK_NB`
-    NonBlockingLockExclusive = linux_raw_sys::general::LOCK_EX | linux_raw_sys::general::LOCK_NB,
-    /// `LOCK_UN | LOCK_NB`
-    NonBlockingUnlock = linux_raw_sys::general::LOCK_UN | linux_raw_sys::general::LOCK_NB,
-}
-
-/// `struct stat` for use with [`statat`] and [`fstat`].
-///
-/// [`statat`]: crate::fs::statat
-/// [`fstat`]: crate::fs::fstat
-// On 32-bit, and mips64, 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(any(
-    target_pointer_width = "32",
-    target_arch = "mips64",
-    target_arch = "mips64r6"
-))]
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-#[allow(missing_docs)]
-pub struct Stat {
-    pub st_dev: u64,
-    pub st_mode: u32,
-    pub st_nlink: u32,
-    pub st_uid: u32,
-    pub st_gid: u32,
-    pub st_rdev: u64,
-    pub st_size: i64,
-    pub st_blksize: u32,
-    pub st_blocks: u64,
-    pub st_atime: u64,
-    pub st_atime_nsec: u32,
-    pub st_mtime: u64,
-    pub st_mtime_nsec: u32,
-    pub st_ctime: u64,
-    pub st_ctime_nsec: u32,
-    pub st_ino: u64,
-}
-
-/// `struct stat` for use with [`statat`] and [`fstat`].
-///
-/// [`statat`]: crate::fs::statat
-/// [`fstat`]: crate::fs::fstat
-#[cfg(all(
-    target_pointer_width = "64",
-    not(target_arch = "mips64"),
-    not(target_arch = "mips64r6")
-))]
-pub type Stat = linux_raw_sys::general::stat;
-
-/// `struct statfs` for use with [`statfs`] and [`fstatfs`].
-///
-/// [`statfs`]: crate::fs::statfs
-/// [`fstatfs`]: crate::fs::fstatfs
-#[allow(clippy::module_name_repetitions)]
-pub type StatFs = linux_raw_sys::general::statfs64;
-
-/// `struct statvfs` for use with [`statvfs`] and [`fstatvfs`].
-///
-/// [`statvfs`]: crate::fs::statvfs
-/// [`fstatvfs`]: crate::fs::fstatvfs
-#[allow(missing_docs)]
-pub struct StatVfs {
-    pub f_bsize: u64,
-    pub f_frsize: u64,
-    pub f_blocks: u64,
-    pub f_bfree: u64,
-    pub f_bavail: u64,
-    pub f_files: u64,
-    pub f_ffree: u64,
-    pub f_favail: u64,
-    pub f_fsid: u64,
-    pub f_flag: StatVfsMountFlags,
-    pub f_namemax: u64,
-}
-
-/// `struct statx` for use with [`statx`].
-///
-/// [`statx`]: crate::fs::statx
-pub type Statx = linux_raw_sys::general::statx;
-
-/// `struct statx_timestamp` for use with [`Statx`].
-pub type StatxTimestamp = linux_raw_sys::general::statx_timestamp;
-
-/// `mode_t`
-#[cfg(not(any(
-    target_arch = "x86",
-    target_arch = "sparc",
-    target_arch = "avr",
-    target_arch = "arm",
-)))]
-pub type RawMode = linux_raw_sys::general::__kernel_mode_t;
-
-/// `mode_t`
-#[cfg(any(
-    target_arch = "x86",
-    target_arch = "sparc",
-    target_arch = "avr",
-    target_arch = "arm",
-))]
-// Don't use `__kernel_mode_t` since it's `u16` which differs from `st_size`.
-pub type RawMode = c::c_uint;
-
-/// `dev_t`
-// Within the kernel the dev_t is 32-bit, but userspace uses a 64-bit field.
-pub type Dev = u64;
-
-/// `__fsword_t`
-#[cfg(not(any(target_arch = "mips64", target_arch = "mips64r6")))]
-pub type FsWord = linux_raw_sys::general::__fsword_t;
-
-/// `__fsword_t`
-#[cfg(any(target_arch = "mips64", target_arch = "mips64r6"))]
-pub type FsWord = i64;
diff --git a/vendor/rustix/src/backend/linux_raw/io/errno.rs b/vendor/rustix/src/backend/linux_raw/io/errno.rs
deleted file mode 100644
index bc40e9a..0000000
--- a/vendor/rustix/src/backend/linux_raw/io/errno.rs
+++ /dev/null
@@ -1,553 +0,0 @@
-//! The `rustix` `Errno` type.
-//!
-//! This type holds an OS error code, which conceptually corresponds to an
-//! `errno` value.
-//!
-//! # Safety
-//!
-//! Linux uses error codes in `-4095..0`; we use rustc attributes to describe
-//! this restricted range of values.
-#![allow(unsafe_code)]
-#![cfg_attr(not(rustc_attrs), allow(unused_unsafe))]
-
-use crate::backend::c;
-use crate::backend::fd::RawFd;
-use crate::backend::reg::{RetNumber, RetReg};
-use crate::io;
-use linux_raw_sys::errno;
-
-/// `errno`—An error code.
-///
-/// The error type for `rustix` APIs. This is similar to [`std::io::Error`],
-/// but only holds an OS error code, and no extra error value.
-///
-/// # References
-///  - [POSIX]
-///  - [Linux]
-///  - [Winsock]
-///  - [FreeBSD]
-///  - [NetBSD]
-///  - [OpenBSD]
-///  - [DragonFly BSD]
-///  - [illumos]
-///  - [glibc]
-///
-/// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/errno.html
-/// [Linux]: https://man7.org/linux/man-pages/man3/errno.3.html
-/// [Winsock]: https://learn.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2
-/// [FreeBSD]: https://man.freebsd.org/cgi/man.cgi?errno
-/// [NetBSD]: https://man.netbsd.org/errno.2
-/// [OpenBSD]: https://man.openbsd.org/errno.2
-/// [DragonFly BSD]: https://man.dragonflybsd.org/?command=errno&section=2
-/// [illumos]: https://illumos.org/man/3C/errno
-/// [glibc]: https://www.gnu.org/software/libc/manual/html_node/Error-Codes.html
-/// [`std::io::Error`]: Result
-#[repr(transparent)]
-#[doc(alias = "errno")]
-#[derive(Eq, PartialEq, Hash, Copy, Clone)]
-// Linux returns negated error codes, and we leave them in negated form, so
-// error codes are in `-4095..0`.
-#[cfg_attr(rustc_attrs, rustc_layout_scalar_valid_range_start(0xf001))]
-#[cfg_attr(rustc_attrs, rustc_layout_scalar_valid_range_end(0xffff))]
-pub struct Errno(u16);
-
-impl Errno {
-    /// Extract an `Errno` value from a `std::io::Error`.
-    ///
-    /// This isn't a `From` conversion because it's expected to be relatively
-    /// uncommon.
-    #[cfg(feature = "std")]
-    #[inline]
-    pub fn from_io_error(io_err: &std::io::Error) -> Option<Self> {
-        io_err.raw_os_error().and_then(|raw| {
-            // `std::io::Error` could theoretically have arbitrary OS error
-            // values, so check that they're in Linux's range.
-            if (1..4096).contains(&raw) {
-                Some(Self::from_errno(raw as u32))
-            } else {
-                None
-            }
-        })
-    }
-
-    /// Extract the raw OS error number from this error.
-    #[inline]
-    pub const fn raw_os_error(self) -> i32 {
-        (self.0 as i16 as i32).wrapping_neg()
-    }
-
-    /// Construct an `Errno` from a raw OS error number.
-    #[inline]
-    pub const fn from_raw_os_error(raw: i32) -> Self {
-        Self::from_errno(raw as u32)
-    }
-
-    /// 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.
-        let encoded = raw.wrapping_neg() as u16;
-
-        // TODO: Use Range::contains, once that's `const`.
-        assert!(encoded >= 0xf001);
-
-        // SAFETY: Linux syscalls return negated error values in the range
-        // `-4095..0`, which we just asserted.
-        unsafe { Self(encoded) }
-    }
-}
-
-/// Check for an error from the result of a syscall which encodes a
-/// `c::c_int` on success.
-#[inline]
-pub(in crate::backend) fn try_decode_c_int<Num: RetNumber>(
-    raw: RetReg<Num>,
-) -> io::Result<c::c_int> {
-    if raw.is_in_range(-4095..0) {
-        // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
-        // in that range.
-        return Err(unsafe { Errno(raw.decode_error_code()) });
-    }
-
-    Ok(raw.decode_c_int())
-}
-
-/// Check for an error from the result of a syscall which encodes a
-/// `c::c_uint` on success.
-#[inline]
-pub(in crate::backend) fn try_decode_c_uint<Num: RetNumber>(
-    raw: RetReg<Num>,
-) -> io::Result<c::c_uint> {
-    if raw.is_in_range(-4095..0) {
-        // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
-        // in that range.
-        return Err(unsafe { Errno(raw.decode_error_code()) });
-    }
-
-    Ok(raw.decode_c_uint())
-}
-
-/// Check for an error from the result of a syscall which encodes a `usize` on
-/// success.
-#[inline]
-pub(in crate::backend) fn try_decode_usize<Num: RetNumber>(raw: RetReg<Num>) -> io::Result<usize> {
-    if raw.is_in_range(-4095..0) {
-        // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
-        // in that range.
-        return Err(unsafe { Errno(raw.decode_error_code()) });
-    }
-
-    Ok(raw.decode_usize())
-}
-
-/// Check for an error from the result of a syscall which encodes a
-/// `*mut c_void` on success.
-#[inline]
-pub(in crate::backend) fn try_decode_void_star<Num: RetNumber>(
-    raw: RetReg<Num>,
-) -> io::Result<*mut c::c_void> {
-    if raw.is_in_range(-4095..0) {
-        // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
-        // in that range.
-        return Err(unsafe { Errno(raw.decode_error_code()) });
-    }
-
-    Ok(raw.decode_void_star())
-}
-
-/// Check for an error from the result of a syscall which encodes a
-/// `u64` on success.
-#[cfg(target_pointer_width = "64")]
-#[inline]
-pub(in crate::backend) fn try_decode_u64<Num: RetNumber>(raw: RetReg<Num>) -> io::Result<u64> {
-    if raw.is_in_range(-4095..0) {
-        // SAFETY: `raw` must be in `-4095..0`, and we just checked that raw is
-        // in that range.
-        return Err(unsafe { Errno(raw.decode_error_code()) });
-    }
-
-    Ok(raw.decode_u64())
-}
-
-/// Check for an error from the result of a syscall which encodes a file
-/// descriptor on success.
-///
-/// # Safety
-///
-/// This must only be used with syscalls which return file descriptors on
-/// success.
-#[inline]
-pub(in crate::backend) unsafe fn try_decode_raw_fd<Num: RetNumber>(
-    raw: RetReg<Num>,
-) -> io::Result<RawFd> {
-    // Instead of using `check_result` here, we just check for negative, since
-    // this function is only used for system calls which return file
-    // descriptors, and this produces smaller code.
-    if raw.is_negative() {
-        debug_assert!(raw.is_in_range(-4095..0));
-
-        // Tell the optimizer that we know the value is in the error range.
-        // This helps it avoid unnecessary integer conversions.
-        #[cfg(core_intrinsics)]
-        {
-            core::intrinsics::assume(raw.is_in_range(-4095..0));
-        }
-
-        return Err(Errno(raw.decode_error_code()));
-    }
-
-    Ok(raw.decode_raw_fd())
-}
-
-/// Check for an error from the result of a syscall which encodes no value on
-/// success. On success, return the unconsumed `raw` value.
-///
-/// # Safety
-///
-/// This must only be used with syscalls which return no value on success.
-#[inline]
-pub(in crate::backend) unsafe fn try_decode_void<Num: RetNumber>(
-    raw: RetReg<Num>,
-) -> io::Result<()> {
-    // Instead of using `check_result` here, we just check for zero, since this
-    // function is only used for system calls which have no other return value,
-    // and this produces smaller code.
-    if raw.is_nonzero() {
-        debug_assert!(raw.is_in_range(-4095..0));
-
-        // Tell the optimizer that we know the value is in the error range.
-        // This helps it avoid unnecessary integer conversions.
-        #[cfg(core_intrinsics)]
-        {
-            core::intrinsics::assume(raw.is_in_range(-4095..0));
-        }
-
-        return Err(Errno(raw.decode_error_code()));
-    }
-
-    raw.decode_void();
-
-    Ok(())
-}
-
-/// Check for an error from the result of a syscall which does not return on
-/// success. On success, return the unconsumed `raw` value.
-///
-/// # Safety
-///
-/// This must only be used with syscalls which do not return on success.
-#[cfg(any(feature = "event", feature = "runtime"))]
-#[inline]
-pub(in crate::backend) unsafe fn try_decode_error<Num: RetNumber>(raw: RetReg<Num>) -> io::Errno {
-    debug_assert!(raw.is_in_range(-4095..0));
-
-    // Tell the optimizer that we know the value is in the error range.
-    // This helps it avoid unnecessary integer conversions.
-    #[cfg(core_intrinsics)]
-    {
-        core::intrinsics::assume(raw.is_in_range(-4095..0));
-    }
-
-    Errno(raw.decode_error_code())
-}
-
-/// Return the contained `usize` value.
-#[cfg(not(debug_assertions))]
-#[inline]
-pub(in crate::backend) fn decode_usize_infallible<Num: RetNumber>(raw: RetReg<Num>) -> usize {
-    raw.decode_usize()
-}
-
-/// 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()
-}
-
-impl Errno {
-    /// `EACCES`
-    #[doc(alias = "ACCES")]
-    pub const ACCESS: Self = Self::from_errno(errno::EACCES);
-    /// `EADDRINUSE`
-    pub const ADDRINUSE: Self = Self::from_errno(errno::EADDRINUSE);
-    /// `EADDRNOTAVAIL`
-    pub const ADDRNOTAVAIL: Self = Self::from_errno(errno::EADDRNOTAVAIL);
-    /// `EADV`
-    pub const ADV: Self = Self::from_errno(errno::EADV);
-    /// `EAFNOSUPPORT`
-    pub const AFNOSUPPORT: Self = Self::from_errno(errno::EAFNOSUPPORT);
-    /// `EAGAIN`
-    pub const AGAIN: Self = Self::from_errno(errno::EAGAIN);
-    /// `EALREADY`
-    pub const ALREADY: Self = Self::from_errno(errno::EALREADY);
-    /// `EBADE`
-    pub const BADE: Self = Self::from_errno(errno::EBADE);
-    /// `EBADF`
-    pub const BADF: Self = Self::from_errno(errno::EBADF);
-    /// `EBADFD`
-    pub const BADFD: Self = Self::from_errno(errno::EBADFD);
-    /// `EBADMSG`
-    pub const BADMSG: Self = Self::from_errno(errno::EBADMSG);
-    /// `EBADR`
-    pub const BADR: Self = Self::from_errno(errno::EBADR);
-    /// `EBADRQC`
-    pub const BADRQC: Self = Self::from_errno(errno::EBADRQC);
-    /// `EBADSLT`
-    pub const BADSLT: Self = Self::from_errno(errno::EBADSLT);
-    /// `EBFONT`
-    pub const BFONT: Self = Self::from_errno(errno::EBFONT);
-    /// `EBUSY`
-    pub const BUSY: Self = Self::from_errno(errno::EBUSY);
-    /// `ECANCELED`
-    pub const CANCELED: Self = Self::from_errno(errno::ECANCELED);
-    /// `ECHILD`
-    pub const CHILD: Self = Self::from_errno(errno::ECHILD);
-    /// `ECHRNG`
-    pub const CHRNG: Self = Self::from_errno(errno::ECHRNG);
-    /// `ECOMM`
-    pub const COMM: Self = Self::from_errno(errno::ECOMM);
-    /// `ECONNABORTED`
-    pub const CONNABORTED: Self = Self::from_errno(errno::ECONNABORTED);
-    /// `ECONNREFUSED`
-    pub const CONNREFUSED: Self = Self::from_errno(errno::ECONNREFUSED);
-    /// `ECONNRESET`
-    pub const CONNRESET: Self = Self::from_errno(errno::ECONNRESET);
-    /// `EDEADLK`
-    pub const DEADLK: Self = Self::from_errno(errno::EDEADLK);
-    /// `EDEADLOCK`
-    pub const DEADLOCK: Self = Self::from_errno(errno::EDEADLOCK);
-    /// `EDESTADDRREQ`
-    pub const DESTADDRREQ: Self = Self::from_errno(errno::EDESTADDRREQ);
-    /// `EDOM`
-    pub const DOM: Self = Self::from_errno(errno::EDOM);
-    /// `EDOTDOT`
-    pub const DOTDOT: Self = Self::from_errno(errno::EDOTDOT);
-    /// `EDQUOT`
-    pub const DQUOT: Self = Self::from_errno(errno::EDQUOT);
-    /// `EEXIST`
-    pub const EXIST: Self = Self::from_errno(errno::EEXIST);
-    /// `EFAULT`
-    pub const FAULT: Self = Self::from_errno(errno::EFAULT);
-    /// `EFBIG`
-    pub const FBIG: Self = Self::from_errno(errno::EFBIG);
-    /// `EHOSTDOWN`
-    pub const HOSTDOWN: Self = Self::from_errno(errno::EHOSTDOWN);
-    /// `EHOSTUNREACH`
-    pub const HOSTUNREACH: Self = Self::from_errno(errno::EHOSTUNREACH);
-    /// `EHWPOISON`
-    pub const HWPOISON: Self = Self::from_errno(errno::EHWPOISON);
-    /// `EIDRM`
-    pub const IDRM: Self = Self::from_errno(errno::EIDRM);
-    /// `EILSEQ`
-    pub const ILSEQ: Self = Self::from_errno(errno::EILSEQ);
-    /// `EINPROGRESS`
-    pub const INPROGRESS: Self = Self::from_errno(errno::EINPROGRESS);
-    /// `EINTR`.
-    ///
-    /// For a convenient way to retry system calls that exit with `INTR`, use
-    /// [`retry_on_intr`].
-    ///
-    /// [`retry_on_intr`]: io::retry_on_intr
-    pub const INTR: Self = Self::from_errno(errno::EINTR);
-    /// `EINVAL`
-    pub const INVAL: Self = Self::from_errno(errno::EINVAL);
-    /// `EIO`
-    pub const IO: Self = Self::from_errno(errno::EIO);
-    /// `EISCONN`
-    pub const ISCONN: Self = Self::from_errno(errno::EISCONN);
-    /// `EISDIR`
-    pub const ISDIR: Self = Self::from_errno(errno::EISDIR);
-    /// `EISNAM`
-    pub const ISNAM: Self = Self::from_errno(errno::EISNAM);
-    /// `EKEYEXPIRED`
-    pub const KEYEXPIRED: Self = Self::from_errno(errno::EKEYEXPIRED);
-    /// `EKEYREJECTED`
-    pub const KEYREJECTED: Self = Self::from_errno(errno::EKEYREJECTED);
-    /// `EKEYREVOKED`
-    pub const KEYREVOKED: Self = Self::from_errno(errno::EKEYREVOKED);
-    /// `EL2HLT`
-    pub const L2HLT: Self = Self::from_errno(errno::EL2HLT);
-    /// `EL2NSYNC`
-    pub const L2NSYNC: Self = Self::from_errno(errno::EL2NSYNC);
-    /// `EL3HLT`
-    pub const L3HLT: Self = Self::from_errno(errno::EL3HLT);
-    /// `EL3RST`
-    pub const L3RST: Self = Self::from_errno(errno::EL3RST);
-    /// `ELIBACC`
-    pub const LIBACC: Self = Self::from_errno(errno::ELIBACC);
-    /// `ELIBBAD`
-    pub const LIBBAD: Self = Self::from_errno(errno::ELIBBAD);
-    /// `ELIBEXEC`
-    pub const LIBEXEC: Self = Self::from_errno(errno::ELIBEXEC);
-    /// `ELIBMAX`
-    pub const LIBMAX: Self = Self::from_errno(errno::ELIBMAX);
-    /// `ELIBSCN`
-    pub const LIBSCN: Self = Self::from_errno(errno::ELIBSCN);
-    /// `ELNRNG`
-    pub const LNRNG: Self = Self::from_errno(errno::ELNRNG);
-    /// `ELOOP`
-    pub const LOOP: Self = Self::from_errno(errno::ELOOP);
-    /// `EMEDIUMTYPE`
-    pub const MEDIUMTYPE: Self = Self::from_errno(errno::EMEDIUMTYPE);
-    /// `EMFILE`
-    pub const MFILE: Self = Self::from_errno(errno::EMFILE);
-    /// `EMLINK`
-    pub const MLINK: Self = Self::from_errno(errno::EMLINK);
-    /// `EMSGSIZE`
-    pub const MSGSIZE: Self = Self::from_errno(errno::EMSGSIZE);
-    /// `EMULTIHOP`
-    pub const MULTIHOP: Self = Self::from_errno(errno::EMULTIHOP);
-    /// `ENAMETOOLONG`
-    pub const NAMETOOLONG: Self = Self::from_errno(errno::ENAMETOOLONG);
-    /// `ENAVAIL`
-    pub const NAVAIL: Self = Self::from_errno(errno::ENAVAIL);
-    /// `ENETDOWN`
-    pub const NETDOWN: Self = Self::from_errno(errno::ENETDOWN);
-    /// `ENETRESET`
-    pub const NETRESET: Self = Self::from_errno(errno::ENETRESET);
-    /// `ENETUNREACH`
-    pub const NETUNREACH: Self = Self::from_errno(errno::ENETUNREACH);
-    /// `ENFILE`
-    pub const NFILE: Self = Self::from_errno(errno::ENFILE);
-    /// `ENOANO`
-    pub const NOANO: Self = Self::from_errno(errno::ENOANO);
-    /// `ENOBUFS`
-    pub const NOBUFS: Self = Self::from_errno(errno::ENOBUFS);
-    /// `ENOCSI`
-    pub const NOCSI: Self = Self::from_errno(errno::ENOCSI);
-    /// `ENODATA`
-    #[doc(alias = "NOATTR")]
-    pub const NODATA: Self = Self::from_errno(errno::ENODATA);
-    /// `ENODEV`
-    pub const NODEV: Self = Self::from_errno(errno::ENODEV);
-    /// `ENOENT`
-    pub const NOENT: Self = Self::from_errno(errno::ENOENT);
-    /// `ENOEXEC`
-    pub const NOEXEC: Self = Self::from_errno(errno::ENOEXEC);
-    /// `ENOKEY`
-    pub const NOKEY: Self = Self::from_errno(errno::ENOKEY);
-    /// `ENOLCK`
-    pub const NOLCK: Self = Self::from_errno(errno::ENOLCK);
-    /// `ENOLINK`
-    pub const NOLINK: Self = Self::from_errno(errno::ENOLINK);
-    /// `ENOMEDIUM`
-    pub const NOMEDIUM: Self = Self::from_errno(errno::ENOMEDIUM);
-    /// `ENOMEM`
-    pub const NOMEM: Self = Self::from_errno(errno::ENOMEM);
-    /// `ENOMSG`
-    pub const NOMSG: Self = Self::from_errno(errno::ENOMSG);
-    /// `ENONET`
-    pub const NONET: Self = Self::from_errno(errno::ENONET);
-    /// `ENOPKG`
-    pub const NOPKG: Self = Self::from_errno(errno::ENOPKG);
-    /// `ENOPROTOOPT`
-    pub const NOPROTOOPT: Self = Self::from_errno(errno::ENOPROTOOPT);
-    /// `ENOSPC`
-    pub const NOSPC: Self = Self::from_errno(errno::ENOSPC);
-    /// `ENOSR`
-    pub const NOSR: Self = Self::from_errno(errno::ENOSR);
-    /// `ENOSTR`
-    pub const NOSTR: Self = Self::from_errno(errno::ENOSTR);
-    /// `ENOSYS`
-    pub const NOSYS: Self = Self::from_errno(errno::ENOSYS);
-    /// `ENOTBLK`
-    pub const NOTBLK: Self = Self::from_errno(errno::ENOTBLK);
-    /// `ENOTCONN`
-    pub const NOTCONN: Self = Self::from_errno(errno::ENOTCONN);
-    /// `ENOTDIR`
-    pub const NOTDIR: Self = Self::from_errno(errno::ENOTDIR);
-    /// `ENOTEMPTY`
-    pub const NOTEMPTY: Self = Self::from_errno(errno::ENOTEMPTY);
-    /// `ENOTNAM`
-    pub const NOTNAM: Self = Self::from_errno(errno::ENOTNAM);
-    /// `ENOTRECOVERABLE`
-    pub const NOTRECOVERABLE: Self = Self::from_errno(errno::ENOTRECOVERABLE);
-    /// `ENOTSOCK`
-    pub const NOTSOCK: Self = Self::from_errno(errno::ENOTSOCK);
-    /// `ENOTSUP`
-    // On Linux, `ENOTSUP` has the same value as `EOPNOTSUPP`.
-    pub const NOTSUP: Self = Self::from_errno(errno::EOPNOTSUPP);
-    /// `ENOTTY`
-    pub const NOTTY: Self = Self::from_errno(errno::ENOTTY);
-    /// `ENOTUNIQ`
-    pub const NOTUNIQ: Self = Self::from_errno(errno::ENOTUNIQ);
-    /// `ENXIO`
-    pub const NXIO: Self = Self::from_errno(errno::ENXIO);
-    /// `EOPNOTSUPP`
-    pub const OPNOTSUPP: Self = Self::from_errno(errno::EOPNOTSUPP);
-    /// `EOVERFLOW`
-    pub const OVERFLOW: Self = Self::from_errno(errno::EOVERFLOW);
-    /// `EOWNERDEAD`
-    pub const OWNERDEAD: Self = Self::from_errno(errno::EOWNERDEAD);
-    /// `EPERM`
-    pub const PERM: Self = Self::from_errno(errno::EPERM);
-    /// `EPFNOSUPPORT`
-    pub const PFNOSUPPORT: Self = Self::from_errno(errno::EPFNOSUPPORT);
-    /// `EPIPE`
-    pub const PIPE: Self = Self::from_errno(errno::EPIPE);
-    /// `EPROTO`
-    pub const PROTO: Self = Self::from_errno(errno::EPROTO);
-    /// `EPROTONOSUPPORT`
-    pub const PROTONOSUPPORT: Self = Self::from_errno(errno::EPROTONOSUPPORT);
-    /// `EPROTOTYPE`
-    pub const PROTOTYPE: Self = Self::from_errno(errno::EPROTOTYPE);
-    /// `ERANGE`
-    pub const RANGE: Self = Self::from_errno(errno::ERANGE);
-    /// `EREMCHG`
-    pub const REMCHG: Self = Self::from_errno(errno::EREMCHG);
-    /// `EREMOTE`
-    pub const REMOTE: Self = Self::from_errno(errno::EREMOTE);
-    /// `EREMOTEIO`
-    pub const REMOTEIO: Self = Self::from_errno(errno::EREMOTEIO);
-    /// `ERESTART`
-    pub const RESTART: Self = Self::from_errno(errno::ERESTART);
-    /// `ERFKILL`
-    pub const RFKILL: Self = Self::from_errno(errno::ERFKILL);
-    /// `EROFS`
-    pub const ROFS: Self = Self::from_errno(errno::EROFS);
-    /// `ESHUTDOWN`
-    pub const SHUTDOWN: Self = Self::from_errno(errno::ESHUTDOWN);
-    /// `ESOCKTNOSUPPORT`
-    pub const SOCKTNOSUPPORT: Self = Self::from_errno(errno::ESOCKTNOSUPPORT);
-    /// `ESPIPE`
-    pub const SPIPE: Self = Self::from_errno(errno::ESPIPE);
-    /// `ESRCH`
-    pub const SRCH: Self = Self::from_errno(errno::ESRCH);
-    /// `ESRMNT`
-    pub const SRMNT: Self = Self::from_errno(errno::ESRMNT);
-    /// `ESTALE`
-    pub const STALE: Self = Self::from_errno(errno::ESTALE);
-    /// `ESTRPIPE`
-    pub const STRPIPE: Self = Self::from_errno(errno::ESTRPIPE);
-    /// `ETIME`
-    pub const TIME: Self = Self::from_errno(errno::ETIME);
-    /// `ETIMEDOUT`
-    pub const TIMEDOUT: Self = Self::from_errno(errno::ETIMEDOUT);
-    /// `E2BIG`
-    #[doc(alias = "2BIG")]
-    pub const TOOBIG: Self = Self::from_errno(errno::E2BIG);
-    /// `ETOOMANYREFS`
-    pub const TOOMANYREFS: Self = Self::from_errno(errno::ETOOMANYREFS);
-    /// `ETXTBSY`
-    pub const TXTBSY: Self = Self::from_errno(errno::ETXTBSY);
-    /// `EUCLEAN`
-    pub const UCLEAN: Self = Self::from_errno(errno::EUCLEAN);
-    /// `EUNATCH`
-    pub const UNATCH: Self = Self::from_errno(errno::EUNATCH);
-    /// `EUSERS`
-    pub const USERS: Self = Self::from_errno(errno::EUSERS);
-    /// `EWOULDBLOCK`
-    pub const WOULDBLOCK: Self = Self::from_errno(errno::EWOULDBLOCK);
-    /// `EXDEV`
-    pub const XDEV: Self = Self::from_errno(errno::EXDEV);
-    /// `EXFULL`
-    pub const XFULL: Self = Self::from_errno(errno::EXFULL);
-}
diff --git a/vendor/rustix/src/backend/linux_raw/io/mod.rs b/vendor/rustix/src/backend/linux_raw/io/mod.rs
deleted file mode 100644
index 9477b9b..0000000
--- a/vendor/rustix/src/backend/linux_raw/io/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub(crate) mod errno;
-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
deleted file mode 100644
index c38f28f..0000000
--- a/vendor/rustix/src/backend/linux_raw/io/syscalls.rs
+++ /dev/null
@@ -1,379 +0,0 @@
-//! linux_raw syscalls supporting `rustix::io`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code)]
-#![allow(clippy::undocumented_unsafe_blocks)]
-
-#[cfg(target_pointer_width = "64")]
-use crate::backend::conv::loff_t_from_u64;
-#[cfg(all(
-    target_pointer_width = "32",
-    any(target_arch = "arm", target_arch = "mips", target_arch = "mips32r6"),
-))]
-use crate::backend::conv::zero;
-use crate::backend::conv::{
-    c_uint, pass_usize, raw_fd, ret, ret_c_int, ret_c_uint, ret_discarded_fd, ret_owned_fd,
-    ret_usize, slice,
-};
-#[cfg(target_pointer_width = "32")]
-use crate::backend::conv::{hi, lo};
-use crate::backend::{c, MAX_IOV};
-use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
-use crate::io::{self, DupFlags, FdFlags, IoSlice, IoSliceMut, ReadWriteFlags};
-use crate::ioctl::{IoctlOutput, RawOpcode};
-#[cfg(all(feature = "fs", feature = "net"))]
-use crate::net::{RecvFlags, SendFlags};
-use core::cmp;
-use linux_raw_sys::general::{F_DUPFD_CLOEXEC, F_GETFD, F_SETFD};
-
-#[inline]
-pub(crate) unsafe fn read(fd: BorrowedFd<'_>, buf: *mut u8, len: usize) -> io::Result<usize> {
-    ret_usize(syscall!(__NR_read, fd, buf, pass_usize(len)))
-}
-
-#[inline]
-pub(crate) unsafe fn pread(
-    fd: BorrowedFd<'_>,
-    buf: *mut u8,
-    len: usize,
-    pos: u64,
-) -> io::Result<usize> {
-    // <https://github.com/torvalds/linux/blob/fcadab740480e0e0e9fa9bd272acd409884d431a/arch/arm64/kernel/sys32.c#L75>
-    #[cfg(all(
-        target_pointer_width = "32",
-        any(target_arch = "arm", target_arch = "mips", target_arch = "mips32r6"),
-    ))]
-    {
-        ret_usize(syscall!(
-            __NR_pread64,
-            fd,
-            buf,
-            pass_usize(len),
-            zero(),
-            hi(pos),
-            lo(pos)
-        ))
-    }
-    #[cfg(all(
-        target_pointer_width = "32",
-        not(any(target_arch = "arm", target_arch = "mips", target_arch = "mips32r6")),
-    ))]
-    {
-        ret_usize(syscall!(
-            __NR_pread64,
-            fd,
-            buf,
-            pass_usize(len),
-            hi(pos),
-            lo(pos)
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    ret_usize(syscall!(
-        __NR_pread64,
-        fd,
-        buf,
-        pass_usize(len),
-        loff_t_from_u64(pos)
-    ))
-}
-
-#[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)]);
-
-    unsafe { ret_usize(syscall!(__NR_readv, fd, bufs_addr, bufs_len)) }
-}
-
-#[inline]
-pub(crate) fn preadv(
-    fd: BorrowedFd<'_>,
-    bufs: &mut [IoSliceMut<'_>],
-    pos: u64,
-) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
-
-    // Unlike the plain "p" functions, the "pv" functions pass their offset in
-    // an endian-independent way, and always in two registers.
-    unsafe {
-        ret_usize(syscall!(
-            __NR_preadv,
-            fd,
-            bufs_addr,
-            bufs_len,
-            pass_usize(pos as usize),
-            pass_usize((pos >> 32) as usize)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn preadv2(
-    fd: BorrowedFd<'_>,
-    bufs: &mut [IoSliceMut<'_>],
-    pos: u64,
-    flags: ReadWriteFlags,
-) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
-
-    // Unlike the plain "p" functions, the "pv" functions pass their offset in
-    // an endian-independent way, and always in two registers.
-    unsafe {
-        ret_usize(syscall!(
-            __NR_preadv2,
-            fd,
-            bufs_addr,
-            bufs_len,
-            pass_usize(pos as usize),
-            pass_usize((pos >> 32) as usize),
-            flags
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn write(fd: BorrowedFd<'_>, buf: &[u8]) -> io::Result<usize> {
-    let (buf_addr, buf_len) = slice(buf);
-
-    unsafe { ret_usize(syscall_readonly!(__NR_write, fd, buf_addr, buf_len)) }
-}
-
-#[inline]
-pub(crate) fn pwrite(fd: BorrowedFd<'_>, buf: &[u8], pos: u64) -> io::Result<usize> {
-    let (buf_addr, buf_len) = slice(buf);
-
-    // <https://github.com/torvalds/linux/blob/fcadab740480e0e0e9fa9bd272acd409884d431a/arch/arm64/kernel/sys32.c#L81-L83>
-    #[cfg(all(
-        target_pointer_width = "32",
-        any(target_arch = "arm", target_arch = "mips", target_arch = "mips32r6"),
-    ))]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_pwrite64,
-            fd,
-            buf_addr,
-            buf_len,
-            zero(),
-            hi(pos),
-            lo(pos)
-        ))
-    }
-    #[cfg(all(
-        target_pointer_width = "32",
-        not(any(target_arch = "arm", target_arch = "mips", target_arch = "mips32r6")),
-    ))]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_pwrite64,
-            fd,
-            buf_addr,
-            buf_len,
-            hi(pos),
-            lo(pos)
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_pwrite64,
-            fd,
-            buf_addr,
-            buf_len,
-            loff_t_from_u64(pos)
-        ))
-    }
-}
-
-#[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)]);
-
-    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)]);
-
-    // Unlike the plain "p" functions, the "pv" functions pass their offset in
-    // an endian-independent way, and always in two registers.
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_pwritev,
-            fd,
-            bufs_addr,
-            bufs_len,
-            pass_usize(pos as usize),
-            pass_usize((pos >> 32) as usize)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn pwritev2(
-    fd: BorrowedFd<'_>,
-    bufs: &[IoSlice<'_>],
-    pos: u64,
-    flags: ReadWriteFlags,
-) -> io::Result<usize> {
-    let (bufs_addr, bufs_len) = slice(&bufs[..cmp::min(bufs.len(), MAX_IOV)]);
-
-    // Unlike the plain "p" functions, the "pv" functions pass their offset in
-    // an endian-independent way, and always in two registers.
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_pwritev2,
-            fd,
-            bufs_addr,
-            bufs_len,
-            pass_usize(pos as usize),
-            pass_usize((pos >> 32) as usize),
-            flags
-        ))
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn close(fd: RawFd) {
-    // See the documentation for [`io::close`] for why errors are ignored.
-    syscall_readonly!(__NR_close, raw_fd(fd)).decode_void();
-}
-
-#[inline]
-pub(crate) unsafe fn ioctl(
-    fd: BorrowedFd<'_>,
-    request: RawOpcode,
-    arg: *mut c::c_void,
-) -> io::Result<IoctlOutput> {
-    ret_c_int(syscall!(__NR_ioctl, fd, c_uint(request), arg))
-}
-
-#[inline]
-pub(crate) unsafe fn ioctl_readonly(
-    fd: BorrowedFd<'_>,
-    request: RawOpcode,
-    arg: *mut c::c_void,
-) -> io::Result<IoctlOutput> {
-    ret_c_int(syscall_readonly!(__NR_ioctl, fd, c_uint(request), arg))
-}
-
-#[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)?;
-    let mut not_socket = false;
-    if read {
-        // Do a `recv` with `PEEK` and `DONTWAIT` for 1 byte. A 0 indicates
-        // the read side is shut down; an `EWOULDBLOCK` indicates the read
-        // side is still open.
-        let mut buf = [core::mem::MaybeUninit::<u8>::uninit()];
-        match unsafe {
-            crate::backend::net::syscalls::recv(
-                fd,
-                buf.as_mut_ptr() as *mut u8,
-                1,
-                RecvFlags::PEEK | RecvFlags::DONTWAIT,
-            )
-        } {
-            Ok(0) => read = false,
-            Err(err) => {
-                #[allow(unreachable_patterns)] // `EAGAIN` may equal `EWOULDBLOCK`
-                match err {
-                    io::Errno::AGAIN | io::Errno::WOULDBLOCK => (),
-                    io::Errno::NOTSOCK => not_socket = true,
-                    _ => return Err(err),
-                }
-            }
-            Ok(_) => (),
-        }
-    }
-    if write && !not_socket {
-        // Do a `send` with `DONTWAIT` for 0 bytes. An `EPIPE` indicates
-        // the write side is shut down.
-        #[allow(unreachable_patterns)] // `EAGAIN` equals `EWOULDBLOCK`
-        match crate::backend::net::syscalls::send(fd, &[], SendFlags::DONTWAIT) {
-            Err(io::Errno::AGAIN | io::Errno::WOULDBLOCK | io::Errno::NOTSOCK) => (),
-            Err(io::Errno::PIPE) => write = false,
-            Err(err) => return Err(err),
-            Ok(_) => (),
-        }
-    }
-    Ok((read, write))
-}
-
-#[inline]
-pub(crate) fn dup(fd: BorrowedFd<'_>) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_dup, fd)) }
-}
-
-#[allow(clippy::needless_pass_by_ref_mut)]
-#[inline]
-pub(crate) fn dup2(fd: BorrowedFd<'_>, new: &mut OwnedFd) -> io::Result<()> {
-    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-    {
-        // We don't need to worry about the difference between `dup2` and
-        // `dup3` when the file descriptors are equal because we have an
-        // `&mut OwnedFd` which means `fd` doesn't alias it.
-        dup3(fd, new, DupFlags::empty())
-    }
-
-    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
-    unsafe {
-        ret_discarded_fd(syscall_readonly!(__NR_dup2, fd, new.as_fd()))
-    }
-}
-
-#[allow(clippy::needless_pass_by_ref_mut)]
-#[inline]
-pub(crate) fn dup3(fd: BorrowedFd<'_>, new: &mut OwnedFd, flags: DupFlags) -> io::Result<()> {
-    unsafe { ret_discarded_fd(syscall_readonly!(__NR_dup3, fd, new.as_fd(), flags)) }
-}
-
-#[inline]
-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_retain)
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_c_uint(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETFD)))
-            .map(FdFlags::from_bits_retain)
-    }
-}
-
-#[inline]
-pub(crate) fn fcntl_setfd(fd: BorrowedFd<'_>, flags: FdFlags) -> io::Result<()> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_SETFD), flags))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(__NR_fcntl, fd, c_uint(F_SETFD), flags))
-    }
-}
-
-#[inline]
-pub(crate) fn fcntl_dupfd_cloexec(fd: BorrowedFd<'_>, min: RawFd) -> io::Result<OwnedFd> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(
-            __NR_fcntl64,
-            fd,
-            c_uint(F_DUPFD_CLOEXEC),
-            raw_fd(min)
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(
-            __NR_fcntl,
-            fd,
-            c_uint(F_DUPFD_CLOEXEC),
-            raw_fd(min)
-        ))
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/io/types.rs b/vendor/rustix/src/backend/linux_raw/io/types.rs
deleted file mode 100644
index 4b3dfc6..0000000
--- a/vendor/rustix/src/backend/linux_raw/io/types.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `RWF_*` constants for use with [`preadv2`] and [`pwritev2`].
-    ///
-    /// [`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;
-        /// `RWF_HIPRI` (since Linux 4.6)
-        const HIPRI = linux_raw_sys::general::RWF_HIPRI;
-        /// `RWF_SYNC` (since Linux 4.7)
-        const SYNC = linux_raw_sys::general::RWF_SYNC;
-        /// `RWF_NOWAIT` (since Linux 4.14)
-        const NOWAIT = linux_raw_sys::general::RWF_NOWAIT;
-        /// `RWF_APPEND` (since Linux 4.16)
-        const APPEND = linux_raw_sys::general::RWF_APPEND;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/io_uring/mod.rs b/vendor/rustix/src/backend/linux_raw/io_uring/mod.rs
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/linux_raw/io_uring/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/linux_raw/io_uring/syscalls.rs b/vendor/rustix/src/backend/linux_raw/io_uring/syscalls.rs
deleted file mode 100644
index d10cd13..0000000
--- a/vendor/rustix/src/backend/linux_raw/io_uring/syscalls.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-//! linux_raw syscalls supporting `rustix::io_uring`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend::syscalls` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-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};
-use core::ffi::c_void;
-
-#[inline]
-pub(crate) fn io_uring_setup(entries: u32, params: &mut io_uring_params) -> io::Result<OwnedFd> {
-    unsafe {
-        ret_owned_fd(syscall!(
-            __NR_io_uring_setup,
-            c_uint(entries),
-            by_mut(params)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn io_uring_register(
-    fd: BorrowedFd<'_>,
-    opcode: IoringRegisterOp,
-    arg: *const c_void,
-    nr_args: u32,
-) -> io::Result<u32> {
-    ret_c_uint(syscall_readonly!(
-        __NR_io_uring_register,
-        fd,
-        c_uint(opcode as u32),
-        arg,
-        c_uint(nr_args)
-    ))
-}
-
-#[inline]
-pub(crate) unsafe fn io_uring_enter(
-    fd: BorrowedFd<'_>,
-    to_submit: u32,
-    min_complete: u32,
-    flags: IoringEnterFlags,
-    arg: *const c_void,
-    size: usize,
-) -> io::Result<u32> {
-    // This is not `_readonly` because `io_uring_enter` waits for I/O to
-    // complete, and I/O could involve writing to memory buffers, which
-    // could be a side effect depended on by the caller.
-    ret_c_uint(syscall!(
-        __NR_io_uring_enter,
-        fd,
-        c_uint(to_submit),
-        c_uint(min_complete),
-        flags,
-        arg,
-        pass_usize(size)
-    ))
-}
diff --git a/vendor/rustix/src/backend/linux_raw/mm/mod.rs b/vendor/rustix/src/backend/linux_raw/mm/mod.rs
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/linux_raw/mm/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/mm/syscalls.rs b/vendor/rustix/src/backend/linux_raw/mm/syscalls.rs
deleted file mode 100644
index 361f111..0000000
--- a/vendor/rustix/src/backend/linux_raw/mm/syscalls.rs
+++ /dev/null
@@ -1,237 +0,0 @@
-//! linux_raw syscalls supporting `rustix::io`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code)]
-#![allow(clippy::undocumented_unsafe_blocks)]
-
-use super::types::{
-    Advice, MapFlags, MlockAllFlags, 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;
-use linux_raw_sys::general::MAP_ANONYMOUS;
-
-#[inline]
-pub(crate) fn madvise(addr: *mut c::c_void, len: usize, advice: Advice) -> io::Result<()> {
-    unsafe {
-        ret(syscall!(
-            __NR_madvise,
-            addr,
-            pass_usize(len),
-            c_uint(advice as c::c_uint)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn msync(addr: *mut c::c_void, len: usize, flags: MsyncFlags) -> io::Result<()> {
-    ret(syscall!(__NR_msync, addr, pass_usize(len), flags))
-}
-
-/// # Safety
-///
-/// `mmap` is primarily unsafe due to the `addr` parameter, as anything working
-/// with memory pointed to by raw pointers is unsafe.
-#[inline]
-pub(crate) unsafe fn mmap(
-    addr: *mut c::c_void,
-    length: usize,
-    prot: ProtFlags,
-    flags: MapFlags,
-    fd: BorrowedFd<'_>,
-    offset: u64,
-) -> io::Result<*mut c::c_void> {
-    #[cfg(target_pointer_width = "32")]
-    {
-        ret_void_star(syscall!(
-            __NR_mmap2,
-            addr,
-            pass_usize(length),
-            prot,
-            flags,
-            fd,
-            (offset / 4096)
-                .try_into()
-                .map(pass_usize)
-                .map_err(|_| io::Errno::INVAL)?
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    {
-        ret_void_star(syscall!(
-            __NR_mmap,
-            addr,
-            pass_usize(length),
-            prot,
-            flags,
-            fd,
-            loff_t_from_u64(offset)
-        ))
-    }
-}
-
-/// # Safety
-///
-/// `mmap` is primarily unsafe due to the `addr` parameter, as anything working
-/// with memory pointed to by raw pointers is unsafe.
-#[inline]
-pub(crate) unsafe fn mmap_anonymous(
-    addr: *mut c::c_void,
-    length: usize,
-    prot: ProtFlags,
-    flags: MapFlags,
-) -> io::Result<*mut c::c_void> {
-    #[cfg(target_pointer_width = "32")]
-    {
-        ret_void_star(syscall!(
-            __NR_mmap2,
-            addr,
-            pass_usize(length),
-            prot,
-            c_uint(flags.bits() | MAP_ANONYMOUS),
-            no_fd(),
-            pass_usize(0)
-        ))
-    }
-    #[cfg(target_pointer_width = "64")]
-    {
-        ret_void_star(syscall!(
-            __NR_mmap,
-            addr,
-            pass_usize(length),
-            prot,
-            c_uint(flags.bits() | MAP_ANONYMOUS),
-            no_fd(),
-            loff_t_from_u64(0)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn mprotect(
-    ptr: *mut c::c_void,
-    len: usize,
-    flags: MprotectFlags,
-) -> io::Result<()> {
-    ret(syscall!(__NR_mprotect, ptr, pass_usize(len), flags))
-}
-
-/// # Safety
-///
-/// `munmap` is primarily unsafe due to the `addr` parameter, as anything
-/// working with memory pointed to by raw pointers is unsafe.
-#[inline]
-pub(crate) unsafe fn munmap(addr: *mut c::c_void, length: usize) -> io::Result<()> {
-    ret(syscall!(__NR_munmap, addr, pass_usize(length)))
-}
-
-/// # Safety
-///
-/// `mremap` is primarily unsafe due to the `old_address` parameter, as
-/// anything working with memory pointed to by raw pointers is unsafe.
-#[inline]
-pub(crate) unsafe fn mremap(
-    old_address: *mut c::c_void,
-    old_size: usize,
-    new_size: usize,
-    flags: MremapFlags,
-) -> io::Result<*mut c::c_void> {
-    ret_void_star(syscall!(
-        __NR_mremap,
-        old_address,
-        pass_usize(old_size),
-        pass_usize(new_size),
-        flags
-    ))
-}
-
-/// # Safety
-///
-/// `mremap_fixed` is primarily unsafe due to the `old_address` and
-/// `new_address` parameters, as anything working with memory pointed to by raw
-/// pointers is unsafe.
-#[inline]
-pub(crate) unsafe fn mremap_fixed(
-    old_address: *mut c::c_void,
-    old_size: usize,
-    new_size: usize,
-    flags: MremapFlags,
-    new_address: *mut c::c_void,
-) -> io::Result<*mut c::c_void> {
-    ret_void_star(syscall!(
-        __NR_mremap,
-        old_address,
-        pass_usize(old_size),
-        pass_usize(new_size),
-        flags,
-        new_address
-    ))
-}
-
-/// # Safety
-///
-/// `mlock` operates on raw pointers and may round out to the nearest page
-/// boundaries.
-#[inline]
-pub(crate) unsafe fn mlock(addr: *mut c::c_void, length: usize) -> io::Result<()> {
-    ret(syscall!(__NR_mlock, addr, pass_usize(length)))
-}
-
-/// # Safety
-///
-/// `mlock_with` operates on raw pointers and may round out to the nearest page
-/// boundaries.
-#[inline]
-pub(crate) unsafe fn mlock_with(
-    addr: *mut c::c_void,
-    length: usize,
-    flags: MlockFlags,
-) -> io::Result<()> {
-    ret(syscall!(__NR_mlock2, addr, pass_usize(length), flags))
-}
-
-/// # Safety
-///
-/// `munlock` operates on raw pointers and may round out to the nearest page
-/// boundaries.
-#[inline]
-pub(crate) unsafe fn munlock(addr: *mut c::c_void, length: usize) -> io::Result<()> {
-    ret(syscall!(__NR_munlock, addr, pass_usize(length)))
-}
-
-#[inline]
-pub(crate) unsafe fn userfaultfd(flags: UserfaultfdFlags) -> io::Result<OwnedFd> {
-    ret_owned_fd(syscall_readonly!(__NR_userfaultfd, flags))
-}
-
-/// Locks all pages mapped into the address space of the calling process.
-///
-/// This includes the pages of the code, data, and stack segment, as well as
-/// shared libraries, user space kernel data, shared memory, and memory-mapped
-/// files. All mapped pages are guaranteed to be resident in RAM when the call
-/// returns successfully; the pages are guaranteed to stay in RAM until later
-/// unlocked.
-#[inline]
-pub(crate) fn mlockall(flags: MlockAllFlags) -> io::Result<()> {
-    // When `mlockall` is used with `MCL_ONFAULT | MCL_FUTURE`, the ordering
-    // of `mlockall` with respect to arbitrary loads may be significant,
-    // because if a load happens and evokes a fault before the `mlockall`,
-    // the memory doesn't get locked, but if the load and therefore
-    // the fault happens after, then the memory does get locked.
-    // So to be conservative in this regard, we use `syscall` instead
-    // of `syscall_readonly`
-    unsafe { ret(syscall!(__NR_mlockall, flags)) }
-}
-
-/// Unlocks all pages mapped into the address space of the calling process.
-#[inline]
-pub(crate) fn munlockall() -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_munlockall)) }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/mm/types.rs b/vendor/rustix/src/backend/linux_raw/mm/types.rs
deleted file mode 100644
index 68898f5..0000000
--- a/vendor/rustix/src/backend/linux_raw/mm/types.rs
+++ /dev/null
@@ -1,295 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `PROT_*` flags for use with [`mmap`].
-    ///
-    /// For `PROT_NONE`, use `ProtFlags::empty()`.
-    ///
-    /// [`mmap`]: crate::mm::mmap
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct ProtFlags: u32 {
-        /// `PROT_READ`
-        const READ = linux_raw_sys::general::PROT_READ;
-        /// `PROT_WRITE`
-        const WRITE = linux_raw_sys::general::PROT_WRITE;
-        /// `PROT_EXEC`
-        const EXEC = linux_raw_sys::general::PROT_EXEC;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `PROT_*` flags for use with [`mprotect`].
-    ///
-    /// For `PROT_NONE`, use `MprotectFlags::empty()`.
-    ///
-    /// [`mprotect`]: crate::mm::mprotect
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MprotectFlags: u32 {
-        /// `PROT_READ`
-        const READ = linux_raw_sys::general::PROT_READ;
-        /// `PROT_WRITE`
-        const WRITE = linux_raw_sys::general::PROT_WRITE;
-        /// `PROT_EXEC`
-        const EXEC = linux_raw_sys::general::PROT_EXEC;
-        /// `PROT_GROWSUP`
-        const GROWSUP = linux_raw_sys::general::PROT_GROWSUP;
-        /// `PROT_GROWSDOWN`
-        const GROWSDOWN = linux_raw_sys::general::PROT_GROWSDOWN;
-        /// `PROT_SEM`
-        const SEM = linux_raw_sys::general::PROT_SEM;
-        /// `PROT_BTI`
-        #[cfg(target_arch = "aarch64")]
-        const BTI = linux_raw_sys::general::PROT_BTI;
-        /// `PROT_MTE`
-        #[cfg(target_arch = "aarch64")]
-        const MTE = linux_raw_sys::general::PROT_MTE;
-        /// `PROT_SAO`
-        #[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
-        const SAO = linux_raw_sys::general::PROT_SAO;
-        /// `PROT_ADI`
-        #[cfg(any(target_arch = "sparc", target_arch = "sparc64"))]
-        const ADI = linux_raw_sys::general::PROT_ADI;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MAP_*` flags for use with [`mmap`].
-    ///
-    /// For `MAP_ANONYMOUS` (aka `MAP_ANON`), see [`mmap_anonymous`].
-    ///
-    /// [`mmap`]: crate::mm::mmap
-    /// [`mmap_anonymous`]: crates::mm::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;
-        /// `MAP_SHARED_VALIDATE` (since Linux 4.15)
-        const SHARED_VALIDATE = linux_raw_sys::general::MAP_SHARED_VALIDATE;
-        /// `MAP_PRIVATE`
-        const PRIVATE = linux_raw_sys::general::MAP_PRIVATE;
-        /// `MAP_DENYWRITE`
-        const DENYWRITE = linux_raw_sys::general::MAP_DENYWRITE;
-        /// `MAP_FIXED`
-        const FIXED = linux_raw_sys::general::MAP_FIXED;
-        /// `MAP_FIXED_NOREPLACE` (since Linux 4.17)
-        const FIXED_NOREPLACE = linux_raw_sys::general::MAP_FIXED_NOREPLACE;
-        /// `MAP_GROWSDOWN`
-        const GROWSDOWN = linux_raw_sys::general::MAP_GROWSDOWN;
-        /// `MAP_HUGETLB`
-        const HUGETLB = linux_raw_sys::general::MAP_HUGETLB;
-        /// `MAP_HUGE_2MB` (since Linux 3.8)
-        const HUGE_2MB = linux_raw_sys::general::MAP_HUGE_2MB;
-        /// `MAP_HUGE_1GB` (since Linux 3.8)
-        const HUGE_1GB = linux_raw_sys::general::MAP_HUGE_1GB;
-        /// `MAP_LOCKED`
-        const LOCKED = linux_raw_sys::general::MAP_LOCKED;
-        /// `MAP_NORESERVE`
-        const NORESERVE = linux_raw_sys::general::MAP_NORESERVE;
-        /// `MAP_POPULATE`
-        const POPULATE = linux_raw_sys::general::MAP_POPULATE;
-        /// `MAP_STACK`
-        const STACK = linux_raw_sys::general::MAP_STACK;
-        /// `MAP_SYNC` (since Linux 4.15)
-        #[cfg(not(any(target_arch = "mips", target_arch = "mips32r6", target_arch = "mips64", target_arch = "mips64r6")))]
-        const SYNC = linux_raw_sys::general::MAP_SYNC;
-        /// `MAP_UNINITIALIZED`
-        #[cfg(not(any(target_arch = "mips", target_arch = "mips32r6", target_arch = "mips64", target_arch = "mips64r6")))]
-        const UNINITIALIZED = linux_raw_sys::general::MAP_UNINITIALIZED;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MREMAP_*` flags for use with [`mremap`].
-    ///
-    /// For `MREMAP_FIXED`, see [`mremap_fixed`].
-    ///
-    /// [`mremap`]: crate::mm::mremap
-    /// [`mremap_fixed`]: crate::mm::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;
-        /// `MREMAP_DONTUNMAP` (since Linux 5.7)
-        const DONTUNMAP = linux_raw_sys::general::MREMAP_DONTUNMAP;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MS_*` flags for use with [`msync`].
-    ///
-    /// [`msync`]: crate::mm::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;
-        /// `MS_ASYNC`—Specifies that an update be scheduled, but the call
-        /// returns immediately.
-        const ASYNC = linux_raw_sys::general::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 = linux_raw_sys::general::MS_INVALIDATE;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MLOCK_*` flags for use with [`mlock_with`].
-    ///
-    /// [`mlock_with`]: crate::mm::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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `POSIX_MADV_*` constants for use with [`madvise`].
-///
-/// [`madvise`]: crate::mm::madvise
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(u32)]
-#[non_exhaustive]
-pub enum Advice {
-    /// `POSIX_MADV_NORMAL`
-    Normal = linux_raw_sys::general::MADV_NORMAL,
-
-    /// `POSIX_MADV_SEQUENTIAL`
-    Sequential = linux_raw_sys::general::MADV_SEQUENTIAL,
-
-    /// `POSIX_MADV_RANDOM`
-    Random = linux_raw_sys::general::MADV_RANDOM,
-
-    /// `POSIX_MADV_WILLNEED`
-    WillNeed = linux_raw_sys::general::MADV_WILLNEED,
-
-    /// `MADV_DONTNEED`
-    LinuxDontNeed = linux_raw_sys::general::MADV_DONTNEED,
-
-    /// `MADV_FREE` (since Linux 4.5)
-    LinuxFree = linux_raw_sys::general::MADV_FREE,
-    /// `MADV_REMOVE`
-    LinuxRemove = linux_raw_sys::general::MADV_REMOVE,
-    /// `MADV_DONTFORK`
-    LinuxDontFork = linux_raw_sys::general::MADV_DONTFORK,
-    /// `MADV_DOFORK`
-    LinuxDoFork = linux_raw_sys::general::MADV_DOFORK,
-    /// `MADV_HWPOISON`
-    LinuxHwPoison = linux_raw_sys::general::MADV_HWPOISON,
-    /// `MADV_SOFT_OFFLINE`
-    #[cfg(not(any(
-        target_arch = "mips",
-        target_arch = "mips32r6",
-        target_arch = "mips64",
-        target_arch = "mips64r6"
-    )))]
-    LinuxSoftOffline = linux_raw_sys::general::MADV_SOFT_OFFLINE,
-    /// `MADV_MERGEABLE`
-    LinuxMergeable = linux_raw_sys::general::MADV_MERGEABLE,
-    /// `MADV_UNMERGEABLE`
-    LinuxUnmergeable = linux_raw_sys::general::MADV_UNMERGEABLE,
-    /// `MADV_HUGEPAGE`
-    LinuxHugepage = linux_raw_sys::general::MADV_HUGEPAGE,
-    /// `MADV_NOHUGEPAGE`
-    LinuxNoHugepage = linux_raw_sys::general::MADV_NOHUGEPAGE,
-    /// `MADV_DONTDUMP` (since Linux 3.4)
-    LinuxDontDump = linux_raw_sys::general::MADV_DONTDUMP,
-    /// `MADV_DODUMP` (since Linux 3.4)
-    LinuxDoDump = linux_raw_sys::general::MADV_DODUMP,
-    /// `MADV_WIPEONFORK` (since Linux 4.14)
-    LinuxWipeOnFork = linux_raw_sys::general::MADV_WIPEONFORK,
-    /// `MADV_KEEPONFORK` (since Linux 4.14)
-    LinuxKeepOnFork = linux_raw_sys::general::MADV_KEEPONFORK,
-    /// `MADV_COLD` (since Linux 5.4)
-    LinuxCold = linux_raw_sys::general::MADV_COLD,
-    /// `MADV_PAGEOUT` (since Linux 5.4)
-    LinuxPageOut = linux_raw_sys::general::MADV_PAGEOUT,
-    /// `MADV_POPULATE_READ` (since Linux 5.14)
-    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)]
-impl Advice {
-    /// `POSIX_MADV_DONTNEED`
-    ///
-    /// On Linux, this is mapped to `POSIX_MADV_NORMAL` because Linux's
-    /// `MADV_DONTNEED` differs from `POSIX_MADV_DONTNEED`. See `LinuxDontNeed`
-    /// for the Linux behavior.
-    pub const DontNeed: Self = Self::Normal;
-}
-
-bitflags! {
-    /// `O_*` flags for use with [`userfaultfd`].
-    ///
-    /// [`userfaultfd`]: crate::mm::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;
-        /// `O_NONBLOCK`
-        const NONBLOCK = linux_raw_sys::general::O_NONBLOCK;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MCL_*` flags for use with [`mlockall`].
-    ///
-    /// [`mlockall`]: crate::mm::mlockall
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MlockAllFlags: u32 {
-        /// Used together with `MCL_CURRENT`, `MCL_FUTURE`, or both. Mark all
-        /// current (with `MCL_CURRENT`) or future (with `MCL_FUTURE`) mappings
-        /// to lock pages when they are faulted in. When used with
-        /// `MCL_CURRENT`, all present pages are locked, but `mlockall` will
-        /// not fault in non-present pages. When used with `MCL_FUTURE`, all
-        /// future mappings will be marked to lock pages when they are faulted
-        /// in, but they will not be populated by the lock when the mapping is
-        /// created. `MCL_ONFAULT` must be used with either `MCL_CURRENT` or
-        /// `MCL_FUTURE` or both.
-        const ONFAULT = linux_raw_sys::general::MCL_ONFAULT;
-        /// Lock all pages which will become mapped into the address space of
-        /// the process in the future. These could be, for instance, new pages
-        /// required by a growing heap and stack as well as new memory-mapped
-        /// files or shared memory regions.
-        const FUTURE = linux_raw_sys::general::MCL_FUTURE;
-        /// Lock all pages which are currently mapped into the address space of
-        /// the process.
-        const CURRENT = linux_raw_sys::general::MCL_CURRENT;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/mod.rs b/vendor/rustix/src/backend/linux_raw/mod.rs
deleted file mode 100644
index 0d4e533..0000000
--- a/vendor/rustix/src/backend/linux_raw/mod.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-//! The linux_raw backend.
-//!
-//! This makes Linux syscalls directly, without going through libc.
-//!
-//! # Safety
-//!
-//! These files performs raw system calls, and sometimes passes them
-//! uninitialized memory buffers. The signatures in this file are currently
-//! manually maintained and must correspond with the signatures of the actual
-//! Linux syscalls.
-//!
-//! Some of this could be auto-generated from the Linux header file
-//! <linux/syscalls.h>, but we often need more information than it provides,
-//! such as which pointers are array slices, out parameters, or in-out
-//! parameters, which integers are owned or borrowed file descriptors, etc.
-
-#[macro_use]
-mod arch;
-mod conv;
-mod reg;
-#[cfg(any(feature = "time", feature = "process", target_arch = "x86"))]
-mod vdso;
-#[cfg(any(feature = "time", feature = "process", target_arch = "x86"))]
-mod vdso_wrappers;
-
-#[cfg(feature = "event")]
-pub(crate) mod event;
-#[cfg(any(
-    feature = "fs",
-    all(
-        not(feature = "use-libc-auxv"),
-        not(feature = "use-explicitly-provided-auxv"),
-        any(
-            feature = "param",
-            feature = "process",
-            feature = "runtime",
-            feature = "time",
-            target_arch = "x86",
-        )
-    )
-))]
-pub(crate) mod fs;
-pub(crate) mod io;
-#[cfg(feature = "io_uring")]
-pub(crate) mod io_uring;
-#[cfg(feature = "mm")]
-pub(crate) mod mm;
-#[cfg(feature = "mount")]
-pub(crate) mod mount;
-#[cfg(all(feature = "fs", not(feature = "mount")))]
-pub(crate) mod mount; // for deprecated mount functions in "fs"
-#[cfg(feature = "net")]
-pub(crate) mod net;
-#[cfg(any(
-    feature = "param",
-    feature = "process",
-    feature = "runtime",
-    feature = "time",
-    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 = "shm")]
-pub(crate) mod shm;
-#[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;
-
-pub(crate) mod fd {
-    pub use crate::maybe_polyfill::os::fd::{
-        AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd,
-    };
-}
-
-// 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(feature = "use-explicitly-provided-auxv"),
-        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/mount/mod.rs b/vendor/rustix/src/backend/linux_raw/mount/mod.rs
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/linux_raw/mount/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/mount/syscalls.rs b/vendor/rustix/src/backend/linux_raw/mount/syscalls.rs
deleted file mode 100644
index 5cb80cc..0000000
--- a/vendor/rustix/src/backend/linux_raw/mount/syscalls.rs
+++ /dev/null
@@ -1,239 +0,0 @@
-//! linux_raw syscalls supporting `rustix::mount`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code)]
-#![allow(clippy::undocumented_unsafe_blocks)]
-
-use crate::backend::conv::ret;
-#[cfg(feature = "mount")]
-use crate::backend::conv::{ret_owned_fd, slice, zero};
-#[cfg(feature = "mount")]
-use crate::fd::{BorrowedFd, OwnedFd};
-use crate::ffi::CStr;
-use crate::io;
-
-#[inline]
-pub(crate) fn mount(
-    source: Option<&CStr>,
-    target: &CStr,
-    file_system_type: Option<&CStr>,
-    flags: super::types::MountFlagsArg,
-    data: Option<&CStr>,
-) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_mount,
-            source,
-            target,
-            file_system_type,
-            flags,
-            data
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn unmount(target: &CStr, flags: super::types::UnmountFlags) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_umount2, target, flags)) }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsopen(fs_name: &CStr, flags: super::types::FsOpenFlags) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_fsopen, fs_name, flags)) }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsmount(
-    fs_fd: BorrowedFd<'_>,
-    flags: super::types::FsMountFlags,
-    attr_flags: super::types::MountAttrFlags,
-) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_fsmount, fs_fd, flags, attr_flags)) }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn move_mount(
-    from_dfd: BorrowedFd<'_>,
-    from_pathname: &CStr,
-    to_dfd: BorrowedFd<'_>,
-    to_pathname: &CStr,
-    flags: super::types::MoveMountFlags,
-) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_move_mount,
-            from_dfd,
-            from_pathname,
-            to_dfd,
-            to_pathname,
-            flags
-        ))
-    }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn open_tree(
-    dfd: BorrowedFd<'_>,
-    filename: &CStr,
-    flags: super::types::OpenTreeFlags,
-) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_open_tree, dfd, filename, flags)) }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fspick(
-    dfd: BorrowedFd<'_>,
-    path: &CStr,
-    flags: super::types::FsPickFlags,
-) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_fspick, dfd, path, flags)) }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsconfig_set_flag(fs_fd: BorrowedFd<'_>, key: &CStr) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fsconfig,
-            fs_fd,
-            super::types::FsConfigCmd::SetFlag,
-            key,
-            zero(),
-            zero()
-        ))
-    }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsconfig_set_string(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    value: &CStr,
-) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fsconfig,
-            fs_fd,
-            super::types::FsConfigCmd::SetString,
-            key,
-            value,
-            zero()
-        ))
-    }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsconfig_set_binary(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    value: &[u8],
-) -> io::Result<()> {
-    let (value_addr, value_len) = slice(value);
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fsconfig,
-            fs_fd,
-            super::types::FsConfigCmd::SetBinary,
-            key,
-            value_addr,
-            value_len
-        ))
-    }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsconfig_set_fd(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    fd: BorrowedFd<'_>,
-) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fsconfig,
-            fs_fd,
-            super::types::FsConfigCmd::SetFd,
-            key,
-            zero(),
-            fd
-        ))
-    }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsconfig_set_path(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    path: &CStr,
-    fd: BorrowedFd<'_>,
-) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fsconfig,
-            fs_fd,
-            super::types::FsConfigCmd::SetPath,
-            key,
-            path,
-            fd
-        ))
-    }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsconfig_set_path_empty(
-    fs_fd: BorrowedFd<'_>,
-    key: &CStr,
-    fd: BorrowedFd<'_>,
-) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fsconfig,
-            fs_fd,
-            super::types::FsConfigCmd::SetPathEmpty,
-            key,
-            cstr!(""),
-            fd
-        ))
-    }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsconfig_create(fs_fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fsconfig,
-            fs_fd,
-            super::types::FsConfigCmd::Create,
-            zero(),
-            zero(),
-            zero()
-        ))
-    }
-}
-
-#[cfg(feature = "mount")]
-#[inline]
-pub(crate) fn fsconfig_reconfigure(fs_fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_fsconfig,
-            fs_fd,
-            super::types::FsConfigCmd::Reconfigure,
-            zero(),
-            zero(),
-            zero()
-        ))
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/mount/types.rs b/vendor/rustix/src/backend/linux_raw/mount/types.rs
deleted file mode 100644
index 43cb8c0..0000000
--- a/vendor/rustix/src/backend/linux_raw/mount/types.rs
+++ /dev/null
@@ -1,332 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `MS_*` constants for use with [`mount`].
-    ///
-    /// [`mount`]: crate::mount::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;
-
-        /// `MS_DIRSYNC`
-        const DIRSYNC = linux_raw_sys::general::MS_DIRSYNC;
-
-        /// `MS_LAZYTIME`
-        const LAZYTIME = linux_raw_sys::general::MS_LAZYTIME;
-
-        /// `MS_MANDLOCK`
-        #[doc(alias = "MANDLOCK")]
-        const PERMIT_MANDATORY_FILE_LOCKING = linux_raw_sys::general::MS_MANDLOCK;
-
-        /// `MS_NOATIME`
-        const NOATIME = linux_raw_sys::general::MS_NOATIME;
-
-        /// `MS_NODEV`
-        const NODEV = linux_raw_sys::general::MS_NODEV;
-
-        /// `MS_NODIRATIME`
-        const NODIRATIME = linux_raw_sys::general::MS_NODIRATIME;
-
-        /// `MS_NOEXEC`
-        const NOEXEC = linux_raw_sys::general::MS_NOEXEC;
-
-        /// `MS_NOSUID`
-        const NOSUID = linux_raw_sys::general::MS_NOSUID;
-
-        /// `MS_RDONLY`
-        const RDONLY = linux_raw_sys::general::MS_RDONLY;
-
-        /// `MS_REC`
-        const REC = linux_raw_sys::general::MS_REC;
-
-        /// `MS_RELATIME`
-        const RELATIME = linux_raw_sys::general::MS_RELATIME;
-
-        /// `MS_SILENT`
-        const SILENT = linux_raw_sys::general::MS_SILENT;
-
-        /// `MS_STRICTATIME`
-        const STRICTATIME = linux_raw_sys::general::MS_STRICTATIME;
-
-        /// `MS_SYNCHRONOUS`
-        const SYNCHRONOUS = linux_raw_sys::general::MS_SYNCHRONOUS;
-
-        /// `MS_NOSYMFOLLOW`
-        const NOSYMFOLLOW = linux_raw_sys::general::MS_NOSYMFOLLOW;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MNT_*` constants for use with [`unmount`].
-    ///
-    /// [`unmount`]: crate::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;
-        /// `MNT_DETACH`
-        const DETACH = linux_raw_sys::general::MNT_DETACH;
-        /// `MNT_EXPIRE`
-        const EXPIRE = linux_raw_sys::general::MNT_EXPIRE;
-        /// `UMOUNT_NOFOLLOW`
-        const NOFOLLOW = linux_raw_sys::general::UMOUNT_NOFOLLOW;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-bitflags! {
-    /// `FSOPEN_*` constants for use with [`fsopen`].
-    ///
-    /// [`fsopen`]: crate::mount::fsopen
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct FsOpenFlags: c::c_uint {
-        /// `FSOPEN_CLOEXEC`
-        const FSOPEN_CLOEXEC = linux_raw_sys::general::FSOPEN_CLOEXEC;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-bitflags! {
-    /// `FSMOUNT_*` constants for use with [`fsmount`].
-    ///
-    /// [`fsmount`]: crate::mount::fsmount
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct FsMountFlags: c::c_uint {
-        /// `FSMOUNT_CLOEXEC`
-        const FSMOUNT_CLOEXEC = linux_raw_sys::general::FSMOUNT_CLOEXEC;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `FSCONFIG_*` constants for use with the `fsconfig` syscall.
-#[cfg(feature = "mount")]
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(u32)]
-pub(crate) enum FsConfigCmd {
-    /// `FSCONFIG_SET_FLAG`
-    SetFlag = linux_raw_sys::general::fsconfig_command::FSCONFIG_SET_FLAG as u32,
-
-    /// `FSCONFIG_SET_STRING`
-    SetString = linux_raw_sys::general::fsconfig_command::FSCONFIG_SET_STRING as u32,
-
-    /// `FSCONFIG_SET_BINARY`
-    SetBinary = linux_raw_sys::general::fsconfig_command::FSCONFIG_SET_BINARY as u32,
-
-    /// `FSCONFIG_SET_PATH`
-    SetPath = linux_raw_sys::general::fsconfig_command::FSCONFIG_SET_PATH as u32,
-
-    /// `FSCONFIG_SET_PATH_EMPTY`
-    SetPathEmpty = linux_raw_sys::general::fsconfig_command::FSCONFIG_SET_PATH_EMPTY as u32,
-
-    /// `FSCONFIG_SET_FD`
-    SetFd = linux_raw_sys::general::fsconfig_command::FSCONFIG_SET_FD as u32,
-
-    /// `FSCONFIG_CMD_CREATE`
-    Create = linux_raw_sys::general::fsconfig_command::FSCONFIG_CMD_CREATE as u32,
-
-    /// `FSCONFIG_CMD_RECONFIGURE`
-    Reconfigure = linux_raw_sys::general::fsconfig_command::FSCONFIG_CMD_RECONFIGURE as u32,
-}
-
-#[cfg(feature = "mount")]
-bitflags! {
-    /// `MOUNT_ATTR_*` constants for use with [`fsmount`].
-    ///
-    /// [`fsmount`]: crate::mount::fsmount
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MountAttrFlags: c::c_uint {
-        /// `MOUNT_ATTR_RDONLY`
-        const MOUNT_ATTR_RDONLY = linux_raw_sys::general::MOUNT_ATTR_RDONLY;
-
-        /// `MOUNT_ATTR_NOSUID`
-        const MOUNT_ATTR_NOSUID = linux_raw_sys::general::MOUNT_ATTR_NOSUID;
-
-        /// `MOUNT_ATTR_NODEV`
-        const MOUNT_ATTR_NODEV = linux_raw_sys::general::MOUNT_ATTR_NODEV;
-
-        /// `MOUNT_ATTR_NOEXEC`
-        const MOUNT_ATTR_NOEXEC = linux_raw_sys::general::MOUNT_ATTR_NOEXEC;
-
-        /// `MOUNT_ATTR__ATIME`
-        const MOUNT_ATTR__ATIME = linux_raw_sys::general::MOUNT_ATTR__ATIME;
-
-        /// `MOUNT_ATTR_RELATIME`
-        const MOUNT_ATTR_RELATIME = linux_raw_sys::general::MOUNT_ATTR_RELATIME;
-
-        /// `MOUNT_ATTR_NOATIME`
-        const MOUNT_ATTR_NOATIME = linux_raw_sys::general::MOUNT_ATTR_NOATIME;
-
-        /// `MOUNT_ATTR_STRICTATIME`
-        const MOUNT_ATTR_STRICTATIME = linux_raw_sys::general::MOUNT_ATTR_STRICTATIME;
-
-        /// `MOUNT_ATTR_NODIRATIME`
-        const MOUNT_ATTR_NODIRATIME = linux_raw_sys::general::MOUNT_ATTR_NODIRATIME;
-
-        /// `MOUNT_ATTR_NOUSER`
-        const MOUNT_ATTR_IDMAP = linux_raw_sys::general::MOUNT_ATTR_IDMAP;
-
-        /// `MOUNT_ATTR__ATIME_FLAGS`
-        const MOUNT_ATTR_NOSYMFOLLOW = linux_raw_sys::general::MOUNT_ATTR_NOSYMFOLLOW;
-
-        /// `MOUNT_ATTR__ATIME_FLAGS`
-        const MOUNT_ATTR_SIZE_VER0 = linux_raw_sys::general::MOUNT_ATTR_SIZE_VER0;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-bitflags! {
-    /// `MOVE_MOUNT_*` constants for use with [`move_mount`].
-    ///
-    /// [`move_mount`]: crate::mount::move_mount
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MoveMountFlags: c::c_uint {
-        /// `MOVE_MOUNT_F_EMPTY_PATH`
-        const MOVE_MOUNT_F_SYMLINKS = linux_raw_sys::general::MOVE_MOUNT_F_SYMLINKS;
-
-        /// `MOVE_MOUNT_F_AUTOMOUNTS`
-        const MOVE_MOUNT_F_AUTOMOUNTS = linux_raw_sys::general::MOVE_MOUNT_F_AUTOMOUNTS;
-
-        /// `MOVE_MOUNT_F_EMPTY_PATH`
-        const MOVE_MOUNT_F_EMPTY_PATH = linux_raw_sys::general::MOVE_MOUNT_F_EMPTY_PATH;
-
-        /// `MOVE_MOUNT_T_SYMLINKS`
-        const MOVE_MOUNT_T_SYMLINKS = linux_raw_sys::general::MOVE_MOUNT_T_SYMLINKS;
-
-        /// `MOVE_MOUNT_T_AUTOMOUNTS`
-        const MOVE_MOUNT_T_AUTOMOUNTS = linux_raw_sys::general::MOVE_MOUNT_T_AUTOMOUNTS;
-
-        /// `MOVE_MOUNT_T_EMPTY_PATH`
-        const MOVE_MOUNT_T_EMPTY_PATH = linux_raw_sys::general::MOVE_MOUNT_T_EMPTY_PATH;
-
-        /// `MOVE_MOUNT__MASK`
-        const MOVE_MOUNT_SET_GROUP = linux_raw_sys::general::MOVE_MOUNT_SET_GROUP;
-
-        // TODO: add when Linux 6.5 is released
-        // /// `MOVE_MOUNT_BENEATH`
-        // const MOVE_MOUNT_BENEATH = linux_raw_sys::general::MOVE_MOUNT_BENEATH;
-
-        /// `MOVE_MOUNT__MASK`
-        const MOVE_MOUNT__MASK = linux_raw_sys::general::MOVE_MOUNT__MASK;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-bitflags! {
-    /// `OPENTREE_*` constants for use with [`open_tree`].
-    ///
-    /// [`open_tree`]: crate::mount::open_tree
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct OpenTreeFlags: c::c_uint {
-        /// `OPENTREE_CLONE`
-        const OPEN_TREE_CLONE = linux_raw_sys::general::OPEN_TREE_CLONE;
-
-        /// `OPENTREE_CLOEXEC`
-        const OPEN_TREE_CLOEXEC = linux_raw_sys::general::OPEN_TREE_CLOEXEC;
-
-        /// `AT_EMPTY_PATH`
-        const AT_EMPTY_PATH = linux_raw_sys::general::AT_EMPTY_PATH;
-
-        /// `AT_NO_AUTOMOUNT`
-        const AT_NO_AUTOMOUNT = linux_raw_sys::general::AT_NO_AUTOMOUNT;
-
-        /// `AT_RECURSIVE`
-        const AT_RECURSIVE = linux_raw_sys::general::AT_RECURSIVE;
-
-        /// `AT_SYMLINK_NOFOLLOW`
-        const AT_SYMLINK_NOFOLLOW = linux_raw_sys::general::AT_SYMLINK_NOFOLLOW;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[cfg(feature = "mount")]
-bitflags! {
-    /// `FSPICK_*` constants for use with [`fspick`].
-    ///
-    /// [`fspick`]: crate::mount::fspick
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct FsPickFlags: c::c_uint {
-        /// `FSPICK_CLOEXEC`
-        const FSPICK_CLOEXEC = linux_raw_sys::general::FSPICK_CLOEXEC;
-
-        /// `FSPICK_SYMLINK_NOFOLLOW`
-        const FSPICK_SYMLINK_NOFOLLOW = linux_raw_sys::general::FSPICK_SYMLINK_NOFOLLOW;
-
-        /// `FSPICK_NO_AUTOMOUNT`
-        const FSPICK_NO_AUTOMOUNT = linux_raw_sys::general::FSPICK_NO_AUTOMOUNT;
-
-        /// `FSPICK_EMPTY_PATH`
-        const FSPICK_EMPTY_PATH = linux_raw_sys::general::FSPICK_EMPTY_PATH;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MS_*` constants for use with [`mount_change`].
-    ///
-    /// [`mount_change`]: crate::mount::mount_change
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct MountPropagationFlags: c::c_uint {
-        /// `MS_SILENT`
-        const SILENT = linux_raw_sys::general::MS_SILENT;
-        /// `MS_SHARED`
-        const SHARED = linux_raw_sys::general::MS_SHARED;
-        /// `MS_PRIVATE`
-        const PRIVATE = linux_raw_sys::general::MS_PRIVATE;
-        /// `MS_SLAVE`
-        const SLAVE = linux_raw_sys::general::MS_SLAVE;
-        /// `MS_UNBINDABLE`
-        const UNBINDABLE = linux_raw_sys::general::MS_UNBINDABLE;
-        /// `MS_REC`
-        const REC = linux_raw_sys::general::MS_REC;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-#[repr(transparent)]
-pub(crate) struct MountFlagsArg(pub(crate) c::c_uint);
diff --git a/vendor/rustix/src/backend/linux_raw/net/addr.rs b/vendor/rustix/src/backend/linux_raw/net/addr.rs
deleted file mode 100644
index 85ba875..0000000
--- a/vendor/rustix/src/backend/linux_raw/net/addr.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-//! Socket address utilities.
-//!
-//! # Safety
-//!
-//! This file uses `CStr::from_bytes_with_nul_unchecked` on a string it knows
-//! to be NUL-terminated.
-#![allow(unsafe_code)]
-
-use crate::backend::c;
-use crate::ffi::CStr;
-use crate::{io, path};
-use core::cmp::Ordering;
-use core::fmt;
-use core::hash::{Hash, Hasher};
-use core::slice;
-
-/// `struct sockaddr_un`
-#[derive(Clone)]
-#[doc(alias = "sockaddr_un")]
-pub struct SocketAddrUnix {
-    pub(crate) unix: c::sockaddr_un,
-    len: c::socklen_t,
-}
-
-impl SocketAddrUnix {
-    /// Construct a new Unix-domain address from a filesystem path.
-    #[inline]
-    pub fn new<P: path::Arg>(path: P) -> io::Result<Self> {
-        path.into_with_c_str(Self::_new)
-    }
-
-    #[inline]
-    fn _new(path: &CStr) -> io::Result<Self> {
-        let mut unix = Self::init();
-        let bytes = path.to_bytes_with_nul();
-        if bytes.len() > unix.sun_path.len() {
-            return Err(io::Errno::NAMETOOLONG);
-        }
-        for (i, b) in bytes.iter().enumerate() {
-            unix.sun_path[i] = *b as _;
-        }
-        let len = offsetof_sun_path() + bytes.len();
-        let len = len.try_into().unwrap();
-        Ok(Self { unix, len })
-    }
-
-    /// Construct a new abstract Unix-domain address from a byte slice.
-    #[inline]
-    pub fn new_abstract_name(name: &[u8]) -> io::Result<Self> {
-        let mut unix = Self::init();
-        let id = &mut unix.sun_path[1..];
-
-        // SAFETY: Convert `&mut [c_char]` to `&mut [u8]`.
-        let id = unsafe { slice::from_raw_parts_mut(id.as_mut_ptr().cast::<u8>(), id.len()) };
-
-        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)
-        }
-    }
-
-    const fn init() -> c::sockaddr_un {
-        c::sockaddr_un {
-            sun_family: c::AF_UNIX as _,
-            sun_path: [0; 108],
-        }
-    }
-
-    /// For a filesystem path address, return the path.
-    #[inline]
-    pub fn path(&self) -> Option<&CStr> {
-        let len = self.len();
-        if len != 0 && self.unix.sun_path[0] as u8 != b'\0' {
-            let end = len as usize - offsetof_sun_path();
-            let bytes = &self.unix.sun_path[..end];
-
-            // SAFETY: Convert `&[c_char]` to `&[u8]`.
-            let bytes = unsafe { slice::from_raw_parts(bytes.as_ptr().cast::<u8>(), 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
-        }
-    }
-
-    /// For an abstract address, return the identifier.
-    #[inline]
-    pub fn abstract_name(&self) -> Option<&[u8]> {
-        let len = self.len();
-        if len != 0 && self.unix.sun_path[0] as u8 == b'\0' {
-            let end = len as usize - offsetof_sun_path();
-            let bytes = &self.unix.sun_path[1..end];
-
-            // SAFETY: Convert `&[c_char]` to `&[u8]`.
-            let bytes = unsafe { slice::from_raw_parts(bytes.as_ptr().cast::<u8>(), bytes.len()) };
-
-            Some(bytes)
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    pub(crate) fn addr_len(&self) -> c::socklen_t {
-        self.len
-    }
-
-    #[inline]
-    pub(crate) fn len(&self) -> usize {
-        self.addr_len() as usize
-    }
-}
-
-impl PartialEq for SocketAddrUnix {
-    #[inline]
-    fn eq(&self, other: &Self) -> bool {
-        let self_len = self.len() - offsetof_sun_path();
-        let other_len = other.len() - offsetof_sun_path();
-        self.unix.sun_path[..self_len].eq(&other.unix.sun_path[..other_len])
-    }
-}
-
-impl Eq for SocketAddrUnix {}
-
-impl PartialOrd for SocketAddrUnix {
-    #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for SocketAddrUnix {
-    #[inline]
-    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 Hash for SocketAddrUnix {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        let self_len = self.len() - offsetof_sun_path();
-        self.unix.sun_path[..self_len].hash(state)
-    }
-}
-
-impl fmt::Debug for SocketAddrUnix {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(path) = self.path() {
-            path.fmt(fmt)
-        } else if let Some(name) = self.abstract_name() {
-            name.fmt(fmt)
-        } else {
-            "(unnamed)".fmt(fmt)
-        }
-    }
-}
-
-/// `struct sockaddr_storage` as a raw struct.
-pub type SocketAddrStorage = c::sockaddr;
-
-/// Return the offset of the `sun_path` field of `sockaddr_un`.
-#[inline]
-pub(crate) fn offsetof_sun_path() -> usize {
-    let z = c::sockaddr_un {
-        sun_family: 0_u16,
-        sun_path: [0; 108],
-    };
-    (crate::utils::as_ptr(&z.sun_path) as usize) - (crate::utils::as_ptr(&z) as usize)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/net/mod.rs b/vendor/rustix/src/backend/linux_raw/net/mod.rs
deleted file mode 100644
index f83c546..0000000
--- a/vendor/rustix/src/backend/linux_raw/net/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-pub(crate) mod addr;
-pub(crate) mod msghdr;
-pub(crate) mod read_sockaddr;
-pub(crate) mod send_recv;
-pub(crate) mod sockopt;
-pub(crate) mod syscalls;
-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
deleted file mode 100644
index 2b88bfb..0000000
--- a/vendor/rustix/src/backend/linux_raw/net/msghdr.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-//! 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, 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()),
-        msg_flags: 0,
-    };
-
-    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()),
-        msg_flags: 0,
-    })
-}
-
-/// 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 = 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()),
-        msg_flags: 0,
-    })
-}
-
-/// 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 = 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()),
-        msg_flags: 0,
-    })
-}
-
-/// 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.unix) 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()),
-        msg_flags: 0,
-    })
-}
-
-/// Create a zero-initialized message header struct value.
-pub(crate) fn zero_msghdr() -> c::msghdr {
-    c::msghdr {
-        msg_name: null_mut(),
-        msg_namelen: 0,
-        msg_iov: null_mut(),
-        msg_iovlen: 0,
-        msg_control: null_mut(),
-        msg_controllen: 0,
-        msg_flags: 0,
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/net/read_sockaddr.rs b/vendor/rustix/src/backend/linux_raw/net/read_sockaddr.rs
deleted file mode 100644
index 5a91707..0000000
--- a/vendor/rustix/src/backend/linux_raw/net/read_sockaddr.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-//! 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.
-#![allow(unsafe_code)]
-
-use crate::backend::c;
-use crate::io;
-use crate::net::{Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrUnix, SocketAddrV4, SocketAddrV6};
-use core::mem::size_of;
-use core::slice;
-
-// This must match the header of `sockaddr`.
-#[repr(C)]
-struct sockaddr_header {
-    ss_family: u16,
-}
-
-/// Read the `ss_family` field from a socket address returned from the OS.
-///
-/// # Safety
-///
-/// `storage` must point to a valid socket address returned from the OS.
-#[inline]
-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::net::__kernel_sockaddr_storage__bindgen_ty_1 {
-                __bindgen_anon_1:
-                    linux_raw_sys::net::__kernel_sockaddr_storage__bindgen_ty_1__bindgen_ty_1 {
-                        ss_family: 0_u16,
-                        __data: [0; 126_usize],
-                    },
-            },
-        },
-    };
-
-    (*storage.cast::<sockaddr_header>()).ss_family
-}
-
-/// Set the `ss_family` field of a socket address to `AF_UNSPEC`, so that we
-/// can test for `AF_UNSPEC` to test whether it was stored to.
-#[inline]
-pub(crate) unsafe fn initialize_family_to_unspec(storage: *mut c::sockaddr) {
-    (*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,
-    len: usize,
-) -> io::Result<SocketAddrAny> {
-    let offsetof_sun_path = super::addr::offsetof_sun_path();
-
-    if len < size_of::<c::sa_family_t>() {
-        return Err(io::Errno::INVAL);
-    }
-    match read_ss_family(storage).into() {
-        c::AF_INET => {
-            if len < size_of::<c::sockaddr_in>() {
-                return Err(io::Errno::INVAL);
-            }
-            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),
-            )))
-        }
-        c::AF_INET6 => {
-            if len < size_of::<c::sockaddr_in6>() {
-                return Err(io::Errno::INVAL);
-            }
-            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),
-                u32::from_be(decode.sin6_flowinfo),
-                decode.sin6_scope_id,
-            )))
-        }
-        c::AF_UNIX => {
-            if len < offsetof_sun_path {
-                return Err(io::Errno::INVAL);
-            }
-            if len == offsetof_sun_path {
-                Ok(SocketAddrAny::Unix(SocketAddrUnix::new(&[][..])?))
-            } else {
-                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 {
-                    let bytes = &decode.sun_path[1..len - offsetof_sun_path];
-
-                    // SAFETY: Convert `&[c_char]` to `&[u8]`.
-                    let bytes = slice::from_raw_parts(bytes.as_ptr().cast::<u8>(), bytes.len());
-
-                    return SocketAddrUnix::new_abstract_name(bytes).map(SocketAddrAny::Unix);
-                }
-
-                // Otherwise we expect a NUL-terminated filesystem path.
-                let bytes = &decode.sun_path[..len - 1 - offsetof_sun_path];
-
-                // SAFETY: Convert `&[c_char]` to `&[u8]`.
-                let bytes = slice::from_raw_parts(bytes.as_ptr().cast::<u8>(), bytes.len());
-
-                assert_eq!(decode.sun_path[len - 1 - offsetof_sun_path], 0);
-                Ok(SocketAddrAny::Unix(SocketAddrUnix::new(bytes)?))
-            }
-        }
-        _ => Err(io::Errno::NOTSUP),
-    }
-}
-
-/// Read an optional socket address returned from the OS.
-///
-/// # Safety
-///
-/// `storage` must point to a valid socket address returned from the OS.
-pub(crate) unsafe fn maybe_read_sockaddr_os(
-    storage: *const c::sockaddr,
-    len: usize,
-) -> Option<SocketAddrAny> {
-    if len == 0 {
-        None
-    } else {
-        Some(read_sockaddr_os(storage, len))
-    }
-}
-
-/// Read a socket address returned from the OS.
-///
-/// # Safety
-///
-/// `storage` must point to a valid socket address returned from the OS.
-pub(crate) unsafe fn read_sockaddr_os(storage: *const c::sockaddr, len: usize) -> SocketAddrAny {
-    let offsetof_sun_path = super::addr::offsetof_sun_path();
-
-    assert!(len >= size_of::<c::sa_family_t>());
-    match read_ss_family(storage).into() {
-        c::AF_INET => {
-            assert!(len >= size_of::<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),
-            ))
-        }
-        c::AF_INET6 => {
-            assert!(len >= size_of::<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),
-                u32::from_be(decode.sin6_flowinfo),
-                decode.sin6_scope_id,
-            ))
-        }
-        c::AF_UNIX => {
-            assert!(len >= offsetof_sun_path);
-            if len == offsetof_sun_path {
-                SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap())
-            } else {
-                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 {
-                    let bytes = &decode.sun_path[1..len - offsetof_sun_path];
-
-                    // SAFETY: Convert `&[c_char]` to `&[u8]`.
-                    let bytes = slice::from_raw_parts(bytes.as_ptr().cast::<u8>(), bytes.len());
-
-                    return SocketAddrAny::Unix(SocketAddrUnix::new_abstract_name(bytes).unwrap());
-                }
-
-                // Otherwise we expect a NUL-terminated filesystem path.
-                assert_eq!(decode.sun_path[len - 1 - offsetof_sun_path], 0);
-
-                let bytes = &decode.sun_path[..len - 1 - offsetof_sun_path];
-
-                // SAFETY: Convert `&[c_char]` to `&[u8]`.
-                let bytes = slice::from_raw_parts(bytes.as_ptr().cast::<u8>(), bytes.len());
-
-                SocketAddrAny::Unix(SocketAddrUnix::new(bytes).unwrap())
-            }
-        }
-        other => unimplemented!("{:?}", other),
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/net/send_recv.rs b/vendor/rustix/src/backend/linux_raw/net/send_recv.rs
deleted file mode 100644
index d5cdd07..0000000
--- a/vendor/rustix/src/backend/linux_raw/net/send_recv.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `MSG_*` flags for use with [`send`], [`send_to`], and related
-    /// functions.
-    ///
-    /// [`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;
-        /// `MSG_DONTROUTE`
-        const DONTROUTE = c::MSG_DONTROUTE;
-        /// `MSG_DONTWAIT`
-        const DONTWAIT = c::MSG_DONTWAIT;
-        /// `MSG_EOT`
-        const EOT = c::MSG_EOR;
-        /// `MSG_MORE`
-        const MORE = c::MSG_MORE;
-        /// `MSG_NOSIGNAL`
-        const NOSIGNAL = c::MSG_NOSIGNAL;
-        /// `MSG_OOB`
-        const OOB = c::MSG_OOB;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-bitflags! {
-    /// `MSG_*` flags for use with [`recv`], [`recvfrom`], and related
-    /// functions.
-    ///
-    /// [`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;
-        /// `MSG_DONTWAIT`
-        const DONTWAIT = c::MSG_DONTWAIT;
-        /// `MSG_ERRQUEUE`
-        const ERRQUEUE = c::MSG_ERRQUEUE;
-        /// `MSG_OOB`
-        const OOB = c::MSG_OOB;
-        /// `MSG_PEEK`
-        const PEEK = c::MSG_PEEK;
-        /// `MSG_TRUNC`
-        const TRUNC = c::MSG_TRUNC;
-        /// `MSG_WAITALL`
-        const WAITALL = c::MSG_WAITALL;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/net/sockopt.rs b/vendor/rustix/src/backend/linux_raw/net/sockopt.rs
deleted file mode 100644
index 6a740bb..0000000
--- a/vendor/rustix/src/backend/linux_raw/net/sockopt.rs
+++ /dev/null
@@ -1,879 +0,0 @@
-//! linux_raw syscalls supporting `rustix::net::sockopt`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use crate::backend::c;
-use crate::backend::conv::{by_mut, c_uint, ret, socklen_t};
-use crate::fd::BorrowedFd;
-#[cfg(feature = "alloc")]
-use crate::ffi::CStr;
-use crate::io;
-use crate::net::sockopt::Timeout;
-use crate::net::{
-    AddressFamily, Ipv4Addr, Ipv6Addr, Protocol, RawProtocol, SocketAddrAny, SocketAddrStorage,
-    SocketAddrV4, SocketAddrV6, SocketType, UCred,
-};
-#[cfg(feature = "alloc")]
-use alloc::borrow::ToOwned;
-#[cfg(feature = "alloc")]
-use alloc::string::String;
-use core::mem::MaybeUninit;
-use core::time::Duration;
-use linux_raw_sys::general::{__kernel_old_timeval, __kernel_sock_timeval};
-#[cfg(target_arch = "x86")]
-use {
-    crate::backend::conv::{slice_just_addr, x86_sys},
-    crate::backend::reg::{ArgReg, SocketArg},
-    linux_raw_sys::net::{SYS_GETSOCKOPT, SYS_SETSOCKOPT},
-};
-
-#[inline]
-fn getsockopt<T: Copy>(fd: BorrowedFd<'_>, level: u32, optname: u32) -> io::Result<T> {
-    let mut optlen: c::socklen_t = core::mem::size_of::<T>().try_into().unwrap();
-    debug_assert!(
-        optlen as usize >= core::mem::size_of::<c::c_int>(),
-        "Socket APIs don't ever use `bool` directly"
-    );
-
-    let mut value = MaybeUninit::<T>::uninit();
-    getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
-
-    assert_eq!(
-        optlen as usize,
-        core::mem::size_of::<T>(),
-        "unexpected getsockopt size"
-    );
-
-    unsafe { Ok(value.assume_init()) }
-}
-
-#[inline]
-fn getsockopt_raw<T>(
-    fd: BorrowedFd<'_>,
-    level: u32,
-    optname: u32,
-    value: &mut MaybeUninit<T>,
-    optlen: &mut c::socklen_t,
-) -> io::Result<()> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall!(
-            __NR_getsockopt,
-            fd,
-            c_uint(level),
-            c_uint(optname),
-            value,
-            by_mut(optlen)
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall!(
-            __NR_socketcall,
-            x86_sys(SYS_GETSOCKOPT),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                c_uint(level),
-                c_uint(optname),
-                value.into(),
-                by_mut(optlen),
-            ])
-        ))
-    }
-}
-
-#[inline]
-fn setsockopt<T: Copy>(fd: BorrowedFd<'_>, level: u32, optname: u32, value: T) -> io::Result<()> {
-    let optlen = core::mem::size_of::<T>().try_into().unwrap();
-    debug_assert!(
-        optlen as usize >= core::mem::size_of::<c::c_int>(),
-        "Socket APIs don't ever use `bool` directly"
-    );
-    setsockopt_raw(fd, level, optname, &value, optlen)
-}
-
-#[inline]
-fn setsockopt_raw<T>(
-    fd: BorrowedFd<'_>,
-    level: u32,
-    optname: u32,
-    ptr: *const T,
-    optlen: c::socklen_t,
-) -> io::Result<()> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_setsockopt,
-            fd,
-            c_uint(level),
-            c_uint(optname),
-            ptr,
-            socklen_t(optlen)
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_SETSOCKOPT),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                c_uint(level),
-                c_uint(optname),
-                ptr.into(),
-                socklen_t(optlen),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn get_socket_type(fd: BorrowedFd<'_>) -> io::Result<SocketType> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_TYPE)
-}
-
-#[inline]
-pub(crate) fn set_socket_reuseaddr(fd: BorrowedFd<'_>, reuseaddr: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_REUSEADDR, from_bool(reuseaddr))
-}
-
-#[inline]
-pub(crate) fn get_socket_reuseaddr(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_REUSEADDR).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_broadcast(fd: BorrowedFd<'_>, broadcast: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_BROADCAST, from_bool(broadcast))
-}
-
-#[inline]
-pub(crate) fn get_socket_broadcast(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_BROADCAST).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_linger(fd: BorrowedFd<'_>, linger: Option<Duration>) -> io::Result<()> {
-    // Convert `linger` to seconds, rounding up.
-    let l_linger = if let Some(linger) = linger {
-        duration_to_secs(linger)?
-    } else {
-        0
-    };
-    let linger = c::linger {
-        l_onoff: c::c_int::from(linger.is_some()),
-        l_linger,
-    };
-    setsockopt(fd, c::SOL_SOCKET, c::SO_LINGER, linger)
-}
-
-#[inline]
-pub(crate) fn get_socket_linger(fd: BorrowedFd<'_>) -> io::Result<Option<Duration>> {
-    let linger: c::linger = getsockopt(fd, c::SOL_SOCKET, c::SO_LINGER)?;
-    Ok((linger.l_onoff != 0).then(|| Duration::from_secs(linger.l_linger as u64)))
-}
-
-#[inline]
-pub(crate) fn set_socket_passcred(fd: BorrowedFd<'_>, passcred: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_PASSCRED, from_bool(passcred))
-}
-
-#[inline]
-pub(crate) fn get_socket_passcred(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_PASSCRED).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_timeout(
-    fd: BorrowedFd<'_>,
-    id: Timeout,
-    timeout: Option<Duration>,
-) -> io::Result<()> {
-    let time = duration_to_linux_sock_timeval(timeout)?;
-    let optname = match id {
-        Timeout::Recv => c::SO_RCVTIMEO_NEW,
-        Timeout::Send => c::SO_SNDTIMEO_NEW,
-    };
-    match setsockopt(fd, c::SOL_SOCKET, optname, time) {
-        Err(io::Errno::NOPROTOOPT) if c::SO_RCVTIMEO_NEW != c::SO_RCVTIMEO_OLD => {
-            set_socket_timeout_old(fd, id, timeout)
-        }
-        otherwise => otherwise,
-    }
-}
-
-/// Same as `set_socket_timeout` but uses `__kernel_old_timeval` instead of
-/// `__kernel_sock_timeval` and `_OLD` constants instead of `_NEW`.
-fn set_socket_timeout_old(
-    fd: BorrowedFd<'_>,
-    id: Timeout,
-    timeout: Option<Duration>,
-) -> io::Result<()> {
-    let time = duration_to_linux_old_timeval(timeout)?;
-    let optname = match id {
-        Timeout::Recv => c::SO_RCVTIMEO_OLD,
-        Timeout::Send => c::SO_SNDTIMEO_OLD,
-    };
-    setsockopt(fd, c::SOL_SOCKET, optname, time)
-}
-
-#[inline]
-pub(crate) fn get_socket_timeout(fd: BorrowedFd<'_>, id: Timeout) -> io::Result<Option<Duration>> {
-    let optname = match id {
-        Timeout::Recv => c::SO_RCVTIMEO_NEW,
-        Timeout::Send => c::SO_SNDTIMEO_NEW,
-    };
-    let time: __kernel_sock_timeval = match getsockopt(fd, c::SOL_SOCKET, optname) {
-        Err(io::Errno::NOPROTOOPT) if c::SO_RCVTIMEO_NEW != c::SO_RCVTIMEO_OLD => {
-            return get_socket_timeout_old(fd, id)
-        }
-        otherwise => otherwise?,
-    };
-    Ok(duration_from_linux_sock_timeval(time))
-}
-
-/// Same as `get_socket_timeout` but uses `__kernel_old_timeval` instead of
-/// `__kernel_sock_timeval` and `_OLD` constants instead of `_NEW`.
-fn get_socket_timeout_old(fd: BorrowedFd<'_>, id: Timeout) -> io::Result<Option<Duration>> {
-    let optname = match id {
-        Timeout::Recv => c::SO_RCVTIMEO_OLD,
-        Timeout::Send => c::SO_SNDTIMEO_OLD,
-    };
-    let time: __kernel_old_timeval = getsockopt(fd, c::SOL_SOCKET, optname)?;
-    Ok(duration_from_linux_old_timeval(time))
-}
-
-/// Convert a `__linux_sock_timeval` to a Rust `Option<Duration>`.
-#[inline]
-fn duration_from_linux_sock_timeval(time: __kernel_sock_timeval) -> Option<Duration> {
-    if time.tv_sec == 0 && time.tv_usec == 0 {
-        None
-    } else {
-        Some(Duration::from_secs(time.tv_sec as u64) + Duration::from_micros(time.tv_usec as u64))
-    }
-}
-
-/// Like `duration_from_linux` but uses Linux's old 32-bit
-/// `__kernel_old_timeval`.
-fn duration_from_linux_old_timeval(time: __kernel_old_timeval) -> Option<Duration> {
-    if time.tv_sec == 0 && time.tv_usec == 0 {
-        None
-    } else {
-        Some(Duration::from_secs(time.tv_sec as u64) + Duration::from_micros(time.tv_usec as u64))
-    }
-}
-
-/// Convert a Rust `Option<Duration>` to a `__kernel_sock_timeval`.
-#[inline]
-fn duration_to_linux_sock_timeval(timeout: Option<Duration>) -> io::Result<__kernel_sock_timeval> {
-    Ok(match timeout {
-        Some(timeout) => {
-            if timeout == Duration::ZERO {
-                return Err(io::Errno::INVAL);
-            }
-            // `subsec_micros` rounds down, so we use `subsec_nanos` and
-            // manually round up.
-            let mut timeout = __kernel_sock_timeval {
-                tv_sec: timeout.as_secs().try_into().unwrap_or(i64::MAX),
-                tv_usec: ((timeout.subsec_nanos() + 999) / 1000) as _,
-            };
-            if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
-                timeout.tv_usec = 1;
-            }
-            timeout
-        }
-        None => __kernel_sock_timeval {
-            tv_sec: 0,
-            tv_usec: 0,
-        },
-    })
-}
-
-/// Like `duration_to_linux` but uses Linux's old 32-bit
-/// `__kernel_old_timeval`.
-fn duration_to_linux_old_timeval(timeout: Option<Duration>) -> io::Result<__kernel_old_timeval> {
-    Ok(match timeout {
-        Some(timeout) => {
-            if timeout == Duration::ZERO {
-                return Err(io::Errno::INVAL);
-            }
-
-            // `subsec_micros` rounds down, so we use `subsec_nanos` and
-            // manually round up.
-            let mut timeout = __kernel_old_timeval {
-                tv_sec: timeout.as_secs().try_into().unwrap_or(c::c_long::MAX),
-                tv_usec: ((timeout.subsec_nanos() + 999) / 1000) as _,
-            };
-            if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
-                timeout.tv_usec = 1;
-            }
-            timeout
-        }
-        None => __kernel_old_timeval {
-            tv_sec: 0,
-            tv_usec: 0,
-        },
-    })
-}
-
-#[inline]
-pub(crate) fn get_socket_error(fd: BorrowedFd<'_>) -> io::Result<Result<(), io::Errno>> {
-    let err: c::c_int = getsockopt(fd, c::SOL_SOCKET, c::SO_ERROR)?;
-    Ok(if err == 0 {
-        Ok(())
-    } else {
-        Err(io::Errno::from_raw_os_error(err))
-    })
-}
-
-#[inline]
-pub(crate) fn set_socket_keepalive(fd: BorrowedFd<'_>, keepalive: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_KEEPALIVE, from_bool(keepalive))
-}
-
-#[inline]
-pub(crate) fn get_socket_keepalive(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_KEEPALIVE).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_recv_buffer_size(fd: BorrowedFd<'_>, size: usize) -> io::Result<()> {
-    let size: c::c_int = size.try_into().map_err(|_| io::Errno::INVAL)?;
-    setsockopt(fd, c::SOL_SOCKET, c::SO_RCVBUF, size)
-}
-
-#[inline]
-pub(crate) fn get_socket_recv_buffer_size(fd: BorrowedFd<'_>) -> io::Result<usize> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_RCVBUF).map(|size: u32| size as usize)
-}
-
-#[inline]
-pub(crate) fn set_socket_send_buffer_size(fd: BorrowedFd<'_>, size: usize) -> io::Result<()> {
-    let size: c::c_int = size.try_into().map_err(|_| io::Errno::INVAL)?;
-    setsockopt(fd, c::SOL_SOCKET, c::SO_SNDBUF, size)
-}
-
-#[inline]
-pub(crate) fn get_socket_send_buffer_size(fd: BorrowedFd<'_>) -> io::Result<usize> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_SNDBUF).map(|size: u32| size as usize)
-}
-
-#[inline]
-pub(crate) fn get_socket_domain(fd: BorrowedFd<'_>) -> io::Result<AddressFamily> {
-    let domain: c::c_int = getsockopt(fd, c::SOL_SOCKET, c::SO_DOMAIN)?;
-    Ok(AddressFamily(
-        domain.try_into().map_err(|_| io::Errno::OPNOTSUPP)?,
-    ))
-}
-
-#[inline]
-pub(crate) fn get_socket_acceptconn(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_ACCEPTCONN).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_oobinline(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_OOBINLINE, from_bool(value))
-}
-
-#[inline]
-pub(crate) fn get_socket_oobinline(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_OOBINLINE).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_socket_reuseport(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_REUSEPORT, from_bool(value))
-}
-
-#[inline]
-pub(crate) fn get_socket_reuseport(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_REUSEPORT).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn get_socket_protocol(fd: BorrowedFd<'_>) -> io::Result<Option<Protocol>> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_PROTOCOL)
-        .map(|raw: u32| RawProtocol::new(raw).map(Protocol::from_raw))
-}
-
-#[inline]
-pub(crate) fn get_socket_cookie(fd: BorrowedFd<'_>) -> io::Result<u64> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_COOKIE)
-}
-
-#[inline]
-pub(crate) fn get_socket_incoming_cpu(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::SOL_SOCKET, c::SO_INCOMING_CPU)
-}
-
-#[inline]
-pub(crate) fn set_socket_incoming_cpu(fd: BorrowedFd<'_>, value: u32) -> io::Result<()> {
-    setsockopt(fd, c::SOL_SOCKET, c::SO_INCOMING_CPU, value)
-}
-
-#[inline]
-pub(crate) fn set_ip_ttl(fd: BorrowedFd<'_>, ttl: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_TTL, ttl)
-}
-
-#[inline]
-pub(crate) fn get_ip_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_TTL)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_v6only(fd: BorrowedFd<'_>, only_v6: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_V6ONLY, from_bool(only_v6))
-}
-
-#[inline]
-pub(crate) fn get_ipv6_v6only(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_V6ONLY).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_ip_multicast_loop(fd: BorrowedFd<'_>, multicast_loop: bool) -> io::Result<()> {
-    setsockopt(
-        fd,
-        c::IPPROTO_IP,
-        c::IP_MULTICAST_LOOP,
-        from_bool(multicast_loop),
-    )
-}
-
-#[inline]
-pub(crate) fn get_ip_multicast_loop(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_MULTICAST_LOOP).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_ip_multicast_ttl(fd: BorrowedFd<'_>, multicast_ttl: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_MULTICAST_TTL, multicast_ttl)
-}
-
-#[inline]
-pub(crate) fn get_ip_multicast_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_MULTICAST_TTL)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_multicast_loop(fd: BorrowedFd<'_>, multicast_loop: bool) -> io::Result<()> {
-    setsockopt(
-        fd,
-        c::IPPROTO_IPV6,
-        c::IPV6_MULTICAST_LOOP,
-        from_bool(multicast_loop),
-    )
-}
-
-#[inline]
-pub(crate) fn get_ipv6_multicast_loop(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_MULTICAST_LOOP).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_multicast_hops(fd: BorrowedFd<'_>, multicast_hops: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IPV6_MULTICAST_HOPS, multicast_hops)
-}
-
-#[inline]
-pub(crate) fn get_ipv6_multicast_hops(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_IP, c::IPV6_MULTICAST_HOPS)
-}
-
-#[inline]
-pub(crate) fn set_ip_add_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-) -> io::Result<()> {
-    let mreq = to_ip_mreq(multiaddr, interface);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_ADD_MEMBERSHIP, mreq)
-}
-
-#[inline]
-pub(crate) fn set_ip_add_membership_with_ifindex(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    address: &Ipv4Addr,
-    ifindex: i32,
-) -> io::Result<()> {
-    let mreqn = to_ip_mreqn(multiaddr, address, ifindex);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_ADD_MEMBERSHIP, mreqn)
-}
-
-#[inline]
-pub(crate) fn set_ip_add_source_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-    sourceaddr: &Ipv4Addr,
-) -> io::Result<()> {
-    let mreq_source = to_imr_source(multiaddr, interface, sourceaddr);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_ADD_SOURCE_MEMBERSHIP, mreq_source)
-}
-
-#[inline]
-pub(crate) fn set_ip_drop_source_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-    sourceaddr: &Ipv4Addr,
-) -> io::Result<()> {
-    let mreq_source = to_imr_source(multiaddr, interface, sourceaddr);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_DROP_SOURCE_MEMBERSHIP, mreq_source)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_add_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv6Addr,
-    interface: u32,
-) -> io::Result<()> {
-    let mreq = to_ipv6mr(multiaddr, interface);
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_ADD_MEMBERSHIP, mreq)
-}
-
-#[inline]
-pub(crate) fn set_ip_drop_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-) -> io::Result<()> {
-    let mreq = to_ip_mreq(multiaddr, interface);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_DROP_MEMBERSHIP, mreq)
-}
-
-#[inline]
-pub(crate) fn set_ip_drop_membership_with_ifindex(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv4Addr,
-    address: &Ipv4Addr,
-    ifindex: i32,
-) -> io::Result<()> {
-    let mreqn = to_ip_mreqn(multiaddr, address, ifindex);
-    setsockopt(fd, c::IPPROTO_IP, c::IP_DROP_MEMBERSHIP, mreqn)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_drop_membership(
-    fd: BorrowedFd<'_>,
-    multiaddr: &Ipv6Addr,
-    interface: u32,
-) -> io::Result<()> {
-    let mreq = to_ipv6mr(multiaddr, interface);
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_DROP_MEMBERSHIP, mreq)
-}
-
-#[inline]
-pub(crate) fn get_ipv6_unicast_hops(fd: BorrowedFd<'_>) -> io::Result<u8> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS).map(|hops: c::c_int| hops as u8)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_unicast_hops(fd: BorrowedFd<'_>, hops: Option<u8>) -> io::Result<()> {
-    let hops = match hops {
-        Some(hops) => hops.into(),
-        None => -1,
-    };
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS, hops)
-}
-
-#[inline]
-pub(crate) fn set_ip_tos(fd: BorrowedFd<'_>, value: u8) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_TOS, i32::from(value))
-}
-
-#[inline]
-pub(crate) fn get_ip_tos(fd: BorrowedFd<'_>) -> io::Result<u8> {
-    let value: i32 = getsockopt(fd, c::IPPROTO_IP, c::IP_TOS)?;
-    Ok(value as u8)
-}
-
-#[inline]
-pub(crate) fn set_ip_recvtos(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_RECVTOS, from_bool(value))
-}
-
-#[inline]
-pub(crate) fn get_ip_recvtos(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_RECVTOS).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_recvtclass(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_RECVTCLASS, from_bool(value))
-}
-
-#[inline]
-pub(crate) fn get_ipv6_recvtclass(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_RECVTCLASS).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_ip_freebind(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IP, c::IP_FREEBIND, from_bool(value))
-}
-
-#[inline]
-pub(crate) fn get_ip_freebind(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IP, c::IP_FREEBIND).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_ipv6_freebind(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_FREEBIND, from_bool(value))
-}
-
-#[inline]
-pub(crate) fn get_ipv6_freebind(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_FREEBIND).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn get_ip_original_dst(fd: BorrowedFd<'_>) -> io::Result<SocketAddrV4> {
-    let level = c::IPPROTO_IP;
-    let optname = c::SO_ORIGINAL_DST;
-    let mut value = MaybeUninit::<SocketAddrStorage>::uninit();
-    let mut optlen = core::mem::size_of_val(&value).try_into().unwrap();
-
-    getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
-
-    let any = unsafe { SocketAddrAny::read(value.as_ptr(), optlen as usize)? };
-    match any {
-        SocketAddrAny::V4(v4) => Ok(v4),
-        _ => unreachable!(),
-    }
-}
-
-#[inline]
-pub(crate) fn get_ipv6_original_dst(fd: BorrowedFd<'_>) -> io::Result<SocketAddrV6> {
-    let level = c::IPPROTO_IPV6;
-    let optname = c::IP6T_SO_ORIGINAL_DST;
-    let mut value = MaybeUninit::<SocketAddrStorage>::uninit();
-    let mut optlen = core::mem::size_of_val(&value).try_into().unwrap();
-
-    getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
-
-    let any = unsafe { SocketAddrAny::read(value.as_ptr(), optlen as usize)? };
-    match any {
-        SocketAddrAny::V6(v6) => Ok(v6),
-        _ => unreachable!(),
-    }
-}
-
-#[inline]
-pub(crate) fn set_ipv6_tclass(fd: BorrowedFd<'_>, value: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_IPV6, c::IPV6_TCLASS, value)
-}
-
-#[inline]
-pub(crate) fn get_ipv6_tclass(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_IPV6, c::IPV6_TCLASS)
-}
-
-#[inline]
-pub(crate) fn set_tcp_nodelay(fd: BorrowedFd<'_>, nodelay: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_NODELAY, from_bool(nodelay))
-}
-
-#[inline]
-pub(crate) fn get_tcp_nodelay(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_NODELAY).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_tcp_keepcnt(fd: BorrowedFd<'_>, count: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPCNT, count)
-}
-
-#[inline]
-pub(crate) fn get_tcp_keepcnt(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPCNT)
-}
-
-#[inline]
-pub(crate) fn set_tcp_keepidle(fd: BorrowedFd<'_>, duration: Duration) -> io::Result<()> {
-    let secs: c::c_uint = duration_to_secs(duration)?;
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPIDLE, secs)
-}
-
-#[inline]
-pub(crate) fn get_tcp_keepidle(fd: BorrowedFd<'_>) -> io::Result<Duration> {
-    let secs: c::c_uint = getsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPIDLE)?;
-    Ok(Duration::from_secs(secs as u64))
-}
-
-#[inline]
-pub(crate) fn set_tcp_keepintvl(fd: BorrowedFd<'_>, duration: Duration) -> io::Result<()> {
-    let secs: c::c_uint = duration_to_secs(duration)?;
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPINTVL, secs)
-}
-
-#[inline]
-pub(crate) fn get_tcp_keepintvl(fd: BorrowedFd<'_>) -> io::Result<Duration> {
-    let secs: c::c_uint = getsockopt(fd, c::IPPROTO_TCP, c::TCP_KEEPINTVL)?;
-    Ok(Duration::from_secs(secs as u64))
-}
-
-#[inline]
-pub(crate) fn set_tcp_user_timeout(fd: BorrowedFd<'_>, value: u32) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_USER_TIMEOUT, value)
-}
-
-#[inline]
-pub(crate) fn get_tcp_user_timeout(fd: BorrowedFd<'_>) -> io::Result<u32> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_USER_TIMEOUT)
-}
-
-#[inline]
-pub(crate) fn set_tcp_quickack(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_QUICKACK, from_bool(value))
-}
-
-#[inline]
-pub(crate) fn get_tcp_quickack(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_QUICKACK).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_tcp_congestion(fd: BorrowedFd<'_>, value: &str) -> io::Result<()> {
-    let level = c::IPPROTO_TCP;
-    let optname = c::TCP_CONGESTION;
-    let optlen = value.len().try_into().unwrap();
-    setsockopt_raw(fd, level, optname, value.as_ptr(), optlen)
-}
-
-#[cfg(feature = "alloc")]
-#[inline]
-pub(crate) fn get_tcp_congestion(fd: BorrowedFd<'_>) -> io::Result<String> {
-    let level = c::IPPROTO_TCP;
-    let optname = c::TCP_CONGESTION;
-    const OPTLEN: c::socklen_t = 16;
-    let mut value = MaybeUninit::<[MaybeUninit<u8>; OPTLEN as usize]>::uninit();
-    let mut optlen = OPTLEN;
-    getsockopt_raw(fd, level, optname, &mut value, &mut optlen)?;
-    unsafe {
-        let value = value.assume_init();
-        let slice: &[u8] = core::mem::transmute(&value[..optlen as usize]);
-        assert!(slice.iter().any(|b| *b == b'\0'));
-        Ok(
-            core::str::from_utf8(CStr::from_ptr(slice.as_ptr().cast()).to_bytes())
-                .unwrap()
-                .to_owned(),
-        )
-    }
-}
-
-#[inline]
-pub(crate) fn set_tcp_thin_linear_timeouts(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(
-        fd,
-        c::IPPROTO_TCP,
-        c::TCP_THIN_LINEAR_TIMEOUTS,
-        from_bool(value),
-    )
-}
-
-#[inline]
-pub(crate) fn get_tcp_thin_linear_timeouts(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_THIN_LINEAR_TIMEOUTS).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn set_tcp_cork(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    setsockopt(fd, c::IPPROTO_TCP, c::TCP_CORK, from_bool(value))
-}
-
-#[inline]
-pub(crate) fn get_tcp_cork(fd: BorrowedFd<'_>) -> io::Result<bool> {
-    getsockopt(fd, c::IPPROTO_TCP, c::TCP_CORK).map(to_bool)
-}
-
-#[inline]
-pub(crate) fn get_socket_peercred(fd: BorrowedFd<'_>) -> io::Result<UCred> {
-    getsockopt(fd, c::SOL_SOCKET, linux_raw_sys::net::SO_PEERCRED)
-}
-
-#[inline]
-fn to_ip_mreq(multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> c::ip_mreq {
-    c::ip_mreq {
-        imr_multiaddr: to_imr_addr(multiaddr),
-        imr_interface: to_imr_addr(interface),
-    }
-}
-
-#[inline]
-fn to_ip_mreqn(multiaddr: &Ipv4Addr, address: &Ipv4Addr, ifindex: i32) -> c::ip_mreqn {
-    c::ip_mreqn {
-        imr_multiaddr: to_imr_addr(multiaddr),
-        imr_address: to_imr_addr(address),
-        imr_ifindex: ifindex,
-    }
-}
-
-#[inline]
-fn to_imr_source(
-    multiaddr: &Ipv4Addr,
-    interface: &Ipv4Addr,
-    sourceaddr: &Ipv4Addr,
-) -> c::ip_mreq_source {
-    c::ip_mreq_source {
-        imr_multiaddr: to_imr_addr(multiaddr).s_addr,
-        imr_interface: to_imr_addr(interface).s_addr,
-        imr_sourceaddr: to_imr_addr(sourceaddr).s_addr,
-    }
-}
-
-#[inline]
-fn to_imr_addr(addr: &Ipv4Addr) -> c::in_addr {
-    c::in_addr {
-        s_addr: u32::from_ne_bytes(addr.octets()),
-    }
-}
-
-#[inline]
-fn to_ipv6mr(multiaddr: &Ipv6Addr, interface: u32) -> c::ipv6_mreq {
-    c::ipv6_mreq {
-        ipv6mr_multiaddr: to_ipv6mr_multiaddr(multiaddr),
-        ipv6mr_ifindex: to_ipv6mr_interface(interface),
-    }
-}
-
-#[inline]
-fn to_ipv6mr_multiaddr(multiaddr: &Ipv6Addr) -> c::in6_addr {
-    c::in6_addr {
-        in6_u: linux_raw_sys::net::in6_addr__bindgen_ty_1 {
-            u6_addr8: multiaddr.octets(),
-        },
-    }
-}
-
-#[inline]
-fn to_ipv6mr_interface(interface: u32) -> c::c_int {
-    interface as c::c_int
-}
-
-#[inline]
-fn from_bool(value: bool) -> c::c_uint {
-    c::c_uint::from(value)
-}
-
-#[inline]
-fn to_bool(value: c::c_uint) -> bool {
-    value != 0
-}
-
-/// Convert to seconds, rounding up if necessary.
-#[inline]
-fn duration_to_secs<T: TryFrom<u64>>(duration: Duration) -> io::Result<T> {
-    let mut secs = duration.as_secs();
-    if duration.subsec_nanos() != 0 {
-        secs = secs.checked_add(1).ok_or(io::Errno::INVAL)?;
-    }
-    T::try_from(secs).map_err(|_e| io::Errno::INVAL)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/net/syscalls.rs b/vendor/rustix/src/backend/linux_raw/net/syscalls.rs
deleted file mode 100644
index 726f022..0000000
--- a/vendor/rustix/src/backend/linux_raw/net/syscalls.rs
+++ /dev/null
@@ -1,949 +0,0 @@
-//! linux_raw syscalls supporting `rustix::net`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-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::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6};
-use crate::backend::c;
-use crate::backend::conv::{
-    by_mut, by_ref, c_int, c_uint, pass_usize, ret, ret_owned_fd, ret_usize, size_of, slice,
-    socklen_t, zero,
-};
-use crate::fd::{BorrowedFd, OwnedFd};
-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::mem::MaybeUninit;
-#[cfg(target_arch = "x86")]
-use {
-    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_LISTEN, SYS_RECV, SYS_RECVFROM, SYS_RECVMSG, SYS_SEND, SYS_SENDMSG, SYS_SENDTO,
-        SYS_SHUTDOWN, SYS_SOCKET, SYS_SOCKETPAIR,
-    },
-};
-
-#[inline]
-pub(crate) fn socket(
-    family: AddressFamily,
-    type_: SocketType,
-    protocol: Option<Protocol>,
-) -> io::Result<OwnedFd> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(__NR_socket, family, type_, protocol))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_SOCKET),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                family.into(),
-                type_.into(),
-                protocol.into(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn socket_with(
-    family: AddressFamily,
-    type_: SocketType,
-    flags: SocketFlags,
-    protocol: Option<Protocol>,
-) -> io::Result<OwnedFd> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(
-            __NR_socket,
-            family,
-            (type_, flags),
-            protocol
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret_owned_fd(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_SOCKET),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                family.into(),
-                (type_, flags).into(),
-                protocol.into(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn socketpair(
-    family: AddressFamily,
-    type_: SocketType,
-    flags: SocketFlags,
-    protocol: Option<Protocol>,
-) -> io::Result<(OwnedFd, OwnedFd)> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
-        ret(syscall!(
-            __NR_socketpair,
-            family,
-            (type_, flags),
-            protocol,
-            &mut result
-        ))?;
-        let [fd0, fd1] = result.assume_init();
-        Ok((fd0, fd1))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
-        ret(syscall!(
-            __NR_socketcall,
-            x86_sys(SYS_SOCKETPAIR),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                family.into(),
-                (type_, flags).into(),
-                protocol.into(),
-                (&mut result).into(),
-            ])
-        ))?;
-        let [fd0, fd1] = result.assume_init();
-        Ok((fd0, fd1))
-    }
-}
-
-#[inline]
-pub(crate) fn accept(fd: BorrowedFd<'_>) -> io::Result<OwnedFd> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        let fd = ret_owned_fd(syscall_readonly!(__NR_accept, fd, zero(), zero()))?;
-        Ok(fd)
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        let fd = ret_owned_fd(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_ACCEPT),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[fd.into(), zero(), zero()])
-        ))?;
-        Ok(fd)
-    }
-}
-
-#[inline]
-pub(crate) fn accept_with(fd: BorrowedFd<'_>, flags: SocketFlags) -> io::Result<OwnedFd> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        let fd = ret_owned_fd(syscall_readonly!(__NR_accept4, fd, zero(), zero(), flags))?;
-        Ok(fd)
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        let fd = ret_owned_fd(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_ACCEPT4),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[fd.into(), zero(), zero(), flags.into()])
-        ))?;
-        Ok(fd)
-    }
-}
-
-#[inline]
-pub(crate) fn acceptfrom(fd: BorrowedFd<'_>) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
-        let mut storage = MaybeUninit::<sockaddr>::uninit();
-        let fd = ret_owned_fd(syscall!(
-            __NR_accept,
-            fd,
-            &mut storage,
-            by_mut(&mut addrlen)
-        ))?;
-        Ok((
-            fd,
-            maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
-        let mut storage = MaybeUninit::<sockaddr>::uninit();
-        let fd = ret_owned_fd(syscall!(
-            __NR_socketcall,
-            x86_sys(SYS_ACCEPT),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                (&mut storage).into(),
-                by_mut(&mut addrlen),
-            ])
-        ))?;
-        Ok((
-            fd,
-            maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn acceptfrom_with(
-    fd: BorrowedFd<'_>,
-    flags: SocketFlags,
-) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
-        let mut storage = MaybeUninit::<sockaddr>::uninit();
-        let fd = ret_owned_fd(syscall!(
-            __NR_accept4,
-            fd,
-            &mut storage,
-            by_mut(&mut addrlen),
-            flags
-        ))?;
-        Ok((
-            fd,
-            maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
-        let mut storage = MaybeUninit::<sockaddr>::uninit();
-        let fd = ret_owned_fd(syscall!(
-            __NR_socketcall,
-            x86_sys(SYS_ACCEPT4),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                (&mut storage).into(),
-                by_mut(&mut addrlen),
-                flags.into(),
-            ])
-        ))?;
-        Ok((
-            fd,
-            maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
-        ))
-    }
-}
-
-#[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 {
-        ret(syscall_readonly!(
-            __NR_shutdown,
-            fd,
-            c_uint(how as c::c_uint)
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_SHUTDOWN),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[fd.into(), c_uint(how as c::c_uint)])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn send(fd: BorrowedFd<'_>, buf: &[u8], flags: SendFlags) -> io::Result<usize> {
-    let (buf_addr, buf_len) = slice(buf);
-
-    #[cfg(not(any(
-        target_arch = "aarch64",
-        target_arch = "mips64",
-        target_arch = "mips64r6",
-        target_arch = "riscv64",
-        target_arch = "x86",
-        target_arch = "x86_64",
-    )))]
-    unsafe {
-        ret_usize(syscall_readonly!(__NR_send, fd, buf_addr, buf_len, flags))
-    }
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "mips64",
-        target_arch = "mips64r6",
-        target_arch = "riscv64",
-        target_arch = "x86_64",
-    ))]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_sendto,
-            fd,
-            buf_addr,
-            buf_len,
-            flags,
-            zero(),
-            zero()
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_SEND),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                buf_addr,
-                buf_len,
-                flags.into()
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn sendto_v4(
-    fd: BorrowedFd<'_>,
-    buf: &[u8],
-    flags: SendFlags,
-    addr: &SocketAddrV4,
-) -> io::Result<usize> {
-    let (buf_addr, buf_len) = slice(buf);
-
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_sendto,
-            fd,
-            buf_addr,
-            buf_len,
-            flags,
-            by_ref(&encode_sockaddr_v4(addr)),
-            size_of::<sockaddr_in, _>()
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_SENDTO),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                buf_addr,
-                buf_len,
-                flags.into(),
-                by_ref(&encode_sockaddr_v4(addr)),
-                size_of::<sockaddr_in, _>(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn sendto_v6(
-    fd: BorrowedFd<'_>,
-    buf: &[u8],
-    flags: SendFlags,
-    addr: &SocketAddrV6,
-) -> io::Result<usize> {
-    let (buf_addr, buf_len) = slice(buf);
-
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_sendto,
-            fd,
-            buf_addr,
-            buf_len,
-            flags,
-            by_ref(&encode_sockaddr_v6(addr)),
-            size_of::<sockaddr_in6, _>()
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_SENDTO),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                buf_addr,
-                buf_len,
-                flags.into(),
-                by_ref(&encode_sockaddr_v6(addr)),
-                size_of::<sockaddr_in6, _>(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn sendto_unix(
-    fd: BorrowedFd<'_>,
-    buf: &[u8],
-    flags: SendFlags,
-    addr: &SocketAddrUnix,
-) -> io::Result<usize> {
-    let (buf_addr, buf_len) = slice(buf);
-
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_sendto,
-            fd,
-            buf_addr,
-            buf_len,
-            flags,
-            by_ref(&addr.unix),
-            socklen_t(addr.addr_len())
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret_usize(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_SENDTO),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                buf_addr,
-                buf_len,
-                flags.into(),
-                by_ref(&addr.unix),
-                socklen_t(addr.addr_len()),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn recv(
-    fd: BorrowedFd<'_>,
-    buf: *mut u8,
-    len: usize,
-    flags: RecvFlags,
-) -> io::Result<usize> {
-    #[cfg(not(any(
-        target_arch = "aarch64",
-        target_arch = "mips64",
-        target_arch = "mips64r6",
-        target_arch = "riscv64",
-        target_arch = "x86",
-        target_arch = "x86_64",
-    )))]
-    {
-        ret_usize(syscall!(__NR_recv, fd, buf, pass_usize(len), flags))
-    }
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "mips64",
-        target_arch = "mips64r6",
-        target_arch = "riscv64",
-        target_arch = "x86_64",
-    ))]
-    {
-        ret_usize(syscall!(
-            __NR_recvfrom,
-            fd,
-            buf,
-            pass_usize(len),
-            flags,
-            zero(),
-            zero()
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    {
-        ret_usize(syscall!(
-            __NR_socketcall,
-            x86_sys(SYS_RECV),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                buf.into(),
-                pass_usize(len),
-                flags.into(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn recvfrom(
-    fd: BorrowedFd<'_>,
-    buf: *mut u8,
-    len: usize,
-    flags: RecvFlags,
-) -> io::Result<(usize, Option<SocketAddrAny>)> {
-    let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
-    let mut storage = MaybeUninit::<sockaddr>::uninit();
-
-    // `recvfrom` does not write to the storage if the socket is
-    // connection-oriented sockets, so we initialize the family field to
-    // `AF_UNSPEC` so that we can detect this case.
-    initialize_family_to_unspec(storage.as_mut_ptr());
-
-    #[cfg(not(target_arch = "x86"))]
-    let nread = ret_usize(syscall!(
-        __NR_recvfrom,
-        fd,
-        buf,
-        pass_usize(len),
-        flags,
-        &mut storage,
-        by_mut(&mut addrlen)
-    ))?;
-    #[cfg(target_arch = "x86")]
-    let nread = ret_usize(syscall!(
-        __NR_socketcall,
-        x86_sys(SYS_RECVFROM),
-        slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-            fd.into(),
-            buf.into(),
-            pass_usize(len),
-            flags.into(),
-            (&mut storage).into(),
-            by_mut(&mut addrlen),
-        ])
-    ))?;
-
-    Ok((
-        nread,
-        maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
-    ))
-}
-
-#[inline]
-pub(crate) fn getpeername(fd: BorrowedFd<'_>) -> io::Result<Option<SocketAddrAny>> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
-        let mut storage = MaybeUninit::<sockaddr>::uninit();
-        ret(syscall!(
-            __NR_getpeername,
-            fd,
-            &mut storage,
-            by_mut(&mut addrlen)
-        ))?;
-        Ok(maybe_read_sockaddr_os(
-            &storage.assume_init(),
-            addrlen.try_into().unwrap(),
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
-        let mut storage = MaybeUninit::<sockaddr>::uninit();
-        ret(syscall!(
-            __NR_socketcall,
-            x86_sys(SYS_GETPEERNAME),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                (&mut storage).into(),
-                by_mut(&mut addrlen),
-            ])
-        ))?;
-        Ok(maybe_read_sockaddr_os(
-            &storage.assume_init(),
-            addrlen.try_into().unwrap(),
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn getsockname(fd: BorrowedFd<'_>) -> io::Result<SocketAddrAny> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
-        let mut storage = MaybeUninit::<sockaddr>::uninit();
-        ret(syscall!(
-            __NR_getsockname,
-            fd,
-            &mut storage,
-            by_mut(&mut addrlen)
-        ))?;
-        Ok(read_sockaddr_os(
-            &storage.assume_init(),
-            addrlen.try_into().unwrap(),
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
-        let mut storage = MaybeUninit::<sockaddr>::uninit();
-        ret(syscall!(
-            __NR_socketcall,
-            x86_sys(SYS_GETSOCKNAME),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                (&mut storage).into(),
-                by_mut(&mut addrlen),
-            ])
-        ))?;
-        Ok(read_sockaddr_os(
-            &storage.assume_init(),
-            addrlen.try_into().unwrap(),
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn bind_v4(fd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_bind,
-            fd,
-            by_ref(&encode_sockaddr_v4(addr)),
-            size_of::<sockaddr_in, _>()
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_BIND),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                by_ref(&encode_sockaddr_v4(addr)),
-                size_of::<sockaddr_in, _>(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn bind_v6(fd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_bind,
-            fd,
-            by_ref(&encode_sockaddr_v6(addr)),
-            size_of::<sockaddr_in6, _>()
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_BIND),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                by_ref(&encode_sockaddr_v6(addr)),
-                size_of::<sockaddr_in6, _>(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn bind_unix(fd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_bind,
-            fd,
-            by_ref(&addr.unix),
-            socklen_t(addr.addr_len())
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_BIND),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                by_ref(&addr.unix),
-                socklen_t(addr.addr_len()),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn connect_v4(fd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_connect,
-            fd,
-            by_ref(&encode_sockaddr_v4(addr)),
-            size_of::<sockaddr_in, _>()
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_CONNECT),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                by_ref(&encode_sockaddr_v4(addr)),
-                size_of::<sockaddr_in, _>(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn connect_v6(fd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_connect,
-            fd,
-            by_ref(&encode_sockaddr_v6(addr)),
-            size_of::<sockaddr_in6, _>()
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_CONNECT),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                by_ref(&encode_sockaddr_v6(addr)),
-                size_of::<sockaddr_in6, _>(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn connect_unix(fd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_connect,
-            fd,
-            by_ref(&addr.unix),
-            socklen_t(addr.addr_len())
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_CONNECT),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                by_ref(&addr.unix),
-                socklen_t(addr.addr_len()),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn connect_unspec(fd: BorrowedFd<'_>) -> io::Result<()> {
-    debug_assert_eq!(c::AF_UNSPEC, 0);
-    let addr = MaybeUninit::<c::sockaddr_storage>::zeroed();
-
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_connect,
-            fd,
-            by_ref(&addr),
-            size_of::<c::sockaddr_storage, _>()
-        ))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_CONNECT),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
-                fd.into(),
-                by_ref(&addr),
-                size_of::<c::sockaddr_storage, _>(),
-            ])
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn listen(fd: BorrowedFd<'_>, backlog: c::c_int) -> io::Result<()> {
-    #[cfg(not(target_arch = "x86"))]
-    unsafe {
-        ret(syscall_readonly!(__NR_listen, fd, c_int(backlog)))
-    }
-    #[cfg(target_arch = "x86")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_socketcall,
-            x86_sys(SYS_LISTEN),
-            slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[fd.into(), c_int(backlog)])
-        ))
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/net/write_sockaddr.rs b/vendor/rustix/src/backend/linux_raw/net/write_sockaddr.rs
deleted file mode 100644
index 24edd49..0000000
--- a/vendor/rustix/src/backend/linux_raw/net/write_sockaddr.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-//! 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.
-#![allow(unsafe_code)]
-
-use crate::backend::c;
-use crate::net::{SocketAddrAny, SocketAddrStorage, SocketAddrUnix, SocketAddrV4, SocketAddrV6};
-use core::mem::size_of;
-
-pub(crate) unsafe fn write_sockaddr(
-    addr: &SocketAddrAny,
-    storage: *mut SocketAddrStorage,
-) -> usize {
-    match addr {
-        SocketAddrAny::V4(v4) => write_sockaddr_v4(v4, storage),
-        SocketAddrAny::V6(v6) => write_sockaddr_v6(v6, storage),
-        SocketAddrAny::Unix(unix) => write_sockaddr_unix(unix, storage),
-    }
-}
-
-pub(crate) fn encode_sockaddr_v4(v4: &SocketAddrV4) -> c::sockaddr_in {
-    c::sockaddr_in {
-        sin_family: c::AF_INET as _,
-        sin_port: u16::to_be(v4.port()),
-        sin_addr: c::in_addr {
-            s_addr: u32::from_ne_bytes(v4.ip().octets()),
-        },
-        __pad: [0_u8; 8],
-    }
-}
-
-unsafe fn write_sockaddr_v4(v4: &SocketAddrV4, storage: *mut SocketAddrStorage) -> usize {
-    let encoded = encode_sockaddr_v4(v4);
-    core::ptr::write(storage.cast(), encoded);
-    size_of::<c::sockaddr_in>()
-}
-
-pub(crate) fn encode_sockaddr_v6(v6: &SocketAddrV6) -> c::sockaddr_in6 {
-    c::sockaddr_in6 {
-        sin6_family: c::AF_INET6 as _,
-        sin6_port: u16::to_be(v6.port()),
-        sin6_flowinfo: u32::to_be(v6.flowinfo()),
-        sin6_addr: c::in6_addr {
-            in6_u: linux_raw_sys::net::in6_addr__bindgen_ty_1 {
-                u6_addr8: v6.ip().octets(),
-            },
-        },
-        sin6_scope_id: v6.scope_id(),
-    }
-}
-
-unsafe fn write_sockaddr_v6(v6: &SocketAddrV6, storage: *mut SocketAddrStorage) -> usize {
-    let encoded = encode_sockaddr_v6(v6);
-    core::ptr::write(storage.cast(), encoded);
-    size_of::<c::sockaddr_in6>()
-}
-
-unsafe fn write_sockaddr_unix(unix: &SocketAddrUnix, storage: *mut SocketAddrStorage) -> usize {
-    core::ptr::write(storage.cast(), unix.unix);
-    unix.len()
-}
diff --git a/vendor/rustix/src/backend/linux_raw/param/auxv.rs b/vendor/rustix/src/backend/linux_raw/param/auxv.rs
deleted file mode 100644
index b9ac27e..0000000
--- a/vendor/rustix/src/backend/linux_raw/param/auxv.rs
+++ /dev/null
@@ -1,507 +0,0 @@
-//! Linux auxv support.
-//!
-//! # Safety
-//!
-//! This uses raw pointers to locate and read the kernel-provided auxv array.
-#![allow(unsafe_code)]
-
-use crate::backend::c;
-use crate::fd::OwnedFd;
-#[cfg(feature = "param")]
-use crate::ffi::CStr;
-use crate::fs::{Mode, OFlags};
-use crate::utils::{as_ptr, check_raw_pointer};
-#[cfg(feature = "alloc")]
-use alloc::vec::Vec;
-use core::mem::size_of;
-use core::ptr::{null_mut, read_unaligned, NonNull};
-#[cfg(feature = "runtime")]
-use core::sync::atomic::AtomicU8;
-use core::sync::atomic::Ordering::Relaxed;
-use core::sync::atomic::{AtomicPtr, AtomicUsize};
-use linux_raw_sys::elf::*;
-use linux_raw_sys::general::{
-    AT_BASE, AT_CLKTCK, AT_EXECFN, AT_HWCAP, AT_HWCAP2, AT_NULL, AT_PAGESZ, AT_SYSINFO_EHDR,
-};
-#[cfg(feature = "runtime")]
-use linux_raw_sys::general::{
-    AT_EGID, AT_ENTRY, AT_EUID, AT_GID, AT_PHDR, AT_PHENT, AT_PHNUM, AT_RANDOM, AT_SECURE, AT_UID,
-};
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn page_size() -> usize {
-    let mut page_size = PAGE_SIZE.load(Relaxed);
-
-    if page_size == 0 {
-        init_auxv();
-        page_size = PAGE_SIZE.load(Relaxed);
-    }
-
-    page_size
-}
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn clock_ticks_per_second() -> u64 {
-    let mut ticks = CLOCK_TICKS_PER_SECOND.load(Relaxed);
-
-    if ticks == 0 {
-        init_auxv();
-        ticks = CLOCK_TICKS_PER_SECOND.load(Relaxed);
-    }
-
-    ticks as u64
-}
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn linux_hwcap() -> (usize, usize) {
-    let mut hwcap = HWCAP.load(Relaxed);
-    let mut hwcap2 = HWCAP2.load(Relaxed);
-
-    if hwcap == 0 || hwcap2 == 0 {
-        init_auxv();
-        hwcap = HWCAP.load(Relaxed);
-        hwcap2 = HWCAP2.load(Relaxed);
-    }
-
-    (hwcap, hwcap2)
-}
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn linux_execfn() -> &'static CStr {
-    let mut execfn = EXECFN.load(Relaxed);
-
-    if execfn.is_null() {
-        init_auxv();
-        execfn = EXECFN.load(Relaxed);
-    }
-
-    // SAFETY: We assume the `AT_EXECFN` value provided by the kernel is a
-    // valid pointer to a valid NUL-terminated array of bytes.
-    unsafe { CStr::from_ptr(execfn.cast()) }
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn linux_secure() -> bool {
-    let mut secure = SECURE.load(Relaxed);
-
-    // 0 means not initialized yet.
-    if secure == 0 {
-        init_auxv();
-        secure = SECURE.load(Relaxed);
-    }
-
-    // 0 means not present. Libc `getauxval(AT_SECURE)` would return 0.
-    // 1 means not in secure mode.
-    // 2 means in secure mode.
-    secure > 1
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn exe_phdrs() -> (*const c::c_void, usize, usize) {
-    let mut phdr = PHDR.load(Relaxed);
-    let mut phent = PHENT.load(Relaxed);
-    let mut phnum = PHNUM.load(Relaxed);
-
-    if phdr.is_null() || phnum == 0 {
-        init_auxv();
-        phdr = PHDR.load(Relaxed);
-        phent = PHENT.load(Relaxed);
-        phnum = PHNUM.load(Relaxed);
-    }
-
-    (phdr.cast(), phent, phnum)
-}
-
-/// `AT_SYSINFO_EHDR` isn't present on all platforms in all configurations, so
-/// if we don't see it, this function returns a null pointer.
-#[inline]
-pub(in super::super) fn sysinfo_ehdr() -> *const Elf_Ehdr {
-    let mut ehdr = SYSINFO_EHDR.load(Relaxed);
-
-    if ehdr.is_null() {
-        init_auxv();
-        ehdr = SYSINFO_EHDR.load(Relaxed);
-    }
-
-    ehdr
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn entry() -> usize {
-    let mut entry = ENTRY.load(Relaxed);
-
-    if entry == 0 {
-        init_auxv();
-        entry = ENTRY.load(Relaxed);
-    }
-
-    entry
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn random() -> *const [u8; 16] {
-    let mut random = RANDOM.load(Relaxed);
-
-    if random.is_null() {
-        init_auxv();
-        random = RANDOM.load(Relaxed);
-    }
-
-    random
-}
-
-static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
-static CLOCK_TICKS_PER_SECOND: AtomicUsize = AtomicUsize::new(0);
-static HWCAP: AtomicUsize = AtomicUsize::new(0);
-static HWCAP2: AtomicUsize = AtomicUsize::new(0);
-static EXECFN: AtomicPtr<c::c_char> = AtomicPtr::new(null_mut());
-static SYSINFO_EHDR: AtomicPtr<Elf_Ehdr> = AtomicPtr::new(null_mut());
-#[cfg(feature = "runtime")]
-static SECURE: AtomicU8 = AtomicU8::new(0);
-#[cfg(feature = "runtime")]
-static PHDR: AtomicPtr<Elf_Phdr> = AtomicPtr::new(null_mut());
-#[cfg(feature = "runtime")]
-static PHENT: AtomicUsize = AtomicUsize::new(0);
-#[cfg(feature = "runtime")]
-static PHNUM: AtomicUsize = AtomicUsize::new(0);
-#[cfg(feature = "runtime")]
-static ENTRY: AtomicUsize = AtomicUsize::new(0);
-#[cfg(feature = "runtime")]
-static RANDOM: AtomicPtr<[u8; 16]> = AtomicPtr::new(null_mut());
-
-#[cfg(feature = "alloc")]
-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 = 0x4155_5856;
-    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()),
-            pass_usize(0),
-            pass_usize(0)
-        ))?
-    };
-    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()),
-            pass_usize(0),
-            pass_usize(0)
-        ))?
-    };
-    assert_eq!(len, buffer.len());
-    return Ok(buffer);
-}
-
-/// If we don't have "use-explicitly-provided-auxv" or "use-libc-auxv", 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`.
-#[cold]
-fn init_auxv() {
-    #[cfg(feature = "alloc")]
-    {
-        match pr_get_auxv() {
-            Ok(buffer) => {
-                // SAFETY: We assume the kernel returns a valid auxv.
-                unsafe {
-                    init_from_aux_iter(AuxPointer(buffer.as_ptr().cast())).unwrap();
-                }
-                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::open("/proc/self/auxv", OFlags::RDONLY, Mode::empty()).unwrap();
-
-    #[cfg(feature = "alloc")]
-    init_from_auxv_file(file).unwrap();
-
-    #[cfg(not(feature = "alloc"))]
-    unsafe {
-        init_from_aux_iter(AuxFile(file)).unwrap();
-    }
-}
-
-/// Process auxv entries from the open file `auxv`.
-#[cfg(feature = "alloc")]
-#[cold]
-#[must_use]
-fn init_from_auxv_file(auxv: OwnedFd) -> Option<()> {
-    let mut buffer = Vec::<u8>::with_capacity(512);
-    loop {
-        let cur = buffer.len();
-
-        // Request one extra byte; `Vec` will often allocate more.
-        buffer.reserve(1);
-
-        // Use all the space it allocated.
-        buffer.resize(buffer.capacity(), 0);
-
-        // Read up to that many bytes.
-        let n = match crate::io::read(&auxv, &mut buffer[cur..]) {
-            Err(crate::io::Errno::INTR) => 0,
-            Err(_err) => panic!(),
-            Ok(0) => break,
-            Ok(n) => n,
-        };
-
-        // Account for the number of bytes actually read.
-        buffer.resize(cur + n, 0_u8);
-    }
-
-    // SAFETY: We loaded from an auxv file into the buffer.
-    unsafe { init_from_aux_iter(AuxPointer(buffer.as_ptr().cast())) }
-}
-
-/// Process auxv entries from the auxv array pointed to by `auxp`.
-///
-/// # Safety
-///
-/// This must be passed a pointer to an auxv array.
-///
-/// The buffer contains `Elf_aux_t` elements, though it need not be aligned;
-/// function uses `read_unaligned` to read from it.
-#[cold]
-#[must_use]
-unsafe fn init_from_aux_iter(aux_iter: impl Iterator<Item = Elf_auxv_t>) -> Option<()> {
-    let mut pagesz = 0;
-    let mut clktck = 0;
-    let mut hwcap = 0;
-    let mut hwcap2 = 0;
-    let mut execfn = null_mut();
-    let mut sysinfo_ehdr = null_mut();
-    #[cfg(feature = "runtime")]
-    let mut secure = 0;
-    #[cfg(feature = "runtime")]
-    let mut phdr = null_mut();
-    #[cfg(feature = "runtime")]
-    let mut phnum = 0;
-    #[cfg(feature = "runtime")]
-    let mut phent = 0;
-    #[cfg(feature = "runtime")]
-    let mut entry = 0;
-    #[cfg(feature = "runtime")]
-    let mut uid = None;
-    #[cfg(feature = "runtime")]
-    let mut euid = None;
-    #[cfg(feature = "runtime")]
-    let mut gid = None;
-    #[cfg(feature = "runtime")]
-    let mut egid = None;
-    #[cfg(feature = "runtime")]
-    let mut random = null_mut();
-
-    for Elf_auxv_t { a_type, a_val } in aux_iter {
-        match a_type as _ {
-            AT_PAGESZ => pagesz = a_val as usize,
-            AT_CLKTCK => clktck = a_val as usize,
-            AT_HWCAP => hwcap = a_val as usize,
-            AT_HWCAP2 => hwcap2 = a_val as usize,
-            AT_EXECFN => execfn = check_raw_pointer::<c::c_char>(a_val as *mut _)?.as_ptr(),
-            AT_SYSINFO_EHDR => sysinfo_ehdr = check_elf_base(a_val as *mut _)?.as_ptr(),
-
-            AT_BASE => {
-                // The `AT_BASE` value can be NULL in a static executable that
-                // doesn't use a dynamic linker. If so, ignore it.
-                if !a_val.is_null() {
-                    let _ = check_elf_base(a_val.cast())?;
-                }
-            }
-
-            #[cfg(feature = "runtime")]
-            AT_SECURE => secure = (a_val as usize != 0) as u8 + 1,
-            #[cfg(feature = "runtime")]
-            AT_UID => uid = Some(a_val),
-            #[cfg(feature = "runtime")]
-            AT_EUID => euid = Some(a_val),
-            #[cfg(feature = "runtime")]
-            AT_GID => gid = Some(a_val),
-            #[cfg(feature = "runtime")]
-            AT_EGID => egid = Some(a_val),
-            #[cfg(feature = "runtime")]
-            AT_PHDR => phdr = check_raw_pointer::<Elf_Phdr>(a_val as *mut _)?.as_ptr(),
-            #[cfg(feature = "runtime")]
-            AT_PHNUM => phnum = a_val as usize,
-            #[cfg(feature = "runtime")]
-            AT_PHENT => phent = a_val as usize,
-            #[cfg(feature = "runtime")]
-            AT_ENTRY => entry = a_val as usize,
-            #[cfg(feature = "runtime")]
-            AT_RANDOM => random = check_raw_pointer::<[u8; 16]>(a_val as *mut _)?.as_ptr(),
-
-            AT_NULL => break,
-            _ => (),
-        }
-    }
-
-    #[cfg(feature = "runtime")]
-    assert_eq!(phent, size_of::<Elf_Phdr>());
-
-    // If we're running set-uid or set-gid, enable “secure execution” mode,
-    // which doesn't do much, but users may be depending on the things that
-    // it does do.
-    #[cfg(feature = "runtime")]
-    if uid != euid || gid != egid {
-        secure = 2;
-    }
-
-    // The base and sysinfo_ehdr (if present) matches our platform. Accept the
-    // aux values.
-    PAGE_SIZE.store(pagesz, Relaxed);
-    CLOCK_TICKS_PER_SECOND.store(clktck, Relaxed);
-    HWCAP.store(hwcap, Relaxed);
-    HWCAP2.store(hwcap2, Relaxed);
-    EXECFN.store(execfn, Relaxed);
-    SYSINFO_EHDR.store(sysinfo_ehdr, Relaxed);
-    #[cfg(feature = "runtime")]
-    SECURE.store(secure, Relaxed);
-    #[cfg(feature = "runtime")]
-    PHDR.store(phdr, Relaxed);
-    #[cfg(feature = "runtime")]
-    PHNUM.store(phnum, Relaxed);
-    #[cfg(feature = "runtime")]
-    ENTRY.store(entry, Relaxed);
-    #[cfg(feature = "runtime")]
-    RANDOM.store(random, Relaxed);
-
-    Some(())
-}
-
-/// Check that `base` is a valid pointer to the kernel-provided vDSO.
-///
-/// `base` is some value we got from a `AT_SYSINFO_EHDR` aux record somewhere,
-/// which hopefully holds the value of the kernel-provided vDSO in memory. Do a
-/// series of checks to be as sure as we can that it's safe to use.
-#[cold]
-#[must_use]
-unsafe fn check_elf_base(base: *const Elf_Ehdr) -> Option<NonNull<Elf_Ehdr>> {
-    // If we're reading a 64-bit auxv on a 32-bit platform, we'll see a zero
-    // `a_val` because `AT_*` values are never greater than `u32::MAX`. Zero is
-    // used by libc's `getauxval` to indicate errors, so it should never be a
-    // valid value.
-    if base.is_null() {
-        return None;
-    }
-
-    let hdr = match check_raw_pointer::<Elf_Ehdr>(base as *mut _) {
-        Some(hdr) => hdr,
-        None => return None,
-    };
-
-    let hdr = hdr.as_ref();
-    if hdr.e_ident[..SELFMAG] != ELFMAG {
-        return None; // Wrong ELF magic
-    }
-    if !matches!(hdr.e_ident[EI_OSABI], ELFOSABI_SYSV | ELFOSABI_LINUX) {
-        return None; // Unrecognized ELF OS ABI
-    }
-    if hdr.e_ident[EI_ABIVERSION] != ELFABIVERSION {
-        return None; // Unrecognized ELF ABI version
-    }
-    if hdr.e_type != ET_DYN {
-        return None; // Wrong ELF type
-    }
-
-    // If ELF is extended, we'll need to adjust.
-    if hdr.e_ident[EI_VERSION] != EV_CURRENT
-        || hdr.e_ehsize as usize != size_of::<Elf_Ehdr>()
-        || hdr.e_phentsize as usize != size_of::<Elf_Phdr>()
-    {
-        return None;
-    }
-    // We don't currently support extra-large numbers of segments.
-    if hdr.e_phnum == PN_XNUM {
-        return None;
-    }
-
-    // If `e_phoff` is zero, it's more likely that we're looking at memory that
-    // has been zeroed than that the kernel has somehow aliased the `Ehdr` and
-    // the `Phdr`.
-    if hdr.e_phoff < size_of::<Elf_Ehdr>() {
-        return None;
-    }
-
-    // Verify that the `EI_CLASS`/`EI_DATA`/`e_machine` fields match the
-    // architecture we're running as. This helps catch cases where we're
-    // running under QEMU.
-    if hdr.e_ident[EI_CLASS] != ELFCLASS {
-        return None; // Wrong ELF class
-    }
-    if hdr.e_ident[EI_DATA] != ELFDATA {
-        return None; // Wrong ELF data
-    }
-    if hdr.e_machine != EM_CURRENT {
-        return None; // Wrong machine type
-    }
-
-    Some(NonNull::new_unchecked(as_ptr(hdr) as *mut _))
-}
-
-// Aux reading utilities
-
-// Read auxv records from an array in memory.
-struct AuxPointer(*const Elf_auxv_t);
-
-impl Iterator for AuxPointer {
-    type Item = Elf_auxv_t;
-
-    #[cold]
-    fn next(&mut self) -> Option<Self::Item> {
-        unsafe {
-            let value = read_unaligned(self.0);
-            self.0 = self.0.add(1);
-            Some(value)
-        }
-    }
-}
-
-// Read auxv records from a file.
-#[cfg(not(feature = "alloc"))]
-struct AuxFile(OwnedFd);
-
-#[cfg(not(feature = "alloc"))]
-impl Iterator for AuxFile {
-    type Item = Elf_auxv_t;
-
-    // This implementation does lots of `read`s and it isn't amazing, but
-    // hopefully we won't use it often.
-    #[cold]
-    fn next(&mut self) -> Option<Self::Item> {
-        let mut buf = [0_u8; size_of::<Self::Item>()];
-        let mut slice = &mut buf[..];
-        while !slice.is_empty() {
-            match crate::io::read(&self.0, slice) {
-                Ok(0) => panic!("unexpected end of auxv file"),
-                Ok(n) => slice = &mut slice[n..],
-                Err(crate::io::Errno::INTR) => continue,
-                Err(err) => panic!("{:?}", err),
-            }
-        }
-        Some(unsafe { read_unaligned(buf.as_ptr().cast()) })
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/param/init.rs b/vendor/rustix/src/backend/linux_raw/param/init.rs
deleted file mode 100644
index fe29e9c..0000000
--- a/vendor/rustix/src/backend/linux_raw/param/init.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-//! Linux auxv `init` function, for "use-explicitly-provided-auxv" mode.
-//!
-//! # Safety
-//!
-//! This uses raw pointers to locate and read the kernel-provided auxv array.
-#![allow(unsafe_code)]
-
-use crate::backend::c;
-#[cfg(feature = "param")]
-use crate::ffi::CStr;
-use core::ffi::c_void;
-use core::ptr::{null_mut, read, NonNull};
-#[cfg(feature = "runtime")]
-use core::sync::atomic::AtomicBool;
-use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
-use linux_raw_sys::elf::*;
-use linux_raw_sys::general::{
-    AT_CLKTCK, AT_EXECFN, AT_HWCAP, AT_HWCAP2, AT_NULL, AT_PAGESZ, AT_SYSINFO_EHDR,
-};
-#[cfg(feature = "runtime")]
-use linux_raw_sys::general::{AT_ENTRY, AT_PHDR, AT_PHENT, AT_PHNUM, AT_RANDOM, AT_SECURE};
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn page_size() -> usize {
-    unsafe { PAGE_SIZE.load(Ordering::Relaxed) }
-}
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn clock_ticks_per_second() -> u64 {
-    unsafe { CLOCK_TICKS_PER_SECOND.load(Ordering::Relaxed) as u64 }
-}
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn linux_hwcap() -> (usize, usize) {
-    unsafe {
-        (
-            HWCAP.load(Ordering::Relaxed),
-            HWCAP2.load(Ordering::Relaxed),
-        )
-    }
-}
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn linux_execfn() -> &'static CStr {
-    let execfn = unsafe { EXECFN.load(Ordering::Relaxed) };
-
-    // SAFETY: We initialize `EXECFN` to a valid `CStr` pointer, and we assume
-    // the `AT_EXECFN` value provided by the kernel points to a valid C string.
-    unsafe { CStr::from_ptr(execfn.cast()) }
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn linux_secure() -> bool {
-    unsafe { SECURE.load(Ordering::Relaxed) }
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn exe_phdrs() -> (*const c_void, usize, usize) {
-    unsafe {
-        (
-            PHDR.load(Ordering::Relaxed).cast(),
-            PHENT.load(Ordering::Relaxed),
-            PHNUM.load(Ordering::Relaxed),
-        )
-    }
-}
-
-/// `AT_SYSINFO_EHDR` isn't present on all platforms in all configurations, so
-/// if we don't see it, this function returns a null pointer.
-#[inline]
-pub(in super::super) fn sysinfo_ehdr() -> *const Elf_Ehdr {
-    unsafe { SYSINFO_EHDR.load(Ordering::Relaxed) }
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn entry() -> usize {
-    unsafe { ENTRY.load(Ordering::Relaxed) }
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn random() -> *const [u8; 16] {
-    unsafe { RANDOM.load(Ordering::Relaxed) }
-}
-
-static mut PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
-static mut CLOCK_TICKS_PER_SECOND: AtomicUsize = AtomicUsize::new(0);
-static mut HWCAP: AtomicUsize = AtomicUsize::new(0);
-static mut HWCAP2: AtomicUsize = AtomicUsize::new(0);
-static mut SYSINFO_EHDR: AtomicPtr<Elf_Ehdr> = AtomicPtr::new(null_mut());
-// Initialize `EXECFN` to a valid `CStr` pointer so that we don't need to check
-// for null on every `execfn` call.
-static mut EXECFN: AtomicPtr<c::c_char> = AtomicPtr::new(b"\0".as_ptr() as _);
-#[cfg(feature = "runtime")]
-static mut SECURE: AtomicBool = AtomicBool::new(false);
-// Use `dangling` so that we can always treat it like an empty slice.
-#[cfg(feature = "runtime")]
-static mut PHDR: AtomicPtr<Elf_Phdr> = AtomicPtr::new(NonNull::dangling().as_ptr());
-#[cfg(feature = "runtime")]
-static mut PHENT: AtomicUsize = AtomicUsize::new(0);
-#[cfg(feature = "runtime")]
-static mut PHNUM: AtomicUsize = AtomicUsize::new(0);
-#[cfg(feature = "runtime")]
-static mut ENTRY: AtomicUsize = AtomicUsize::new(0);
-#[cfg(feature = "runtime")]
-static mut RANDOM: AtomicPtr<[u8; 16]> = AtomicPtr::new(NonNull::dangling().as_ptr());
-
-/// When "use-explicitly-provided-auxv" is enabled, we export a function to be
-/// called during initialization, and passed a pointer to the original
-/// environment variable block set up by the OS.
-pub(crate) unsafe fn init(envp: *mut *mut u8) {
-    init_from_envp(envp);
-}
-
-/// # Safety
-///
-/// This must be passed a pointer to the environment variable buffer
-/// provided by the kernel, which is followed in memory by the auxv array.
-unsafe fn init_from_envp(mut envp: *mut *mut u8) {
-    while !(*envp).is_null() {
-        envp = envp.add(1);
-    }
-    init_from_auxp(envp.add(1).cast())
-}
-
-/// Process auxv entries from the auxv array pointed to by `auxp`.
-///
-/// # Safety
-///
-/// This must be passed a pointer to an auxv array.
-///
-/// The buffer contains `Elf_aux_t` elements, though it need not be aligned;
-/// function uses `read_unaligned` to read from it.
-unsafe fn init_from_auxp(mut auxp: *const Elf_auxv_t) {
-    loop {
-        let Elf_auxv_t { a_type, a_val } = read(auxp);
-
-        match a_type as _ {
-            AT_PAGESZ => PAGE_SIZE.store(a_val as usize, Ordering::Relaxed),
-            AT_CLKTCK => CLOCK_TICKS_PER_SECOND.store(a_val as usize, Ordering::Relaxed),
-            AT_HWCAP => HWCAP.store(a_val as usize, Ordering::Relaxed),
-            AT_HWCAP2 => HWCAP2.store(a_val as usize, Ordering::Relaxed),
-            AT_EXECFN => EXECFN.store(a_val.cast::<c::c_char>(), Ordering::Relaxed),
-            AT_SYSINFO_EHDR => SYSINFO_EHDR.store(a_val.cast::<Elf_Ehdr>(), Ordering::Relaxed),
-
-            #[cfg(feature = "runtime")]
-            AT_SECURE => SECURE.store(a_val as usize != 0, Ordering::Relaxed),
-            #[cfg(feature = "runtime")]
-            AT_PHDR => PHDR.store(a_val.cast::<Elf_Phdr>(), Ordering::Relaxed),
-            #[cfg(feature = "runtime")]
-            AT_PHNUM => PHNUM.store(a_val as usize, Ordering::Relaxed),
-            #[cfg(feature = "runtime")]
-            AT_PHENT => PHENT.store(a_val as usize, Ordering::Relaxed),
-            #[cfg(feature = "runtime")]
-            AT_ENTRY => ENTRY.store(a_val as usize, Ordering::Relaxed),
-            #[cfg(feature = "runtime")]
-            AT_RANDOM => RANDOM.store(a_val.cast::<[u8; 16]>(), Ordering::Relaxed),
-
-            AT_NULL => break,
-            _ => (),
-        }
-        auxp = auxp.add(1);
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/param/libc_auxv.rs b/vendor/rustix/src/backend/linux_raw/param/libc_auxv.rs
deleted file mode 100644
index cfdd7a5..0000000
--- a/vendor/rustix/src/backend/linux_raw/param/libc_auxv.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-//! Linux auxv support, using libc.
-//!
-//! # Safety
-//!
-//! This uses raw pointers to locate and read the kernel-provided auxv array.
-#![allow(unsafe_code)]
-
-use crate::backend::c;
-#[cfg(feature = "param")]
-use crate::ffi::CStr;
-#[cfg(not(feature = "runtime"))]
-use core::ptr::null;
-use linux_raw_sys::elf::*;
-
-// `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;
-}
-
-#[cfg(feature = "runtime")]
-const AT_PHDR: c::c_ulong = 3;
-#[cfg(feature = "runtime")]
-const AT_PHENT: c::c_ulong = 4;
-#[cfg(feature = "runtime")]
-const AT_PHNUM: c::c_ulong = 5;
-#[cfg(feature = "runtime")]
-const AT_ENTRY: c::c_ulong = 9;
-const AT_HWCAP: c::c_ulong = 16;
-#[cfg(feature = "runtime")]
-const AT_RANDOM: c::c_ulong = 25;
-const AT_HWCAP2: c::c_ulong = 26;
-const AT_SECURE: c::c_ulong = 23;
-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 = "linux")]
-const _SC_PAGESIZE: c::c_int = 30;
-#[cfg(target_os = "android")]
-const _SC_CLK_TCK: c::c_int = 6;
-#[cfg(target_os = "linux")]
-const _SC_CLK_TCK: c::c_int = 2;
-
-#[test]
-fn test_abi() {
-    const_assert_eq!(self::_SC_PAGESIZE, ::libc::_SC_PAGESIZE);
-    const_assert_eq!(self::_SC_CLK_TCK, ::libc::_SC_CLK_TCK);
-    const_assert_eq!(self::AT_HWCAP, ::libc::AT_HWCAP);
-    const_assert_eq!(self::AT_HWCAP2, ::libc::AT_HWCAP2);
-    const_assert_eq!(self::AT_EXECFN, ::libc::AT_EXECFN);
-    const_assert_eq!(self::AT_SECURE, ::libc::AT_SECURE);
-    const_assert_eq!(self::AT_SYSINFO_EHDR, ::libc::AT_SYSINFO_EHDR);
-    #[cfg(feature = "runtime")]
-    const_assert_eq!(self::AT_PHDR, ::libc::AT_PHDR);
-    #[cfg(feature = "runtime")]
-    const_assert_eq!(self::AT_PHNUM, ::libc::AT_PHNUM);
-    #[cfg(feature = "runtime")]
-    const_assert_eq!(self::AT_ENTRY, ::libc::AT_ENTRY);
-    #[cfg(feature = "runtime")]
-    const_assert_eq!(self::AT_RANDOM, ::libc::AT_RANDOM);
-}
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn page_size() -> usize {
-    unsafe { sysconf(_SC_PAGESIZE) as usize }
-}
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn clock_ticks_per_second() -> u64 {
-    unsafe { sysconf(_SC_CLK_TCK) as u64 }
-}
-
-#[cfg(feature = "param")]
-#[inline]
-pub(crate) fn linux_hwcap() -> (usize, 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)
-        }
-    }
-
-    #[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 {
-    #[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 linux_secure() -> bool {
-    unsafe { getauxval(AT_SECURE) as usize != 0 }
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn exe_phdrs() -> (*const c::c_void, usize, usize) {
-    unsafe {
-        let phdr = getauxval(AT_PHDR) as *const c::c_void;
-        let phent = getauxval(AT_PHENT) as usize;
-        let phnum = getauxval(AT_PHNUM) as usize;
-        (phdr, phent, phnum)
-    }
-}
-
-/// `AT_SYSINFO_EHDR` isn't present on all platforms in all configurations, so
-/// if we don't see it, this function returns a null pointer.
-#[inline]
-pub(in super::super) fn sysinfo_ehdr() -> *const Elf_Ehdr {
-    #[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
-    }
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn entry() -> usize {
-    unsafe { getauxval(AT_ENTRY) as usize }
-}
-
-#[cfg(feature = "runtime")]
-#[inline]
-pub(crate) fn random() -> *const [u8; 16] {
-    unsafe { getauxval(AT_RANDOM) as *const [u8; 16] }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/param/mod.rs b/vendor/rustix/src/backend/linux_raw/param/mod.rs
deleted file mode 100644
index 365f016..0000000
--- a/vendor/rustix/src/backend/linux_raw/param/mod.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// With "use-explicitly-provided-auxv" enabled, we expect to be initialized
-// with an explicit `rustix::param::init` call.
-//
-// With "use-libc-auxv" enabled, use libc's `getauxval`.
-//
-// Otherwise, we read aux values from /proc/self/auxv.
-#[cfg_attr(feature = "use-explicitly-provided-auxv", path = "init.rs")]
-#[cfg_attr(
-    all(
-        not(feature = "use-explicitly-provided-auxv"),
-        feature = "use-libc-auxv"
-    ),
-    path = "libc_auxv.rs"
-)]
-pub(crate) mod auxv;
diff --git a/vendor/rustix/src/backend/linux_raw/pid/mod.rs b/vendor/rustix/src/backend/linux_raw/pid/mod.rs
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/linux_raw/pid/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-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
deleted file mode 100644
index 9665ab3..0000000
--- a/vendor/rustix/src/backend/linux_raw/pid/syscalls.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//! linux_raw syscalls for PIDs
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, 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
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/linux_raw/pipe/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-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
deleted file mode 100644
index ec3e459..0000000
--- a/vendor/rustix/src/backend/linux_raw/pipe/syscalls.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-//! linux_raw syscalls supporting `rustix::pipe`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, 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 = "mips32r6",
-        target_arch = "mips64",
-        target_arch = "mips64r6",
-        target_arch = "riscv64",
-    ))]
-    {
-        pipe_with(PipeFlags::empty())
-    }
-    #[cfg(not(any(
-        target_arch = "aarch64",
-        target_arch = "mips",
-        target_arch = "mips32r6",
-        target_arch = "mips64",
-        target_arch = "mips64r6",
-        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
deleted file mode 100644
index 2d1ed9a..0000000
--- a/vendor/rustix/src/backend/linux_raw/pipe/types.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-use core::marker::PhantomData;
-
-bitflags! {
-    /// `O_*` constants for use with [`pipe_with`].
-    ///
-    /// [`pipe_with`]: crate::pipe::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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-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;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// A buffer type for use 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.
-///
-/// [`vmsplice`]: crate::pipe::vmsplice
-#[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
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/linux_raw/prctl/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-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
deleted file mode 100644
index 1410d51..0000000
--- a/vendor/rustix/src/backend/linux_raw/prctl/syscalls.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! linux_raw syscalls supporting modules that use `prctl`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, 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
deleted file mode 100644
index 35146cf..0000000
--- a/vendor/rustix/src/backend/linux_raw/process/cpu_set.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//! Rust implementation of the `CPU_*` macro API.
-
-#![allow(non_snake_case)]
-
-use super::types::RawCpuSet;
-use core::mem::size_of_val;
-
-#[inline]
-pub(crate) fn CPU_SET(cpu: usize, cpuset: &mut RawCpuSet) {
-    let size_in_bits = 8 * size_of_val(&cpuset.bits[0]); // 32, 64 etc
-    let (idx, offset) = (cpu / size_in_bits, cpu % size_in_bits);
-    cpuset.bits[idx] |= 1 << offset
-}
-
-#[inline]
-pub(crate) fn CPU_ZERO(cpuset: &mut RawCpuSet) {
-    cpuset.bits.fill(0)
-}
-
-#[inline]
-pub(crate) fn CPU_CLR(cpu: usize, cpuset: &mut RawCpuSet) {
-    let size_in_bits = 8 * size_of_val(&cpuset.bits[0]); // 32, 64 etc
-    let (idx, offset) = (cpu / size_in_bits, cpu % size_in_bits);
-    cpuset.bits[idx] &= !(1 << offset)
-}
-
-#[inline]
-pub(crate) fn CPU_ISSET(cpu: usize, cpuset: &RawCpuSet) -> bool {
-    let size_in_bits = 8 * size_of_val(&cpuset.bits[0]);
-    let (idx, offset) = (cpu / size_in_bits, cpu % size_in_bits);
-    (cpuset.bits[idx] & (1 << offset)) != 0
-}
-
-#[inline]
-pub(crate) fn CPU_COUNT_S(size_in_bytes: usize, cpuset: &RawCpuSet) -> u32 {
-    let size_of_mask = size_of_val(&cpuset.bits[0]);
-    let idx = size_in_bytes / size_of_mask;
-    cpuset.bits[..idx]
-        .iter()
-        .fold(0, |acc, i| acc + i.count_ones())
-}
-
-#[inline]
-pub(crate) fn CPU_COUNT(cpuset: &RawCpuSet) -> u32 {
-    CPU_COUNT_S(core::mem::size_of::<RawCpuSet>(), cpuset)
-}
diff --git a/vendor/rustix/src/backend/linux_raw/process/mod.rs b/vendor/rustix/src/backend/linux_raw/process/mod.rs
deleted file mode 100644
index 9b2c25f..0000000
--- a/vendor/rustix/src/backend/linux_raw/process/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub(crate) mod cpu_set;
-pub(crate) mod syscalls;
-pub(crate) mod types;
-pub(crate) mod wait;
diff --git a/vendor/rustix/src/backend/linux_raw/process/syscalls.rs b/vendor/rustix/src/backend/linux_raw/process/syscalls.rs
deleted file mode 100644
index bc00af9..0000000
--- a/vendor/rustix/src/backend/linux_raw/process/syscalls.rs
+++ /dev/null
@@ -1,603 +0,0 @@
-//! linux_raw syscalls supporting `rustix::process`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use super::types::RawCpuSet;
-use crate::backend::c;
-#[cfg(all(feature = "alloc", 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, zero,
-};
-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, MembarrierCommand, MembarrierQuery, Pid, PidfdFlags, PidfdGetfdFlags, Resource, Rlimit,
-    Uid, WaitId, WaitOptions, WaitStatus, WaitidOptions, WaitidStatus,
-};
-use crate::signal::Signal;
-use crate::utils::as_mut_ptr;
-use core::mem::MaybeUninit;
-use core::ptr::{null, null_mut};
-use linux_raw_sys::general::{
-    membarrier_cmd, membarrier_cmd_flag, rlimit64, PRIO_PGRP, PRIO_PROCESS, PRIO_USER,
-    RLIM64_INFINITY,
-};
-#[cfg(feature = "fs")]
-use {crate::backend::conv::ret_c_uint_infallible, crate::fs::Mode};
-#[cfg(feature = "alloc")]
-use {crate::backend::conv::slice_just_addr_mut, crate::process::Gid};
-
-// `sched_getcpu` has special optimizations via the vDSO on some architectures.
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "riscv64",
-    target_arch = "powerpc64"
-))]
-pub(crate) use crate::backend::vdso_wrappers::sched_getcpu;
-
-// `sched_getcpu` on platforms without a vDSO entry for it.
-#[cfg(not(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "riscv64",
-    target_arch = "powerpc64"
-)))]
-#[inline]
-pub(crate) fn sched_getcpu() -> usize {
-    let mut cpu = MaybeUninit::<u32>::uninit();
-    unsafe {
-        let r = ret(syscall!(__NR_getcpu, &mut cpu, zero(), zero()));
-        debug_assert!(r.is_ok());
-        cpu.assume_init() as usize
-    }
-}
-
-#[cfg(feature = "fs")]
-#[inline]
-pub(crate) fn chdir(filename: &CStr) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_chdir, filename)) }
-}
-
-#[inline]
-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(all(feature = "alloc", feature = "fs"))]
-#[inline]
-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)) }
-}
-
-#[inline]
-pub(crate) fn membarrier_query() -> MembarrierQuery {
-    unsafe {
-        match ret_c_uint(syscall!(
-            __NR_membarrier,
-            c_int(membarrier_cmd::MEMBARRIER_CMD_QUERY as _),
-            c_uint(0)
-        )) {
-            Ok(query) => MembarrierQuery::from_bits_retain(query),
-            Err(_) => MembarrierQuery::empty(),
-        }
-    }
-}
-
-#[inline]
-pub(crate) fn membarrier(cmd: MembarrierCommand) -> io::Result<()> {
-    unsafe { ret(syscall!(__NR_membarrier, cmd, c_uint(0))) }
-}
-
-#[inline]
-pub(crate) fn membarrier_cpu(cmd: MembarrierCommand, cpu: Cpuid) -> io::Result<()> {
-    unsafe {
-        ret(syscall!(
-            __NR_membarrier,
-            cmd,
-            c_uint(membarrier_cmd_flag::MEMBARRIER_CMD_FLAG_CPU as _),
-            cpu
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn getppid() -> Option<Pid> {
-    unsafe {
-        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 = ret_c_int(syscall_readonly!(__NR_getpgid, c_int(Pid::as_raw(pid))))?;
-        debug_assert!(pgid > 0);
-        Ok(Pid::from_raw_unchecked(pgid))
-    }
-}
-
-#[inline]
-pub(crate) fn setpgid(pid: Option<Pid>, pgid: Option<Pid>) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_setpgid,
-            c_int(Pid::as_raw(pid)),
-            c_int(Pid::as_raw(pgid))
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn getpgrp() -> Pid {
-    // Use the `getpgrp` syscall if available.
-    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
-    unsafe {
-        let pgid = ret_c_int_infallible(syscall_readonly!(__NR_getpgrp));
-        debug_assert!(pgid > 0);
-        Pid::from_raw_unchecked(pgid)
-    }
-
-    // Otherwise use `getpgrp` and pass it zero.
-    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
-    unsafe {
-        let pgid = ret_c_int_infallible(syscall_readonly!(__NR_getpgid, c_uint(0)));
-        debug_assert!(pgid > 0);
-        Pid::from_raw_unchecked(pgid)
-    }
-}
-
-#[inline]
-pub(crate) fn sched_getaffinity(pid: Option<Pid>, cpuset: &mut RawCpuSet) -> io::Result<()> {
-    unsafe {
-        // The raw Linux syscall returns the size (in bytes) of the `cpumask_t`
-        // data type that is used internally by the kernel to represent the CPU
-        // set bit mask.
-        let size = ret_usize(syscall!(
-            __NR_sched_getaffinity,
-            c_int(Pid::as_raw(pid)),
-            size_of::<RawCpuSet, _>(),
-            by_mut(&mut cpuset.bits)
-        ))?;
-        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);
-        Ok(())
-    }
-}
-
-#[inline]
-pub(crate) fn sched_setaffinity(pid: Option<Pid>, cpuset: &RawCpuSet) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_sched_setaffinity,
-            c_int(Pid::as_raw(pid)),
-            size_of::<RawCpuSet, _>(),
-            slice_just_addr(&cpuset.bits)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn sched_yield() {
-    unsafe {
-        // See the documentation for [`crate::process::sched_yield`] for why
-        // errors are ignored.
-        syscall_readonly!(__NR_sched_yield).decode_void();
-    }
-}
-
-#[cfg(feature = "fs")]
-#[inline]
-pub(crate) fn umask(mode: Mode) -> 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 {
-        inc + getpriority_process(None)?
-    } else {
-        inc
-    })
-    .clamp(-20, 19);
-    setpriority_process(None, priority)?;
-    Ok(priority)
-}
-
-#[inline]
-pub(crate) fn getpriority_user(uid: Uid) -> io::Result<i32> {
-    unsafe {
-        Ok(20
-            - ret_c_int(syscall_readonly!(
-                __NR_getpriority,
-                c_uint(PRIO_USER),
-                c_uint(uid.as_raw())
-            ))?)
-    }
-}
-
-#[inline]
-pub(crate) fn getpriority_pgrp(pgid: Option<Pid>) -> io::Result<i32> {
-    unsafe {
-        Ok(20
-            - ret_c_int(syscall_readonly!(
-                __NR_getpriority,
-                c_uint(PRIO_PGRP),
-                c_int(Pid::as_raw(pgid))
-            ))?)
-    }
-}
-
-#[inline]
-pub(crate) fn getpriority_process(pid: Option<Pid>) -> io::Result<i32> {
-    unsafe {
-        Ok(20
-            - ret_c_int(syscall_readonly!(
-                __NR_getpriority,
-                c_uint(PRIO_PROCESS),
-                c_int(Pid::as_raw(pid))
-            ))?)
-    }
-}
-
-#[inline]
-pub(crate) fn setpriority_user(uid: Uid, priority: i32) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_setpriority,
-            c_uint(PRIO_USER),
-            c_uint(uid.as_raw()),
-            c_int(priority)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn setpriority_pgrp(pgid: Option<Pid>, priority: i32) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_setpriority,
-            c_uint(PRIO_PGRP),
-            c_int(Pid::as_raw(pgid)),
-            c_int(priority)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn setpriority_process(pid: Option<Pid>, priority: i32) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_setpriority,
-            c_uint(PRIO_PROCESS),
-            c_int(Pid::as_raw(pid)),
-            c_int(priority)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn getrlimit(limit: Resource) -> Rlimit {
-    let mut result = MaybeUninit::<rlimit64>::uninit();
-    unsafe {
-        ret_infallible(syscall!(
-            __NR_prlimit64,
-            c_uint(0),
-            limit,
-            null::<c::c_void>(),
-            &mut result
-        ));
-        rlimit_from_linux(result.assume_init())
-    }
-}
-
-#[inline]
-pub(crate) fn setrlimit(limit: Resource, new: Rlimit) -> io::Result<()> {
-    unsafe {
-        let lim = rlimit_to_linux(new.clone());
-        match ret(syscall_readonly!(
-            __NR_prlimit64,
-            c_uint(0),
-            limit,
-            by_ref(&lim),
-            null_mut::<c::c_void>()
-        )) {
-            Ok(()) => Ok(()),
-            Err(err) => Err(err),
-        }
-    }
-}
-
-#[inline]
-pub(crate) fn prlimit(pid: Option<Pid>, limit: Resource, new: Rlimit) -> io::Result<Rlimit> {
-    let lim = rlimit_to_linux(new);
-    let mut result = MaybeUninit::<rlimit64>::uninit();
-    unsafe {
-        match ret(syscall!(
-            __NR_prlimit64,
-            c_int(Pid::as_raw(pid)),
-            limit,
-            by_ref(&lim),
-            &mut result
-        )) {
-            Ok(()) => Ok(rlimit_from_linux(result.assume_init())),
-            Err(err) => Err(err),
-        }
-    }
-}
-
-/// Convert a Rust [`Rlimit`] to a C `rlimit64`.
-#[inline]
-fn rlimit_from_linux(lim: rlimit64) -> Rlimit {
-    let current = if lim.rlim_cur == RLIM64_INFINITY as _ {
-        None
-    } else {
-        Some(lim.rlim_cur)
-    };
-    let maximum = if lim.rlim_max == RLIM64_INFINITY as _ {
-        None
-    } else {
-        Some(lim.rlim_max)
-    };
-    Rlimit { current, maximum }
-}
-
-/// Convert a C `rlimit64` to a Rust `Rlimit`.
-#[inline]
-fn rlimit_to_linux(lim: Rlimit) -> rlimit64 {
-    let rlim_cur = match lim.current {
-        Some(r) => r,
-        None => RLIM64_INFINITY as _,
-    };
-    let rlim_max = match lim.maximum {
-        Some(r) => r,
-        None => RLIM64_INFINITY as _,
-    };
-    rlimit64 { rlim_cur, rlim_max }
-}
-
-#[inline]
-pub(crate) fn wait(waitopts: WaitOptions) -> io::Result<Option<(Pid, WaitStatus)>> {
-    _waitpid(!0, waitopts)
-}
-
-#[inline]
-pub(crate) fn waitpid(
-    pid: Option<Pid>,
-    waitopts: WaitOptions,
-) -> io::Result<Option<(Pid, WaitStatus)>> {
-    _waitpid(Pid::as_raw(pid), waitopts)
-}
-
-#[inline]
-pub(crate) fn waitpgid(pgid: Pid, waitopts: WaitOptions) -> io::Result<Option<(Pid, WaitStatus)>> {
-    _waitpid(-pgid.as_raw_nonzero().get(), waitopts)
-}
-
-#[inline]
-pub(crate) fn _waitpid(
-    pid: RawPid,
-    waitopts: WaitOptions,
-) -> io::Result<Option<(Pid, WaitStatus)>> {
-    unsafe {
-        let mut status = MaybeUninit::<u32>::uninit();
-        let pid = ret_c_int(syscall!(
-            __NR_wait4,
-            c_int(pid as _),
-            &mut status,
-            c_int(waitopts.bits() as _),
-            zero()
-        ))?;
-        Ok(Pid::from_raw(pid).map(|pid| (pid, WaitStatus::new(status.assume_init()))))
-    }
-}
-
-#[inline]
-pub(crate) fn waitid(id: WaitId<'_>, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // Get the id to wait on.
-    match id {
-        WaitId::All => _waitid_all(options),
-        WaitId::Pid(pid) => _waitid_pid(pid, options),
-        WaitId::Pgid(pid) => _waitid_pgid(pid, options),
-        WaitId::PidFd(fd) => _waitid_pidfd(fd, options),
-    }
-}
-
-#[inline]
-fn _waitid_all(options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // `waitid` can return successfully without initializing the struct (no
-    // children found when using `WNOHANG`)
-    let mut status = MaybeUninit::<c::siginfo_t>::zeroed();
-    unsafe {
-        ret(syscall!(
-            __NR_waitid,
-            c_uint(c::P_ALL),
-            c_uint(0),
-            by_mut(&mut status),
-            c_int(options.bits() as _),
-            zero()
-        ))?
-    };
-
-    Ok(unsafe { cvt_waitid_status(status) })
-}
-
-#[inline]
-fn _waitid_pid(pid: Pid, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // `waitid` can return successfully without initializing the struct (no
-    // children found when using `WNOHANG`)
-    let mut status = MaybeUninit::<c::siginfo_t>::zeroed();
-    unsafe {
-        ret(syscall!(
-            __NR_waitid,
-            c_uint(c::P_PID),
-            c_int(Pid::as_raw(Some(pid))),
-            by_mut(&mut status),
-            c_int(options.bits() as _),
-            zero()
-        ))?
-    };
-
-    Ok(unsafe { cvt_waitid_status(status) })
-}
-
-#[inline]
-fn _waitid_pgid(pgid: Option<Pid>, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // `waitid` can return successfully without initializing the struct (no
-    // children found when using `WNOHANG`)
-    let mut status = MaybeUninit::<c::siginfo_t>::zeroed();
-    unsafe {
-        ret(syscall!(
-            __NR_waitid,
-            c_uint(c::P_PGID),
-            c_int(Pid::as_raw(pgid)),
-            by_mut(&mut status),
-            c_int(options.bits() as _),
-            zero()
-        ))?
-    };
-
-    Ok(unsafe { cvt_waitid_status(status) })
-}
-
-#[inline]
-fn _waitid_pidfd(fd: BorrowedFd<'_>, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> {
-    // `waitid` can return successfully without initializing the struct (no
-    // children found when using `WNOHANG`)
-    let mut status = MaybeUninit::<c::siginfo_t>::zeroed();
-    unsafe {
-        ret(syscall!(
-            __NR_waitid,
-            c_uint(c::P_PIDFD),
-            c_uint(fd.as_raw_fd() as _),
-            by_mut(&mut status),
-            c_int(options.bits() as _),
-            zero()
-        ))?
-    };
-
-    Ok(unsafe { cvt_waitid_status(status) })
-}
-
-/// Convert a `siginfo_t` to a `WaitidStatus`.
-///
-/// # Safety
-///
-/// The caller must ensure that `status` is initialized and that `waitid`
-/// returned successfully.
-#[inline]
-#[rustfmt::skip]
-unsafe fn cvt_waitid_status(status: MaybeUninit<c::siginfo_t>) -> Option<WaitidStatus> {
-    let status = status.assume_init();
-    if status.__bindgen_anon_1.__bindgen_anon_1._sifields._sigchld._pid == 0 {
-        None
-    } else {
-        Some(WaitidStatus(status))
-    }
-}
-
-#[inline]
-pub(crate) fn getsid(pid: Option<Pid>) -> io::Result<Pid> {
-    unsafe {
-        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_c_int(syscall_readonly!(__NR_setsid))?;
-        Ok(Pid::from_raw_unchecked(pid))
-    }
-}
-
-#[inline]
-pub(crate) fn kill_process(pid: Pid, sig: Signal) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_kill, pid, sig)) }
-}
-
-#[inline]
-pub(crate) fn kill_process_group(pid: Pid, sig: Signal) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_kill, negative_pid(pid), sig)) }
-}
-
-#[inline]
-pub(crate) fn kill_current_process_group(sig: Signal) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_kill, pass_usize(0), sig)) }
-}
-
-#[inline]
-pub(crate) fn test_kill_process(pid: Pid) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_kill, pid, pass_usize(0))) }
-}
-
-#[inline]
-pub(crate) fn test_kill_process_group(pid: Pid) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_kill,
-            negative_pid(pid),
-            pass_usize(0)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn test_kill_current_process_group() -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_kill, pass_usize(0), pass_usize(0))) }
-}
-
-#[inline]
-pub(crate) fn pidfd_getfd(
-    pidfd: BorrowedFd<'_>,
-    targetfd: RawFd,
-    flags: PidfdGetfdFlags,
-) -> io::Result<OwnedFd> {
-    unsafe {
-        ret_owned_fd(syscall_readonly!(
-            __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)) }
-}
-
-#[cfg(feature = "alloc")]
-#[inline]
-pub(crate) fn getgroups(buf: &mut [Gid]) -> io::Result<usize> {
-    let len = buf.len().try_into().map_err(|_| io::Errno::NOMEM)?;
-
-    unsafe {
-        ret_usize(syscall!(
-            __NR_getgroups,
-            c_int(len),
-            slice_just_addr_mut(buf)
-        ))
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/process/types.rs b/vendor/rustix/src/backend/linux_raw/process/types.rs
deleted file mode 100644
index 841668a..0000000
--- a/vendor/rustix/src/backend/linux_raw/process/types.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use linux_raw_sys::general::membarrier_cmd;
-
-/// A command for use with [`membarrier`] and [`membarrier_cpu`].
-///
-/// For `MEMBARRIER_CMD_QUERY`, see [`membarrier_query`].
-///
-/// [`membarrier`]: crate::process::membarrier
-/// [`membarrier_cpu`]: crate::process::membarrier_cpu
-/// [`membarrier_query`]: crate::process::membarrier_query
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
-#[repr(u32)]
-pub enum MembarrierCommand {
-    /// `MEMBARRIER_CMD_GLOBAL`
-    #[doc(alias = "Shared")]
-    #[doc(alias = "MEMBARRIER_CMD_SHARED")]
-    Global = membarrier_cmd::MEMBARRIER_CMD_GLOBAL as _,
-    /// `MEMBARRIER_CMD_GLOBAL_EXPEDITED`
-    GlobalExpedited = membarrier_cmd::MEMBARRIER_CMD_GLOBAL_EXPEDITED as _,
-    /// `MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED`
-    RegisterGlobalExpedited = membarrier_cmd::MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED as _,
-    /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED`
-    PrivateExpedited = membarrier_cmd::MEMBARRIER_CMD_PRIVATE_EXPEDITED as _,
-    /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED`
-    RegisterPrivateExpedited = membarrier_cmd::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED as _,
-    /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE`
-    PrivateExpeditedSyncCore = membarrier_cmd::MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE as _,
-    /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE`
-    RegisterPrivateExpeditedSyncCore =
-        membarrier_cmd::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE as _,
-    /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)
-    PrivateExpeditedRseq = membarrier_cmd::MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ as _,
-    /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)
-    RegisterPrivateExpeditedRseq =
-        membarrier_cmd::MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ as _,
-}
-
-/// A resource value for use with [`getrlimit`], [`setrlimit`], and
-/// [`prlimit`].
-///
-/// [`getrlimit`]: crate::process::getrlimit
-/// [`setrlimit`]: crate::process::setrlimit
-/// [`prlimit`]: crate::process::prlimit
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[repr(u32)]
-pub enum Resource {
-    /// `RLIMIT_CPU`
-    Cpu = linux_raw_sys::general::RLIMIT_CPU,
-    /// `RLIMIT_FSIZE`
-    Fsize = linux_raw_sys::general::RLIMIT_FSIZE,
-    /// `RLIMIT_DATA`
-    Data = linux_raw_sys::general::RLIMIT_DATA,
-    /// `RLIMIT_STACK`
-    Stack = linux_raw_sys::general::RLIMIT_STACK,
-    /// `RLIMIT_CORE`
-    Core = linux_raw_sys::general::RLIMIT_CORE,
-    /// `RLIMIT_RSS`
-    Rss = linux_raw_sys::general::RLIMIT_RSS,
-    /// `RLIMIT_NPROC`
-    Nproc = linux_raw_sys::general::RLIMIT_NPROC,
-    /// `RLIMIT_NOFILE`
-    Nofile = linux_raw_sys::general::RLIMIT_NOFILE,
-    /// `RLIMIT_MEMLOCK`
-    Memlock = linux_raw_sys::general::RLIMIT_MEMLOCK,
-    /// `RLIMIT_AS`
-    As = linux_raw_sys::general::RLIMIT_AS,
-    /// `RLIMIT_LOCKS`
-    Locks = linux_raw_sys::general::RLIMIT_LOCKS,
-    /// `RLIMIT_SIGPENDING`
-    Sigpending = linux_raw_sys::general::RLIMIT_SIGPENDING,
-    /// `RLIMIT_MSGQUEUE`
-    Msgqueue = linux_raw_sys::general::RLIMIT_MSGQUEUE,
-    /// `RLIMIT_NICE`
-    Nice = linux_raw_sys::general::RLIMIT_NICE,
-    /// `RLIMIT_RTPRIO`
-    Rtprio = linux_raw_sys::general::RLIMIT_RTPRIO,
-    /// `RLIMIT_RTTIME`
-    Rttime = linux_raw_sys::general::RLIMIT_RTTIME,
-}
-
-/// A CPU identifier as a raw integer.
-pub type RawCpuid = u32;
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub(crate) struct RawCpuSet {
-    #[cfg(all(target_pointer_width = "32", not(target_arch = "x86_64")))]
-    pub(crate) bits: [u32; 32],
-    #[cfg(not(all(target_pointer_width = "32", not(target_arch = "x86_64"))))]
-    pub(crate) bits: [u64; 16],
-}
-
-#[inline]
-pub(crate) fn raw_cpu_set_new() -> RawCpuSet {
-    #[cfg(all(target_pointer_width = "32", not(target_arch = "x86_64")))]
-    {
-        RawCpuSet { bits: [0; 32] }
-    }
-    #[cfg(not(all(target_pointer_width = "32", not(target_arch = "x86_64"))))]
-    {
-        RawCpuSet { bits: [0; 16] }
-    }
-}
-
-pub(crate) const CPU_SETSIZE: usize = 8 * core::mem::size_of::<RawCpuSet>();
diff --git a/vendor/rustix/src/backend/linux_raw/process/wait.rs b/vendor/rustix/src/backend/linux_raw/process/wait.rs
deleted file mode 100644
index 9af7f2b..0000000
--- a/vendor/rustix/src/backend/linux_raw/process/wait.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-// The functions replacing the C macros use the same names as in libc.
-#![allow(non_snake_case, unsafe_code)]
-
-use linux_raw_sys::ctypes::c_int;
-pub(crate) use linux_raw_sys::general::{
-    siginfo_t, WCONTINUED, WEXITED, WNOHANG, WNOWAIT, WSTOPPED, WUNTRACED,
-};
-
-#[inline]
-pub(crate) fn WIFSTOPPED(status: u32) -> bool {
-    (status & 0xff) == 0x7f
-}
-
-#[inline]
-pub(crate) fn WSTOPSIG(status: u32) -> u32 {
-    (status >> 8) & 0xff
-}
-
-#[inline]
-pub(crate) fn WIFCONTINUED(status: u32) -> bool {
-    status == 0xffff
-}
-
-#[inline]
-pub(crate) fn WIFSIGNALED(status: u32) -> bool {
-    ((status & 0x7f) + 1) as i8 >= 2
-}
-
-#[inline]
-pub(crate) fn WTERMSIG(status: u32) -> u32 {
-    status & 0x7f
-}
-
-#[inline]
-pub(crate) fn WIFEXITED(status: u32) -> bool {
-    (status & 0x7f) == 0
-}
-
-#[inline]
-pub(crate) fn WEXITSTATUS(status: u32) -> u32 {
-    (status >> 8) & 0xff
-}
-
-pub(crate) trait SiginfoExt {
-    fn si_code(&self) -> c_int;
-    unsafe fn si_status(&self) -> c_int;
-}
-
-impl SiginfoExt for siginfo_t {
-    #[inline]
-    fn si_code(&self) -> c_int {
-        // SAFETY: This is technically a union access, but it's only a union
-        // with padding.
-        unsafe { self.__bindgen_anon_1.__bindgen_anon_1.si_code }
-    }
-
-    /// Return the exit status or signal number recorded in a `siginfo_t`.
-    ///
-    /// # Safety
-    ///
-    /// `si_signo` must equal `SIGCHLD` (as it is guaranteed to do after a
-    /// `waitid` call).
-    #[inline]
-    #[rustfmt::skip]
-    unsafe fn si_status(&self) -> c_int {
-        self.__bindgen_anon_1.__bindgen_anon_1._sifields._sigchld._status
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/pty/mod.rs b/vendor/rustix/src/backend/linux_raw/pty/mod.rs
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/linux_raw/pty/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-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
deleted file mode 100644
index b64344f..0000000
--- a/vendor/rustix/src/backend/linux_raw/pty/syscalls.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//! linux_raw syscalls supporting `rustix::pty`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use crate::backend::conv::{by_ref, c_uint, ret};
-use crate::fd::BorrowedFd;
-use crate::io;
-use linux_raw_sys::ioctl::TIOCSPTLCK;
-#[cfg(feature = "alloc")]
-use {
-    crate::backend::c, crate::ffi::CString, crate::path::DecInt, alloc::vec::Vec,
-    core::mem::MaybeUninit, linux_raw_sys::ioctl::TIOCGPTN,
-};
-
-#[cfg(feature = "alloc")]
-#[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)
-        ))
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/rand/mod.rs b/vendor/rustix/src/backend/linux_raw/rand/mod.rs
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/linux_raw/rand/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/rand/syscalls.rs b/vendor/rustix/src/backend/linux_raw/rand/syscalls.rs
deleted file mode 100644
index c0f497b..0000000
--- a/vendor/rustix/src/backend/linux_raw/rand/syscalls.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//! linux_raw syscalls supporting `rustix::rand`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use crate::backend::conv::{pass_usize, ret_usize};
-use crate::io;
-use crate::rand::GetRandomFlags;
-
-#[inline]
-pub(crate) unsafe fn getrandom(
-    buf: *mut u8,
-    cap: usize,
-    flags: GetRandomFlags,
-) -> io::Result<usize> {
-    ret_usize(syscall!(__NR_getrandom, buf, pass_usize(cap), flags))
-}
diff --git a/vendor/rustix/src/backend/linux_raw/rand/types.rs b/vendor/rustix/src/backend/linux_raw/rand/types.rs
deleted file mode 100644
index 9bc857f..0000000
--- a/vendor/rustix/src/backend/linux_raw/rand/types.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use bitflags::bitflags;
-
-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;
-        /// `GRND_NONBLOCK`
-        const NONBLOCK = linux_raw_sys::general::GRND_NONBLOCK;
-        /// `GRND_INSECURE`
-        const INSECURE = linux_raw_sys::general::GRND_INSECURE;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/reg.rs b/vendor/rustix/src/backend/linux_raw/reg.rs
deleted file mode 100644
index 10f95a5..0000000
--- a/vendor/rustix/src/backend/linux_raw/reg.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-//! Encapsulation for system call arguments and return values.
-//!
-//! The inline-asm code paths do some amount of reordering of arguments; to
-//! ensure that we don't accidentally misroute an argument or return value, we
-//! use distinct types for each argument index and return value.
-//!
-//! # Safety
-//!
-//! The `ToAsm` and `FromAsm` traits are unsafe to use; they should only be
-//! used by the syscall code which executes actual syscall machine
-//! instructions.
-
-#![allow(unsafe_code)]
-
-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
-    /// machine instruction.
-    ///
-    /// # Safety
-    ///
-    /// This should be used immediately before the syscall instruction, and the
-    /// returned value shouldn't be used for any other purpose.
-    #[must_use]
-    unsafe fn to_asm(self) -> *mut Opaque;
-}
-
-pub(super) trait FromAsm: private::Sealed {
-    /// Convert `raw` from a value produced by a syscall machine instruction
-    /// into a `Self`.
-    ///
-    /// # Safety
-    ///
-    /// This should be used immediately after the syscall instruction, and the
-    /// operand value shouldn't be used for any other purpose.
-    #[must_use]
-    unsafe fn from_asm(raw: *mut Opaque) -> Self;
-}
-
-/// To preserve provenance, syscall arguments and return values are passed as
-/// pointer types. They need a type to point to, so we define a custom private
-/// type, to prevent it from being used for anything else.
-#[repr(transparent)]
-pub(super) struct Opaque(c::c_void);
-
-// Argument numbers.
-pub(super) struct A0(());
-pub(super) struct A1(());
-pub(super) struct A2(());
-pub(super) struct A3(());
-pub(super) struct A4(());
-pub(super) struct A5(());
-#[cfg(any(target_arch = "mips", target_arch = "mips32r6"))]
-pub(super) struct A6(());
-#[cfg(target_arch = "x86")]
-pub(super) struct SocketArg;
-
-pub(super) trait ArgNumber: private::Sealed {}
-impl ArgNumber for A0 {}
-impl ArgNumber for A1 {}
-impl ArgNumber for A2 {}
-impl ArgNumber for A3 {}
-impl ArgNumber for A4 {}
-impl ArgNumber for A5 {}
-#[cfg(any(target_arch = "mips", target_arch = "mips32r6"))]
-impl ArgNumber for A6 {}
-#[cfg(target_arch = "x86")]
-impl ArgNumber for SocketArg {}
-
-// Return value numbers.
-pub(super) struct R0(());
-
-pub(super) trait RetNumber: private::Sealed {}
-impl RetNumber for R0 {}
-
-/// Syscall arguments use register-sized types. We use a newtype to
-/// discourage accidental misuse of the raw integer values.
-///
-/// This type doesn't implement `Clone` or `Copy`; it should be used exactly
-/// once. And it has a lifetime to ensure that it doesn't outlive any resources
-/// it might be pointing to.
-#[repr(transparent)]
-#[must_use]
-pub(super) struct ArgReg<'a, Num: ArgNumber> {
-    raw: *mut Opaque,
-    _phantom: PhantomData<(&'a (), Num)>,
-}
-
-impl<'a, Num: ArgNumber> ToAsm for ArgReg<'a, Num> {
-    #[inline]
-    unsafe fn to_asm(self) -> *mut Opaque {
-        self.raw
-    }
-}
-
-/// Syscall return values use register-sized types. We use a newtype to
-/// discourage accidental misuse of the raw integer values.
-///
-/// This type doesn't implement `Clone` or `Copy`; it should be used exactly
-/// once.
-#[repr(transparent)]
-#[must_use]
-pub(super) struct RetReg<Num: RetNumber> {
-    raw: *mut Opaque,
-    _phantom: PhantomData<Num>,
-}
-
-impl<Num: RetNumber> RetReg<Num> {
-    #[inline]
-    pub(super) fn decode_usize(self) -> usize {
-        debug_assert!(!(-4095..0).contains(&(self.raw as isize)));
-        self.raw as usize
-    }
-
-    #[inline]
-    pub(super) fn decode_raw_fd(self) -> RawFd {
-        let bits = self.decode_usize();
-        let raw_fd = bits as RawFd;
-
-        // Converting `raw` to `RawFd` should be lossless.
-        debug_assert_eq!(raw_fd as usize, bits);
-
-        raw_fd
-    }
-
-    #[inline]
-    pub(super) fn decode_c_int(self) -> c::c_int {
-        let bits = self.decode_usize();
-        let c_int_ = bits as c::c_int;
-
-        // Converting `raw` to `c_int` should be lossless.
-        debug_assert_eq!(c_int_ as usize, bits);
-
-        c_int_
-    }
-
-    #[inline]
-    pub(super) fn decode_c_uint(self) -> c::c_uint {
-        let bits = self.decode_usize();
-        let c_uint_ = bits as c::c_uint;
-
-        // Converting `raw` to `c_uint` should be lossless.
-        debug_assert_eq!(c_uint_ as usize, bits);
-
-        c_uint_
-    }
-
-    #[inline]
-    pub(super) fn decode_void_star(self) -> *mut c::c_void {
-        self.raw.cast()
-    }
-
-    #[cfg(target_pointer_width = "64")]
-    #[inline]
-    pub(super) fn decode_u64(self) -> u64 {
-        self.decode_usize() as u64
-    }
-
-    #[inline]
-    pub(super) fn decode_void(self) {
-        let ignore = self.decode_usize();
-        debug_assert_eq!(ignore, 0);
-    }
-
-    #[inline]
-    pub(super) fn decode_error_code(self) -> u16 {
-        let bits = self.raw as usize;
-
-        // `raw` must be in `-4095..0`. Linux always returns errors in
-        // `-4095..0`, and we double-check it here.
-        debug_assert!((-4095..0).contains(&(bits as isize)));
-
-        bits as u16
-    }
-
-    #[inline]
-    pub(super) fn is_nonzero(&self) -> bool {
-        !self.raw.is_null()
-    }
-
-    #[inline]
-    pub(super) fn is_negative(&self) -> bool {
-        (self.raw as isize) < 0
-    }
-
-    #[inline]
-    pub(super) fn is_in_range(&self, range: Range<isize>) -> bool {
-        range.contains(&(self.raw as isize))
-    }
-}
-
-impl<Num: RetNumber> FromAsm for RetReg<Num> {
-    #[inline]
-    unsafe fn from_asm(raw: *mut Opaque) -> Self {
-        Self {
-            raw,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-#[repr(transparent)]
-pub(super) struct SyscallNumber<'a> {
-    nr: usize,
-    _phantom: PhantomData<&'a ()>,
-}
-
-impl<'a> ToAsm for SyscallNumber<'a> {
-    #[inline]
-    unsafe fn to_asm(self) -> *mut Opaque {
-        self.nr as usize as *mut Opaque
-    }
-}
-
-/// Encode a system call argument as an `ArgReg`.
-#[inline]
-pub(super) fn raw_arg<'a, Num: ArgNumber>(raw: *mut Opaque) -> ArgReg<'a, Num> {
-    ArgReg {
-        raw,
-        _phantom: PhantomData,
-    }
-}
-
-/// Encode a system call number (a `__NR_*` constant) as a `SyscallNumber`.
-#[inline]
-pub(super) const fn nr<'a>(nr: u32) -> SyscallNumber<'a> {
-    SyscallNumber {
-        nr: nr as usize,
-        _phantom: PhantomData,
-    }
-}
-
-/// Seal our various traits using the technique documented [here].
-///
-/// [here]: https://rust-lang.github.io/api-guidelines/future-proofing.html
-mod private {
-    pub trait Sealed {}
-
-    // Implement for those same types, but no others.
-    impl<'a, Num: super::ArgNumber> Sealed for super::ArgReg<'a, Num> {}
-    impl<Num: super::RetNumber> Sealed for super::RetReg<Num> {}
-    impl<'a> Sealed for super::SyscallNumber<'a> {}
-    impl Sealed for super::A0 {}
-    impl Sealed for super::A1 {}
-    impl Sealed for super::A2 {}
-    impl Sealed for super::A3 {}
-    impl Sealed for super::A4 {}
-    impl Sealed for super::A5 {}
-    #[cfg(any(target_arch = "mips", target_arch = "mips32r6"))]
-    impl Sealed for super::A6 {}
-    #[cfg(target_arch = "x86")]
-    impl Sealed for super::SocketArg {}
-    impl Sealed for super::R0 {}
-}
diff --git a/vendor/rustix/src/backend/linux_raw/runtime/mod.rs b/vendor/rustix/src/backend/linux_raw/runtime/mod.rs
deleted file mode 100644
index 0b48649..0000000
--- a/vendor/rustix/src/backend/linux_raw/runtime/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod syscalls;
-pub(crate) mod tls;
diff --git a/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs b/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs
deleted file mode 100644
index e00acc6..0000000
--- a/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs
+++ /dev/null
@@ -1,318 +0,0 @@
-//! linux_raw syscalls supporting `rustix::runtime`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use crate::backend::c;
-#[cfg(target_arch = "x86")]
-use crate::backend::conv::by_mut;
-#[cfg(target_arch = "x86_64")]
-use crate::backend::conv::c_uint;
-use crate::backend::conv::{
-    by_ref, c_int, ret, ret_c_int, ret_c_int_infallible, ret_error, ret_infallible, ret_void_star,
-    size_of, zero,
-};
-#[cfg(feature = "fs")]
-use crate::fd::BorrowedFd;
-use crate::ffi::CStr;
-#[cfg(feature = "fs")]
-use crate::fs::AtFlags;
-use crate::io;
-use crate::pid::{Pid, RawPid};
-use crate::runtime::{Fork, How, Sigaction, Siginfo, Sigset, Stack};
-use crate::signal::Signal;
-use crate::timespec::Timespec;
-use crate::utils::option_as_ptr;
-use core::ffi::c_void;
-use core::mem::MaybeUninit;
-#[cfg(target_pointer_width = "32")]
-use linux_raw_sys::general::__kernel_old_timespec;
-use linux_raw_sys::general::kernel_sigset_t;
-#[cfg(target_arch = "x86_64")]
-use linux_raw_sys::general::ARCH_SET_FS;
-
-#[inline]
-pub(crate) unsafe fn fork() -> io::Result<Fork> {
-    let mut child_pid = MaybeUninit::<RawPid>::uninit();
-
-    // Unix `fork` only returns the child PID in the parent; we'd like it in
-    // the child too, so set `CLONE_CHILD_SETTID` and pass in the address of
-    // a memory location to store it to in the child.
-    //
-    // Architectures differ on the order of the parameters.
-    #[cfg(target_arch = "x86_64")]
-    let pid = ret_c_int(syscall_readonly!(
-        __NR_clone,
-        c_int(c::SIGCHLD | c::CLONE_CHILD_SETTID),
-        zero(),
-        zero(),
-        &mut child_pid,
-        zero()
-    ))?;
-    #[cfg(any(
-        target_arch = "aarch64",
-        target_arch = "arm",
-        target_arch = "mips",
-        target_arch = "mips32r6",
-        target_arch = "mips64",
-        target_arch = "mips64r6",
-        target_arch = "powerpc64",
-        target_arch = "riscv64",
-        target_arch = "x86"
-    ))]
-    let pid = ret_c_int(syscall_readonly!(
-        __NR_clone,
-        c_int(c::SIGCHLD | c::CLONE_CHILD_SETTID),
-        zero(),
-        zero(),
-        zero(),
-        &mut child_pid
-    ))?;
-
-    Ok(if let Some(pid) = Pid::from_raw(pid) {
-        Fork::Parent(pid)
-    } else {
-        Fork::Child(Pid::from_raw_unchecked(child_pid.assume_init()))
-    })
-}
-
-#[cfg(feature = "fs")]
-pub(crate) unsafe fn execveat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    args: *const *const u8,
-    env_vars: *const *const u8,
-    flags: AtFlags,
-) -> io::Errno {
-    ret_error(syscall_readonly!(
-        __NR_execveat,
-        dirfd,
-        path,
-        args,
-        env_vars,
-        flags
-    ))
-}
-
-pub(crate) unsafe fn execve(
-    path: &CStr,
-    args: *const *const u8,
-    env_vars: *const *const u8,
-) -> io::Errno {
-    ret_error(syscall_readonly!(__NR_execve, path, args, env_vars))
-}
-
-pub(crate) mod tls {
-    use super::*;
-    #[cfg(target_arch = "x86")]
-    use crate::backend::runtime::tls::UserDesc;
-
-    #[cfg(target_arch = "x86")]
-    #[inline]
-    pub(crate) unsafe fn set_thread_area(u_info: &mut UserDesc) -> io::Result<()> {
-        ret(syscall!(__NR_set_thread_area, by_mut(u_info)))
-    }
-
-    #[cfg(target_arch = "arm")]
-    #[inline]
-    pub(crate) unsafe fn arm_set_tls(data: *mut c::c_void) -> io::Result<()> {
-        ret(syscall_readonly!(__ARM_NR_set_tls, data))
-    }
-
-    #[cfg(target_arch = "x86_64")]
-    #[inline]
-    pub(crate) unsafe fn set_fs(data: *mut c::c_void) {
-        ret_infallible(syscall_readonly!(
-            __NR_arch_prctl,
-            c_uint(ARCH_SET_FS),
-            data,
-            zero(),
-            zero(),
-            zero()
-        ))
-    }
-
-    #[inline]
-    pub(crate) unsafe fn set_tid_address(data: *mut c::c_void) -> Pid {
-        let tid: i32 = ret_c_int_infallible(syscall_readonly!(__NR_set_tid_address, data));
-        Pid::from_raw_unchecked(tid)
-    }
-
-    #[inline]
-    pub(crate) fn exit_thread(code: c::c_int) -> ! {
-        unsafe { syscall_noreturn!(__NR_exit, c_int(code)) }
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn sigaction(signal: Signal, new: Option<Sigaction>) -> io::Result<Sigaction> {
-    let mut old = MaybeUninit::<Sigaction>::uninit();
-    let new = option_as_ptr(new.as_ref());
-    ret(syscall!(
-        __NR_rt_sigaction,
-        signal,
-        new,
-        &mut old,
-        size_of::<kernel_sigset_t, _>()
-    ))?;
-    Ok(old.assume_init())
-}
-
-#[inline]
-pub(crate) unsafe fn sigaltstack(new: Option<Stack>) -> io::Result<Stack> {
-    let mut old = MaybeUninit::<Stack>::uninit();
-    let new = option_as_ptr(new.as_ref());
-    ret(syscall!(__NR_sigaltstack, new, &mut old))?;
-    Ok(old.assume_init())
-}
-
-#[inline]
-pub(crate) unsafe fn tkill(tid: Pid, sig: Signal) -> io::Result<()> {
-    ret(syscall_readonly!(__NR_tkill, tid, sig))
-}
-
-#[inline]
-pub(crate) unsafe fn sigprocmask(how: How, new: Option<&Sigset>) -> io::Result<Sigset> {
-    let mut old = MaybeUninit::<Sigset>::uninit();
-    let new = option_as_ptr(new);
-    ret(syscall!(
-        __NR_rt_sigprocmask,
-        how,
-        new,
-        &mut old,
-        size_of::<kernel_sigset_t, _>()
-    ))?;
-    Ok(old.assume_init())
-}
-
-#[inline]
-pub(crate) fn sigpending() -> Sigset {
-    let mut pending = MaybeUninit::<Sigset>::uninit();
-    unsafe {
-        ret_infallible(syscall!(
-            __NR_rt_sigpending,
-            &mut pending,
-            size_of::<kernel_sigset_t, _>()
-        ));
-        pending.assume_init()
-    }
-}
-
-#[inline]
-pub(crate) fn sigsuspend(set: &Sigset) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_rt_sigsuspend,
-            by_ref(set),
-            size_of::<kernel_sigset_t, _>()
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn sigwait(set: &Sigset) -> io::Result<Signal> {
-    unsafe {
-        match Signal::from_raw(ret_c_int(syscall_readonly!(
-            __NR_rt_sigtimedwait,
-            by_ref(set),
-            zero(),
-            zero(),
-            size_of::<kernel_sigset_t, _>()
-        ))?) {
-            Some(signum) => Ok(signum),
-            None => Err(io::Errno::NOTSUP),
-        }
-    }
-}
-
-#[inline]
-pub(crate) fn sigwaitinfo(set: &Sigset) -> io::Result<Siginfo> {
-    let mut info = MaybeUninit::<Siginfo>::uninit();
-    unsafe {
-        let _signum = ret_c_int(syscall!(
-            __NR_rt_sigtimedwait,
-            by_ref(set),
-            &mut info,
-            zero(),
-            size_of::<kernel_sigset_t, _>()
-        ))?;
-        Ok(info.assume_init())
-    }
-}
-
-#[inline]
-pub(crate) fn sigtimedwait(set: &Sigset, timeout: Option<Timespec>) -> io::Result<Siginfo> {
-    let mut info = MaybeUninit::<Siginfo>::uninit();
-    let timeout_ptr = option_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!(
-            __NR_rt_sigtimedwait_time64,
-            by_ref(set),
-            &mut info,
-            timeout_ptr,
-            size_of::<kernel_sigset_t, _>()
-        )) {
-            Ok(_signum) => (),
-            Err(io::Errno::NOSYS) => sigtimedwait_old(set, timeout, &mut info)?,
-            Err(err) => return Err(err),
-        }
-        Ok(info.assume_init())
-    }
-
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        let _signum = ret_c_int(syscall!(
-            __NR_rt_sigtimedwait,
-            by_ref(set),
-            &mut info,
-            timeout_ptr,
-            size_of::<kernel_sigset_t, _>()
-        ))?;
-        Ok(info.assume_init())
-    }
-}
-
-#[cfg(target_pointer_width = "32")]
-unsafe fn sigtimedwait_old(
-    set: &Sigset,
-    timeout: Option<Timespec>,
-    info: &mut MaybeUninit<Siginfo>,
-) -> io::Result<()> {
-    let old_timeout = match timeout {
-        Some(timeout) => Some(__kernel_old_timespec {
-            tv_sec: timeout.tv_sec.try_into().map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: timeout.tv_nsec as _,
-        }),
-        None => None,
-    };
-
-    let old_timeout_ptr = option_as_ptr(old_timeout.as_ref());
-
-    let _signum = ret_c_int(syscall!(
-        __NR_rt_sigtimedwait,
-        by_ref(set),
-        info,
-        old_timeout_ptr,
-        size_of::<kernel_sigset_t, _>()
-    ))?;
-
-    Ok(())
-}
-
-#[inline]
-pub(crate) fn exit_group(code: c::c_int) -> ! {
-    unsafe { syscall_noreturn!(__NR_exit_group, c_int(code)) }
-}
-
-#[inline]
-pub(crate) unsafe fn brk(addr: *mut c::c_void) -> io::Result<*mut c_void> {
-    // This is non-`readonly`, to prevent loads from being reordered past it.
-    ret_void_star(syscall!(__NR_brk, addr))
-}
diff --git a/vendor/rustix/src/backend/linux_raw/runtime/tls.rs b/vendor/rustix/src/backend/linux_raw/runtime/tls.rs
deleted file mode 100644
index 69bd5ce..0000000
--- a/vendor/rustix/src/backend/linux_raw/runtime/tls.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-//! TLS utilities.
-//!
-//! # Safety
-//!
-//! This file contains code that reads the raw phdr array pointed to by the
-//! kernel-provided AUXV values.
-#![allow(unsafe_code)]
-
-use crate::backend::c;
-use crate::backend::param::auxv::exe_phdrs;
-use core::arch::global_asm;
-use core::ptr::{null, NonNull};
-use linux_raw_sys::elf::*;
-
-/// For use with [`set_thread_area`].
-///
-/// [`set_thread_area`]: crate::runtime::set_thread_area
-#[cfg(target_arch = "x86")]
-pub type UserDesc = linux_raw_sys::general::user_desc;
-
-pub(crate) fn startup_tls_info() -> StartupTlsInfo {
-    let mut base = null();
-    let mut tls_phdr = null();
-    let mut stack_size = 0;
-
-    let (first_phdr, phent, phnum) = exe_phdrs();
-    let mut current_phdr = first_phdr.cast::<Elf_Phdr>();
-
-    // The dynamic address of the dynamic section, which we can compare with
-    // the `PT_DYNAMIC` header's static address, if present.
-    let dynamic_addr: *const c::c_void = unsafe { &_DYNAMIC };
-
-    // SAFETY: We assume the phdr array pointer and length the kernel provided
-    // to the process describe a valid phdr array.
-    unsafe {
-        let phdrs_end = current_phdr.cast::<u8>().add(phnum * phent).cast();
-        while current_phdr != phdrs_end {
-            let phdr = &*current_phdr;
-            current_phdr = current_phdr.cast::<u8>().add(phent).cast();
-
-            match phdr.p_type {
-                // Compute the offset from the static virtual addresses
-                // in the `p_vaddr` fields to the dynamic addresses. We don't
-                // always get a `PT_PHDR` or `PT_DYNAMIC` header, so use
-                // whichever one we get.
-                PT_PHDR => base = first_phdr.cast::<u8>().wrapping_sub(phdr.p_vaddr),
-                PT_DYNAMIC => base = dynamic_addr.cast::<u8>().wrapping_sub(phdr.p_vaddr),
-
-                PT_TLS => tls_phdr = phdr,
-                PT_GNU_STACK => stack_size = phdr.p_memsz,
-                _ => {}
-            }
-        }
-
-        if tls_phdr.is_null() {
-            StartupTlsInfo {
-                addr: NonNull::dangling().as_ptr(),
-                mem_size: 0,
-                file_size: 0,
-                align: 1,
-                stack_size: 0,
-            }
-        } else {
-            StartupTlsInfo {
-                addr: base.cast::<u8>().wrapping_add((*tls_phdr).p_vaddr).cast(),
-                mem_size: (*tls_phdr).p_memsz,
-                file_size: (*tls_phdr).p_filesz,
-                align: (*tls_phdr).p_align,
-                stack_size,
-            }
-        }
-    }
-}
-
-extern "C" {
-    /// Declare the `_DYNAMIC` symbol so that we can compare its address with
-    /// the static address in the `PT_DYNAMIC` header to learn our offset. Use
-    /// a weak symbol because `_DYNAMIC` is not always present.
-    static _DYNAMIC: c::c_void;
-}
-// Rust has `extern_weak` but it isn't stable, so use a `global_asm`.
-global_asm!(".weak _DYNAMIC");
-
-/// The values returned from [`startup_tls_info`].
-///
-/// [`startup_tls_info`]: crate::runtime::startup_tls_info
-pub struct StartupTlsInfo {
-    /// The base address of the TLS segment.
-    pub addr: *const c::c_void,
-    /// The size of the memory region.
-    pub mem_size: usize,
-    /// The size beyond which all memory is zero-initialized.
-    pub file_size: usize,
-    /// The required alignment for the TLS segment.
-    pub align: usize,
-    /// The requested minimum size for stacks.
-    pub stack_size: usize,
-}
diff --git a/vendor/rustix/src/backend/linux_raw/shm/mod.rs b/vendor/rustix/src/backend/linux_raw/shm/mod.rs
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/linux_raw/shm/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/shm/syscalls.rs b/vendor/rustix/src/backend/linux_raw/shm/syscalls.rs
deleted file mode 100644
index 3b083f4..0000000
--- a/vendor/rustix/src/backend/linux_raw/shm/syscalls.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use crate::ffi::CStr;
-
-use crate::backend::fs::syscalls::{open, unlink};
-use crate::backend::fs::types::{Mode, OFlags};
-use crate::fd::OwnedFd;
-use crate::io;
-use crate::shm::ShmOFlags;
-
-const NAME_MAX: usize = 255;
-const SHM_DIR: &[u8] = b"/dev/shm/";
-
-fn get_shm_name(name: &CStr) -> io::Result<([u8; NAME_MAX + SHM_DIR.len() + 1], usize)> {
-    let name = name.to_bytes();
-
-    if name.len() > NAME_MAX {
-        return Err(io::Errno::NAMETOOLONG);
-    }
-
-    let num_slashes = name.iter().take_while(|x| **x == b'/').count();
-    let after_slashes = &name[num_slashes..];
-    if after_slashes.is_empty()
-        || after_slashes == b"."
-        || after_slashes == b".."
-        || after_slashes.contains(&b'/')
-    {
-        return Err(io::Errno::INVAL);
-    }
-
-    let mut path = [0; NAME_MAX + SHM_DIR.len() + 1];
-    path[..SHM_DIR.len()].copy_from_slice(SHM_DIR);
-    path[SHM_DIR.len()..SHM_DIR.len() + name.len()].copy_from_slice(name);
-    Ok((path, SHM_DIR.len() + name.len() + 1))
-}
-
-pub(crate) fn shm_open(name: &CStr, oflags: ShmOFlags, mode: Mode) -> io::Result<OwnedFd> {
-    let (path, len) = get_shm_name(name)?;
-    open(
-        CStr::from_bytes_with_nul(&path[..len]).unwrap(),
-        OFlags::from_bits(oflags.bits()).unwrap() | OFlags::CLOEXEC,
-        mode,
-    )
-}
-
-pub(crate) fn shm_unlink(name: &CStr) -> io::Result<()> {
-    let (path, len) = get_shm_name(name)?;
-    unlink(CStr::from_bytes_with_nul(&path[..len]).unwrap())
-}
diff --git a/vendor/rustix/src/backend/linux_raw/shm/types.rs b/vendor/rustix/src/backend/linux_raw/shm/types.rs
deleted file mode 100644
index 3343d44..0000000
--- a/vendor/rustix/src/backend/linux_raw/shm/types.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use crate::backend::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `O_*` constants for use with [`shm_open`].
-    ///
-    /// [`shm_open`]: crate:shm::shm_open
-    #[repr(transparent)]
-    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct ShmOFlags: c::c_uint {
-        /// `O_CREAT`
-        #[doc(alias = "CREAT")]
-        const CREATE = linux_raw_sys::general::O_CREAT;
-
-        /// `O_EXCL`
-        const EXCL = linux_raw_sys::general::O_EXCL;
-
-        /// `O_RDONLY`
-        const RDONLY = linux_raw_sys::general::O_RDONLY;
-
-        /// `O_RDWR`
-        const RDWR = linux_raw_sys::general::O_RDWR;
-
-        /// `O_TRUNC`
-        const TRUNC = linux_raw_sys::general::O_TRUNC;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/system/mod.rs b/vendor/rustix/src/backend/linux_raw/system/mod.rs
deleted file mode 100644
index 1e0181a..0000000
--- a/vendor/rustix/src/backend/linux_raw/system/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-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
deleted file mode 100644
index 6b41cdb..0000000
--- a/vendor/rustix/src/backend/linux_raw/system/syscalls.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//! linux_raw syscalls supporting `rustix::system`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use super::types::RawUname;
-use crate::backend::c;
-use crate::backend::conv::{c_int, ret, ret_infallible, slice};
-use crate::io;
-use crate::system::{RebootCommand, 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)) }
-}
-
-#[inline]
-pub(crate) fn reboot(cmd: RebootCommand) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_reboot,
-            c_int(c::LINUX_REBOOT_MAGIC1),
-            c_int(c::LINUX_REBOOT_MAGIC2),
-            c_int(cmd as i32)
-        ))
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/system/types.rs b/vendor/rustix/src/backend/linux_raw/system/types.rs
deleted file mode 100644
index 4729273..0000000
--- a/vendor/rustix/src/backend/linux_raw/system/types.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-/// `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
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/linux_raw/termios/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/linux_raw/termios/syscalls.rs b/vendor/rustix/src/backend/linux_raw/termios/syscalls.rs
deleted file mode 100644
index 5a24c0a..0000000
--- a/vendor/rustix/src/backend/linux_raw/termios/syscalls.rs
+++ /dev/null
@@ -1,330 +0,0 @@
-//! linux_raw syscalls supporting `rustix::termios`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use crate::backend::c;
-use crate::backend::conv::{by_ref, c_uint, ret};
-use crate::fd::BorrowedFd;
-use crate::io;
-use crate::pid::Pid;
-#[cfg(all(feature = "alloc", feature = "procfs"))]
-use crate::procfs;
-use crate::termios::{
-    Action, ControlModes, InputModes, LocalModes, OptionalActions, OutputModes, QueueSelector,
-    SpecialCodeIndex, Termios, Winsize,
-};
-#[cfg(all(feature = "alloc", feature = "procfs"))]
-use crate::{ffi::CStr, fs::FileType, path::DecInt};
-use core::mem::MaybeUninit;
-use linux_raw_sys::general::IBSHIFT;
-use linux_raw_sys::ioctl::{
-    TCFLSH, TCSBRK, TCXONC, TIOCGPGRP, TIOCGSID, TIOCGWINSZ, TIOCSPGRP, TIOCSWINSZ,
-};
-
-#[inline]
-pub(crate) fn tcgetwinsize(fd: BorrowedFd<'_>) -> io::Result<Winsize> {
-    unsafe {
-        let mut result = MaybeUninit::<Winsize>::uninit();
-        ret(syscall!(__NR_ioctl, fd, c_uint(TIOCGWINSZ), &mut result))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[inline]
-pub(crate) fn tcgetattr(fd: BorrowedFd<'_>) -> io::Result<Termios> {
-    unsafe {
-        let mut result = MaybeUninit::<Termios>::uninit();
-
-        // QEMU's `TCGETS2` doesn't currently set `input_speed` or
-        // `output_speed` on PowerPC, so zero out the fields ourselves.
-        #[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
-        {
-            result.write(core::mem::zeroed());
-        }
-
-        ret(syscall!(__NR_ioctl, fd, c_uint(c::TCGETS2), &mut result))?;
-
-        let result = result.assume_init();
-
-        // QEMU's `TCGETS2` doesn't currently set `input_speed` or
-        // `output_speed` on PowerPC, so set them manually if we can.
-        #[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
-        let result = {
-            use crate::termios::speed;
-            let mut result = result;
-            if result.output_speed == 0 && (result.control_modes.bits() & c::CBAUD) != c::BOTHER {
-                if let Some(output_speed) = speed::decode(result.control_modes.bits() & c::CBAUD) {
-                    result.output_speed = output_speed;
-                }
-            }
-            if result.input_speed == 0
-                && ((result.control_modes.bits() & c::CIBAUD) >> c::IBSHIFT) != c::BOTHER
-            {
-                // For input speeds, `B0` is special-cased to mean the input
-                // speed is the same as the output speed.
-                if ((result.control_modes.bits() & c::CIBAUD) >> c::IBSHIFT) == c::B0 {
-                    result.input_speed = result.output_speed;
-                } else if let Some(input_speed) =
-                    speed::decode((result.control_modes.bits() & c::CIBAUD) >> c::IBSHIFT)
-                {
-                    result.input_speed = input_speed;
-                }
-            }
-            result
-        };
-
-        Ok(result)
-    }
-}
-
-#[inline]
-pub(crate) fn tcgetpgrp(fd: BorrowedFd<'_>) -> io::Result<Pid> {
-    unsafe {
-        let mut result = MaybeUninit::<c::pid_t>::uninit();
-        ret(syscall!(__NR_ioctl, fd, c_uint(TIOCGPGRP), &mut result))?;
-        let pid = result.assume_init();
-
-        // This doesn't appear to be documented, but it appears `tcsetpgrp` can
-        // succceed and set the pid to 0 if we pass it a pseudo-terminal device
-        // fd. For now, fail with `OPNOTSUPP`.
-        if pid == 0 {
-            return Err(io::Errno::OPNOTSUPP);
-        }
-
-        Ok(Pid::from_raw_unchecked(pid))
-    }
-}
-
-#[inline]
-pub(crate) fn tcsetattr(
-    fd: BorrowedFd<'_>,
-    optional_actions: OptionalActions,
-    termios: &Termios,
-) -> io::Result<()> {
-    // Translate from `optional_actions` into an ioctl request code. On MIPS,
-    // `optional_actions` already has `TCGETS` added to it.
-    let request = linux_raw_sys::ioctl::TCSETS2
-        + if cfg!(any(
-            target_arch = "mips",
-            target_arch = "mips32r6",
-            target_arch = "mips64",
-            target_arch = "mips64r6"
-        )) {
-            optional_actions as u32 - linux_raw_sys::ioctl::TCSETS
-        } else {
-            optional_actions as u32
-        };
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_ioctl,
-            fd,
-            c_uint(request),
-            by_ref(termios)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn tcsendbreak(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_ioctl, fd, c_uint(TCSBRK), c_uint(0))) }
-}
-
-#[inline]
-pub(crate) fn tcdrain(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_ioctl, fd, c_uint(TCSBRK), c_uint(1))) }
-}
-
-#[inline]
-pub(crate) fn tcflush(fd: BorrowedFd<'_>, queue_selector: QueueSelector) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_ioctl,
-            fd,
-            c_uint(TCFLSH),
-            c_uint(queue_selector as u32)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn tcflow(fd: BorrowedFd<'_>, action: Action) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_ioctl,
-            fd,
-            c_uint(TCXONC),
-            c_uint(action as u32)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn tcgetsid(fd: BorrowedFd<'_>) -> io::Result<Pid> {
-    unsafe {
-        let mut result = MaybeUninit::<c::pid_t>::uninit();
-        ret(syscall!(__NR_ioctl, fd, c_uint(TIOCGSID), &mut result))?;
-        let pid = result.assume_init();
-        Ok(Pid::from_raw_unchecked(pid))
-    }
-}
-
-#[inline]
-pub(crate) fn tcsetwinsize(fd: BorrowedFd<'_>, winsize: Winsize) -> io::Result<()> {
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_ioctl,
-            fd,
-            c_uint(TIOCSWINSZ),
-            by_ref(&winsize)
-        ))
-    }
-}
-
-#[inline]
-pub(crate) fn tcsetpgrp(fd: BorrowedFd<'_>, pid: Pid) -> io::Result<()> {
-    let raw_pid: c::c_int = pid.as_raw_nonzero().get();
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_ioctl,
-            fd,
-            c_uint(TIOCSPGRP),
-            by_ref(&raw_pid)
-        ))
-    }
-}
-
-/// A wrapper around a conceptual `cfsetspeed` which handles an arbitrary
-/// integer speed value.
-#[inline]
-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);
-
-    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 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 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 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]
-pub(crate) fn isatty(fd: BorrowedFd<'_>) -> bool {
-    // On error, Linux will return either `EINVAL` (2.6.32) or `ENOTTY`
-    // (otherwise), because we assume we're never passing an invalid
-    // file descriptor (which would get `EBADF`). Either way, an error
-    // means we don't have a tty.
-    tcgetwinsize(fd).is_ok()
-}
-
-#[cfg(all(feature = "alloc", feature = "procfs"))]
-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 {
-        return Err(io::Errno::NOTTY);
-    }
-
-    // Check that `fd` is really a tty.
-    tcgetwinsize(fd)?;
-
-    // Get a fd to "/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 = 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
-    // adding a NUL terminator.
-    if r == buf.len() {
-        return Err(io::Errno::RANGE);
-    }
-
-    // `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`.
-    {
-        // SAFETY: We just wrote the NUL byte above
-        let path = unsafe { CStr::from_ptr(buf.as_ptr().cast()) };
-
-        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/thread/futex.rs b/vendor/rustix/src/backend/linux_raw/thread/futex.rs
deleted file mode 100644
index 263e980..0000000
--- a/vendor/rustix/src/backend/linux_raw/thread/futex.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-bitflags::bitflags! {
-    /// `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;
-        /// `FUTEX_CLOCK_REALTIME`
-        const CLOCK_REALTIME = linux_raw_sys::general::FUTEX_CLOCK_REALTIME;
-
-        // This deliberately lacks a `const _ = !0`, so that users can use
-        // `from_bits_truncate` to extract the `SocketFlags` from a flags
-        // value that also includes a `SocketType`.
-    }
-}
-
-/// `FUTEX_*` operations for use with [`futex`].
-///
-/// [`futex`]: crate::thread::futex
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(u32)]
-pub enum FutexOperation {
-    /// `FUTEX_WAIT`
-    Wait = linux_raw_sys::general::FUTEX_WAIT,
-    /// `FUTEX_WAKE`
-    Wake = linux_raw_sys::general::FUTEX_WAKE,
-    /// `FUTEX_FD`
-    Fd = linux_raw_sys::general::FUTEX_FD,
-    /// `FUTEX_REQUEUE`
-    Requeue = linux_raw_sys::general::FUTEX_REQUEUE,
-    /// `FUTEX_CMP_REQUEUE`
-    CmpRequeue = linux_raw_sys::general::FUTEX_CMP_REQUEUE,
-    /// `FUTEX_WAKE_OP`
-    WakeOp = linux_raw_sys::general::FUTEX_WAKE_OP,
-    /// `FUTEX_LOCK_PI`
-    LockPi = linux_raw_sys::general::FUTEX_LOCK_PI,
-    /// `FUTEX_UNLOCK_PI`
-    UnlockPi = linux_raw_sys::general::FUTEX_UNLOCK_PI,
-    /// `FUTEX_TRYLOCK_PI`
-    TrylockPi = linux_raw_sys::general::FUTEX_TRYLOCK_PI,
-    /// `FUTEX_WAIT_BITSET`
-    WaitBitset = linux_raw_sys::general::FUTEX_WAIT_BITSET,
-}
diff --git a/vendor/rustix/src/backend/linux_raw/thread/mod.rs b/vendor/rustix/src/backend/linux_raw/thread/mod.rs
deleted file mode 100644
index 6a002c6..0000000
--- a/vendor/rustix/src/backend/linux_raw/thread/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod futex;
-pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs b/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs
deleted file mode 100644
index 0095eed..0000000
--- a/vendor/rustix/src/backend/linux_raw/thread/syscalls.rs
+++ /dev/null
@@ -1,347 +0,0 @@
-//! linux_raw syscalls supporting `rustix::thread`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-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::pid::Pid;
-use crate::thread::{ClockId, FutexFlags, FutexOperation, NanosleepRelativeResult, Timespec};
-use core::mem::MaybeUninit;
-#[cfg(target_pointer_width = "32")]
-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(
-    id: ClockId,
-    req: &__kernel_timespec,
-) -> NanosleepRelativeResult {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        let mut rem = MaybeUninit::<__kernel_timespec>::uninit();
-        match ret(syscall!(
-            __NR_clock_nanosleep_time64,
-            id,
-            c_int(0),
-            by_ref(req),
-            &mut rem
-        ))
-        .or_else(|err| {
-            // See the comments in `rustix_clock_gettime_via_syscall` about
-            // emulation.
-            if err == io::Errno::NOSYS {
-                clock_nanosleep_relative_old(id, req, &mut rem)
-            } else {
-                Err(err)
-            }
-        }) {
-            Ok(()) => NanosleepRelativeResult::Ok,
-            Err(io::Errno::INTR) => NanosleepRelativeResult::Interrupted(rem.assume_init()),
-            Err(err) => NanosleepRelativeResult::Err(err),
-        }
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        let mut rem = MaybeUninit::<__kernel_timespec>::uninit();
-        match ret(syscall!(
-            __NR_clock_nanosleep,
-            id,
-            c_int(0),
-            by_ref(req),
-            &mut rem
-        )) {
-            Ok(()) => NanosleepRelativeResult::Ok,
-            Err(io::Errno::INTR) => NanosleepRelativeResult::Interrupted(rem.assume_init()),
-            Err(err) => NanosleepRelativeResult::Err(err),
-        }
-    }
-}
-
-#[cfg(target_pointer_width = "32")]
-unsafe fn clock_nanosleep_relative_old(
-    id: ClockId,
-    req: &__kernel_timespec,
-    rem: &mut MaybeUninit<__kernel_timespec>,
-) -> io::Result<()> {
-    let old_req = __kernel_old_timespec {
-        tv_sec: req.tv_sec.try_into().map_err(|_| io::Errno::INVAL)?,
-        tv_nsec: req.tv_nsec.try_into().map_err(|_| io::Errno::INVAL)?,
-    };
-    let mut old_rem = MaybeUninit::<__kernel_old_timespec>::uninit();
-    ret(syscall!(
-        __NR_clock_nanosleep,
-        id,
-        c_int(0),
-        by_ref(&old_req),
-        &mut old_rem
-    ))?;
-    let old_rem = old_rem.assume_init();
-    rem.write(__kernel_timespec {
-        tv_sec: old_rem.tv_sec.into(),
-        tv_nsec: old_rem.tv_nsec.into(),
-    });
-    Ok(())
-}
-
-#[inline]
-pub(crate) fn clock_nanosleep_absolute(id: ClockId, req: &__kernel_timespec) -> io::Result<()> {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_clock_nanosleep_time64,
-            id,
-            c_uint(TIMER_ABSTIME),
-            by_ref(req),
-            zero()
-        ))
-        .or_else(|err| {
-            // See the comments in `rustix_clock_gettime_via_syscall` about
-            // emulation.
-            if err == io::Errno::NOSYS {
-                clock_nanosleep_absolute_old(id, req)
-            } else {
-                Err(err)
-            }
-        })
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_clock_nanosleep,
-            id,
-            c_uint(TIMER_ABSTIME),
-            by_ref(req),
-            zero()
-        ))
-    }
-}
-
-#[cfg(target_pointer_width = "32")]
-unsafe fn clock_nanosleep_absolute_old(id: ClockId, req: &__kernel_timespec) -> io::Result<()> {
-    let old_req = __kernel_old_timespec {
-        tv_sec: req.tv_sec.try_into().map_err(|_| io::Errno::INVAL)?,
-        tv_nsec: req.tv_nsec.try_into().map_err(|_| io::Errno::INVAL)?,
-    };
-    ret(syscall_readonly!(
-        __NR_clock_nanosleep,
-        id,
-        c_int(0),
-        by_ref(&old_req),
-        zero()
-    ))
-}
-
-#[inline]
-pub(crate) fn nanosleep(req: &__kernel_timespec) -> NanosleepRelativeResult {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        let mut rem = MaybeUninit::<__kernel_timespec>::uninit();
-        match ret(syscall!(
-            __NR_clock_nanosleep_time64,
-            ClockId::Realtime,
-            c_int(0),
-            by_ref(req),
-            &mut rem
-        ))
-        .or_else(|err| {
-            // See the comments in `rustix_clock_gettime_via_syscall` about
-            // emulation.
-            if err == io::Errno::NOSYS {
-                nanosleep_old(req, &mut rem)
-            } else {
-                Err(err)
-            }
-        }) {
-            Ok(()) => NanosleepRelativeResult::Ok,
-            Err(io::Errno::INTR) => NanosleepRelativeResult::Interrupted(rem.assume_init()),
-            Err(err) => NanosleepRelativeResult::Err(err),
-        }
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        let mut rem = MaybeUninit::<__kernel_timespec>::uninit();
-        match ret(syscall!(__NR_nanosleep, by_ref(req), &mut rem)) {
-            Ok(()) => NanosleepRelativeResult::Ok,
-            Err(io::Errno::INTR) => NanosleepRelativeResult::Interrupted(rem.assume_init()),
-            Err(err) => NanosleepRelativeResult::Err(err),
-        }
-    }
-}
-
-#[cfg(target_pointer_width = "32")]
-unsafe fn nanosleep_old(
-    req: &__kernel_timespec,
-    rem: &mut MaybeUninit<__kernel_timespec>,
-) -> io::Result<()> {
-    let old_req = __kernel_old_timespec {
-        tv_sec: req.tv_sec.try_into().map_err(|_| io::Errno::INVAL)?,
-        tv_nsec: req.tv_nsec.try_into().map_err(|_| io::Errno::INVAL)?,
-    };
-    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();
-    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 = ret_c_int_infallible(syscall_readonly!(__NR_gettid));
-        Pid::from_raw_unchecked(tid)
-    }
-}
-
-// TODO: This could be de-multiplexed.
-#[inline]
-pub(crate) unsafe fn futex(
-    uaddr: *mut u32,
-    op: FutexOperation,
-    flags: FutexFlags,
-    val: u32,
-    utime: *const Timespec,
-    uaddr2: *mut u32,
-    val3: u32,
-) -> io::Result<usize> {
-    #[cfg(target_pointer_width = "32")]
-    {
-        ret_usize(syscall!(
-            __NR_futex_time64,
-            uaddr,
-            (op, flags),
-            c_uint(val),
-            utime,
-            uaddr2,
-            c_uint(val3)
-        ))
-        .or_else(|err| {
-            // See the comments in `rustix_clock_gettime_via_syscall` about
-            // emulation.
-            if err == io::Errno::NOSYS {
-                futex_old(uaddr, op, flags, val, utime, uaddr2, val3)
-            } else {
-                Err(err)
-            }
-        })
-    }
-    #[cfg(target_pointer_width = "64")]
-    ret_usize(syscall!(
-        __NR_futex,
-        uaddr,
-        (op, flags),
-        c_uint(val),
-        utime,
-        uaddr2,
-        c_uint(val3)
-    ))
-}
-
-#[cfg(target_pointer_width = "32")]
-unsafe fn futex_old(
-    uaddr: *mut u32,
-    op: FutexOperation,
-    flags: FutexFlags,
-    val: u32,
-    utime: *const Timespec,
-    uaddr2: *mut u32,
-    val3: u32,
-) -> io::Result<usize> {
-    let old_utime = __kernel_old_timespec {
-        tv_sec: (*utime).tv_sec.try_into().map_err(|_| io::Errno::INVAL)?,
-        tv_nsec: (*utime).tv_nsec.try_into().map_err(|_| io::Errno::INVAL)?,
-    };
-    ret_usize(syscall!(
-        __NR_futex,
-        uaddr,
-        (op, flags),
-        c_uint(val),
-        by_ref(&old_utime),
-        uaddr2,
-        c_uint(val3)
-    ))
-}
-
-#[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))) }
-}
-
-#[inline]
-pub(crate) fn unshare(flags: crate::thread::UnshareFlags) -> io::Result<()> {
-    unsafe { ret(syscall_readonly!(__NR_unshare, flags)) }
-}
-
-#[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<()> {
-    unsafe {
-        ret(syscall!(
-            __NR_capget,
-            by_mut(header),
-            slice_just_addr_mut(data)
-        ))
-    }
-}
-
-#[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<()> {
-    unsafe { ret(syscall!(__NR_capset, by_mut(header), slice_just_addr(data))) }
-}
-
-#[inline]
-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::ugid::Uid,
-    euid: crate::ugid::Uid,
-    suid: crate::ugid::Uid,
-) -> io::Result<()> {
-    #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))]
-    unsafe {
-        ret(syscall_readonly!(__NR_setresuid32, ruid, euid, suid))
-    }
-    #[cfg(not(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc")))]
-    unsafe {
-        ret(syscall_readonly!(__NR_setresuid, ruid, euid, suid))
-    }
-}
-
-#[inline]
-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::ugid::Gid,
-    egid: crate::ugid::Gid,
-    sgid: crate::ugid::Gid,
-) -> io::Result<()> {
-    #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))]
-    unsafe {
-        ret(syscall_readonly!(__NR_setresgid32, rgid, egid, sgid))
-    }
-    #[cfg(not(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc")))]
-    unsafe {
-        ret(syscall_readonly!(__NR_setresgid, rgid, egid, sgid))
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/time/mod.rs b/vendor/rustix/src/backend/linux_raw/time/mod.rs
deleted file mode 100644
index c42592c..0000000
--- a/vendor/rustix/src/backend/linux_raw/time/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-#[cfg(any(feature = "time", target_arch = "x86"))]
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix/src/backend/linux_raw/time/syscalls.rs b/vendor/rustix/src/backend/linux_raw/time/syscalls.rs
deleted file mode 100644
index d20bcfa..0000000
--- a/vendor/rustix/src/backend/linux_raw/time/syscalls.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-//! linux_raw syscalls supporting `rustix::time`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use crate::backend::conv::{ret, ret_infallible};
-use crate::clockid::ClockId;
-use crate::io;
-use crate::timespec::Timespec;
-use core::mem::MaybeUninit;
-#[cfg(all(feature = "time", target_pointer_width = "32"))]
-use linux_raw_sys::general::itimerspec as __kernel_old_itimerspec;
-#[cfg(target_pointer_width = "32")]
-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 crate::backend::vdso_wrappers::{clock_gettime, clock_gettime_dynamic};
-
-#[inline]
-pub(crate) fn clock_getres(which_clock: ClockId) -> Timespec {
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        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.
-            debug_assert_eq!(err, io::Errno::NOSYS);
-            clock_getres_old(which_clock, &mut result);
-        }
-        result.assume_init()
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        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<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();
-    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: 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!(
-            __NR_clock_settime64,
-            which_clock,
-            by_ref(&timespec)
-        )) {
-            Err(io::Errno::NOSYS) => clock_settime_old(which_clock, timespec),
-            otherwise => otherwise,
-        }
-    }
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall_readonly!(
-            __NR_clock_settime,
-            which_clock,
-            by_ref(&timespec)
-        ))
-    }
-}
-
-#[cfg(feature = "time")]
-#[cfg(target_pointer_width = "32")]
-unsafe fn clock_settime_old(which_clock: ClockId, timespec: Timespec) -> io::Result<()> {
-    let old_timespec = __kernel_old_timespec {
-        tv_sec: timespec
-            .tv_sec
-            .try_into()
-            .map_err(|_| io::Errno::OVERFLOW)?,
-        tv_nsec: timespec.tv_nsec as _,
-    };
-    ret(syscall_readonly!(
-        __NR_clock_settime,
-        which_clock,
-        by_ref(&old_timespec)
-    ))
-}
-
-#[cfg(feature = "time")]
-#[inline]
-pub(crate) fn timerfd_create(clockid: TimerfdClockId, flags: TimerfdFlags) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(syscall_readonly!(__NR_timerfd_create, clockid, flags)) }
-}
-
-#[cfg(feature = "time")]
-#[inline]
-pub(crate) fn timerfd_settime(
-    fd: BorrowedFd<'_>,
-    flags: TimerfdTimerFlags,
-    new_value: &Itimerspec,
-) -> io::Result<Itimerspec> {
-    let mut result = MaybeUninit::<Itimerspec>::uninit();
-
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall!(
-            __NR_timerfd_settime,
-            fd,
-            flags,
-            by_ref(new_value),
-            &mut result
-        ))?;
-        Ok(result.assume_init())
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall!(
-            __NR_timerfd_settime64,
-            fd,
-            flags,
-            by_ref(new_value),
-            &mut result
-        ))
-        .or_else(|err| {
-            // See the comments in `rustix_clock_gettime_via_syscall` about
-            // emulation.
-            if err == io::Errno::NOSYS {
-                timerfd_settime_old(fd, flags, new_value, &mut result)
-            } else {
-                Err(err)
-            }
-        })?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(feature = "time")]
-#[cfg(target_pointer_width = "32")]
-unsafe fn timerfd_settime_old(
-    fd: BorrowedFd<'_>,
-    flags: TimerfdTimerFlags,
-    new_value: &Itimerspec,
-    result: &mut MaybeUninit<Itimerspec>,
-) -> io::Result<()> {
-    let mut old_result = MaybeUninit::<__kernel_old_itimerspec>::uninit();
-
-    // Convert `new_value` to the old `__kernel_old_itimerspec` format.
-    let old_new_value = __kernel_old_itimerspec {
-        it_interval: __kernel_old_timespec {
-            tv_sec: new_value
-                .it_interval
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: new_value
-                .it_interval
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::INVAL)?,
-        },
-        it_value: __kernel_old_timespec {
-            tv_sec: new_value
-                .it_value
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: new_value
-                .it_value
-                .tv_nsec
-                .try_into()
-                .map_err(|_| io::Errno::INVAL)?,
-        },
-    };
-    ret(syscall!(
-        __NR_timerfd_settime,
-        fd,
-        flags,
-        by_ref(&old_new_value),
-        &mut old_result
-    ))?;
-    let old_result = old_result.assume_init();
-    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(())
-}
-
-#[cfg(feature = "time")]
-#[inline]
-pub(crate) fn timerfd_gettime(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> {
-    let mut result = MaybeUninit::<Itimerspec>::uninit();
-
-    #[cfg(target_pointer_width = "64")]
-    unsafe {
-        ret(syscall!(__NR_timerfd_gettime, fd, &mut result))?;
-        Ok(result.assume_init())
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    unsafe {
-        ret(syscall!(__NR_timerfd_gettime64, fd, &mut result)).or_else(|err| {
-            // See the comments in `rustix_clock_gettime_via_syscall` about
-            // emulation.
-            if err == io::Errno::NOSYS {
-                timerfd_gettime_old(fd, &mut result)
-            } else {
-                Err(err)
-            }
-        })?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(feature = "time")]
-#[cfg(target_pointer_width = "32")]
-unsafe fn timerfd_gettime_old(
-    fd: BorrowedFd<'_>,
-    result: &mut MaybeUninit<Itimerspec>,
-) -> io::Result<()> {
-    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();
-    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
deleted file mode 100644
index c26812c..0000000
--- a/vendor/rustix/src/backend/linux_raw/time/types.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-use crate::backend::c;
-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
-pub type Itimerspec = linux_raw_sys::general::__kernel_itimerspec;
-
-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`
-        #[doc(alias = "TFD_NONBLOCK")]
-        const NONBLOCK = linux_raw_sys::general::TFD_NONBLOCK;
-
-        /// `TFD_CLOEXEC`
-        #[doc(alias = "TFD_CLOEXEC")]
-        const CLOEXEC = linux_raw_sys::general::TFD_CLOEXEC;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-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`
-        #[doc(alias = "TFD_TIMER_ABSTIME")]
-        const ABSTIME = linux_raw_sys::general::TFD_TIMER_ABSTIME;
-
-        /// `TFD_TIMER_CANCEL_ON_SET`
-        #[doc(alias = "TFD_TIMER_CANCEL_ON_SET")]
-        const CANCEL_ON_SET = linux_raw_sys::general::TFD_TIMER_CANCEL_ON_SET;
-
-        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
-        const _ = !0;
-    }
-}
-
-/// `CLOCK_*` constants for use with [`timerfd_create`].
-///
-/// [`timerfd_create`]: crate::time::timerfd_create
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-#[repr(u32)]
-#[non_exhaustive]
-pub enum TimerfdClockId {
-    /// `CLOCK_REALTIME`—A clock that tells the “real” time.
-    ///
-    /// This is a clock that tells the amount of time elapsed since the 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.
-    #[doc(alias = "CLOCK_REALTIME")]
-    Realtime = linux_raw_sys::general::CLOCK_REALTIME,
-
-    /// `CLOCK_MONOTONIC`—A clock that tells an abstract time.
-    ///
-    /// Unlike `Realtime`, this clock is not based on a fixed known epoch, so
-    /// individual times aren't meaningful. However, since it isn't settable,
-    /// it is reliable for measuring durations.
-    ///
-    /// This clock does not advance while the system is suspended; see
-    /// `Boottime` for a clock that does.
-    #[doc(alias = "CLOCK_MONOTONIC")]
-    Monotonic = linux_raw_sys::general::CLOCK_MONOTONIC,
-
-    /// `CLOCK_BOOTTIME`—Like `Monotonic`, but advances while suspended.
-    ///
-    /// This clock is similar to `Monotonic`, but does advance while the system
-    /// is suspended.
-    #[doc(alias = "CLOCK_BOOTTIME")]
-    Boottime = linux_raw_sys::general::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.
-    #[doc(alias = "CLOCK_REALTIME_ALARM")]
-    RealtimeAlarm = linux_raw_sys::general::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.
-    #[doc(alias = "CLOCK_BOOTTIME_ALARM")]
-    BoottimeAlarm = linux_raw_sys::general::CLOCK_BOOTTIME_ALARM,
-}
diff --git a/vendor/rustix/src/backend/linux_raw/ugid/mod.rs b/vendor/rustix/src/backend/linux_raw/ugid/mod.rs
deleted file mode 100644
index ef944f0..0000000
--- a/vendor/rustix/src/backend/linux_raw/ugid/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-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
deleted file mode 100644
index 5f1551e..0000000
--- a/vendor/rustix/src/backend/linux_raw/ugid/syscalls.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//! linux_raw syscalls for UIDs and GIDs
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, 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.rs b/vendor/rustix/src/backend/linux_raw/vdso.rs
deleted file mode 100644
index 102fa6b..0000000
--- a/vendor/rustix/src/backend/linux_raw/vdso.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-//! Parse the Linux vDSO.
-//!
-//! The following code is transliterated from
-//! tools/testing/selftests/vDSO/parse_vdso.c in Linux 5.11, which is licensed
-//! with Creative Commons Zero License, version 1.0,
-//! available at <https://creativecommons.org/publicdomain/zero/1.0/legalcode>
-//!
-//! # Safety
-//!
-//! Parsing the vDSO involves a lot of raw pointer manipulation. This
-//! implementation follows Linux's reference implementation, and adds several
-//! additional safety checks.
-#![allow(unsafe_code)]
-
-use super::c;
-use crate::ffi::CStr;
-use crate::utils::check_raw_pointer;
-use core::ffi::c_void;
-use core::mem::size_of;
-use core::ptr::{null, null_mut};
-use linux_raw_sys::elf::*;
-
-pub(super) struct Vdso {
-    // Load information
-    load_addr: *const Elf_Ehdr,
-    load_end: *const c_void, // the end of the `PT_LOAD` segment
-    pv_offset: usize,        // recorded paddr - recorded vaddr
-
-    // Symbol table
-    symtab: *const Elf_Sym,
-    symstrings: *const u8,
-    bucket: *const u32,
-    chain: *const u32,
-    nbucket: u32,
-    //nchain: u32,
-
-    // Version table
-    versym: *const u16,
-    verdef: *const Elf_Verdef,
-}
-
-// Straight from the ELF specification.
-fn elf_hash(name: &CStr) -> u32 {
-    let mut h: u32 = 0;
-    for b in name.to_bytes() {
-        h = (h << 4).wrapping_add(u32::from(*b));
-        let g = h & 0xf000_0000;
-        if g != 0 {
-            h ^= g >> 24;
-        }
-        h &= !g;
-    }
-    h
-}
-
-/// Create a `Vdso` value by parsing the vDSO at the `sysinfo_ehdr` address.
-fn init_from_sysinfo_ehdr() -> Option<Vdso> {
-    // SAFETY: The auxv initialization code does extensive checks to ensure
-    // that the value we get really is an `AT_SYSINFO_EHDR` value from the
-    // kernel.
-    unsafe {
-        let hdr = super::param::auxv::sysinfo_ehdr();
-
-        // If the platform doesn't provide a `AT_SYSINFO_EHDR`, we can't locate
-        // the vDSO.
-        if hdr.is_null() {
-            return None;
-        }
-
-        let mut vdso = Vdso {
-            load_addr: hdr,
-            load_end: hdr.cast(),
-            pv_offset: 0,
-            symtab: null(),
-            symstrings: null(),
-            bucket: null(),
-            chain: null(),
-            nbucket: 0,
-            //nchain: 0,
-            versym: null(),
-            verdef: null(),
-        };
-
-        let hdr = &*hdr;
-        let pt = check_raw_pointer::<Elf_Phdr>(vdso.base_plus(hdr.e_phoff)? as *mut _)?.as_ptr();
-        let mut dyn_: *const Elf_Dyn = null();
-        let mut num_dyn = 0;
-
-        // We need two things from the segment table: the load offset
-        // and the dynamic table.
-        let mut found_vaddr = false;
-        for i in 0..hdr.e_phnum {
-            let phdr = &*pt.add(i as usize);
-            if phdr.p_flags & PF_W != 0 {
-                // Don't trust any vDSO that claims to be loading writable
-                // segments into memory.
-                return None;
-            }
-            if phdr.p_type == PT_LOAD && !found_vaddr {
-                // The segment should be readable and executable, because it
-                // contains the symbol table and the function bodies.
-                if phdr.p_flags & (PF_R | PF_X) != (PF_R | PF_X) {
-                    return None;
-                }
-                found_vaddr = true;
-                vdso.load_end = vdso.base_plus(phdr.p_offset.checked_add(phdr.p_memsz)?)?;
-                vdso.pv_offset = phdr.p_offset.wrapping_sub(phdr.p_vaddr);
-            } else if phdr.p_type == PT_DYNAMIC {
-                // If `p_offset` is zero, it's more likely that we're looking
-                // at memory that has been zeroed than that the kernel has
-                // somehow aliased the `Ehdr` and the `Elf_Dyn` array.
-                if phdr.p_offset < size_of::<Elf_Ehdr>() {
-                    return None;
-                }
-
-                dyn_ = check_raw_pointer::<Elf_Dyn>(vdso.base_plus(phdr.p_offset)? as *mut _)?
-                    .as_ptr();
-                num_dyn = phdr.p_memsz / size_of::<Elf_Dyn>();
-            } else if phdr.p_type == PT_INTERP || phdr.p_type == PT_GNU_RELRO {
-                // Don't trust any ELF image that has an “interpreter” or
-                // that uses RELRO, which is likely to be a user ELF image
-                // rather and not the kernel vDSO.
-                return None;
-            }
-        }
-
-        if !found_vaddr || dyn_.is_null() {
-            return None; // Failed
-        }
-
-        // Fish out the useful bits of the dynamic table.
-        let mut hash: *const u32 = null();
-        vdso.symstrings = null();
-        vdso.symtab = null();
-        vdso.versym = null();
-        vdso.verdef = null();
-        let mut i = 0;
-        loop {
-            if i == num_dyn {
-                return None;
-            }
-            let d = &*dyn_.add(i);
-            match d.d_tag {
-                DT_STRTAB => {
-                    vdso.symstrings =
-                        check_raw_pointer::<u8>(vdso.addr_from_elf(d.d_un.d_ptr)? as *mut _)?
-                            .as_ptr();
-                }
-                DT_SYMTAB => {
-                    vdso.symtab =
-                        check_raw_pointer::<Elf_Sym>(vdso.addr_from_elf(d.d_un.d_ptr)? as *mut _)?
-                            .as_ptr();
-                }
-                DT_HASH => {
-                    hash = check_raw_pointer::<u32>(vdso.addr_from_elf(d.d_un.d_ptr)? as *mut _)?
-                        .as_ptr();
-                }
-                DT_VERSYM => {
-                    vdso.versym =
-                        check_raw_pointer::<u16>(vdso.addr_from_elf(d.d_un.d_ptr)? as *mut _)?
-                            .as_ptr();
-                }
-                DT_VERDEF => {
-                    vdso.verdef = check_raw_pointer::<Elf_Verdef>(
-                        vdso.addr_from_elf(d.d_un.d_ptr)? as *mut _,
-                    )?
-                    .as_ptr();
-                }
-                DT_SYMENT => {
-                    if d.d_un.d_ptr != size_of::<Elf_Sym>() {
-                        return None; // Failed
-                    }
-                }
-                DT_NULL => break,
-                _ => {}
-            }
-            i = i.checked_add(1)?;
-        }
-        // The upstream code checks `symstrings`, `symtab`, and `hash` for
-        // null; here, `check_raw_pointer` has already done that.
-
-        if vdso.verdef.is_null() {
-            vdso.versym = null();
-        }
-
-        // Parse the hash table header.
-        vdso.nbucket = *hash.add(0);
-        //vdso.nchain = *hash.add(1);
-        vdso.bucket = hash.add(2);
-        vdso.chain = hash.add(vdso.nbucket as usize + 2);
-
-        // That's all we need.
-        Some(vdso)
-    }
-}
-
-impl Vdso {
-    /// Parse the vDSO.
-    ///
-    /// Returns `None` if the vDSO can't be located or if it doesn't conform to
-    /// our expectations.
-    #[inline]
-    pub(super) fn new() -> Option<Self> {
-        init_from_sysinfo_ehdr()
-    }
-
-    /// Check the version for a symbol.
-    ///
-    /// # Safety
-    ///
-    /// The raw pointers inside `self` must be valid.
-    unsafe fn match_version(&self, mut ver: u16, name: &CStr, hash: u32) -> bool {
-        // This is a helper function to check if the version indexed by
-        // ver matches name (which hashes to hash).
-        //
-        // The version definition table is a mess, and I don't know how
-        // to do this in better than linear time without allocating memory
-        // to build an index. I also don't know why the table has
-        // variable size entries in the first place.
-        //
-        // For added fun, I can't find a comprehensible specification of how
-        // to parse all the weird flags in the table.
-        //
-        // So I just parse the whole table every time.
-
-        // First step: find the version definition
-        ver &= 0x7fff; // Apparently bit 15 means "hidden"
-        let mut def = self.verdef;
-        loop {
-            if (*def).vd_version != VER_DEF_CURRENT {
-                return false; // Failed
-            }
-
-            if ((*def).vd_flags & VER_FLG_BASE) == 0 && ((*def).vd_ndx & 0x7fff) == ver {
-                break;
-            }
-
-            if (*def).vd_next == 0 {
-                return false; // No definition.
-            }
-
-            def = def
-                .cast::<u8>()
-                .add((*def).vd_next as usize)
-                .cast::<Elf_Verdef>();
-        }
-
-        // Now figure out whether it matches.
-        let aux = &*(def.cast::<u8>())
-            .add((*def).vd_aux as usize)
-            .cast::<Elf_Verdaux>();
-        (*def).vd_hash == hash
-            && (name == CStr::from_ptr(self.symstrings.add(aux.vda_name as usize).cast()))
-    }
-
-    /// Look up a symbol in the vDSO.
-    pub(super) fn sym(&self, version: &CStr, name: &CStr) -> *mut c::c_void {
-        let ver_hash = elf_hash(version);
-        let name_hash = elf_hash(name);
-
-        // SAFETY: The pointers in `self` must be valid.
-        unsafe {
-            let mut chain = *self.bucket.add((name_hash % self.nbucket) as usize);
-
-            while chain != STN_UNDEF {
-                let sym = &*self.symtab.add(chain as usize);
-
-                // Check for a defined global or weak function w/ right name.
-                //
-                // The reference parser in Linux's parse_vdso.c requires
-                // symbols to have type `STT_FUNC`, but on powerpc64, the vDSO
-                // uses `STT_NOTYPE`, so allow that too.
-                if (ELF_ST_TYPE(sym.st_info) != STT_FUNC &&
-                        ELF_ST_TYPE(sym.st_info) != STT_NOTYPE)
-                    || (ELF_ST_BIND(sym.st_info) != STB_GLOBAL
-                        && ELF_ST_BIND(sym.st_info) != STB_WEAK)
-                    || sym.st_shndx == SHN_UNDEF
-                    || sym.st_shndx == SHN_ABS
-                    || ELF_ST_VISIBILITY(sym.st_other) != STV_DEFAULT
-                    || (name != CStr::from_ptr(self.symstrings.add(sym.st_name as usize).cast()))
-                    // Check symbol version.
-                    || (!self.versym.is_null()
-                        && !self.match_version(*self.versym.add(chain as usize), version, ver_hash))
-                {
-                    chain = *self.chain.add(chain as usize);
-                    continue;
-                }
-
-                let sum = self.addr_from_elf(sym.st_value).unwrap();
-                assert!(
-                    sum as usize >= self.load_addr as usize
-                        && sum as usize <= self.load_end as usize
-                );
-                return sum as *mut c::c_void;
-            }
-        }
-
-        null_mut()
-    }
-
-    /// Add the given address to the vDSO base address.
-    unsafe fn base_plus(&self, offset: usize) -> Option<*const c_void> {
-        // Check for overflow.
-        let _ = (self.load_addr as usize).checked_add(offset)?;
-        // Add the offset to the base.
-        Some(self.load_addr.cast::<u8>().add(offset).cast())
-    }
-
-    /// Translate an ELF-address-space address into a usable virtual address.
-    unsafe fn addr_from_elf(&self, elf_addr: usize) -> Option<*const c_void> {
-        self.base_plus(elf_addr.wrapping_add(self.pv_offset))
-    }
-}
diff --git a/vendor/rustix/src/backend/linux_raw/vdso_wrappers.rs b/vendor/rustix/src/backend/linux_raw/vdso_wrappers.rs
deleted file mode 100644
index 441738f..0000000
--- a/vendor/rustix/src/backend/linux_raw/vdso_wrappers.rs
+++ /dev/null
@@ -1,608 +0,0 @@
-//! Implement syscalls using the vDSO.
-//!
-//! <https://man7.org/linux/man-pages/man7/vdso.7.html>
-//!
-//! # Safety
-//!
-//! Similar to syscalls.rs, this file performs raw system calls, and sometimes
-//! passes them uninitialized memory buffers. This file also calls vDSO
-//! functions.
-#![allow(unsafe_code)]
-
-#[cfg(target_arch = "x86")]
-use super::reg::{ArgReg, RetReg, SyscallNumber, A0, A1, A2, A3, A4, A5, R0};
-use super::vdso;
-#[cfg(target_arch = "x86")]
-use core::arch::global_asm;
-#[cfg(feature = "process")]
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "riscv64",
-    target_arch = "powerpc64"
-))]
-use core::ffi::c_void;
-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;
-#[cfg(any(
-    all(
-        feature = "process",
-        any(
-            target_arch = "x86_64",
-            target_arch = "x86",
-            target_arch = "riscv64",
-            target_arch = "powerpc64"
-        )
-    ),
-    feature = "time"
-))]
-use {super::c, super::conv::ret, core::mem::MaybeUninit};
-#[cfg(feature = "time")]
-use {
-    super::conv::c_int,
-    crate::clockid::{ClockId, DynamicClockId},
-    crate::io,
-    crate::timespec::Timespec,
-    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
-    // function with an ABI like libc `clock_gettime`, and calling it has the
-    // side effect of writing to the result buffer, and no others.
-    unsafe {
-        let mut result = MaybeUninit::<__kernel_timespec>::uninit();
-        let callee = match transmute(CLOCK_GETTIME.load(Relaxed)) {
-            Some(callee) => callee,
-            None => init_clock_gettime(),
-        };
-        let r0 = callee(which_clock as c::c_int, result.as_mut_ptr());
-        // The `ClockId` enum only contains clocks which never fail. It may be
-        // tempting to change this to `debug_assert_eq`, however they can still
-        // fail on uncommon kernel configs, so we leave this in place to ensure
-        // that we don't execute undefined behavior if they ever do fail.
-        assert_eq!(r0, 0);
-        result.assume_init()
-    }
-}
-
-#[cfg(feature = "time")]
-#[inline]
-pub(crate) fn clock_gettime_dynamic(which_clock: DynamicClockId<'_>) -> io::Result<Timespec> {
-    let id = match which_clock {
-        DynamicClockId::Known(id) => id as __kernel_clockid_t,
-
-        DynamicClockId::Dynamic(fd) => {
-            // See `FD_TO_CLOCKID` in Linux's `clock_gettime` documentation.
-            use crate::backend::fd::AsRawFd;
-            const CLOCKFD: i32 = 3;
-            ((!fd.as_raw_fd() << 3) | CLOCKFD) as __kernel_clockid_t
-        }
-
-        DynamicClockId::RealtimeAlarm => c::CLOCK_REALTIME_ALARM as __kernel_clockid_t,
-        DynamicClockId::Tai => c::CLOCK_TAI as __kernel_clockid_t,
-        DynamicClockId::Boottime => c::CLOCK_BOOTTIME as __kernel_clockid_t,
-        DynamicClockId::BoottimeAlarm => c::CLOCK_BOOTTIME_ALARM as __kernel_clockid_t,
-    };
-
-    // SAFETY: `CLOCK_GETTIME` contains either null or the address of a
-    // function with an ABI like libc `clock_gettime`, and calling it has the
-    // side effect of writing to the result buffer, and no others.
-    unsafe {
-        const EINVAL: c::c_int = -(c::EINVAL as c::c_int);
-        let mut timespec = MaybeUninit::<Timespec>::uninit();
-        let callee = match transmute(CLOCK_GETTIME.load(Relaxed)) {
-            Some(callee) => callee,
-            None => init_clock_gettime(),
-        };
-        match callee(id, timespec.as_mut_ptr()) {
-            0 => (),
-            EINVAL => return Err(io::Errno::INVAL),
-            _ => _rustix_clock_gettime_via_syscall(id, timespec.as_mut_ptr())?,
-        }
-        Ok(timespec.assume_init())
-    }
-}
-
-#[cfg(feature = "process")]
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "riscv64",
-    target_arch = "powerpc64"
-))]
-#[inline]
-pub(crate) fn sched_getcpu() -> usize {
-    // SAFETY: `GETCPU` contains either null or the address of a function with
-    // an ABI like libc `getcpu`, and calling it has the side effect of writing
-    // to the result buffers, and no others.
-    unsafe {
-        let mut cpu = MaybeUninit::<u32>::uninit();
-        let callee = match transmute(GETCPU.load(Relaxed)) {
-            Some(callee) => callee,
-            None => init_getcpu(),
-        };
-        let r0 = callee(cpu.as_mut_ptr(), null_mut(), null_mut());
-        debug_assert_eq!(r0, 0);
-        cpu.assume_init() as usize
-    }
-}
-
-#[cfg(target_arch = "x86")]
-pub(super) mod x86_via_vdso {
-    use super::{transmute, ArgReg, Relaxed, RetReg, SyscallNumber, A0, A1, A2, A3, A4, A5, R0};
-    use crate::backend::arch::asm;
-
-    #[inline]
-    pub(in crate::backend) unsafe fn syscall0(nr: SyscallNumber<'_>) -> RetReg<R0> {
-        let callee = match transmute(super::SYSCALL.load(Relaxed)) {
-            Some(callee) => callee,
-            None => super::init_syscall(),
-        };
-        asm::indirect_syscall0(callee, nr)
-    }
-
-    #[inline]
-    pub(in crate::backend) unsafe fn syscall1<'a>(
-        nr: SyscallNumber<'a>,
-        a0: ArgReg<'a, A0>,
-    ) -> RetReg<R0> {
-        let callee = match transmute(super::SYSCALL.load(Relaxed)) {
-            Some(callee) => callee,
-            None => super::init_syscall(),
-        };
-        asm::indirect_syscall1(callee, nr, a0)
-    }
-
-    #[inline]
-    pub(in crate::backend) unsafe fn syscall1_noreturn<'a>(
-        nr: SyscallNumber<'a>,
-        a0: ArgReg<'a, A0>,
-    ) -> ! {
-        let callee = match transmute(super::SYSCALL.load(Relaxed)) {
-            Some(callee) => callee,
-            None => super::init_syscall(),
-        };
-        asm::indirect_syscall1_noreturn(callee, nr, a0)
-    }
-
-    #[inline]
-    pub(in crate::backend) unsafe fn syscall2<'a>(
-        nr: SyscallNumber<'a>,
-        a0: ArgReg<'a, A0>,
-        a1: ArgReg<'a, A1>,
-    ) -> RetReg<R0> {
-        let callee = match transmute(super::SYSCALL.load(Relaxed)) {
-            Some(callee) => callee,
-            None => super::init_syscall(),
-        };
-        asm::indirect_syscall2(callee, nr, a0, a1)
-    }
-
-    #[inline]
-    pub(in crate::backend) unsafe fn syscall3<'a>(
-        nr: SyscallNumber<'a>,
-        a0: ArgReg<'a, A0>,
-        a1: ArgReg<'a, A1>,
-        a2: ArgReg<'a, A2>,
-    ) -> RetReg<R0> {
-        let callee = match transmute(super::SYSCALL.load(Relaxed)) {
-            Some(callee) => callee,
-            None => super::init_syscall(),
-        };
-        asm::indirect_syscall3(callee, nr, a0, a1, a2)
-    }
-
-    #[inline]
-    pub(in crate::backend) unsafe fn syscall4<'a>(
-        nr: SyscallNumber<'a>,
-        a0: ArgReg<'a, A0>,
-        a1: ArgReg<'a, A1>,
-        a2: ArgReg<'a, A2>,
-        a3: ArgReg<'a, A3>,
-    ) -> RetReg<R0> {
-        let callee = match transmute(super::SYSCALL.load(Relaxed)) {
-            Some(callee) => callee,
-            None => super::init_syscall(),
-        };
-        asm::indirect_syscall4(callee, nr, a0, a1, a2, a3)
-    }
-
-    #[inline]
-    pub(in crate::backend) unsafe fn syscall5<'a>(
-        nr: SyscallNumber<'a>,
-        a0: ArgReg<'a, A0>,
-        a1: ArgReg<'a, A1>,
-        a2: ArgReg<'a, A2>,
-        a3: ArgReg<'a, A3>,
-        a4: ArgReg<'a, A4>,
-    ) -> RetReg<R0> {
-        let callee = match transmute(super::SYSCALL.load(Relaxed)) {
-            Some(callee) => callee,
-            None => super::init_syscall(),
-        };
-        asm::indirect_syscall5(callee, nr, a0, a1, a2, a3, a4)
-    }
-
-    #[inline]
-    pub(in crate::backend) unsafe fn syscall6<'a>(
-        nr: SyscallNumber<'a>,
-        a0: ArgReg<'a, A0>,
-        a1: ArgReg<'a, A1>,
-        a2: ArgReg<'a, A2>,
-        a3: ArgReg<'a, A3>,
-        a4: ArgReg<'a, A4>,
-        a5: ArgReg<'a, A5>,
-    ) -> RetReg<R0> {
-        let callee = match transmute(super::SYSCALL.load(Relaxed)) {
-            Some(callee) => callee,
-            None => super::init_syscall(),
-        };
-        asm::indirect_syscall6(callee, nr, a0, a1, a2, a3, a4, a5)
-    }
-
-    // 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,
-        syscall4 as syscall4_readonly, syscall5 as syscall5_readonly,
-        syscall6 as syscall6_readonly,
-    };
-}
-
-#[cfg(feature = "time")]
-type ClockGettimeType = unsafe extern "C" fn(c::c_int, *mut Timespec) -> c::c_int;
-
-#[cfg(feature = "process")]
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "riscv64",
-    target_arch = "powerpc64"
-))]
-type GetcpuType = unsafe extern "C" fn(*mut u32, *mut u32, *mut c_void) -> c::c_int;
-
-/// The underlying syscall functions are only called from asm, using the
-/// special syscall calling convention to pass arguments and return values,
-/// which the signature here doesn't reflect.
-#[cfg(target_arch = "x86")]
-pub(super) type SyscallType = unsafe extern "C" fn();
-
-/// Initialize `CLOCK_GETTIME` and return its value.
-#[cfg(feature = "time")]
-#[cold]
-fn init_clock_gettime() -> ClockGettimeType {
-    init();
-    // SAFETY: Load the function address from static storage that we just
-    // initialized.
-    unsafe { transmute(CLOCK_GETTIME.load(Relaxed)) }
-}
-
-/// Initialize `GETCPU` and return its value.
-#[cfg(feature = "process")]
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "riscv64",
-    target_arch = "powerpc64"
-))]
-#[cold]
-fn init_getcpu() -> GetcpuType {
-    init();
-    // SAFETY: Load the function address from static storage that we just
-    // initialized.
-    unsafe { transmute(GETCPU.load(Relaxed)) }
-}
-
-/// Initialize `SYSCALL` and return its value.
-#[cfg(target_arch = "x86")]
-#[cold]
-fn init_syscall() -> SyscallType {
-    init();
-    // SAFETY: Load the function address from static storage that we just
-    // initialized.
-    unsafe { transmute(SYSCALL.load(Relaxed)) }
-}
-
-/// `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(feature = "process")]
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "riscv64",
-    target_arch = "powerpc64"
-))]
-static mut GETCPU: 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,
-) -> c::c_int {
-    match _rustix_clock_gettime_via_syscall(clockid, res) {
-        Ok(()) => 0,
-        Err(err) => err.raw_os_error().wrapping_neg(),
-    }
-}
-
-#[cfg(feature = "time")]
-#[cfg(target_pointer_width = "32")]
-unsafe fn _rustix_clock_gettime_via_syscall(
-    clockid: c::c_int,
-    res: *mut Timespec,
-) -> io::Result<()> {
-    let r0 = syscall!(__NR_clock_gettime64, c_int(clockid), res);
-    match ret(r0) {
-        Err(io::Errno::NOSYS) => _rustix_clock_gettime_via_syscall_old(clockid, res),
-        otherwise => otherwise,
-    }
-}
-
-#[cfg(feature = "time")]
-#[cfg(target_pointer_width = "32")]
-unsafe fn _rustix_clock_gettime_via_syscall_old(
-    clockid: c::c_int,
-    res: *mut Timespec,
-) -> io::Result<()> {
-    // Ordinarily `rustix` doesn't like to emulate system calls, but in the
-    // case of time APIs, it's specific to Linux, specific to 32-bit
-    // architectures *and* specific to old kernel versions, and it's not that
-    // hard to fix up here, so that no other code needs to worry about this.
-    let mut old_result = MaybeUninit::<__kernel_old_timespec>::uninit();
-    let r0 = syscall!(__NR_clock_gettime, c_int(clockid), &mut old_result);
-    match ret(r0) {
-        Ok(()) => {
-            let old_result = old_result.assume_init();
-            *res = Timespec {
-                tv_sec: old_result.tv_sec.into(),
-                tv_nsec: old_result.tv_nsec.into(),
-            };
-            Ok(())
-        }
-        otherwise => otherwise,
-    }
-}
-
-#[cfg(feature = "time")]
-#[cfg(target_pointer_width = "64")]
-unsafe fn _rustix_clock_gettime_via_syscall(
-    clockid: c::c_int,
-    res: *mut Timespec,
-) -> io::Result<()> {
-    ret(syscall!(__NR_clock_gettime, c_int(clockid), res))
-}
-
-#[cfg(feature = "process")]
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "riscv64",
-    target_arch = "powerpc64"
-))]
-unsafe extern "C" fn rustix_getcpu_via_syscall(
-    cpu: *mut u32,
-    node: *mut u32,
-    unused: *mut c_void,
-) -> c::c_int {
-    match ret(syscall!(__NR_getcpu, cpu, node, unused)) {
-        Ok(()) => 0,
-        Err(err) => err.raw_os_error().wrapping_neg(),
-    }
-}
-
-#[cfg(target_arch = "x86")]
-extern "C" {
-    /// A symbol pointing to an `int 0x80` instruction. This “function” is only
-    /// called from assembly, and only with the x86 syscall calling convention,
-    /// so its signature here is not its true signature.
-    ///
-    /// This extern block and the `global_asm!` below can be replaced with
-    /// `#[naked]` if it's stabilized.
-    fn rustix_int_0x80();
-}
-
-#[cfg(target_arch = "x86")]
-global_asm!(
-    r#"
-    .section    .text.rustix_int_0x80,"ax",@progbits
-    .p2align    4
-    .weak       rustix_int_0x80
-    .hidden     rustix_int_0x80
-    .type       rustix_int_0x80, @function
-rustix_int_0x80:
-    .cfi_startproc
-    int    0x80
-    ret
-    .cfi_endproc
-    .size rustix_int_0x80, .-rustix_int_0x80
-"#
-);
-
-fn minimal_init() {
-    // SAFETY: Store default function addresses in static storage so that if we
-    // end up making any system calls while we read the vDSO, they'll work. If
-    // the memory happens to already be initialized, this is redundant, but not
-    // harmful.
-    unsafe {
-        #[cfg(feature = "time")]
-        {
-            CLOCK_GETTIME
-                .compare_exchange(
-                    null_mut(),
-                    rustix_clock_gettime_via_syscall as *mut Function,
-                    Relaxed,
-                    Relaxed,
-                )
-                .ok();
-        }
-
-        #[cfg(feature = "process")]
-        #[cfg(any(
-            target_arch = "x86_64",
-            target_arch = "x86",
-            target_arch = "riscv64",
-            target_arch = "powerpc64"
-        ))]
-        {
-            GETCPU
-                .compare_exchange(
-                    null_mut(),
-                    rustix_getcpu_via_syscall as *mut Function,
-                    Relaxed,
-                    Relaxed,
-                )
-                .ok();
-        }
-
-        #[cfg(target_arch = "x86")]
-        {
-            SYSCALL
-                .compare_exchange(
-                    null_mut(),
-                    rustix_int_0x80 as *mut Function,
-                    Relaxed,
-                    Relaxed,
-                )
-                .ok();
-        }
-    }
-}
-
-fn init() {
-    minimal_init();
-
-    if let Some(vdso) = vdso::Vdso::new() {
-        #[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(any(target_arch = "mips", target_arch = "mips32r6"))]
-            let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_clock_gettime64"));
-            #[cfg(any(target_arch = "mips64", target_arch = "mips64r6"))]
-            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 = "mips32r6",
-                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 = "process")]
-        #[cfg(any(
-            target_arch = "x86_64",
-            target_arch = "x86",
-            target_arch = "riscv64",
-            target_arch = "powerpc64"
-        ))]
-        {
-            // Look up the platform-specific `getcpu` symbol as documented
-            // [here].
-            //
-            // [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_getcpu"));
-            #[cfg(target_arch = "x86")]
-            let ptr = vdso.sym(cstr!("LINUX_2.6"), cstr!("__vdso_getcpu"));
-            #[cfg(target_arch = "riscv64")]
-            let ptr = vdso.sym(cstr!("LINUX_4.15"), cstr!("__kernel_getcpu"));
-            #[cfg(target_arch = "powerpc64")]
-            let ptr = vdso.sym(cstr!("LINUX_2.6.15"), cstr!("__kernel_getcpu"));
-
-            #[cfg(any(
-                target_arch = "x86_64",
-                target_arch = "riscv64",
-                target_arch = "powerpc64"
-            ))]
-            let ok = true;
-
-            // On 32-bit x86, the symbol doesn't appear present sometimes.
-            #[cfg(target_arch = "x86")]
-            let ok = !ptr.is_null();
-
-            #[cfg(any(
-                target_arch = "aarch64",
-                target_arch = "arm",
-                target_arch = "mips",
-                target_arch = "mips32r6",
-                target_arch = "mips64",
-                target_arch = "mips64r6"
-            ))]
-            let ok = false;
-
-            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 {
-                    GETCPU.store(ptr.cast(), Relaxed);
-                }
-            }
-        }
-
-        // On x86, also look up the vsyscall entry point.
-        #[cfg(target_arch = "x86")]
-        {
-            let ptr = vdso.sym(cstr!("LINUX_2.5"), cstr!("__kernel_vsyscall"));
-            assert!(!ptr.is_null());
-
-            // SAFETY: As above, store the computed function addresses in
-            // static storage.
-            unsafe {
-                SYSCALL.store(ptr.cast(), Relaxed);
-            }
-        }
-    }
-}