Merging upstream version 1.71.1+dfsg1.

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

50 files changed, 0 insertions, 13856 deletions

diff --git a/vendor/rustix-0.36.5/src/backend/libc/conv.rs b/vendor/rustix-0.36.5/src/backend/libc/conv.rs
deleted file mode 100644
index 1e74ea9ba..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/conv.rs
+++ /dev/null
@@ -1,222 +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.
-
-#![allow(dead_code)]
-
-use super::c;
-use super::fd::{AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, LibcFd, OwnedFd, RawFd};
-#[cfg(not(windows))]
-#[cfg(feature = "fs")]
-use super::offset::libc_off_t;
-#[cfg(not(windows))]
-use crate::ffi::CStr;
-use crate::io;
-#[cfg(windows)]
-use core::convert::TryInto;
-
-#[cfg(not(windows))]
-#[inline]
-pub(super) fn c_str(c: &CStr) -> *const c::c_char {
-    c.as_ptr()
-}
-
-#[cfg(not(windows))]
-#[inline]
-pub(super) fn no_fd() -> LibcFd {
-    -1
-}
-
-#[inline]
-pub(super) fn borrowed_fd(fd: BorrowedFd<'_>) -> LibcFd {
-    fd.as_raw_fd() as LibcFd
-}
-
-#[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())
-    }
-}
-
-#[inline]
-pub(super) fn syscall_ret(raw: c::c_long) -> io::Result<()> {
-    if raw == 0 {
-        Ok(())
-    } else {
-        Err(io::Errno::last_os_error())
-    }
-}
-
-#[inline]
-pub(super) fn nonnegative_ret(raw: c::c_int) -> io::Result<()> {
-    if raw >= 0 {
-        Ok(())
-    } else {
-        Err(io::Errno::last_os_error())
-    }
-}
-
-#[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)
-    }
-}
-
-#[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_ssize_t(raw: c::ssize_t) -> io::Result<c::ssize_t> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(raw)
-    }
-}
-
-#[inline]
-pub(super) fn syscall_ret_ssize_t(raw: c::c_long) -> io::Result<c::ssize_t> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(raw as c::ssize_t)
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(super) fn syscall_ret_u32(raw: c::c_long) -> io::Result<u32> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        let r32 = raw as u32;
-
-        // Converting `raw` to `u32` should be lossless.
-        debug_assert_eq!(r32 as c::c_long, raw);
-
-        Ok(r32)
-    }
-}
-
-#[cfg(not(windows))]
-#[cfg(feature = "fs")]
-#[inline]
-pub(super) fn ret_off_t(raw: libc_off_t) -> io::Result<libc_off_t> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(raw)
-    }
-}
-
-#[cfg(not(windows))]
-#[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))
-    }
-}
-
-#[inline]
-pub(super) fn ret_discarded_fd(raw: LibcFd) -> io::Result<()> {
-    if raw == !0 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(())
-    }
-}
-
-#[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 a `c_long` returned from `syscall` to an `OwnedFd`, if valid.
-///
-/// # Safety
-///
-/// The caller must ensure that this is the return value of a `syscall` call
-/// which returns an owned file descriptor.
-#[cfg(not(windows))]
-#[inline]
-pub(super) unsafe fn syscall_ret_owned_fd(raw: c::c_long) -> io::Result<OwnedFd> {
-    if raw == -1 {
-        Err(io::Errno::last_os_error())
-    } else {
-        Ok(OwnedFd::from_raw_fd(raw as RawFd))
-    }
-}
-
-/// Convert the buffer-length argument value of a `send` or `recv` call.
-#[cfg(not(windows))]
-#[inline]
-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(windows))]
-#[inline]
-pub(super) fn ret_send_recv(len: isize) -> io::Result<c::ssize_t> {
-    ret_ssize_t(len)
-}
-
-/// Convert the return value of a `send` or `recv` call.
-#[cfg(windows)]
-#[inline]
-pub(super) fn ret_send_recv(len: i32) -> io::Result<c::ssize_t> {
-    ret_ssize_t(len as isize)
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/fs/dir.rs b/vendor/rustix-0.36.5/src/backend/libc/fs/dir.rs
deleted file mode 100644
index 6b69c3600..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/fs/dir.rs
+++ /dev/null
@@ -1,487 +0,0 @@
-use super::super::c;
-use super::super::conv::owned_fd;
-#[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-use super::types::FileType;
-use crate::fd::{AsFd, BorrowedFd};
-use crate::ffi::CStr;
-#[cfg(target_os = "wasi")]
-use crate::ffi::CString;
-use crate::fs::{fcntl_getfl, fstat, openat, Mode, OFlags, Stat};
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "netbsd",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-use crate::fs::{fstatfs, StatFs};
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-use crate::fs::{fstatvfs, StatVfs};
-use crate::io;
-#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
-use crate::process::fchdir;
-#[cfg(target_os = "wasi")]
-use alloc::borrow::ToOwned;
-#[cfg(not(any(
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "l4re",
-    target_os = "linux",
-    target_os = "openbsd",
-)))]
-use c::dirent as libc_dirent;
-#[cfg(not(any(
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "l4re",
-    target_os = "linux",
-)))]
-use c::readdir as libc_readdir;
-#[cfg(any(
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "l4re",
-    target_os = "linux",
-))]
-use c::{dirent64 as libc_dirent, readdir64 as libc_readdir};
-use core::fmt;
-use core::mem::zeroed;
-use core::ptr::NonNull;
-use libc_errno::{errno, set_errno, Errno};
-
-/// `DIR*`
-#[repr(transparent)]
-pub struct Dir(NonNull<c::DIR>);
-
-impl Dir {
-    /// 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> {
-        // 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 = openat(fd, cstr!("."), flags | OFlags::CLOEXEC, Mode::empty())?;
-
-        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))
-            } else {
-                let err = io::Errno::last_os_error();
-                let _ = c::close(raw);
-                Err(err)
-            }
-        }
-    }
-
-    /// `rewinddir(self)`
-    #[inline]
-    pub fn rewind(&mut self) {
-        unsafe { c::rewinddir(self.0.as_ptr()) }
-    }
-
-    /// `readdir(self)`, where `None` means the end of the directory.
-    pub fn read(&mut self) -> Option<io::Result<DirEntry>> {
-        set_errno(Errno(0));
-        let dirent_ptr = unsafe { libc_readdir(self.0.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.
-                Some(Err(io::Errno(curr_errno)))
-            }
-        } else {
-            // We successfully read an entry.
-            unsafe {
-                // 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_ptr);
-
-                let result = DirEntry {
-                    dirent: read_dirent(&*dirent_ptr.cast()),
-
-                    #[cfg(target_os = "wasi")]
-                    name: CStr::from_ptr((*dirent_ptr).d_name.as_ptr()).to_owned(),
-                };
-
-                Some(Ok(result))
-            }
-        }
-    }
-
-    /// `fstat(self)`
-    #[inline]
-    pub fn stat(&self) -> io::Result<Stat> {
-        fstat(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.0.as_ptr())) })
-    }
-
-    /// `fstatfs(self)`
-    #[cfg(not(any(
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "netbsd",
-        target_os = "redox",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    #[inline]
-    pub fn statfs(&self) -> io::Result<StatFs> {
-        fstatfs(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.0.as_ptr())) })
-    }
-
-    /// `fstatvfs(self)`
-    #[cfg(not(any(
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "redox",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    #[inline]
-    pub fn statvfs(&self) -> io::Result<StatVfs> {
-        fstatvfs(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.0.as_ptr())) })
-    }
-
-    /// `fchdir(self)`
-    #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
-    #[inline]
-    pub fn chdir(&self) -> io::Result<()> {
-        fchdir(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.0.as_ptr())) })
-    }
-}
-
-// A `dirent` pointer returned from `readdir` may not point to a full `dirent`
-// struct, as the name is NUL-terminated and memory may not be allocated for
-// the full extent of the struct. Copy the fields one at a time.
-unsafe fn read_dirent(input: &libc_dirent) -> libc_dirent {
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "solaris"
-    )))]
-    let d_type = input.d_type;
-
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "wasi",
-    )))]
-    let d_off = input.d_off;
-
-    #[cfg(target_os = "aix")]
-    let d_offset = input.d_offset;
-
-    #[cfg(not(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    )))]
-    let d_ino = input.d_ino;
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd"
-    ))]
-    let d_fileno = input.d_fileno;
-
-    #[cfg(not(any(target_os = "dragonfly", target_os = "wasi")))]
-    let d_reclen = input.d_reclen;
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "ios",
-        target_os = "macos",
-    ))]
-    let d_namlen = input.d_namlen;
-
-    #[cfg(any(target_os = "ios", target_os = "macos"))]
-    let d_seekoff = input.d_seekoff;
-
-    #[cfg(target_os = "haiku")]
-    let d_dev = input.d_dev;
-    #[cfg(target_os = "haiku")]
-    let d_pdev = input.d_pdev;
-    #[cfg(target_os = "haiku")]
-    let d_pino = input.d_pino;
-
-    // Construct the input. Rust will give us an error if any OS has a input
-    // with a field that we missed here. And we can avoid blindly copying the
-    // whole `d_name` field, which may not be entirely allocated.
-    #[cfg_attr(target_os = "wasi", allow(unused_mut))]
-    #[cfg(not(any(target_os = "freebsd", target_os = "dragonfly")))]
-    let mut dirent = libc_dirent {
-        #[cfg(not(any(
-            target_os = "aix",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "solaris"
-        )))]
-        d_type,
-        #[cfg(not(any(
-            target_os = "aix",
-            target_os = "freebsd",  // Until FreeBSD 12
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "wasi",
-        )))]
-        d_off,
-        #[cfg(target_os = "aix")]
-        d_offset,
-        #[cfg(not(any(target_os = "freebsd", target_os = "netbsd", target_os = "openbsd")))]
-        d_ino,
-        #[cfg(any(target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
-        d_fileno,
-        #[cfg(not(target_os = "wasi"))]
-        d_reclen,
-        #[cfg(any(
-            target_os = "aix",
-            target_os = "freebsd",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        d_namlen,
-        #[cfg(any(target_os = "ios", target_os = "macos"))]
-        d_seekoff,
-        // The `d_name` field is NUL-terminated, and we need to be careful not
-        // to read bytes past the NUL, even though they're within the nominal
-        // extent of the `struct dirent`, because they may not be allocated. So
-        // don't read it from `dirent_ptr`.
-        //
-        // In theory this could use `MaybeUninit::uninit().assume_init()`, but
-        // that [invokes undefined behavior].
-        //
-        // [invokes undefined behavior]: https://doc.rust-lang.org/stable/core/mem/union.MaybeUninit.html#initialization-invariant
-        d_name: zeroed(),
-        #[cfg(target_os = "openbsd")]
-        __d_padding: zeroed(),
-        #[cfg(target_os = "haiku")]
-        d_dev,
-        #[cfg(target_os = "haiku")]
-        d_pdev,
-        #[cfg(target_os = "haiku")]
-        d_pino,
-    };
-    /*
-    pub d_ino: ino_t,
-    pub d_pino: i64,
-    pub d_reclen: ::c_ushort,
-    pub d_name: [::c_char; 1024], // Max length is _POSIX_PATH_MAX
-                                  // */
-
-    // On dragonfly and FreeBSD 12, `dirent` has some non-public padding fields
-    // so we can't directly initialize it.
-    #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
-    let mut dirent = {
-        let mut dirent: libc_dirent = zeroed();
-        dirent.d_fileno = d_fileno;
-        dirent.d_namlen = d_namlen;
-        dirent.d_type = d_type;
-        #[cfg(target_os = "freebsd")]
-        {
-            dirent.d_reclen = d_reclen;
-        }
-        dirent
-    };
-
-    // Copy from d_name, reading up to and including the first NUL.
-    #[cfg(not(target_os = "wasi"))]
-    {
-        let name_len = CStr::from_ptr(input.d_name.as_ptr())
-            .to_bytes_with_nul()
-            .len();
-        dirent.d_name[..name_len].copy_from_slice(&input.d_name[..name_len]);
-    }
-
-    dirent
-}
-
-/// `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.0.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 {
-        f.debug_struct("Dir")
-            .field("fd", unsafe { &c::dirfd(self.0.as_ptr()) })
-            .finish()
-    }
-}
-
-/// `struct dirent`
-#[derive(Debug)]
-pub struct DirEntry {
-    dirent: libc_dirent,
-
-    #[cfg(target_os = "wasi")]
-    name: CString,
-}
-
-impl DirEntry {
-    /// Returns the file name of this directory entry.
-    #[inline]
-    pub fn file_name(&self) -> &CStr {
-        #[cfg(not(target_os = "wasi"))]
-        unsafe {
-            CStr::from_ptr(self.dirent.d_name.as_ptr())
-        }
-
-        #[cfg(target_os = "wasi")]
-        &self.name
-    }
-
-    /// Returns the type of this directory entry.
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "solaris"
-    )))]
-    #[inline]
-    pub fn file_type(&self) -> FileType {
-        FileType::from_dirent_d_type(self.dirent.d_type)
-    }
-
-    /// Return the inode number of this directory entry.
-    #[cfg(not(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    )))]
-    #[inline]
-    pub fn ino(&self) -> u64 {
-        self.dirent.d_ino as u64
-    }
-
-    /// Return the inode number of this directory entry.
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    #[inline]
-    pub fn ino(&self) -> u64 {
-        #[allow(clippy::useless_conversion)]
-        self.dirent.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;
-    use core::mem::{align_of, size_of};
-
-    // Check that the basic layouts match.
-    assert_eq!(size_of::<libc_dirent>(), size_of::<c::dirent>());
-    assert_eq!(align_of::<libc_dirent>(), align_of::<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,
-            )
-        }
-    );
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/fs/makedev.rs b/vendor/rustix-0.36.5/src/backend/libc/fs/makedev.rs
deleted file mode 100644
index 08ecd872e..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/fs/makedev.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-#[cfg(not(all(target_os = "android", target_pointer_width = "32")))]
-use super::super::c;
-use crate::fs::Dev;
-
-#[cfg(not(any(target_os = "android", target_os = "emscripten")))]
-#[inline]
-pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
-    c::makedev(maj, min)
-}
-
-#[cfg(all(target_os = "android", not(target_pointer_width = "32")))]
-#[inline]
-pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
-    // Android's `makedev` oddly has signed argument types.
-    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(not(any(target_os = "android", target_os = "emscripten")))]
-#[inline]
-pub(crate) fn major(dev: Dev) -> u32 {
-    unsafe { c::major(dev) }
-}
-
-#[cfg(all(target_os = "android", not(target_pointer_width = "32")))]
-#[inline]
-pub(crate) fn major(dev: Dev) -> u32 {
-    // Android's `major` oddly has signed return types.
-    (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(target_os = "android", target_os = "emscripten")))]
-#[inline]
-pub(crate) fn minor(dev: Dev) -> u32 {
-    unsafe { c::minor(dev) }
-}
-
-#[cfg(all(target_os = "android", not(target_pointer_width = "32")))]
-#[inline]
-pub(crate) fn minor(dev: Dev) -> u32 {
-    // Android's `minor` oddly has signed return types.
-    (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-0.36.5/src/backend/libc/fs/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/fs/mod.rs
deleted file mode 100644
index d0fc08765..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/fs/mod.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#[cfg(not(target_os = "redox"))]
-pub(crate) mod dir;
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-pub(crate) mod makedev;
-#[cfg(not(windows))]
-pub(crate) mod syscalls;
-pub(crate) mod types;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/fs/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/fs/syscalls.rs
deleted file mode 100644
index 1d1891f0f..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/fs/syscalls.rs
+++ /dev/null
@@ -1,1772 +0,0 @@
-//! libc syscalls supporting `rustix::fs`.
-
-use super::super::c;
-use super::super::conv::{
-    borrowed_fd, c_str, ret, ret_c_int, ret_off_t, ret_owned_fd, ret_ssize_t,
-};
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::{syscall_ret, syscall_ret_owned_fd, syscall_ret_ssize_t};
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-use super::super::offset::libc_fallocate;
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-use super::super::offset::libc_posix_fadvise;
-#[cfg(not(any(
-    target_os = "aix",
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "linux",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-use super::super::offset::libc_posix_fallocate;
-use super::super::offset::{libc_fstat, libc_fstatat, libc_ftruncate, libc_lseek, libc_off_t};
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "netbsd",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-use super::super::offset::{libc_fstatfs, libc_statfs};
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-use super::super::offset::{libc_fstatvfs, libc_statvfs};
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-use super::super::time::types::LibcTimespec;
-use crate::fd::{BorrowedFd, OwnedFd};
-use crate::ffi::CStr;
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-use crate::ffi::CString;
-#[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
-use crate::fs::Access;
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-use crate::fs::Advice;
-#[cfg(not(any(
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "illumos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-use crate::fs::FallocateFlags;
-#[cfg(not(any(target_os = "solaris", target_os = "wasi")))]
-use crate::fs::FlockOperation;
-#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
-use crate::fs::MemfdFlags;
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-use crate::fs::SealFlags;
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "netbsd",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-use crate::fs::StatFs;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::fs::{cwd, RenameFlags, ResolveFlags, Statx, StatxFlags};
-#[cfg(not(any(
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-use crate::fs::{Dev, FileType};
-use crate::fs::{Mode, OFlags, Stat, Timestamps};
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-use crate::fs::{StatVfs, StatVfsMountFlags};
-use crate::io::{self, SeekFrom};
-#[cfg(not(target_os = "wasi"))]
-use crate::process::{Gid, Uid};
-#[cfg(not(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-)))]
-use crate::utils::as_ptr;
-use core::convert::TryInto;
-#[cfg(any(
-    target_os = "android",
-    target_os = "ios",
-    target_os = "linux",
-    target_os = "macos",
-))]
-use core::mem::size_of;
-use core::mem::MaybeUninit;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use core::ptr::null;
-#[cfg(any(
-    target_os = "android",
-    target_os = "ios",
-    target_os = "linux",
-    target_os = "macos",
-))]
-use core::ptr::null_mut;
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-use {
-    super::super::conv::nonnegative_ret,
-    crate::fs::{copyfile_state_t, CloneFlags, CopyfileFlags},
-};
-#[cfg(not(target_os = "redox"))]
-use {super::super::offset::libc_openat, crate::fs::AtFlags};
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-weak!(fn __utimensat64(c::c_int, *const c::c_char, *const LibcTimespec, c::c_int) -> c::c_int);
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-weak!(fn __futimens64(c::c_int, *const LibcTimespec) -> c::c_int);
-
-/// 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"))]
-fn openat_via_syscall(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    oflags: OFlags,
-    mode: Mode,
-) -> io::Result<OwnedFd> {
-    unsafe {
-        let dirfd = borrowed_fd(dirfd);
-        let path = c_str(path);
-        let oflags = oflags.bits();
-        let mode = c::c_uint::from(mode.bits());
-        ret_owned_fd(c::syscall(
-            c::SYS_openat,
-            c::c_long::from(dirfd),
-            path,
-            c::c_long::from(oflags),
-            mode as c::c_long,
-        ) as c::c_int)
-    }
-}
-
-#[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>.
-    // Basically old glibc versions don't handle O_TMPFILE correctly.
-    #[cfg(all(unix, target_env = "gnu"))]
-    if oflags.contains(OFlags::TMPFILE) && crate::backend::if_glibc_is_less_than_2_25() {
-        return openat_via_syscall(dirfd, path, oflags, mode);
-    }
-    unsafe {
-        // Pass `mode` as a `c_uint` even if `mode_t` is narrower, since
-        // `libc_openat` is declared as a variadic function and narrower
-        // arguments are promoted.
-        ret_owned_fd(libc_openat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            oflags.bits(),
-            c::c_uint::from(mode.bits()),
-        ))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "netbsd",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-#[inline]
-pub(crate) fn statfs(filename: &CStr) -> io::Result<StatFs> {
-    unsafe {
-        let mut result = MaybeUninit::<StatFs>::uninit();
-        ret(libc_statfs(c_str(filename), result.as_mut_ptr()))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-#[inline]
-pub(crate) fn statvfs(filename: &CStr) -> io::Result<StatVfs> {
-    unsafe {
-        let mut result = MaybeUninit::<libc_statvfs>::uninit();
-        ret(libc_statvfs(c_str(filename), result.as_mut_ptr()))?;
-        Ok(libc_statvfs_to_statvfs(result.assume_init()))
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-#[inline]
-pub(crate) fn readlinkat(dirfd: BorrowedFd<'_>, path: &CStr, buf: &mut [u8]) -> io::Result<usize> {
-    unsafe {
-        ret_ssize_t(c::readlinkat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            buf.as_mut_ptr().cast::<c::c_char>(),
-            buf.len(),
-        ))
-        .map(|nread| nread as usize)
-    }
-}
-
-#[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(not(target_os = "redox"))]
-pub(crate) fn linkat(
-    old_dirfd: BorrowedFd<'_>,
-    old_path: &CStr,
-    new_dirfd: BorrowedFd<'_>,
-    new_path: &CStr,
-    flags: AtFlags,
-) -> io::Result<()> {
-    unsafe {
-        ret(c::linkat(
-            borrowed_fd(old_dirfd),
-            c_str(old_path),
-            borrowed_fd(new_dirfd),
-            c_str(new_path),
-            flags.bits(),
-        ))
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-pub(crate) fn unlinkat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<()> {
-    unsafe { ret(c::unlinkat(borrowed_fd(dirfd), c_str(path), flags.bits())) }
-}
-
-#[cfg(not(target_os = "redox"))]
-pub(crate) fn renameat(
-    old_dirfd: BorrowedFd<'_>,
-    old_path: &CStr,
-    new_dirfd: BorrowedFd<'_>,
-    new_path: &CStr,
-) -> io::Result<()> {
-    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<()> {
-    // `getrandom` 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(),
-        ))
-    }
-}
-
-/// At present, `libc` only has `renameat2` defined for glibc. On other
-/// ABIs, `RenameFlags` has no flags defined, and we use plain `renameat`.
-#[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<()> {
-    assert!(flags.is_empty());
-    renameat(old_dirfd, old_path, new_dirfd, 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),
-        ))
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-pub(crate) fn statat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> {
-    // 32-bit and mips64 Linux: `struct stat64` is not y2038 compatible; use
-    // `statx`.
-    #[cfg(all(
-        any(target_os = "android", target_os = "linux"),
-        any(target_pointer_width = "32", target_arch = "mips64"),
-    ))]
-    {
-        match 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(
-        any(target_os = "android", target_os = "linux"),
-        any(target_pointer_width = "32", target_arch = "mips64"),
-    )))]
-    unsafe {
-        let mut stat = MaybeUninit::<Stat>::uninit();
-        ret(libc_fstatat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            stat.as_mut_ptr(),
-            flags.bits(),
-        ))?;
-        Ok(stat.assume_init())
-    }
-}
-
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    any(target_pointer_width = "32", target_arch = "mips64"),
-))]
-fn statat_old(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> {
-    unsafe {
-        let mut result = MaybeUninit::<c::stat64>::uninit();
-        ret(libc_fstatat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            result.as_mut_ptr(),
-            flags.bits(),
-        ))?;
-        stat64_to_stat(result.assume_init())
-    }
-}
-
-#[cfg(not(any(
-    target_os = "emscripten",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub(crate) fn accessat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    access: Access,
-    flags: AtFlags,
-) -> io::Result<()> {
-    unsafe {
-        ret(c::faccessat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            access.bits(),
-            flags.bits(),
-        ))
-    }
-}
-
-#[cfg(target_os = "emscripten")]
-pub(crate) fn accessat(
-    _dirfd: BorrowedFd<'_>,
-    _path: &CStr,
-    _access: Access,
-    _flags: AtFlags,
-) -> io::Result<()> {
-    Ok(())
-}
-
-#[cfg(not(target_os = "redox"))]
-pub(crate) fn utimensat(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    times: &Timestamps,
-    flags: AtFlags,
-) -> io::Result<()> {
-    // 32-bit gnu version: libc has `utimensat` but it is not y2038 safe by
-    // default.
-    #[cfg(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    ))]
-    unsafe {
-        if let Some(libc_utimensat) = __utimensat64.get() {
-            let libc_times: [LibcTimespec; 2] = [
-                times.last_access.clone().into(),
-                times.last_modification.clone().into(),
-            ];
-
-            ret(libc_utimensat(
-                borrowed_fd(dirfd),
-                c_str(path),
-                libc_times.as_ptr(),
-                flags.bits(),
-            ))
-        } else {
-            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(
-        target_os = "ios",
-        target_os = "macos",
-        all(
-            any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-            target_env = "gnu",
-        )
-    )))]
-    unsafe {
-        // Assert that `Timestamps` has the expected layout.
-        let _ = core::mem::transmute::<Timestamps, [c::timespec; 2]>(times.clone());
-
-        ret(c::utimensat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            as_ptr(times).cast(),
-            flags.bits(),
-        ))
-    }
-
-    // `utimensat` was introduced in macOS 10.13.
-    #[cfg(any(target_os = "ios", target_os = "macos"))]
-    unsafe {
-        // 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() {
-            // Assert that `Timestamps` has the expected layout.
-            let _ = core::mem::transmute::<Timestamps, [c::timespec; 2]>(times.clone());
-
-            return ret(have_utimensat(
-                borrowed_fd(dirfd),
-                c_str(path),
-                as_ptr(times).cast(),
-                flags.bits(),
-            ));
-        }
-
-        // `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(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-unsafe 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,
-        },
-        c::timespec {
-            tv_sec: times
-                .last_modification
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: times.last_modification.tv_nsec,
-        },
-    ];
-    ret(c::utimensat(
-        borrowed_fd(dirfd),
-        c_str(path),
-        old_times.as_ptr(),
-        flags.bits(),
-    ))
-}
-
-#[cfg(not(any(
-    target_os = "android",
-    target_os = "linux",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-pub(crate) fn chmodat(dirfd: BorrowedFd<'_>, path: &CStr, mode: Mode) -> io::Result<()> {
-    unsafe { ret(c::fchmodat(borrowed_fd(dirfd), c_str(path), mode.bits(), 0)) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn chmodat(dirfd: BorrowedFd<'_>, path: &CStr, mode: Mode) -> io::Result<()> {
-    // Linux's `fchmodat` does not have a flags argument.
-    unsafe {
-        // Pass `mode` as a `c_uint` even if `mode_t` is narrower, since
-        // `libc_openat` is declared as a variadic function and narrower
-        // arguments are promoted.
-        syscall_ret(c::syscall(
-            c::SYS_fchmodat,
-            borrowed_fd(dirfd),
-            c_str(path),
-            c::c_uint::from(mode.bits()),
-        ))
-    }
-}
-
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-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), flags.bits())) }
-}
-
-#[cfg(not(any(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::process::translate_fchown_args(owner, group);
-        ret(c::fchownat(
-            borrowed_fd(dirfd),
-            c_str(path),
-            ow,
-            gr,
-            flags.bits(),
-        ))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox",
-    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(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn copy_file_range(
-    fd_in: BorrowedFd<'_>,
-    off_in: Option<&mut u64>,
-    fd_out: BorrowedFd<'_>,
-    off_out: Option<&mut u64>,
-    len: u64,
-) -> io::Result<u64> {
-    assert_eq!(size_of::<c::loff_t>(), size_of::<u64>());
-
-    let mut off_in_val: c::loff_t = 0;
-    let mut off_out_val: c::loff_t = 0;
-    // Silently cast; we'll get `EINVAL` if the value is negative.
-    let off_in_ptr = if let Some(off_in) = &off_in {
-        off_in_val = (**off_in) as i64;
-        &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 len: usize = len.try_into().unwrap_or(usize::MAX);
-    let copied = unsafe {
-        syscall_ret_ssize_t(c::syscall(
-            c::SYS_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 as u64)
-}
-
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-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 { libc_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> {
-    unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETFL)).map(OFlags::from_bits_truncate) }
-}
-
-pub(crate) fn fcntl_setfl(fd: BorrowedFd<'_>, flags: OFlags) -> io::Result<()> {
-    unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_SETFL, flags.bits())) }
-}
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-pub(crate) fn fcntl_get_seals(fd: BorrowedFd<'_>) -> io::Result<SealFlags> {
-    unsafe {
-        ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GET_SEALS))
-            .map(|flags| SealFlags::from_bits_unchecked(flags))
-    }
-}
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-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())) }
-}
-
-pub(crate) fn seek(fd: BorrowedFd<'_>, pos: SeekFrom) -> io::Result<u64> {
-    let (whence, offset): (c::c_int, libc_off_t) = 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),
-    };
-    let offset = unsafe { ret_off_t(libc_lseek(borrowed_fd(fd), offset, whence))? };
-    Ok(offset as u64)
-}
-
-pub(crate) fn tell(fd: BorrowedFd<'_>) -> io::Result<u64> {
-    let offset = unsafe { ret_off_t(libc_lseek(borrowed_fd(fd), 0, c::SEEK_CUR))? };
-    Ok(offset as u64)
-}
-
-#[cfg(not(any(target_os = "android", target_os = "linux", target_os = "wasi")))]
-pub(crate) fn fchmod(fd: BorrowedFd<'_>, mode: Mode) -> io::Result<()> {
-    unsafe { ret(c::fchmod(borrowed_fd(fd), mode.bits())) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn fchmod(fd: BorrowedFd<'_>, mode: Mode) -> io::Result<()> {
-    // Use `c::syscall` rather than `c::fchmod` because some libc
-    // implementations, such as musl, add extra logic to `fchmod` to emulate
-    // support for `O_PATH`, which uses `/proc` outside our control and
-    // interferes with our own use of `O_PATH`.
-    unsafe {
-        syscall_ret(c::syscall(
-            c::SYS_fchmod,
-            borrowed_fd(fd),
-            c::c_uint::from(mode.bits()),
-        ))
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-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`.
-    unsafe {
-        let (ow, gr) = crate::process::translate_fchown_args(owner, group);
-        syscall_ret(c::syscall(c::SYS_fchown, borrowed_fd(fd), ow, gr))
-    }
-}
-
-#[cfg(not(any(target_os = "android", target_os = "linux", target_os = "wasi")))]
-pub(crate) fn fchown(fd: BorrowedFd<'_>, owner: Option<Uid>, group: Option<Gid>) -> io::Result<()> {
-    unsafe {
-        let (ow, gr) = crate::process::translate_fchown_args(owner, group);
-        ret(c::fchown(borrowed_fd(fd), ow, gr))
-    }
-}
-
-#[cfg(not(any(target_os = "solaris", 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)) }
-}
-
-pub(crate) fn fstat(fd: BorrowedFd<'_>) -> io::Result<Stat> {
-    // 32-bit and mips64 Linux: `struct stat64` is not y2038 compatible; use
-    // `statx`.
-    #[cfg(all(
-        any(target_os = "android", target_os = "linux"),
-        any(target_pointer_width = "32", target_arch = "mips64"),
-    ))]
-    {
-        match 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(
-        any(target_os = "android", target_os = "linux"),
-        any(target_pointer_width = "32", target_arch = "mips64"),
-    )))]
-    unsafe {
-        let mut stat = MaybeUninit::<Stat>::uninit();
-        ret(libc_fstat(borrowed_fd(fd), stat.as_mut_ptr()))?;
-        Ok(stat.assume_init())
-    }
-}
-
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    any(target_pointer_width = "32", target_arch = "mips64"),
-))]
-fn fstat_old(fd: BorrowedFd<'_>) -> io::Result<Stat> {
-    unsafe {
-        let mut result = MaybeUninit::<c::stat64>::uninit();
-        ret(libc_fstat(borrowed_fd(fd), result.as_mut_ptr()))?;
-        stat64_to_stat(result.assume_init())
-    }
-}
-
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "netbsd",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-pub(crate) fn fstatfs(fd: BorrowedFd<'_>) -> io::Result<StatFs> {
-    let mut statfs = MaybeUninit::<StatFs>::uninit();
-    unsafe {
-        ret(libc_fstatfs(borrowed_fd(fd), statfs.as_mut_ptr()))?;
-        Ok(statfs.assume_init())
-    }
-}
-
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-pub(crate) fn fstatvfs(fd: BorrowedFd<'_>) -> io::Result<StatVfs> {
-    let mut statvfs = MaybeUninit::<libc_statvfs>::uninit();
-    unsafe {
-        ret(libc_fstatvfs(borrowed_fd(fd), statvfs.as_mut_ptr()))?;
-        Ok(libc_statvfs_to_statvfs(statvfs.assume_init()))
-    }
-}
-
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi"
-)))]
-fn libc_statvfs_to_statvfs(from: libc_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,
-        f_fsid: from.f_fsid as u64,
-        f_flag: unsafe { StatVfsMountFlags::from_bits_unchecked(from.f_flag as u64) },
-        f_namemax: from.f_namemax as u64,
-    }
-}
-
-pub(crate) fn futimens(fd: BorrowedFd<'_>, times: &Timestamps) -> io::Result<()> {
-    // 32-bit gnu version: libc has `futimens` but it is not y2038 safe by default.
-    #[cfg(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    ))]
-    unsafe {
-        if let Some(libc_futimens) = __futimens64.get() {
-            let libc_times: [LibcTimespec; 2] = [
-                times.last_access.clone().into(),
-                times.last_modification.clone().into(),
-            ];
-
-            ret(libc_futimens(borrowed_fd(fd), libc_times.as_ptr()))
-        } else {
-            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(
-        target_os = "ios",
-        target_os = "macos",
-        all(
-            any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-            target_env = "gnu",
-        )
-    )))]
-    unsafe {
-        // Assert that `Timestamps` has the expected layout.
-        let _ = core::mem::transmute::<Timestamps, [c::timespec; 2]>(times.clone());
-
-        ret(c::futimens(borrowed_fd(fd), as_ptr(times).cast()))
-    }
-
-    // `futimens` was introduced in macOS 10.13.
-    #[cfg(any(target_os = "ios", target_os = "macos"))]
-    unsafe {
-        // 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() {
-            // Assert that `Timestamps` has the expected layout.
-            let _ = core::mem::transmute::<Timestamps, [c::timespec; 2]>(times.clone());
-
-            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(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-unsafe 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,
-        },
-        c::timespec {
-            tv_sec: times
-                .last_modification
-                .tv_sec
-                .try_into()
-                .map_err(|_| io::Errno::OVERFLOW)?,
-            tv_nsec: times.last_modification.tv_nsec,
-        },
-    ];
-
-    ret(c::futimens(borrowed_fd(fd), old_times.as_ptr()))
-}
-
-#[cfg(not(any(
-    target_os = "aix",
-    target_os = "dragonfly",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-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(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    unsafe {
-        ret(libc_fallocate(borrowed_fd(fd), mode.bits(), offset, len))
-    }
-
-    #[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))]
-    {
-        assert!(mode.is_empty());
-        let err = unsafe { libc_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(any(target_os = "ios", target_os = "macos"))]
-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 {
-            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(
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox",
-)))]
-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(libc_ftruncate(borrowed_fd(fd), length)) }
-}
-
-#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
-pub(crate) fn memfd_create(path: &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(any(target_os = "android", target_os = "linux"))]
-    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(path), flags.bits())) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn openat2(
-    dirfd: BorrowedFd<'_>,
-    path: &CStr,
-    oflags: OFlags,
-    mode: Mode,
-    resolve: ResolveFlags,
-) -> io::Result<OwnedFd> {
-    let oflags: i32 = oflags.bits();
-    let open_how = OpenHow {
-        oflag: u64::from(oflags as u32),
-        mode: u64::from(mode.bits()),
-        resolve: resolve.bits(),
-    };
-
-    unsafe {
-        syscall_ret_owned_fd(c::syscall(
-            SYS_OPENAT2,
-            borrowed_fd(dirfd),
-            c_str(path),
-            &open_how,
-            SIZEOF_OPEN_HOW,
-        ))
-    }
-}
-#[cfg(all(
-    target_pointer_width = "32",
-    any(target_os = "android", target_os = "linux"),
-))]
-const SYS_OPENAT2: i32 = 437;
-#[cfg(all(
-    target_pointer_width = "64",
-    any(target_os = "android", target_os = "linux"),
-))]
-const SYS_OPENAT2: i64 = 437;
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[repr(C)]
-#[derive(Debug)]
-struct OpenHow {
-    oflag: u64,
-    mode: u64,
-    resolve: u64,
-}
-#[cfg(any(target_os = "android", target_os = "linux"))]
-const SIZEOF_OPEN_HOW: usize = size_of::<OpenHow>();
-
-#[cfg(target_os = "linux")]
-pub(crate) fn sendfile(
-    out_fd: BorrowedFd<'_>,
-    in_fd: BorrowedFd<'_>,
-    offset: Option<&mut u64>,
-    count: usize,
-) -> io::Result<usize> {
-    unsafe {
-        let nsent = ret_ssize_t(c::sendfile64(
-            borrowed_fd(out_fd),
-            borrowed_fd(in_fd),
-            offset.map_or(null_mut(), crate::utils::as_mut_ptr).cast(),
-            count,
-        ))?;
-        Ok(nsent as usize)
-    }
-}
-
-/// Convert from a Linux `statx` value to rustix's `Stat`.
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    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(
-    any(target_os = "android", target_os = "linux"),
-    target_arch = "mips64",
-))]
-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(
-    any(target_os = "android", target_os = "linux"),
-    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(
-    any(target_os = "android", target_os = "linux"),
-    target_arch = "mips64",
-))]
-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(any(target_os = "android", target_os = "linux"))]
-#[allow(non_upper_case_globals)]
-mod sys {
-    use super::{c, BorrowedFd, Statx};
-
-    #[cfg(all(target_os = "android", target_arch = "arm"))]
-    const SYS_statx: c::c_long = 397;
-    #[cfg(all(target_os = "android", target_arch = "x86"))]
-    const SYS_statx: c::c_long = 383;
-    #[cfg(all(target_os = "android", target_arch = "aarch64"))]
-    const SYS_statx: c::c_long = 291;
-    #[cfg(all(target_os = "android", target_arch = "x86_64"))]
-    const SYS_statx: c::c_long = 332;
-
-    weak_or_syscall! {
-        pub(super) fn statx(
-            pirfd: BorrowedFd<'_>,
-            path: *const c::c_char,
-            flags: c::c_int,
-            mask: c::c_uint,
-            buf: *mut Statx
-        ) via SYS_statx -> c::c_int
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[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 = libc::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),
-            flags.bits(),
-            mask.bits(),
-            statx_buf.as_mut_ptr(),
-        ))?;
-        Ok(statx_buf.assume_init())
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[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(any(target_os = "ios", target_os = "macos"))]
-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,
-        flags.bits(),
-    ))
-}
-
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-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(any(target_os = "ios", target_os = "macos"))]
-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(any(target_os = "ios", target_os = "macos"))]
-const COPYFILE_STATE_COPIED: u32 = 8;
-
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-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(any(target_os = "ios", target_os = "macos"))]
-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(any(target_os = "ios", target_os = "macos"))]
-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 = alloc::vec![0; c::PATH_MAX as usize];
-
-    // From the [macOS `fcntl` man page]:
-    // `F_GETPATH` - Get the path of the file descriptor `Fildes`. The argument
-    //               must be a buffer of size `MAXPATHLEN` or greater.
-    //
-    // [macOS `fcntl` man 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);
-
-    // TODO: On Rust 1.56, we can use `shrink_to` here.
-    //buf.shrink_to(l + 1);
-    buf.shrink_to_fit();
-
-    Ok(CString::new(buf).unwrap())
-}
-
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-pub(crate) fn fcntl_rdadvise(fd: BorrowedFd<'_>, offset: u64, len: u64) -> io::Result<()> {
-    // From the [macOS `fcntl` man 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` man 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(any(target_os = "ios", target_os = "macos"))]
-pub(crate) fn fcntl_fullfsync(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_FULLFSYNC)) }
-}
-
-/// Convert `times` from a `futimens`/`utimensat` argument into `setattrlist`
-/// arguments.
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-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(any(target_os = "ios", target_os = "macos"))]
-type Attrgroup = u32;
-
-/// Attribute list for use with `setattrlist`.
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-#[repr(C)]
-struct Attrlist {
-    bitmapcount: u16,
-    reserved: u16,
-    commonattr: Attrgroup,
-    volattr: Attrgroup,
-    dirattr: Attrgroup,
-    fileattr: Attrgroup,
-    forkattr: Attrgroup,
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/fs/types.rs b/vendor/rustix-0.36.5/src/backend/libc/fs/types.rs
deleted file mode 100644
index 8d8ec08bf..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/fs/types.rs
+++ /dev/null
@@ -1,1116 +0,0 @@
-use super::super::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `*_OK` constants for use with [`accessat`].
-    ///
-    /// [`accessat`]: fn.accessat.html
-    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;
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-bitflags! {
-    /// `AT_*` constants for use with [`openat`], [`statat`], and other `*at`
-    /// functions.
-    ///
-    /// [`openat`]: crate::fs::openat
-    /// [`statat`]: crate::fs::statat
-    pub struct AtFlags: c::c_int {
-        /// `AT_REMOVEDIR`
-        const REMOVEDIR = c::AT_REMOVEDIR;
-
-        /// `AT_SYMLINK_FOLLOW`
-        const SYMLINK_FOLLOW = c::AT_SYMLINK_FOLLOW;
-
-        /// `AT_SYMLINK_NOFOLLOW`
-        const SYMLINK_NOFOLLOW = c::AT_SYMLINK_NOFOLLOW;
-
-        /// `AT_EMPTY_PATH`
-        #[cfg(any(
-            target_os = "android",
-            target_os = "fuchsia",
-            target_os = "linux",
-        ))]
-        const EMPTY_PATH = c::AT_EMPTY_PATH;
-
-        /// `AT_EACCESS`
-        #[cfg(not(any(target_os = "emscripten", target_os = "android")))]
-        const EACCESS = c::AT_EACCESS;
-
-        /// `AT_STATX_SYNC_AS_STAT`
-        #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const STATX_SYNC_AS_STAT = c::AT_STATX_SYNC_AS_STAT;
-
-        /// `AT_STATX_FORCE_SYNC`
-        #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const STATX_FORCE_SYNC = c::AT_STATX_FORCE_SYNC;
-
-        /// `AT_STATX_DONT_SYNC`
-        #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const STATX_DONT_SYNC = c::AT_STATX_DONT_SYNC;
-    }
-}
-
-bitflags! {
-    /// `S_I*` constants for use with [`openat`], [`chmodat`], and [`fchmod`].
-    ///
-    /// [`openat`]: crate::fs::openat
-    /// [`chmodat`]: crate::fs::chmodat
-    /// [`fchmod`]: crate::fs::fchmod
-    pub struct Mode: RawMode {
-        /// `S_IRWXU`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const RWXU = c::S_IRWXU as RawMode;
-
-        /// `S_IRUSR`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const RUSR = c::S_IRUSR as RawMode;
-
-        /// `S_IWUSR`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const WUSR = c::S_IWUSR as RawMode;
-
-        /// `S_IXUSR`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const XUSR = c::S_IXUSR as RawMode;
-
-        /// `S_IRWXG`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const RWXG = c::S_IRWXG as RawMode;
-
-        /// `S_IRGRP`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const RGRP = c::S_IRGRP as RawMode;
-
-        /// `S_IWGRP`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const WGRP = c::S_IWGRP as RawMode;
-
-        /// `S_IXGRP`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const XGRP = c::S_IXGRP as RawMode;
-
-        /// `S_IRWXO`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const RWXO = c::S_IRWXO as RawMode;
-
-        /// `S_IROTH`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const ROTH = c::S_IROTH as RawMode;
-
-        /// `S_IWOTH`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const WOTH = c::S_IWOTH as RawMode;
-
-        /// `S_IXOTH`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const XOTH = c::S_IXOTH as RawMode;
-
-        /// `S_ISUID`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const SUID = c::S_ISUID as RawMode;
-
-        /// `S_ISGID`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const SGID = c::S_ISGID as RawMode;
-
-        /// `S_ISVTX`
-        #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags.
-        const SVTX = c::S_ISVTX as RawMode;
-    }
-}
-
-impl Mode {
-    /// Construct a `Mode` from the mode bits of the `st_mode` field of
-    /// a `Stat`.
-    #[inline]
-    pub const fn from_raw_mode(st_mode: RawMode) -> Self {
-        Self::from_bits_truncate(st_mode)
-    }
-
-    /// Construct an `st_mode` value from `Stat`.
-    #[inline]
-    pub const fn as_raw_mode(self) -> RawMode {
-        self.bits()
-    }
-}
-
-bitflags! {
-    /// `O_*` constants for use with [`openat`].
-    ///
-    /// [`openat`]: crate::fs::openat
-    pub struct OFlags: c::c_int {
-        /// `O_ACCMODE`
-        const ACCMODE = c::O_ACCMODE;
-
-        /// Similar to `ACCMODE`, but just includes the read/write flags, and
-        /// no other flags.
-        ///
-        /// Some implementations include `O_PATH` in `O_ACCMODE`, when
-        /// sometimes we really just want the read/write bits. Caution is
-        /// indicated, as the presence of `O_PATH` may mean that the read/write
-        /// bits don't have their usual meaning.
-        const RWMODE = c::O_RDONLY | c::O_WRONLY | c::O_RDWR;
-
-        /// `O_APPEND`
-        const APPEND = c::O_APPEND;
-
-        /// `O_CREAT`
-        #[doc(alias = "CREAT")]
-        const CREATE = c::O_CREAT;
-
-        /// `O_DIRECTORY`
-        const DIRECTORY = c::O_DIRECTORY;
-
-        /// `O_DSYNC`
-        #[cfg(not(any(target_os = "dragonfly", target_os = "freebsd", target_os = "redox")))]
-        const DSYNC = c::O_DSYNC;
-
-        /// `O_EXCL`
-        const EXCL = c::O_EXCL;
-
-        /// `O_FSYNC`
-        #[cfg(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "ios",
-            all(target_os = "linux", not(target_env = "musl")),
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        const FSYNC = c::O_FSYNC;
-
-        /// `O_NOFOLLOW`
-        const NOFOLLOW = c::O_NOFOLLOW;
-
-        /// `O_NONBLOCK`
-        const NONBLOCK = c::O_NONBLOCK;
-
-        /// `O_RDONLY`
-        const RDONLY = c::O_RDONLY;
-
-        /// `O_WRONLY`
-        const WRONLY = c::O_WRONLY;
-
-        /// `O_RDWR`
-        const RDWR = c::O_RDWR;
-
-        /// `O_NOCTTY`
-        #[cfg(not(target_os = "redox"))]
-        const NOCTTY = c::O_NOCTTY;
-
-        /// `O_RSYNC`
-        #[cfg(any(
-            target_os = "android",
-            target_os = "emscripten",
-            target_os = "linux",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "wasi",
-        ))]
-        const RSYNC = c::O_RSYNC;
-
-        /// `O_SYNC`
-        #[cfg(not(target_os = "redox"))]
-        const SYNC = c::O_SYNC;
-
-        /// `O_TRUNC`
-        const TRUNC = c::O_TRUNC;
-
-        /// `O_PATH`
-        #[cfg(any(
-            target_os = "android",
-            target_os = "emscripten",
-            target_os = "fuchsia",
-            target_os = "linux",
-            target_os = "redox",
-        ))]
-        const PATH = c::O_PATH;
-
-        /// `O_CLOEXEC`
-        const CLOEXEC = c::O_CLOEXEC;
-
-        /// `O_TMPFILE`
-        #[cfg(any(
-            target_os = "android",
-            target_os = "emscripten",
-            target_os = "fuchsia",
-            target_os = "linux",
-        ))]
-        const TMPFILE = c::O_TMPFILE;
-
-        /// `O_NOATIME`
-        #[cfg(any(
-            target_os = "android",
-            target_os = "fuchsia",
-            target_os = "linux",
-        ))]
-        const NOATIME = c::O_NOATIME;
-    }
-}
-
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-bitflags! {
-    /// `CLONE_*` constants for use with [`fclonefileat`].
-    ///
-    /// [`fclonefileat`]: crate::fs::fclonefileat
-    pub struct CloneFlags: c::c_int {
-        /// `CLONE_NOFOLLOW`
-        const NOFOLLOW = 1;
-
-        /// `CLONE_NOOWNERCOPY`
-        const NOOWNERCOPY = 2;
-    }
-}
-
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-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(any(target_os = "ios", target_os = "macos"))]
-bitflags! {
-    /// `COPYFILE_*` constants.
-    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;
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-bitflags! {
-    /// `RESOLVE_*` constants for use with [`openat2`].
-    ///
-    /// [`openat2`]: crate::fs::openat2
-    #[derive(Default)]
-    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;
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-bitflags! {
-    /// `RENAME_*` constants for use with [`renameat_with`].
-    ///
-    /// [`renameat_with`]: crate::fs::renameat_with
-    pub struct RenameFlags: c::c_uint {
-        /// `RENAME_EXCHANGE`
-        const EXCHANGE = c::RENAME_EXCHANGE as _;
-
-        /// `RENAME_NOREPLACE`
-        const NOREPLACE = c::RENAME_NOREPLACE as _;
-
-        /// `RENAME_WHITEOUT`
-        const WHITEOUT = c::RENAME_WHITEOUT as _;
-    }
-}
-
-/// `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`.
-    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 `Stat`.
-    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(
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "redox",
-        target_os = "solaris"
-    )))]
-    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(
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-#[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(target_os = "android", target_os = "freebsd", target_os = "linux"))]
-bitflags! {
-    /// `MFD_*` constants for use with [`memfd_create`].
-    ///
-    /// [`memfd_create`]: crate::fs::memfd_create
-    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`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_64KB = c::MFD_HUGE_64KB;
-        /// `MFD_HUGE_512JB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_512KB = c::MFD_HUGE_512KB;
-        /// `MFD_HUGE_1MB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_1MB = c::MFD_HUGE_1MB;
-        /// `MFD_HUGE_2MB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_2MB = c::MFD_HUGE_2MB;
-        /// `MFD_HUGE_8MB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_8MB = c::MFD_HUGE_8MB;
-        /// `MFD_HUGE_16MB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_16MB = c::MFD_HUGE_16MB;
-        /// `MFD_HUGE_32MB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_32MB = c::MFD_HUGE_32MB;
-        /// `MFD_HUGE_256MB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_256MB = c::MFD_HUGE_256MB;
-        /// `MFD_HUGE_512MB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_512MB = c::MFD_HUGE_512MB;
-        /// `MFD_HUGE_1GB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_1GB = c::MFD_HUGE_1GB;
-        /// `MFD_HUGE_2GB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_2GB = c::MFD_HUGE_2GB;
-        /// `MFD_HUGE_16GB`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const HUGE_16GB = c::MFD_HUGE_16GB;
-    }
-}
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-bitflags! {
-    /// `F_SEAL_*` constants for use with [`fcntl_add_seals`] and
-    /// [`fcntl_get_seals`].
-    ///
-    /// [`fcntl_add_seals`]: crate::fs::fcntl_add_seals
-    /// [`fcntl_get_seals`]: crate::fs::fcntl_get_seals
-    pub struct SealFlags: i32 {
-       /// `F_SEAL_SEAL`.
-       const SEAL = c::F_SEAL_SEAL;
-       /// `F_SEAL_SHRINK`.
-       const SHRINK = c::F_SEAL_SHRINK;
-       /// `F_SEAL_GROW`.
-       const GROW = c::F_SEAL_GROW;
-       /// `F_SEAL_WRITE`.
-       const WRITE = c::F_SEAL_WRITE;
-       /// `F_SEAL_FUTURE_WRITE` (since Linux 5.1)
-       #[cfg(any(target_os = "android", target_os = "linux"))]
-       const FUTURE_WRITE = c::F_SEAL_FUTURE_WRITE;
-    }
-}
-
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-bitflags! {
-    /// `STATX_*` constants for use with [`statx`].
-    ///
-    /// [`statx`]: crate::fs::statx
-    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_ALL`
-        const ALL = c::STATX_ALL;
-    }
-}
-
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-bitflags! {
-    /// `STATX_*` constants for use with [`statx`].
-    ///
-    /// [`statx`]: crate::fs::statx
-    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;
-    }
-}
-
-#[cfg(not(any(
-    target_os = "aix",
-    target_os = "illumos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-bitflags! {
-    /// `FALLOC_FL_*` constants for use with [`fallocate`].
-    ///
-    /// [`fallocate`]: crate::fs::fallocate
-    pub struct FallocateFlags: i32 {
-        /// `FALLOC_FL_KEEP_SIZE`
-        #[cfg(not(any(
-            target_os = "aix",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "wasi",
-        )))]
-        const KEEP_SIZE = c::FALLOC_FL_KEEP_SIZE;
-        /// `FALLOC_FL_PUNCH_HOLE`
-        #[cfg(not(any(
-            target_os = "aix",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "wasi",
-        )))]
-        const PUNCH_HOLE = c::FALLOC_FL_PUNCH_HOLE;
-        /// `FALLOC_FL_NO_HIDE_STALE`
-        #[cfg(not(any(
-            target_os = "aix",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "linux",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "emscripten",
-            target_os = "fuchsia",
-            target_os = "wasi",
-        )))]
-        const NO_HIDE_STALE = c::FALLOC_FL_NO_HIDE_STALE;
-        /// `FALLOC_FL_COLLAPSE_RANGE`
-        #[cfg(not(any(
-            target_os = "aix",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "emscripten",
-            target_os = "wasi",
-        )))]
-        const COLLAPSE_RANGE = c::FALLOC_FL_COLLAPSE_RANGE;
-        /// `FALLOC_FL_ZERO_RANGE`
-        #[cfg(not(any(
-            target_os = "aix",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "emscripten",
-            target_os = "wasi",
-        )))]
-        const ZERO_RANGE = c::FALLOC_FL_ZERO_RANGE;
-        /// `FALLOC_FL_INSERT_RANGE`
-        #[cfg(not(any(
-            target_os = "aix",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "emscripten",
-            target_os = "wasi",
-        )))]
-        const INSERT_RANGE = c::FALLOC_FL_INSERT_RANGE;
-        /// `FALLOC_FL_UNSHARE_RANGE`
-        #[cfg(not(any(
-            target_os = "aix",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "emscripten",
-            target_os = "wasi",
-        )))]
-        const UNSHARE_RANGE = c::FALLOC_FL_UNSHARE_RANGE;
-    }
-}
-
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-bitflags! {
-    /// `ST_*` constants for use with [`StatVfs`].
-    pub struct StatVfsMountFlags: u64 {
-        /// `ST_MANDLOCK`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
-        const MANDLOCK = libc::ST_MANDLOCK as u64;
-
-        /// `ST_NOATIME`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
-        const NOATIME = libc::ST_NOATIME as u64;
-
-        /// `ST_NODEV`
-        #[cfg(any(target_os = "aix", target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
-        const NODEV = libc::ST_NODEV as u64;
-
-        /// `ST_NODIRATIME`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
-        const NODIRATIME = libc::ST_NODIRATIME as u64;
-
-        /// `ST_NOEXEC`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
-        const NOEXEC = libc::ST_NOEXEC as u64;
-
-        /// `ST_NOSUID`
-        const NOSUID = libc::ST_NOSUID as u64;
-
-        /// `ST_RDONLY`
-        const RDONLY = libc::ST_RDONLY as u64;
-
-        /// `ST_RELATIME`
-        #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))]
-        const RELATIME = libc::ST_RELATIME as u64;
-
-        /// `ST_SYNCHRONOUS`
-        #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))]
-        const SYNCHRONOUS = libc::ST_SYNCHRONOUS as u64;
-    }
-}
-
-/// `LOCK_*` constants for use with [`flock`]
-///
-/// [`flock`]: crate::fs::flock
-#[cfg(not(any(target_os = "solaris", target_os = "wasi")))]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-#[repr(i32)]
-pub enum FlockOperation {
-    /// `LOCK_SH`
-    LockShared = c::LOCK_SH,
-    /// `LOCK_EX`
-    LockExclusive = c::LOCK_EX,
-    /// `LOCK_UN`
-    Unlock = c::LOCK_UN,
-    /// `LOCK_SH | LOCK_NB`
-    NonBlockingLockShared = c::LOCK_SH | c::LOCK_NB,
-    /// `LOCK_EX | LOCK_NB`
-    NonBlockingLockExclusive = c::LOCK_EX | c::LOCK_NB,
-    /// `LOCK_UN | LOCK_NB`
-    NonBlockingUnlock = 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(
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-    target_os = "l4re",
-)))]
-pub type Stat = c::stat;
-
-/// `struct stat` for use with [`statat`] and [`fstat`].
-///
-/// [`statat`]: crate::fs::statat
-/// [`fstat`]: crate::fs::fstat
-#[cfg(any(
-    all(
-        any(target_os = "android", target_os = "linux"),
-        target_pointer_width = "64",
-    ),
-    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(
-    any(target_os = "android", target_os = "linux"),
-    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(
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "linux",
-    target_os = "l4re",
-    target_os = "netbsd",
-    target_os = "redox",
-    target_os = "solaris",
-    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(any(
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-    target_os = "l4re",
-))]
-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 = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-    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, even though `__fsword_t` is `u64`.
-#[cfg(all(target_os = "linux", target_arch = "s390x"))]
-pub type FsWord = u32;
-
-#[cfg(not(target_os = "redox"))]
-pub use c::{UTIME_NOW, UTIME_OMIT};
-
-/// `PROC_SUPER_MAGIC`—The magic number for the procfs filesystem.
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    not(target_env = "musl"),
-))]
-pub const PROC_SUPER_MAGIC: FsWord = c::PROC_SUPER_MAGIC as FsWord;
-
-/// `NFS_SUPER_MAGIC`—The magic number for the NFS filesystem.
-#[cfg(all(
-    any(target_os = "android", target_os = "linux"),
-    not(target_env = "musl"),
-))]
-pub const NFS_SUPER_MAGIC: FsWord = c::NFS_SUPER_MAGIC as FsWord;
-
-/// `PROC_SUPER_MAGIC`—The magic number for the procfs filesystem.
-#[cfg(all(any(target_os = "android", target_os = "linux"), target_env = "musl"))]
-pub const PROC_SUPER_MAGIC: FsWord = 0x0000_9fa0;
-
-/// `NFS_SUPER_MAGIC`—The magic number for the NFS filesystem.
-#[cfg(all(any(target_os = "android", target_os = "linux"), target_env = "musl"))]
-pub const NFS_SUPER_MAGIC: FsWord = 0x0000_6969;
-
-/// `copyfile_state_t`—State for use with [`fcopyfile`].
-///
-/// [`fcopyfile`]: crate::fs::fcopyfile
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-#[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-0.36.5/src/backend/libc/io/epoll.rs b/vendor/rustix-0.36.5/src/backend/libc/io/epoll.rs
deleted file mode 100644
index 3205a613f..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io/epoll.rs
+++ /dev/null
@@ -1,573 +0,0 @@
-//! epoll support.
-//!
-//! This is an experiment, and it isn't yet clear whether epoll is the right
-//! level of abstraction at which to introduce safety. But it works fairly well
-//! in simple examples 🙂.
-//!
-//! # Examples
-//!
-//! ```rust,no_run
-//! # #![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
-//! # #[cfg(feature = "net")]
-//! # fn main() -> std::io::Result<()> {
-//! use io_lifetimes::AsFd;
-//! use rustix::io::epoll::{self, Epoll};
-//! use rustix::io::{ioctl_fionbio, read, write};
-//! use rustix::net::{
-//!     accept, bind_v4, listen, socket, AddressFamily, Ipv4Addr, Protocol, SocketAddrV4,
-//!     SocketType,
-//! };
-//! use std::os::unix::io::AsRawFd;
-//!
-//! // Create a socket and listen on it.
-//! let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
-//! 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::new(epoll::CreateFlags::CLOEXEC, epoll::Owning::new())?;
-//!
-//! // Remember the socket raw fd, which we use for comparisons only.
-//! let raw_listen_sock = listen_sock.as_fd().as_raw_fd();
-//!
-//! // Register the socket with the epoll object.
-//! epoll.add(listen_sock, epoll::EventFlags::IN)?;
-//!
-//! // Process events.
-//! let mut event_list = epoll::EventVec::with_capacity(4);
-//! loop {
-//!     epoll.wait(&mut event_list, -1)?;
-//!     for (_event_flags, target) in &event_list {
-//!         if target.as_raw_fd() == raw_listen_sock {
-//!             // 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(&*target)?;
-//!             ioctl_fionbio(&conn_sock, true)?;
-//!             epoll.add(conn_sock, epoll::EventFlags::OUT | epoll::EventFlags::ET)?;
-//!         } else {
-//!             // Write a message to the stream and then unregister it.
-//!             write(&*target, b"hello\n")?;
-//!             let _ = epoll.del(target)?;
-//!         }
-//!     }
-//! }
-//! # }
-//! # #[cfg(not(feature = "net"))]
-//! # fn main() {}
-//! ```
-
-use super::super::c;
-use super::super::conv::{ret, ret_owned_fd, ret_u32};
-use crate::fd::{AsFd, AsRawFd, BorrowedFd, OwnedFd, RawFd};
-#[cfg(not(feature = "rustc-dep-of-std"))]
-use crate::fd::{FromRawFd, IntoRawFd};
-use crate::io;
-use alloc::vec::Vec;
-use bitflags::bitflags;
-use core::convert::TryInto;
-use core::fmt;
-use core::marker::PhantomData;
-use core::ops::Deref;
-use core::ptr::{null, null_mut};
-
-bitflags! {
-    /// `EPOLL_*` for use with [`Epoll::new`].
-    pub struct CreateFlags: c::c_int {
-        /// `EPOLL_CLOEXEC`
-        const CLOEXEC = c::EPOLL_CLOEXEC;
-    }
-}
-
-bitflags! {
-    /// `EPOLL*` for use with [`Epoll::add`].
-    #[derive(Default)]
-    pub struct EventFlags: u32 {
-        /// `EPOLLIN`
-        const IN = c::EPOLLIN as u32;
-
-        /// `EPOLLOUT`
-        const OUT = c::EPOLLOUT as u32;
-
-        /// `EPOLLPRI`
-        const PRI = c::EPOLLPRI as u32;
-
-        /// `EPOLLERR`
-        const ERR = c::EPOLLERR as u32;
-
-        /// `EPOLLHUP`
-        const HUP = c::EPOLLHUP as u32;
-
-        /// `EPOLLET`
-        const ET = c::EPOLLET as u32;
-
-        /// `EPOLLONESHOT`
-        const ONESHOT = c::EPOLLONESHOT as u32;
-
-        /// `EPOLLWAKEUP`
-        const WAKEUP = c::EPOLLWAKEUP as u32;
-
-        /// `EPOLLEXCLUSIVE`
-        #[cfg(not(target_os = "android"))]
-        const EXCLUSIVE = c::EPOLLEXCLUSIVE as u32;
-    }
-}
-
-/// A reference to a `T`.
-pub struct Ref<'a, T> {
-    t: T,
-    _phantom: PhantomData<&'a T>,
-}
-
-impl<'a, T> Ref<'a, T> {
-    #[inline]
-    fn new(t: T) -> Self {
-        Self {
-            t,
-            _phantom: PhantomData,
-        }
-    }
-
-    #[inline]
-    fn consume(self) -> T {
-        self.t
-    }
-}
-
-impl<'a, T> Deref for Ref<'a, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &T {
-        &self.t
-    }
-}
-
-impl<'a, T: fmt::Debug> fmt::Debug for Ref<'a, T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.t.fmt(fmt)
-    }
-}
-
-/// A trait for data stored within an [`Epoll`] instance.
-pub trait Context {
-    /// The type of an element owned by this context.
-    type Data;
-
-    /// The type of a value used to refer to an element owned by this context.
-    type Target: AsFd;
-
-    /// Assume ownership of `data`, and returning a `Target`.
-    fn acquire<'call>(&self, data: Self::Data) -> Ref<'call, Self::Target>;
-
-    /// Encode `target` as a `u64`. The only requirement on this value is that
-    /// it be decodable by `decode`.
-    fn encode(&self, target: Ref<'_, Self::Target>) -> u64;
-
-    /// Decode `raw`, which is a value encoded by `encode`, into a `Target`.
-    ///
-    /// # Safety
-    ///
-    /// `raw` must be a `u64` value returned from `encode`, from the same
-    /// context, and within the context's lifetime.
-    unsafe fn decode<'call>(&self, raw: u64) -> Ref<'call, Self::Target>;
-
-    /// Release ownership of the value referred to by `target` and return it.
-    fn release(&self, target: Ref<'_, Self::Target>) -> Self::Data;
-}
-
-/// A type implementing [`Context`] where the `Data` type is `BorrowedFd<'a>`.
-pub struct Borrowing<'a> {
-    _phantom: PhantomData<BorrowedFd<'a>>,
-}
-
-impl<'a> Context for Borrowing<'a> {
-    type Data = BorrowedFd<'a>;
-    type Target = BorrowedFd<'a>;
-
-    #[inline]
-    fn acquire<'call>(&self, data: Self::Data) -> Ref<'call, Self::Target> {
-        Ref::new(data)
-    }
-
-    #[inline]
-    fn encode(&self, target: Ref<'_, Self::Target>) -> u64 {
-        target.as_raw_fd() as u64
-    }
-
-    #[inline]
-    unsafe fn decode<'call>(&self, raw: u64) -> Ref<'call, Self::Target> {
-        Ref::new(BorrowedFd::<'a>::borrow_raw(raw as RawFd))
-    }
-
-    #[inline]
-    fn release(&self, target: Ref<'_, Self::Target>) -> Self::Data {
-        target.consume()
-    }
-}
-
-/// A type implementing [`Context`] where the `Data` type is `T`, a type
-/// implementing `From<OwnedFd>` and `From<T> for OwnedFd`.
-///
-/// This may be used with [`OwnedFd`], or higher-level types like
-/// [`std::fs::File`] or [`std::net::TcpStream`].
-#[cfg(not(feature = "rustc-dep-of-std"))]
-pub struct Owning<'context, T: Into<OwnedFd> + From<OwnedFd>> {
-    _phantom: PhantomData<&'context T>,
-}
-
-#[cfg(not(feature = "rustc-dep-of-std"))]
-impl<'context, T: Into<OwnedFd> + From<OwnedFd>> Owning<'context, T> {
-    /// Creates a new empty `Owning`.
-    #[allow(clippy::new_without_default)] // This is a specialized type that doesn't need to be generically constructible.
-    #[inline]
-    pub fn new() -> Self {
-        Self {
-            _phantom: PhantomData,
-        }
-    }
-}
-
-#[cfg(not(feature = "rustc-dep-of-std"))]
-impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> Context for Owning<'context, T> {
-    type Data = T;
-    type Target = BorrowedFd<'context>;
-
-    #[inline]
-    fn acquire<'call>(&self, data: Self::Data) -> Ref<'call, Self::Target> {
-        let fd: OwnedFd = data.into();
-        let raw_fd = fd.into_raw_fd();
-        // Safety: `epoll` will assign ownership of the file descriptor to the
-        // kernel epoll object. We use `Into<OwnedFd>`+`IntoRawFd` to consume
-        // the `Data` and extract the raw file descriptor and then "borrow" it
-        // with `borrow_raw` knowing that the borrow won't outlive the
-        // kernel epoll object.
-        unsafe { Ref::new(BorrowedFd::<'context>::borrow_raw(raw_fd)) }
-    }
-
-    #[inline]
-    fn encode(&self, target: Ref<'_, Self::Target>) -> u64 {
-        target.as_fd().as_raw_fd() as u64
-    }
-
-    #[inline]
-    unsafe fn decode<'call>(&self, raw: u64) -> Ref<'call, Self::Target> {
-        Ref::new(BorrowedFd::<'context>::borrow_raw(raw as RawFd))
-    }
-
-    #[inline]
-    fn release(&self, target: Ref<'_, Self::Target>) -> Self::Data {
-        // The file descriptor was held by the kernel epoll object and is now
-        // being released, so we can create a new `OwnedFd` that assumes
-        // ownership.
-        let raw_fd = target.consume().as_raw_fd();
-        unsafe { T::from(OwnedFd::from_raw_fd(raw_fd).into()) }
-    }
-}
-
-/// An "epoll", an interface to an OS object allowing one to repeatedly wait
-/// for events from a set of file descriptors efficiently.
-pub struct Epoll<Context: self::Context> {
-    epoll_fd: OwnedFd,
-    context: Context,
-}
-
-impl<Context: self::Context> Epoll<Context> {
-    /// `epoll_create1(flags)`—Creates a new `Epoll`.
-    ///
-    /// 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 new(flags: CreateFlags, context: Context) -> io::Result<Self> {
-        // Safety: We're calling `epoll_create1` via FFI and we know how it
-        // behaves.
-        unsafe {
-            Ok(Self {
-                epoll_fd: ret_owned_fd(c::epoll_create1(flags.bits()))?,
-                context,
-            })
-        }
-    }
-
-    /// `epoll_ctl(self, EPOLL_CTL_ADD, data, event)`—Adds an element to an
-    /// `Epoll`.
-    ///
-    /// This registers interest in any of the events set in `events` occurring
-    /// on the file descriptor associated with `data`.
-    #[doc(alias = "epoll_ctl")]
-    pub fn add(
-        &self,
-        data: Context::Data,
-        event_flags: EventFlags,
-    ) -> io::Result<Ref<'_, Context::Target>> {
-        // Safety: We're calling `epoll_ctl` via FFI and we know how it
-        // behaves.
-        unsafe {
-            let target = self.context.acquire(data);
-            let raw_fd = target.as_fd().as_raw_fd();
-            let encoded = self.context.encode(target);
-            ret(c::epoll_ctl(
-                self.epoll_fd.as_fd().as_raw_fd(),
-                c::EPOLL_CTL_ADD,
-                raw_fd,
-                &mut c::epoll_event {
-                    events: event_flags.bits(),
-                    r#u64: encoded,
-                },
-            ))?;
-            Ok(self.context.decode(encoded))
-        }
-    }
-
-    /// `epoll_ctl(self, EPOLL_CTL_MOD, target, event)`—Modifies an element in
-    /// this `Epoll`.
-    ///
-    /// This sets the events of interest with `target` to `events`.
-    #[doc(alias = "epoll_ctl")]
-    pub fn mod_(
-        &self,
-        target: Ref<'_, Context::Target>,
-        event_flags: EventFlags,
-    ) -> io::Result<()> {
-        let raw_fd = target.as_fd().as_raw_fd();
-        let encoded = self.context.encode(target);
-        // Safety: We're calling `epoll_ctl` via FFI and we know how it
-        // behaves.
-        unsafe {
-            ret(c::epoll_ctl(
-                self.epoll_fd.as_fd().as_raw_fd(),
-                c::EPOLL_CTL_MOD,
-                raw_fd,
-                &mut c::epoll_event {
-                    events: event_flags.bits(),
-                    r#u64: encoded,
-                },
-            ))
-        }
-    }
-
-    /// `epoll_ctl(self, EPOLL_CTL_DEL, target, NULL)`—Removes an element in
-    /// this `Epoll`.
-    ///
-    /// This also returns the owning `Data`.
-    #[doc(alias = "epoll_ctl")]
-    pub fn del(&self, target: Ref<'_, Context::Target>) -> io::Result<Context::Data> {
-        // Safety: We're calling `epoll_ctl` via FFI and we know how it
-        // behaves.
-        unsafe {
-            let raw_fd = target.as_fd().as_raw_fd();
-            ret(c::epoll_ctl(
-                self.epoll_fd.as_fd().as_raw_fd(),
-                c::EPOLL_CTL_DEL,
-                raw_fd,
-                null_mut(),
-            ))?;
-        }
-        Ok(self.context.release(target))
-    }
-
-    /// `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.
-    #[doc(alias = "epoll_wait")]
-    pub fn wait<'context>(
-        &'context self,
-        event_list: &mut EventVec<'context, Context>,
-        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(
-                self.epoll_fd.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);
-            event_list.context = &self.context;
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(not(feature = "rustc-dep-of-std"))]
-impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> AsRawFd for Epoll<Owning<'context, T>> {
-    fn as_raw_fd(&self) -> RawFd {
-        self.epoll_fd.as_raw_fd()
-    }
-}
-
-#[cfg(not(feature = "rustc-dep-of-std"))]
-impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> IntoRawFd for Epoll<Owning<'context, T>> {
-    fn into_raw_fd(self) -> RawFd {
-        self.epoll_fd.into_raw_fd()
-    }
-}
-
-#[cfg(not(feature = "rustc-dep-of-std"))]
-impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> FromRawFd for Epoll<Owning<'context, T>> {
-    unsafe fn from_raw_fd(fd: RawFd) -> Self {
-        Self {
-            epoll_fd: OwnedFd::from_raw_fd(fd),
-            context: Owning::new(),
-        }
-    }
-}
-
-#[cfg(not(feature = "rustc-dep-of-std"))]
-impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> AsFd for Epoll<Owning<'context, T>> {
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        self.epoll_fd.as_fd()
-    }
-}
-
-#[cfg(not(feature = "rustc-dep-of-std"))]
-impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> From<Epoll<Owning<'context, T>>>
-    for OwnedFd
-{
-    fn from(epoll: Epoll<Owning<'context, T>>) -> Self {
-        epoll.epoll_fd
-    }
-}
-
-#[cfg(not(feature = "rustc-dep-of-std"))]
-impl<'context, T: AsFd + Into<OwnedFd> + From<OwnedFd>> From<OwnedFd>
-    for Epoll<Owning<'context, T>>
-{
-    fn from(fd: OwnedFd) -> Self {
-        Self {
-            epoll_fd: fd,
-            context: Owning::new(),
-        }
-    }
-}
-
-/// An iterator over the `Event`s in an `EventVec`.
-pub struct Iter<'context, Context: self::Context> {
-    iter: core::slice::Iter<'context, Event>,
-    context: *const Context,
-    _phantom: PhantomData<&'context Context>,
-}
-
-impl<'context, Context: self::Context> Iterator for Iter<'context, Context> {
-    type Item = (EventFlags, Ref<'context, Context::Target>);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        // Safety: `self.context` is guaranteed to be valid because we hold
-        // `'context` for it. And we know this event is associated with this
-        // context because `wait` sets both.
-        self.iter.next().map(|event| {
-            (event.event_flags, unsafe {
-                (*self.context).decode(event.encoded)
-            })
-        })
-    }
-}
-
-/// 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)
-)]
-struct Event {
-    // Match the layout of `c::epoll_event`. We just use a `u64` instead of
-    // the full union; `Context` implementations will simply need to deal with
-    // casting the value into and out of the `u64` themselves.
-    event_flags: EventFlags,
-    encoded: u64,
-}
-
-/// A vector of `Event`s, plus context for interpreting them.
-pub struct EventVec<'context, Context: self::Context> {
-    events: Vec<Event>,
-    context: *const Context,
-    _phantom: PhantomData<&'context Context>,
-}
-
-impl<'context, Context: self::Context> EventVec<'context, Context> {
-    /// Constructs an `EventVec` with memory for `capacity` `Event`s.
-    #[inline]
-    pub fn with_capacity(capacity: usize) -> Self {
-        Self {
-            events: Vec::with_capacity(capacity),
-            context: null(),
-            _phantom: PhantomData,
-        }
-    }
-
-    /// 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<'_, Context> {
-        Iter {
-            iter: self.events.iter(),
-            context: self.context,
-            _phantom: PhantomData,
-        }
-    }
-
-    /// 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()
-    }
-}
-
-impl<'context, Context: self::Context> IntoIterator for &'context EventVec<'context, Context> {
-    type IntoIter = Iter<'context, Context>;
-    type Item = (EventFlags, Ref<'context, Context::Target>);
-
-    #[inline]
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/io/errno.rs b/vendor/rustix-0.36.5/src/backend/libc/io/errno.rs
deleted file mode 100644
index 25323771c..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io/errno.rs
+++ /dev/null
@@ -1,1106 +0,0 @@
-//! The `rustix` `Errno` type.
-//!
-//! This type holds an OS error code, which conceptually corresponds to an
-//! `errno` value.
-
-use super::super::c;
-use libc_errno::errno;
-
-/// 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.
-#[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(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const ADV: Self = Self(c::EADV);
-    /// `EAFNOSUPPORT`
-    pub const AFNOSUPPORT: Self = Self(c::EAFNOSUPPORT);
-    /// `EAGAIN`
-    pub const AGAIN: Self = Self(c::EAGAIN);
-    /// `EALREADY`
-    pub const ALREADY: Self = Self(c::EALREADY);
-    /// `EAUTH`
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const AUTH: Self = Self(c::EAUTH);
-    /// `EBADE`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const BADE: Self = Self(c::EBADE);
-    /// `EBADF`
-    pub const BADF: Self = Self(c::EBADF);
-    /// `EBADFD`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const BADFD: Self = Self(c::EBADFD);
-    /// `EBADMSG`
-    #[cfg(not(windows))]
-    pub const BADMSG: Self = Self(c::EBADMSG);
-    /// `EBADR`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const BADR: Self = Self(c::EBADR);
-    /// `EBADRPC`
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const BADRPC: Self = Self(c::EBADRPC);
-    /// `EBADRQC`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const BADRQC: Self = Self(c::EBADRQC);
-    /// `EBADSLT`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const BADSLT: Self = Self(c::EBADSLT);
-    /// `EBFONT`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const BFONT: Self = Self(c::EBFONT);
-    /// `EBUSY`
-    #[cfg(not(windows))]
-    pub const BUSY: Self = Self(c::EBUSY);
-    /// `ECANCELED`
-    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(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const CHRNG: Self = Self(c::ECHRNG);
-    /// `ECOMM`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        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(
-        windows,
-        target_os = "aix",
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const DEADLOCK: Self = Self(c::EDEADLOCK);
-    /// `EDESTADDRREQ`
-    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(any(target_os = "dragonfly", target_os = "freebsd"))]
-    pub const DOOFUS: Self = Self(c::EDOOFUS);
-    /// `EDOTDOT`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        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(
-        target_env = "newlib",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const FTYPE: Self = Self(c::EFTYPE);
-    /// `EHOSTDOWN`
-    #[cfg(not(target_os = "wasi"))]
-    pub const HOSTDOWN: Self = Self(c::EHOSTDOWN);
-    /// `EHOSTUNREACH`
-    pub const HOSTUNREACH: Self = Self(c::EHOSTUNREACH);
-    /// `EHWPOISON`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "redox",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const HWPOISON: Self = Self(c::EHWPOISON);
-    /// `EIDRM`
-    #[cfg(not(windows))]
-    pub const IDRM: Self = Self(c::EIDRM);
-    /// `EILSEQ`
-    #[cfg(not(windows))]
-    pub const ILSEQ: Self = Self(c::EILSEQ);
-    /// `EINPROGRESS`
-    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`
-    pub const ISCONN: Self = Self(c::EISCONN);
-    /// `EISDIR`
-    #[cfg(not(windows))]
-    pub const ISDIR: Self = Self(c::EISDIR);
-    /// `EISNAM`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const ISNAM: Self = Self(c::EISNAM);
-    /// `EKEYEXPIRED`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const KEYEXPIRED: Self = Self(c::EKEYEXPIRED);
-    /// `EKEYREJECTED`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const KEYREJECTED: Self = Self(c::EKEYREJECTED);
-    /// `EKEYREVOKED`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const KEYREVOKED: Self = Self(c::EKEYREVOKED);
-    /// `EL2HLT`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const L2HLT: Self = Self(c::EL2HLT);
-    /// `EL2NSYNC`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const L2NSYNC: Self = Self(c::EL2NSYNC);
-    /// `EL3HLT`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const L3HLT: Self = Self(c::EL3HLT);
-    /// `EL3RST`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const L3RST: Self = Self(c::EL3RST);
-    /// `ELIBACC`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const LIBACC: Self = Self(c::ELIBACC);
-    /// `ELIBBAD`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const LIBBAD: Self = Self(c::ELIBBAD);
-    /// `ELIBEXEC`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const LIBEXEC: Self = Self(c::ELIBEXEC);
-    /// `ELIBMAX`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const LIBMAX: Self = Self(c::ELIBMAX);
-    /// `ELIBSCN`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const LIBSCN: Self = Self(c::ELIBSCN);
-    /// `ELNRNG`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const LNRNG: Self = Self(c::ELNRNG);
-    /// `ELOOP`
-    pub const LOOP: Self = Self(c::ELOOP);
-    /// `EMEDIUMTYPE`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        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`
-    pub const MSGSIZE: Self = Self(c::EMSGSIZE);
-    /// `EMULTIHOP`
-    #[cfg(not(any(windows, target_os = "openbsd")))]
-    pub const MULTIHOP: Self = Self(c::EMULTIHOP);
-    /// `ENAMETOOLONG`
-    pub const NAMETOOLONG: Self = Self(c::ENAMETOOLONG);
-    /// `ENAVAIL`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const NAVAIL: Self = Self(c::ENAVAIL);
-    /// `ENEEDAUTH`
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const NEEDAUTH: Self = Self(c::ENEEDAUTH);
-    /// `ENETDOWN`
-    pub const NETDOWN: Self = Self(c::ENETDOWN);
-    /// `ENETRESET`
-    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(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const NOANO: Self = Self(c::ENOANO);
-    /// `ENOATTR`
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const NOATTR: Self = Self(c::ENOATTR);
-    /// `ENOBUFS`
-    pub const NOBUFS: Self = Self(c::ENOBUFS);
-    /// `ENOCSI`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const NOCSI: Self = Self(c::ENOCSI);
-    /// `ENODATA`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        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(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const NOKEY: Self = Self(c::ENOKEY);
-    /// `ENOLCK`
-    #[cfg(not(windows))]
-    pub const NOLCK: Self = Self(c::ENOLCK);
-    /// `ENOLINK`
-    #[cfg(not(any(windows, target_os = "openbsd")))]
-    pub const NOLINK: Self = Self(c::ENOLINK);
-    /// `ENOMEDIUM`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        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(windows))]
-    pub const NOMSG: Self = Self(c::ENOMSG);
-    /// `ENONET`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const NONET: Self = Self(c::ENONET);
-    /// `ENOPKG`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const NOPKG: Self = Self(c::ENOPKG);
-    /// `ENOPROTOOPT`
-    pub const NOPROTOOPT: Self = Self(c::ENOPROTOOPT);
-    /// `ENOSPC`
-    #[cfg(not(windows))]
-    pub const NOSPC: Self = Self(c::ENOSPC);
-    /// `ENOSR`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const NOSR: Self = Self(c::ENOSR);
-    /// `ENOSTR`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        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 = "haiku", 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(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const NOTNAM: Self = Self(c::ENOTNAM);
-    /// `ENOTRECOVERABLE`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "haiku",
-        target_os = "netbsd"
-    )))]
-    pub const NOTRECOVERABLE: Self = Self(c::ENOTRECOVERABLE);
-    /// `ENOTSOCK`
-    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(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        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(windows))]
-    pub const OVERFLOW: Self = Self(c::EOVERFLOW);
-    /// `EOWNERDEAD`
-    #[cfg(not(any(
-        windows,
-        target_os = "haiku",
-        target_os = "dragonfly",
-        target_os = "netbsd"
-    )))]
-    pub const OWNERDEAD: Self = Self(c::EOWNERDEAD);
-    /// `EPERM`
-    #[cfg(not(windows))]
-    pub const PERM: Self = Self(c::EPERM);
-    /// `EPFNOSUPPORT`
-    #[cfg(not(target_os = "wasi"))]
-    pub const PFNOSUPPORT: Self = Self(c::EPFNOSUPPORT);
-    /// `EPIPE`
-    #[cfg(not(windows))]
-    pub const PIPE: Self = Self(c::EPIPE);
-    /// `EPROCLIM`
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const PROCLIM: Self = Self(c::EPROCLIM);
-    /// `EPROCUNAVAIL`
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const PROCUNAVAIL: Self = Self(c::EPROCUNAVAIL);
-    /// `EPROGMISMATCH`
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const PROGMISMATCH: Self = Self(c::EPROGMISMATCH);
-    /// `EPROGUNAVAIL`
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const PROGUNAVAIL: Self = Self(c::EPROGUNAVAIL);
-    /// `EPROTO`
-    #[cfg(not(windows))]
-    pub const PROTO: Self = Self(c::EPROTO);
-    /// `EPROTONOSUPPORT`
-    pub const PROTONOSUPPORT: Self = Self(c::EPROTONOSUPPORT);
-    /// `EPROTOTYPE`
-    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(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const REMCHG: Self = Self(c::EREMCHG);
-    /// `EREMOTE`
-    #[cfg(not(any(target_os = "haiku", target_os = "wasi")))]
-    pub const REMOTE: Self = Self(c::EREMOTE);
-    /// `EREMOTEIO`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const REMOTEIO: Self = Self(c::EREMOTEIO);
-    /// `ERESTART`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const RESTART: Self = Self(c::ERESTART);
-    /// `ERFKILL`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "redox",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const RFKILL: Self = Self(c::ERFKILL);
-    /// `EROFS`
-    #[cfg(not(windows))]
-    pub const ROFS: Self = Self(c::EROFS);
-    /// `ERPCMISMATCH`
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    pub const RPCMISMATCH: Self = Self(c::ERPCMISMATCH);
-    /// `ESHUTDOWN`
-    #[cfg(not(target_os = "wasi"))]
-    pub const SHUTDOWN: Self = Self(c::ESHUTDOWN);
-    /// `ESOCKTNOSUPPORT`
-    #[cfg(not(any(target_os = "haiku", 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(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const SRMNT: Self = Self(c::ESRMNT);
-    /// `ESTALE`
-    pub const STALE: Self = Self(c::ESTALE);
-    /// `ESTRPIPE`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const STRPIPE: Self = Self(c::ESTRPIPE);
-    /// `ETIME`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        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 = "wasi")))]
-    pub const TOOMANYREFS: Self = Self(c::ETOOMANYREFS);
-    /// `ETXTBSY`
-    #[cfg(not(windows))]
-    pub const TXTBSY: Self = Self(c::ETXTBSY);
-    /// `EUCLEAN`
-    #[cfg(not(any(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        target_os = "wasi",
-    )))]
-    pub const UCLEAN: Self = Self(c::EUCLEAN);
-    /// `EUNATCH`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "wasi",
-    )))]
-    pub const UNATCH: Self = Self(c::EUNATCH);
-    /// `EUSERS`
-    #[cfg(not(any(target_os = "haiku", 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(
-        windows,
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        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-0.36.5/src/backend/libc/io/io_slice.rs b/vendor/rustix-0.36.5/src/backend/libc/io/io_slice.rs
deleted file mode 100644
index de1ef434c..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io/io_slice.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/sys/unix/io.rs
-//! dca3f1b786efd27be3b325ed1e01e247aa589c3b.
-
-#![allow(missing_docs)]
-
-use super::super::c;
-use core::marker::PhantomData;
-use core::slice;
-
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct IoSlice<'a> {
-    vec: c::iovec,
-    _p: PhantomData<&'a [u8]>,
-}
-
-impl<'a> IoSlice<'a> {
-    #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
-        IoSlice {
-            vec: c::iovec {
-                iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void,
-                iov_len: buf.len(),
-            },
-            _p: PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n {
-            panic!("advancing IoSlice beyond its length");
-        }
-
-        unsafe {
-            self.vec.iov_len -= n;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }
-    }
-}
-
-#[repr(transparent)]
-pub struct IoSliceMut<'a> {
-    vec: c::iovec,
-    _p: PhantomData<&'a mut [u8]>,
-}
-
-impl<'a> IoSliceMut<'a> {
-    #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
-        IoSliceMut {
-            vec: c::iovec {
-                iov_base: buf.as_mut_ptr() as *mut c::c_void,
-                iov_len: buf.len(),
-            },
-            _p: PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n {
-            panic!("advancing IoSliceMut beyond its length");
-        }
-
-        unsafe {
-            self.vec.iov_len -= n;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }
-    }
-
-    #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
-        unsafe { slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len) }
-    }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/io/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/io/mod.rs
deleted file mode 100644
index 1378adf3d..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-pub(crate) mod errno;
-#[cfg(not(windows))]
-#[cfg(not(feature = "std"))]
-pub(crate) mod io_slice;
-pub(crate) mod poll_fd;
-#[cfg(not(windows))]
-pub(crate) mod types;
-
-#[cfg_attr(windows, path = "windows_syscalls.rs")]
-pub(crate) mod syscalls;
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub mod epoll;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/io/poll_fd.rs b/vendor/rustix-0.36.5/src/backend/libc/io/poll_fd.rs
deleted file mode 100644
index c516a9309..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io/poll_fd.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-use super::super::c;
-use super::super::conv::borrowed_fd;
-#[cfg(windows)]
-use super::super::fd::RawFd;
-use super::super::fd::{AsFd, AsRawFd, BorrowedFd, LibcFd};
-use bitflags::bitflags;
-use core::marker::PhantomData;
-#[cfg(windows)]
-use std::fmt;
-
-bitflags! {
-    /// `POLL*` flags for use with [`poll`].
-    ///
-    /// [`poll`]: crate::io::poll
-    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`
-        #[cfg(not(target_os = "redox"))]
-        const RDNORM = c::POLLRDNORM;
-        /// `POLLWRNORM`
-        #[cfg(not(target_os = "redox"))]
-        const WRNORM = c::POLLWRNORM;
-        /// `POLLRDBAND`
-        #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-        const RDBAND = c::POLLRDBAND;
-        /// `POLLWRBAND`
-        #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-        const WRBAND = c::POLLWRBAND;
-        /// `POLLERR`
-        const ERR = c::POLLERR;
-        /// `POLLHUP`
-        const HUP = c::POLLHUP;
-        /// `POLLNVAL`
-        const NVAL = c::POLLNVAL;
-        /// `POLLRDHUP`
-        #[cfg(all(
-            any(target_os = "android", target_os = "linux"),
-            not(any(target_arch = "sparc", target_arch = "sparc64"))),
-        )]
-        const RDHUP = c::POLLRDHUP;
-    }
-}
-
-/// `struct pollfd`—File descriptor and flags for use with [`poll`].
-///
-/// [`poll`]: crate::io::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> io_lifetimes::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-0.36.5/src/backend/libc/io/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/io/syscalls.rs
deleted file mode 100644
index 3774e700a..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io/syscalls.rs
+++ /dev/null
@@ -1,533 +0,0 @@
-//! libc syscalls supporting `rustix::io`.
-
-use super::super::c;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::syscall_ret_owned_fd;
-use super::super::conv::{
-    borrowed_fd, ret, ret_c_int, ret_discarded_fd, ret_owned_fd, ret_ssize_t,
-};
-use super::super::offset::{libc_pread, libc_pwrite};
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "solaris")))]
-use super::super::offset::{libc_preadv, libc_pwritev};
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-use super::super::offset::{libc_preadv2, libc_pwritev2};
-use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd};
-#[cfg(not(any(target_os = "aix", target_os = "wasi")))]
-use crate::io::DupFlags;
-#[cfg(not(any(
-    target_os = "aix",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "wasi"
-)))]
-use crate::io::PipeFlags;
-use crate::io::{self, FdFlags, IoSlice, IoSliceMut, PollFd};
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::io::{EventfdFlags, IoSliceRaw, ReadWriteFlags, SpliceFlags};
-use core::cmp::min;
-use core::convert::TryInto;
-use core::mem::MaybeUninit;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use core::ptr;
-#[cfg(all(feature = "fs", feature = "net"))]
-use libc_errno::errno;
-
-pub(crate) fn read(fd: BorrowedFd<'_>, buf: &mut [u8]) -> io::Result<usize> {
-    let nread = unsafe {
-        ret_ssize_t(c::read(
-            borrowed_fd(fd),
-            buf.as_mut_ptr().cast(),
-            min(buf.len(), READ_LIMIT),
-        ))?
-    };
-    Ok(nread as usize)
-}
-
-pub(crate) fn write(fd: BorrowedFd<'_>, buf: &[u8]) -> io::Result<usize> {
-    let nwritten = unsafe {
-        ret_ssize_t(c::write(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            min(buf.len(), READ_LIMIT),
-        ))?
-    };
-    Ok(nwritten as usize)
-}
-
-pub(crate) fn pread(fd: BorrowedFd<'_>, buf: &mut [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;
-
-    let nread = unsafe {
-        ret_ssize_t(libc_pread(
-            borrowed_fd(fd),
-            buf.as_mut_ptr().cast(),
-            len,
-            offset,
-        ))?
-    };
-    Ok(nread as usize)
-}
-
-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;
-
-    let nwritten = unsafe {
-        ret_ssize_t(libc_pwrite(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            len,
-            offset,
-        ))?
-    };
-    Ok(nwritten as usize)
-}
-
-pub(crate) fn readv(fd: BorrowedFd<'_>, bufs: &mut [IoSliceMut]) -> io::Result<usize> {
-    let nread = unsafe {
-        ret_ssize_t(c::readv(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
-        ))?
-    };
-    Ok(nread as usize)
-}
-
-pub(crate) fn writev(fd: BorrowedFd<'_>, bufs: &[IoSlice]) -> io::Result<usize> {
-    let nwritten = unsafe {
-        ret_ssize_t(c::writev(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
-        ))?
-    };
-    Ok(nwritten as usize)
-}
-
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "solaris")))]
-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;
-    let nread = unsafe {
-        ret_ssize_t(libc_preadv(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
-            offset,
-        ))?
-    };
-    Ok(nread as usize)
-}
-
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "solaris")))]
-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;
-    let nwritten = unsafe {
-        ret_ssize_t(libc_pwritev(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
-            offset,
-        ))?
-    };
-    Ok(nwritten as usize)
-}
-
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-pub(crate) fn preadv2(
-    fd: BorrowedFd<'_>,
-    bufs: &mut [IoSliceMut],
-    offset: u64,
-    flags: ReadWriteFlags,
-) -> io::Result<usize> {
-    // Silently cast; we'll get `EINVAL` if the value is negative.
-    let offset = offset as i64;
-    let nread = unsafe {
-        ret_ssize_t(libc_preadv2(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
-            offset,
-            flags.bits(),
-        ))?
-    };
-    Ok(nread as usize)
-}
-
-/// At present, `libc` only has `preadv2` defined for glibc. On other
-/// ABIs, `ReadWriteFlags` has no flags defined, and we use plain `preadv`.
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-#[inline]
-pub(crate) fn preadv2(
-    fd: BorrowedFd<'_>,
-    bufs: &mut [IoSliceMut],
-    offset: u64,
-    flags: ReadWriteFlags,
-) -> io::Result<usize> {
-    assert!(flags.is_empty());
-    preadv(fd, bufs, offset)
-}
-
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-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;
-    let nwritten = unsafe {
-        ret_ssize_t(libc_pwritev2(
-            borrowed_fd(fd),
-            bufs.as_ptr().cast::<c::iovec>(),
-            min(bufs.len(), max_iov()) as c::c_int,
-            offset,
-            flags.bits(),
-        ))?
-    };
-    Ok(nwritten as usize)
-}
-
-/// At present, `libc` only has `pwritev2` defined for glibc. On other
-/// ABIs, `ReadWriteFlags` has no flags defined, and we use plain `pwritev`.
-#[cfg(any(
-    target_os = "android",
-    all(target_os = "linux", not(target_env = "gnu")),
-))]
-#[inline]
-pub(crate) fn pwritev2(
-    fd: BorrowedFd<'_>,
-    bufs: &[IoSlice],
-    offset: u64,
-    flags: ReadWriteFlags,
-) -> io::Result<usize> {
-    assert!(flags.is_empty());
-    pwritev(fd, bufs, offset)
-}
-
-// These functions are derived from Rust's library/std/src/sys/unix/fd.rs at
-// revision a77da2d454e6caa227a85b16410b95f93495e7e0.
-
-// The maximum read limit on most POSIX-like systems is `SSIZE_MAX`, with the
-// man 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;
-
-#[cfg(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-))]
-const fn max_iov() -> usize {
-    c::IOV_MAX as usize
-}
-
-#[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
-const fn max_iov() -> usize {
-    c::UIO_MAXIOV as usize
-}
-
-#[cfg(not(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "ios",
-    target_os = "linux",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-)))]
-const fn max_iov() -> usize {
-    16 // The minimum value required by POSIX.
-}
-
-pub(crate) unsafe fn close(raw_fd: RawFd) {
-    let _ = c::close(raw_fd as c::c_int);
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn eventfd(initval: u32, flags: EventfdFlags) -> io::Result<OwnedFd> {
-    unsafe { syscall_ret_owned_fd(c::syscall(c::SYS_eventfd2, initval, flags.bits())) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) fn ioctl_blksszget(fd: BorrowedFd) -> io::Result<u32> {
-    let mut result = MaybeUninit::<c::c_uint>::uninit();
-    unsafe {
-        ret(c::ioctl(borrowed_fd(fd), c::BLKSSZGET, result.as_mut_ptr()))?;
-        Ok(result.assume_init() as u32)
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) fn ioctl_blkpbszget(fd: BorrowedFd) -> io::Result<u32> {
-    let mut result = MaybeUninit::<c::c_uint>::uninit();
-    unsafe {
-        ret(c::ioctl(
-            borrowed_fd(fd),
-            c::BLKPBSZGET,
-            result.as_mut_ptr(),
-        ))?;
-        Ok(result.assume_init() as u32)
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-pub(crate) fn ioctl_fionread(fd: BorrowedFd<'_>) -> io::Result<u64> {
-    let mut nread = MaybeUninit::<c::c_int>::uninit();
-    unsafe {
-        ret(c::ioctl(borrowed_fd(fd), c::FIONREAD, nread.as_mut_ptr()))?;
-        // `FIONREAD` returns the number of bytes silently casted to a `c_int`,
-        // even when this is lossy. The best we can do is convert it back to a
-        // `u64` without sign-extending it back first.
-        Ok(u64::from(nread.assume_init() as c::c_uint))
-    }
-}
-
-pub(crate) fn ioctl_fionbio(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    unsafe {
-        let data = value as c::c_int;
-        ret(c::ioctl(borrowed_fd(fd), c::FIONBIO, &data))
-    }
-}
-
-#[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)> {
-    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> {
-    unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETFD)).map(FdFlags::from_bits_truncate) }
-}
-
-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(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(not(target_os = "wasi"))]
-pub(crate) fn dup(fd: BorrowedFd<'_>) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::dup(borrowed_fd(fd))) }
-}
-
-#[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()))) }
-}
-
-#[cfg(not(any(
-    target_os = "aix",
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox",
-    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()),
-            flags.bits(),
-        ))
-    }
-}
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    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)
-}
-
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-pub(crate) fn ioctl_fioclex(fd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(c::ioctl(borrowed_fd(fd), c::FIOCLEX)) }
-}
-
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-pub(crate) fn ioctl_tiocexcl(fd: BorrowedFd) -> io::Result<()> {
-    unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCEXCL as _)) }
-}
-
-#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))]
-pub(crate) fn ioctl_tiocnxcl(fd: BorrowedFd) -> io::Result<()> {
-    unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCNXCL as _)) }
-}
-
-#[cfg(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(
-    target_os = "aix",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "wasi"
-)))]
-pub(crate) fn pipe_with(flags: PipeFlags) -> io::Result<(OwnedFd, OwnedFd)> {
-    unsafe {
-        let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
-        ret(c::pipe2(result.as_mut_ptr().cast::<i32>(), flags.bits()))?;
-        let [p0, p1] = result.assume_init();
-        Ok((p0, p1))
-    }
-}
-
-#[inline]
-pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> {
-    let nfds = fds
-        .len()
-        .try_into()
-        .map_err(|_convert_err| io::Errno::INVAL)?;
-
-    ret_c_int(unsafe { c::poll(fds.as_mut_ptr().cast(), nfds, timeout) })
-        .map(|nready| nready as usize)
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub fn splice(
-    fd_in: BorrowedFd,
-    off_in: Option<&mut u64>,
-    fd_out: BorrowedFd,
-    off_out: Option<&mut u64>,
-    len: usize,
-    flags: SpliceFlags,
-) -> io::Result<usize> {
-    let off_in = off_in
-        .map(|off| (off as *mut u64).cast())
-        .unwrap_or(ptr::null_mut());
-
-    let off_out = off_out
-        .map(|off| (off as *mut u64).cast())
-        .unwrap_or(ptr::null_mut());
-
-    ret_ssize_t(unsafe {
-        c::splice(
-            borrowed_fd(fd_in),
-            off_in,
-            borrowed_fd(fd_out),
-            off_out,
-            len,
-            flags.bits(),
-        )
-    })
-    .map(|spliced| spliced as usize)
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub unsafe fn vmsplice(
-    fd: BorrowedFd,
-    bufs: &[IoSliceRaw],
-    flags: SpliceFlags,
-) -> io::Result<usize> {
-    ret_ssize_t(c::vmsplice(
-        borrowed_fd(fd),
-        bufs.as_ptr().cast::<c::iovec>(),
-        min(bufs.len(), max_iov()),
-        flags.bits(),
-    ))
-    .map(|spliced| spliced as usize)
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/io/types.rs b/vendor/rustix-0.36.5/src/backend/libc/io/types.rs
deleted file mode 100644
index 46d5f6332..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io/types.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-use super::super::c;
-use bitflags::bitflags;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use core::marker::PhantomData;
-
-bitflags! {
-    /// `FD_*` constants for use with [`fcntl_getfd`] and [`fcntl_setfd`].
-    ///
-    /// [`fcntl_getfd`]: crate::io::fcntl_getfd
-    /// [`fcntl_setfd`]: crate::io::fcntl_setfd
-    pub struct FdFlags: c::c_int {
-        /// `FD_CLOEXEC`
-        const CLOEXEC = c::FD_CLOEXEC;
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-bitflags! {
-    /// `RWF_*` constants for use with [`preadv2`] and [`pwritev2`].
-    ///
-    /// [`preadv2`]: crate::io::preadv2
-    /// [`pwritev2`]: crate::io::pwritev
-    pub struct ReadWriteFlags: c::c_int {
-        /// `RWF_DSYNC` (since Linux 4.7)
-        #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const DSYNC = c::RWF_DSYNC;
-        /// `RWF_HIPRI` (since Linux 4.6)
-        #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const HIPRI = c::RWF_HIPRI;
-        /// `RWF_SYNC` (since Linux 4.7)
-        #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const SYNC = c::RWF_SYNC;
-        /// `RWF_NOWAIT` (since Linux 4.14)
-        #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const NOWAIT = c::RWF_NOWAIT;
-        /// `RWF_APPEND` (since Linux 4.16)
-        #[cfg(all(target_os = "linux", target_env = "gnu"))]
-        const APPEND = c::RWF_APPEND;
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-bitflags! {
-    /// `SPLICE_F_*` constants for use with [`splice`] and [`vmsplice`].
-    pub struct SpliceFlags: c::c_uint {
-        /// `SPLICE_F_MOVE`
-        const MOVE = c::SPLICE_F_MOVE;
-        /// `SPLICE_F_NONBLOCK`
-        const NONBLOCK = c::SPLICE_F_NONBLOCK;
-        /// `SPLICE_F_MORE`
-        const MORE = c::SPLICE_F_MORE;
-        /// `SPLICE_F_GIFT`
-        const GIFT = c::SPLICE_F_GIFT;
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-bitflags! {
-    /// `O_*` constants for use with [`dup2`].
-    ///
-    /// [`dup2`]: crate::io::dup2
-    pub struct DupFlags: c::c_int {
-        /// `O_CLOEXEC`
-        #[cfg(not(any(
-            target_os = "android",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "redox",
-        )))] // Android 5.0 has dup3, but libc doesn't have bindings
-        const CLOEXEC = c::O_CLOEXEC;
-    }
-}
-
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "wasi")))]
-bitflags! {
-    /// `O_*` constants for use with [`pipe_with`].
-    ///
-    /// [`pipe_with`]: crate::io::pipe_with
-    pub struct PipeFlags: c::c_int {
-        /// `O_CLOEXEC`
-        const CLOEXEC = c::O_CLOEXEC;
-        /// `O_DIRECT`
-        #[cfg(not(any(
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const DIRECT = c::O_DIRECT;
-        /// `O_NONBLOCK`
-        const NONBLOCK = c::O_NONBLOCK;
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-bitflags! {
-    /// `EFD_*` flags for use with [`eventfd`].
-    ///
-    /// [`eventfd`]: crate::io::eventfd
-    pub struct EventfdFlags: c::c_int {
-        /// `EFD_CLOEXEC`
-        const CLOEXEC = c::EFD_CLOEXEC;
-        /// `EFD_NONBLOCK`
-        const NONBLOCK = c::EFD_NONBLOCK;
-        /// `EFD_SEMAPHORE`
-        const SEMAPHORE = c::EFD_SEMAPHORE;
-    }
-}
-
-/// `PIPE_BUF`—The maximum size of a write to a pipe guaranteed to be atomic.
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-pub const PIPE_BUF: usize = c::PIPE_BUF;
-
-#[cfg(not(any(windows, target_os = "redox")))]
-pub(crate) const AT_FDCWD: c::c_int = c::AT_FDCWD;
-#[cfg(not(windows))]
-pub(crate) const STDIN_FILENO: c::c_int = c::STDIN_FILENO;
-#[cfg(not(windows))]
-pub(crate) const STDOUT_FILENO: c::c_int = c::STDOUT_FILENO;
-#[cfg(not(windows))]
-pub(crate) const STDERR_FILENO: c::c_int = c::STDERR_FILENO;
-
-/// A buffer type used with `vmsplice`.
-/// It is guaranteed to be ABI compatible with the iovec type on Unix platforms and WSABUF on Windows.
-/// Unlike `IoSlice` and `IoSliceMut` it is semantically like a raw pointer,
-/// and therefore can be shared or mutated as needed.
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[repr(transparent)]
-pub struct IoSliceRaw<'a> {
-    _buf: c::iovec,
-    _lifetime: PhantomData<&'a ()>,
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-impl<'a> IoSliceRaw<'a> {
-    /// Creates a new IoSlice wrapping a byte slice.
-    pub fn from_slice(buf: &'a [u8]) -> Self {
-        IoSliceRaw {
-            _buf: c::iovec {
-                iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _lifetime: PhantomData,
-        }
-    }
-
-    /// Creates a new IoSlice wrapping a mutable byte slice.
-    pub fn from_slice_mut(buf: &'a mut [u8]) -> Self {
-        IoSliceRaw {
-            _buf: c::iovec {
-                iov_base: buf.as_mut_ptr() as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _lifetime: PhantomData,
-        }
-    }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/io/windows_syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/io/windows_syscalls.rs
deleted file mode 100644
index 4c6e86f94..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io/windows_syscalls.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Windows system calls in the `io` module.
-
-use super::super::c;
-use super::super::conv::{borrowed_fd, ret, ret_c_int};
-use super::super::fd::LibcFd;
-use crate::fd::{BorrowedFd, RawFd};
-use crate::io;
-use crate::io::PollFd;
-use core::convert::TryInto;
-use core::mem::MaybeUninit;
-
-pub(crate) unsafe fn close(raw_fd: RawFd) {
-    let _ = c::close(raw_fd as LibcFd);
-}
-
-pub(crate) fn ioctl_fionread(fd: BorrowedFd<'_>) -> io::Result<u64> {
-    let mut nread = MaybeUninit::<c::c_ulong>::uninit();
-    unsafe {
-        ret(c::ioctl(borrowed_fd(fd), c::FIONREAD, nread.as_mut_ptr()))?;
-        Ok(u64::from(nread.assume_init()))
-    }
-}
-
-pub(crate) fn ioctl_fionbio(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> {
-    unsafe {
-        let mut data = value as c::c_uint;
-        ret(c::ioctl(borrowed_fd(fd), c::FIONBIO, &mut data))
-    }
-}
-
-pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> {
-    let nfds = fds
-        .len()
-        .try_into()
-        .map_err(|_convert_err| io::Errno::INVAL)?;
-
-    ret_c_int(unsafe { c::poll(fds.as_mut_ptr().cast(), nfds, timeout) })
-        .map(|nready| nready as usize)
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/io_lifetimes.rs b/vendor/rustix-0.36.5/src/backend/libc/io_lifetimes.rs
deleted file mode 100644
index 2dcd772e8..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io_lifetimes.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-//! `io_lifetimes` types for Windows assuming that Fd is Socket.
-//!
-//! We can make this assumption since `rustix` supports only `rustix::net` on
-//! Windows.
-
-pub use io_lifetimes::{BorrowedSocket as BorrowedFd, OwnedSocket as OwnedFd};
-#[cfg(feature = "std")]
-pub use std::os::windows::io::RawSocket as RawFd;
-pub(crate) use windows_sys::Win32::Networking::WinSock::SOCKET as LibcFd;
-
-// Re-export the `Socket` traits so that users can implement them.
-pub use io_lifetimes::AsSocket;
-
-/// A version of [`AsRawFd`] for use with Winsock2 API.
-///
-/// [`AsRawFd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.AsRawFd.html
-pub trait AsRawFd {
-    /// A version of [`as_raw_fd`] for use with Winsock2 API.
-    ///
-    /// [`as_raw_fd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.FromRawFd.html#tymethod.as_raw_fd
-    fn as_raw_fd(&self) -> RawFd;
-}
-#[cfg(feature = "std")]
-impl<T: std::os::windows::io::AsRawSocket> AsRawFd for T {
-    #[inline]
-    fn as_raw_fd(&self) -> RawFd {
-        self.as_raw_socket()
-    }
-}
-
-/// A version of [`IntoRawFd`] for use with Winsock2 API.
-///
-/// [`IntoRawFd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.IntoRawFd.html
-pub trait IntoRawFd {
-    /// A version of [`into_raw_fd`] for use with Winsock2 API.
-    ///
-    /// [`into_raw_fd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.FromRawFd.html#tymethod.into_raw_fd
-    fn into_raw_fd(self) -> RawFd;
-}
-#[cfg(feature = "std")]
-impl<T: std::os::windows::io::IntoRawSocket> IntoRawFd for T {
-    #[inline]
-    fn into_raw_fd(self) -> RawFd {
-        self.into_raw_socket()
-    }
-}
-
-/// A version of [`FromRawFd`] for use with Winsock2 API.
-///
-/// [`FromRawFd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.FromRawFd.html
-pub trait FromRawFd {
-    /// A version of [`from_raw_fd`] for use with Winsock2 API.
-    ///
-    /// [`from_raw_fd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.FromRawFd.html#tymethod.from_raw_fd
-    unsafe fn from_raw_fd(raw_fd: RawFd) -> Self;
-}
-#[cfg(feature = "std")]
-impl<T: std::os::windows::io::FromRawSocket> FromRawFd for T {
-    #[inline]
-    unsafe fn from_raw_fd(raw_fd: RawFd) -> Self {
-        Self::from_raw_socket(raw_fd)
-    }
-}
-
-/// A version of [`AsFd`] for use with Winsock2 API.
-///
-/// [`AsFd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.AsFd.html
-pub trait AsFd {
-    /// An `as_fd` function for Winsock2, where a `Fd` is a `Socket`.
-    fn as_fd(&self) -> BorrowedFd;
-}
-impl<T: AsSocket> AsFd for T {
-    #[inline]
-    fn as_fd(&self) -> BorrowedFd {
-        self.as_socket()
-    }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/io_uring/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/io_uring/mod.rs
deleted file mode 100644
index ef944f04d..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io_uring/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod syscalls;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/io_uring/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/io_uring/syscalls.rs
deleted file mode 100644
index 31fcec3db..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/io_uring/syscalls.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//! libc syscalls supporting `rustix::io_uring`.
-
-use super::super::c;
-use super::super::conv::{borrowed_fd, syscall_ret, syscall_ret_owned_fd, syscall_ret_u32};
-use crate::fd::{BorrowedFd, OwnedFd};
-use crate::io;
-use crate::io_uring::{io_uring_params, IoringEnterFlags, IoringRegisterOp};
-use linux_raw_sys::general::{__NR_io_uring_enter, __NR_io_uring_register, __NR_io_uring_setup};
-
-#[inline]
-pub(crate) fn io_uring_setup(entries: u32, params: &mut io_uring_params) -> io::Result<OwnedFd> {
-    unsafe {
-        syscall_ret_owned_fd(c::syscall(
-            __NR_io_uring_setup as _,
-            entries as usize,
-            params,
-        ))
-    }
-}
-
-#[inline]
-pub(crate) unsafe fn io_uring_register(
-    fd: BorrowedFd<'_>,
-    opcode: IoringRegisterOp,
-    arg: *const c::c_void,
-    nr_args: u32,
-) -> io::Result<()> {
-    syscall_ret(c::syscall(
-        __NR_io_uring_register as _,
-        borrowed_fd(fd),
-        opcode as u32 as usize,
-        arg,
-        nr_args as usize,
-    ))
-}
-
-#[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_ret_u32(c::syscall(
-        __NR_io_uring_enter as _,
-        borrowed_fd(fd),
-        to_submit as usize,
-        min_complete as usize,
-        flags.bits() as usize,
-        arg,
-        size,
-    ))
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/mm/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/mm/mod.rs
deleted file mode 100644
index 1e0181a99..000000000
--- a/vendor/rustix-0.36.5/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-0.36.5/src/backend/libc/mm/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/mm/syscalls.rs
deleted file mode 100644
index a1d2df1af..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/mm/syscalls.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-//! libc syscalls supporting `rustix::mm`.
-
-use super::super::c;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::syscall_ret_owned_fd;
-use super::super::conv::{borrowed_fd, no_fd, ret};
-use super::super::offset::libc_mmap;
-#[cfg(not(target_os = "redox"))]
-use super::types::Advice;
-#[cfg(target_os = "linux")]
-use super::types::MremapFlags;
-use super::types::{MapFlags, MprotectFlags, MsyncFlags, ProtFlags};
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::types::{MlockFlags, UserfaultfdFlags};
-use crate::fd::BorrowedFd;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-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, flags.bits());
-
-    // `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 = libc_mmap(
-        ptr,
-        len,
-        prot.bits(),
-        flags.bits(),
-        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 = libc_mmap(
-        ptr,
-        len,
-        prot.bits(),
-        flags.bits() | 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, flags.bits()))
-}
-
-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(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, flags.bits());
-    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(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,
-        flags.bits() | 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(any(target_os = "android", target_os = "linux"))]
-#[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, flags.bits()))
-}
-
-/// # 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(any(target_os = "android", target_os = "linux"))]
-pub(crate) unsafe fn userfaultfd(flags: UserfaultfdFlags) -> io::Result<OwnedFd> {
-    syscall_ret_owned_fd(c::syscall(c::SYS_userfaultfd, flags.bits()))
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/mm/types.rs b/vendor/rustix-0.36.5/src/backend/libc/mm/types.rs
deleted file mode 100644
index 11ab708cf..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/mm/types.rs
+++ /dev/null
@@ -1,428 +0,0 @@
-use super::super::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `PROT_*` flags for use with [`mmap`].
-    ///
-    /// For `PROT_NONE`, use `ProtFlags::empty()`.
-    ///
-    /// [`mmap`]: crate::io::mmap
-    pub struct ProtFlags: c::c_int {
-        /// `PROT_READ`
-        const READ = c::PROT_READ;
-        /// `PROT_WRITE`
-        const WRITE = c::PROT_WRITE;
-        /// `PROT_EXEC`
-        const EXEC = c::PROT_EXEC;
-    }
-}
-
-bitflags! {
-    /// `PROT_*` flags for use with [`mprotect`].
-    ///
-    /// For `PROT_NONE`, use `MprotectFlags::empty()`.
-    ///
-    /// [`mprotect`]: crate::io::mprotect
-    pub struct MprotectFlags: c::c_int {
-        /// `PROT_READ`
-        const READ = c::PROT_READ;
-        /// `PROT_WRITE`
-        const WRITE = c::PROT_WRITE;
-        /// `PROT_EXEC`
-        const EXEC = c::PROT_EXEC;
-        /// `PROT_GROWSUP`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const GROWSUP = c::PROT_GROWSUP;
-        /// `PROT_GROWSDOWN`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const GROWSDOWN = c::PROT_GROWSDOWN;
-    }
-}
-
-bitflags! {
-    /// `MAP_*` flags for use with [`mmap`].
-    ///
-    /// For `MAP_ANONYMOUS` (aka `MAP_ANON`), see [`mmap_anonymous`].
-    ///
-    /// [`mmap`]: crate::io::mmap
-    /// [`mmap_anonymous`]: crates::io::mmap_anonymous
-    pub struct MapFlags: c::c_int {
-        /// `MAP_SHARED`
-        const SHARED = c::MAP_SHARED;
-        /// `MAP_SHARED_VALIDATE`
-        #[cfg(not(any(
-            target_os = "android",
-            target_os = "dragonfly",
-            target_os = "emscripten",
-            target_os = "freebsd",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const SHARED_VALIDATE = c::MAP_SHARED_VALIDATE;
-        /// `MAP_PRIVATE`
-        const PRIVATE = c::MAP_PRIVATE;
-        /// `MAP_DENYWRITE`
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const DENYWRITE = c::MAP_DENYWRITE;
-        /// `MAP_FIXED`
-        const FIXED = c::MAP_FIXED;
-        /// `MAP_FIXED_NOREPLACE`
-        #[cfg(not(any(
-            target_os = "android",
-            target_os = "dragonfly",
-            target_os = "emscripten",
-            target_os = "freebsd",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const FIXED_NOREPLACE = c::MAP_FIXED_NOREPLACE;
-        /// `MAP_GROWSDOWN`
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const GROWSDOWN = c::MAP_GROWSDOWN;
-        /// `MAP_HUGETLB`
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const HUGETLB = c::MAP_HUGETLB;
-        /// `MAP_HUGE_2MB`
-        #[cfg(not(any(
-            target_os = "android",
-            target_os = "dragonfly",
-            target_os = "emscripten",
-            target_os = "freebsd",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const HUGE_2MB = c::MAP_HUGE_2MB;
-        /// `MAP_HUGE_1GB`
-        #[cfg(not(any(
-            target_os = "android",
-            target_os = "dragonfly",
-            target_os = "emscripten",
-            target_os = "freebsd",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const HUGE_1GB = c::MAP_HUGE_1GB;
-        /// `MAP_LOCKED`
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const LOCKED = c::MAP_LOCKED;
-        /// `MAP_NOCORE`
-        #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
-        const NOCORE = c::MAP_NOCORE;
-        /// `MAP_NORESERVE`
-        #[cfg(not(any(target_os = "dragonfly", target_os = "freebsd", target_os = "redox")))]
-        const NORESERVE = c::MAP_NORESERVE;
-        /// `MAP_NOSYNC`
-        #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
-        const NOSYNC = c::MAP_NOSYNC;
-        /// `MAP_POPULATE`
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const POPULATE = c::MAP_POPULATE;
-        /// `MAP_STACK`
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "redox",
-            target_os = "solaris",
-        )))]
-        const STACK = c::MAP_STACK;
-        /// `MAP_PREFAULT_READ`
-        #[cfg(target_os = "freebsd")]
-        const PREFAULT_READ = c::MAP_PREFAULT_READ;
-        /// `MAP_SYNC`
-        #[cfg(not(any(
-            target_os = "android",
-            target_os = "dragonfly",
-            target_os = "emscripten",
-            target_os = "freebsd",
-            target_os = "fuchsia",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "redox",
-            target_os = "solaris",
-            all(
-                any(target_os = "android", target_os = "linux"),
-                any(target_arch = "mips", target_arch = "mips64"),
-            )
-        )))]
-        const SYNC = c::MAP_SYNC;
-        /// `MAP_UNINITIALIZED`
-        #[cfg(any())]
-        const UNINITIALIZED = c::MAP_UNINITIALIZED;
-    }
-}
-
-#[cfg(target_os = "linux")]
-bitflags! {
-    /// `MREMAP_*` flags for use with [`mremap`].
-    ///
-    /// For `MREMAP_FIXED`, see [`mremap_fixed`].
-    ///
-    /// [`mremap`]: crate::io::mremap
-    /// [`mremap_fixed`]: crate::io::mremap_fixed
-    pub struct MremapFlags: i32 {
-        /// `MREMAP_MAYMOVE`
-        const MAYMOVE = c::MREMAP_MAYMOVE;
-    }
-}
-
-bitflags! {
-    /// `MS_*` flags for use with [`msync`].
-    ///
-    /// [`msync`]: crate::io::msync
-    pub struct MsyncFlags: i32 {
-        /// `MS_SYNC`—Requests an update and waits for it to complete.
-        const SYNC = c::MS_SYNC;
-        /// `MS_ASYNC`—Specifies that an update be scheduled, but the call
-        /// returns immediately.
-        const ASYNC = c::MS_ASYNC;
-        /// `MS_INVALIDATE`—Asks to invalidate other mappings of the same
-        /// file (so that they can be updated with the fresh values just
-        /// written).
-        const INVALIDATE = c::MS_INVALIDATE;
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-bitflags! {
-    /// `MLOCK_*` flags for use with [`mlock_with`].
-    ///
-    /// [`mlock_with`]: crate::io::mlock_with
-    pub struct MlockFlags: i32 {
-        /// `MLOCK_ONFAULT`
-        const ONFAULT = c::MLOCK_ONFAULT as _;
-    }
-}
-
-/// `POSIX_MADV_*` constants for use with [`madvise`].
-///
-/// [`madvise`]: crate::mm::madvise
-#[cfg(not(target_os = "redox"))]
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-#[repr(i32)]
-#[non_exhaustive]
-pub enum Advice {
-    /// `POSIX_MADV_NORMAL`
-    #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    Normal = c::POSIX_MADV_NORMAL,
-
-    /// `POSIX_MADV_NORMAL`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    Normal = c::MADV_NORMAL,
-
-    /// `POSIX_MADV_SEQUENTIAL`
-    #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    Sequential = c::POSIX_MADV_SEQUENTIAL,
-
-    /// `POSIX_MADV_SEQUENTIAL`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    Sequential = c::MADV_SEQUENTIAL,
-
-    /// `POSIX_MADV_RANDOM`
-    #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    Random = c::POSIX_MADV_RANDOM,
-
-    /// `POSIX_MADV_RANDOM`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    Random = c::MADV_RANDOM,
-
-    /// `POSIX_MADV_WILLNEED`
-    #[cfg(not(any(target_os = "android", target_os = "haiku")))]
-    WillNeed = c::POSIX_MADV_WILLNEED,
-
-    /// `POSIX_MADV_WILLNEED`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    WillNeed = c::MADV_WILLNEED,
-
-    /// `POSIX_MADV_DONTNEED`
-    #[cfg(not(any(target_os = "android", target_os = "emscripten", target_os = "haiku")))]
-    DontNeed = c::POSIX_MADV_DONTNEED,
-
-    /// `POSIX_MADV_DONTNEED`
-    #[cfg(any(target_os = "android", target_os = "haiku"))]
-    DontNeed = i32::MAX - 1,
-
-    /// `MADV_DONTNEED`
-    // `MADV_DONTNEED` has the same value as `POSIX_MADV_DONTNEED`. We don't
-    // have a separate `posix_madvise` from `madvise`, so we expose a special
-    // value which we special-case.
-    #[cfg(target_os = "linux")]
-    LinuxDontNeed = i32::MAX,
-
-    /// `MADV_DONTNEED`
-    #[cfg(target_os = "android")]
-    LinuxDontNeed = c::MADV_DONTNEED,
-    /// `MADV_FREE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxFree = c::MADV_FREE,
-    /// `MADV_REMOVE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxRemove = c::MADV_REMOVE,
-    /// `MADV_DONTFORK`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxDontFork = c::MADV_DONTFORK,
-    /// `MADV_DOFORK`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxDoFork = c::MADV_DOFORK,
-    /// `MADV_HWPOISON`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxHwPoison = c::MADV_HWPOISON,
-    /// `MADV_SOFT_OFFLINE`
-    #[cfg(all(
-        any(target_os = "android", target_os = "linux"),
-        not(any(target_arch = "mips", target_arch = "mips64")),
-    ))]
-    LinuxSoftOffline = c::MADV_SOFT_OFFLINE,
-    /// `MADV_MERGEABLE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxMergeable = c::MADV_MERGEABLE,
-    /// `MADV_UNMERGEABLE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxUnmergeable = c::MADV_UNMERGEABLE,
-    /// `MADV_HUGEPAGE` (since Linux 2.6.38)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxHugepage = c::MADV_HUGEPAGE,
-    /// `MADV_NOHUGEPAGE` (since Linux 2.6.38)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxNoHugepage = c::MADV_NOHUGEPAGE,
-    /// `MADV_DONTDUMP` (since Linux 3.4)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxDontDump = c::MADV_DONTDUMP,
-    /// `MADV_DODUMP` (since Linux 3.4)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    LinuxDoDump = c::MADV_DODUMP,
-    /// `MADV_WIPEONFORK` (since Linux 4.14)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxWipeOnFork = linux_raw_sys::general::MADV_WIPEONFORK as i32,
-    /// `MADV_KEEPONFORK` (since Linux 4.14)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxKeepOnFork = linux_raw_sys::general::MADV_KEEPONFORK as i32,
-    /// `MADV_COLD` (since Linux 5.4)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxCold = linux_raw_sys::general::MADV_COLD as i32,
-    /// `MADV_PAGEOUT` (since Linux 5.4)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxPageOut = linux_raw_sys::general::MADV_PAGEOUT as i32,
-    /// `MADV_POPULATE_READ` (since Linux 5.14)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxPopulateRead = linux_raw_sys::general::MADV_POPULATE_READ as i32,
-    /// `MADV_POPULATE_WRITE` (since Linux 5.14)
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg(feature = "mm")]
-    LinuxPopulateWrite = linux_raw_sys::general::MADV_POPULATE_WRITE as i32,
-}
-
-#[cfg(target_os = "emscripten")]
-impl Advice {
-    /// `POSIX_MADV_DONTNEED`
-    #[allow(non_upper_case_globals)]
-    pub const DontNeed: Self = Self::Normal;
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-bitflags! {
-    /// `O_*` flags for use with [`userfaultfd`].
-    ///
-    /// [`userfaultfd`]: crate::io::userfaultfd
-    pub struct UserfaultfdFlags: c::c_int {
-        /// `O_CLOEXEC`
-        const CLOEXEC = c::O_CLOEXEC;
-        /// `O_NONBLOCK`
-        const NONBLOCK = c::O_NONBLOCK;
-    }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/mod.rs
deleted file mode 100644
index 70029282f..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/mod.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-//! The libc backend.
-//!
-//! On most platforms, this uses the `libc` crate to make system calls. On
-//! Windows, this uses the Winsock2 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)]
-
-#[cfg(not(any(windows, target_os = "wasi")))]
-#[macro_use]
-mod weak;
-
-mod conv;
-mod offset;
-
-#[cfg(windows)]
-mod io_lifetimes;
-#[cfg(not(windows))]
-#[cfg(not(feature = "std"))]
-pub(crate) mod fd {
-    pub(crate) use super::c::c_int as LibcFd;
-    pub use crate::io::fd::*;
-}
-#[cfg(windows)]
-pub(crate) mod fd {
-    pub use super::io_lifetimes::*;
-}
-#[cfg(not(windows))]
-#[cfg(feature = "std")]
-pub(crate) mod fd {
-    pub use io_lifetimes::*;
-
-    #[cfg(target_os = "wasi")]
-    #[allow(unused_imports)]
-    pub(crate) use super::c::c_int as LibcFd;
-    #[cfg(unix)]
-    #[allow(unused_imports)]
-    pub(crate) use std::os::unix::io::RawFd as LibcFd;
-    #[cfg(unix)]
-    pub use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-    #[cfg(target_os = "wasi")]
-    pub use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-}
-
-// On Windows we emulate selected libc-compatible interfaces. On non-Windows,
-// we just use libc here, since this is the libc backend.
-#[cfg(windows)]
-#[path = "winsock_c.rs"]
-pub(crate) mod c;
-#[cfg(not(windows))]
-pub(crate) use libc as c;
-
-#[cfg(not(windows))]
-#[cfg(feature = "fs")]
-pub(crate) mod fs;
-pub(crate) mod io;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[cfg(feature = "io_uring")]
-pub(crate) mod io_uring;
-#[cfg(not(any(windows, target_os = "wasi")))]
-#[cfg(feature = "mm")]
-pub(crate) mod mm;
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-#[cfg(feature = "net")]
-pub(crate) mod net;
-#[cfg(not(windows))]
-#[cfg(any(
-    feature = "param",
-    feature = "runtime",
-    feature = "time",
-    target_arch = "x86",
-))]
-pub(crate) mod param;
-#[cfg(not(windows))]
-pub(crate) mod process;
-#[cfg(not(windows))]
-#[cfg(feature = "rand")]
-pub(crate) mod rand;
-#[cfg(not(windows))]
-#[cfg(feature = "termios")]
-pub(crate) mod termios;
-#[cfg(not(windows))]
-#[cfg(feature = "thread")]
-pub(crate) mod thread;
-#[cfg(not(windows))]
-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()
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/net/addr.rs b/vendor/rustix-0.36.5/src/backend/libc/net/addr.rs
deleted file mode 100644
index ba64ed279..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/net/addr.rs
+++ /dev/null
@@ -1,330 +0,0 @@
-//! IPv4, IPv6, and Socket addresses.
-
-use super::super::c;
-#[cfg(unix)]
-use crate::ffi::CStr;
-#[cfg(unix)]
-use crate::io;
-#[cfg(unix)]
-use crate::path;
-#[cfg(not(windows))]
-use core::convert::TryInto;
-#[cfg(unix)]
-use core::fmt;
-#[cfg(unix)]
-use core::slice;
-
-/// `struct sockaddr_un`
-#[cfg(unix)]
-#[derive(Clone)]
-#[doc(alias = "sockaddr_un")]
-pub struct SocketAddrUnix {
-    pub(crate) unix: c::sockaddr_un,
-    #[cfg(not(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    )))]
-    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(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        {
-            unix.sun_len = (offsetof_sun_path() + bytes.len()).try_into().unwrap();
-        }
-
-        Ok(Self {
-            unix,
-            #[cfg(not(any(
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "ios",
-                target_os = "macos",
-                target_os = "netbsd",
-                target_os = "openbsd",
-            )))]
-            len: (offsetof_sun_path() + bytes.len()).try_into().unwrap(),
-        })
-    }
-
-    /// Construct a new abstract Unix-domain address from a byte slice.
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[inline]
-    pub fn new_abstract_name(name: &[u8]) -> io::Result<Self> {
-        let mut unix = Self::init();
-        if 1 + name.len() > unix.sun_path.len() {
-            return Err(io::Errno::NAMETOOLONG);
-        }
-        unix.sun_path[0] = b'\0' as c::c_char;
-        for (i, b) in name.iter().enumerate() {
-            unix.sun_path[1 + i] = *b as c::c_char;
-        }
-        let len = offsetof_sun_path() + 1 + name.len();
-        let len = len.try_into().unwrap();
-        Ok(Self {
-            unix,
-            #[cfg(not(any(
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "ios",
-                target_os = "macos",
-                target_os = "netbsd",
-                target_os = "openbsd",
-            )))]
-            len,
-        })
-    }
-
-    fn init() -> c::sockaddr_un {
-        c::sockaddr_un {
-            #[cfg(any(
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "haiku",
-                target_os = "ios",
-                target_os = "macos",
-                target_os = "netbsd",
-                target_os = "openbsd",
-            ))]
-            sun_len: 0,
-            sun_family: c::AF_UNIX as _,
-            #[cfg(any(
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "ios",
-                target_os = "macos",
-                target_os = "netbsd",
-                target_os = "openbsd",
-            ))]
-            sun_path: [0; 104],
-            #[cfg(not(any(
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "haiku",
-                target_os = "ios",
-                target_os = "macos",
-                target_os = "netbsd",
-                target_os = "openbsd",
-            )))]
-            sun_path: [0; 108],
-            #[cfg(target_os = "haiku")]
-            sun_path: [0; 126],
-        }
-    }
-
-    /// 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] != b'\0' as c::c_char {
-            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(any(target_os = "android", target_os = "linux"))]
-    #[inline]
-    pub fn abstract_name(&self) -> Option<&[u8]> {
-        let len = self.len();
-        if len != 0 && self.unix.sun_path[0] == b'\0' as c::c_char {
-            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(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        )))]
-        {
-            self.len
-        }
-        #[cfg(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        {
-            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<core::cmp::Ordering> {
-        let self_len = self.len() - offsetof_sun_path();
-        let other_len = other.len() - offsetof_sun_path();
-        self.unix.sun_path[..self_len].partial_cmp(&other.unix.sun_path[..other_len])
-    }
-}
-
-#[cfg(unix)]
-impl Ord for SocketAddrUnix {
-    #[inline]
-    fn cmp(&self, other: &Self) -> core::cmp::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 core::hash::Hash for SocketAddrUnix {
-    #[inline]
-    fn hash<H: core::hash::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(any(target_os = "android", target_os = "linux"))]
-            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(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        sun_len: 0_u8,
-        #[cfg(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        sun_family: 0_u8,
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        )))]
-        sun_family: 0_u16,
-        #[cfg(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        sun_path: [0; 104],
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        )))]
-        sun_path: [0; 108],
-        #[cfg(target_os = "haiku")]
-        sun_path: [0; 126],
-    };
-    (crate::utils::as_ptr(&z.sun_path) as usize) - (crate::utils::as_ptr(&z) as usize)
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/net/ext.rs b/vendor/rustix-0.36.5/src/backend/libc/net/ext.rs
deleted file mode 100644
index 1c8f9f65c..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/net/ext.rs
+++ /dev/null
@@ -1,210 +0,0 @@
-use super::super::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(not(feature = "std"))]
-#[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) }
-}
-
-// TODO: With Rust 1.55, we can use the above `in_addr_s_addr` definition that
-// uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn in_addr_s_addr(addr: c::in_addr) -> u32 {
-    // This should be `*addr.S_un.S_addr()`, except that isn't a `const fn`.
-    unsafe { core::mem::transmute(addr) }
-}
-
-#[cfg(not(windows))]
-#[inline]
-pub(crate) const fn in_addr_new(s_addr: u32) -> c::in_addr {
-    c::in_addr { s_addr }
-}
-
-#[cfg(not(feature = "std"))]
-#[cfg(windows)]
-#[inline]
-pub(crate) const fn in_addr_new(s_addr: u32) -> c::in_addr {
-    unsafe { core::mem::transmute(s_addr) }
-}
-
-// TODO: With Rust 1.55, we can use the above `in_addr_new` definition that
-// uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn in_addr_new(s_addr: u32) -> c::in_addr {
-    unsafe { core::mem::transmute(s_addr) }
-}
-
-#[cfg(not(windows))]
-#[inline]
-pub(crate) const fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] {
-    addr.s6_addr
-}
-
-#[cfg(not(feature = "std"))]
-#[cfg(windows)]
-#[inline]
-pub(crate) const fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] {
-    unsafe { core::mem::transmute(addr) }
-}
-
-// TODO: With Rust 1.55, we can use the above `in6_addr_s6_addr` definition
-// that uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] {
-    unsafe { core::mem::transmute(addr) }
-}
-
-#[cfg(not(windows))]
-#[inline]
-pub(crate) const fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr {
-    c::in6_addr { s6_addr }
-}
-
-#[cfg(not(feature = "std"))]
-#[cfg(windows)]
-#[inline]
-pub(crate) const fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr {
-    unsafe { core::mem::transmute(s6_addr) }
-}
-
-// TODO: With Rust 1.55, we can use the above `in6_addr_new` definition that
-// uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr {
-    unsafe { core::mem::transmute(s6_addr) }
-}
-
-#[cfg(not(windows))]
-#[inline]
-pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 {
-    addr.sin6_scope_id
-}
-
-#[cfg(not(feature = "std"))]
-#[cfg(windows)]
-#[inline]
-pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 {
-    let addr: sockaddr_in6 = unsafe { core::mem::transmute(addr) };
-    addr.sin6_scope_id
-}
-
-// TODO: With Rust 1.55, we can use the above `sockaddr_in6_sin6_scope_id`
-// definition that uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 {
-    let addr: sockaddr_in6 = unsafe { core::mem::transmute(addr) };
-    addr.sin6_scope_id
-}
-
-#[cfg(not(windows))]
-#[inline]
-pub(crate) const fn sockaddr_in6_new(
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    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(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        sin6_len,
-        sin6_family,
-        sin6_port,
-        sin6_flowinfo,
-        sin6_addr,
-        sin6_scope_id,
-        #[cfg(any(target_os = "illumos", target_os = "solaris"))]
-        __sin6_src_id: 0,
-    }
-}
-
-#[cfg(not(feature = "std"))]
-#[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) }
-}
-
-// TODO: With Rust 1.55, we can use the above `sockaddr_in6_new` definition
-// that uses a const-fn transmute.
-#[cfg(feature = "std")]
-#[cfg(windows)]
-#[inline]
-pub(crate) fn sockaddr_in6_new(
-    sin6_family: u16,
-    sin6_port: u16,
-    sin6_flowinfo: u32,
-    sin6_addr: c::in6_addr,
-    sin6_scope_id: u32,
-) -> c::sockaddr_in6 {
-    let addr = sockaddr_in6 {
-        sin6_family,
-        sin6_port,
-        sin6_flowinfo,
-        sin6_addr,
-        sin6_scope_id,
-    };
-    unsafe { core::mem::transmute(addr) }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/net/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/net/mod.rs
deleted file mode 100644
index f7196ae4f..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/net/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-pub(crate) mod addr;
-pub(crate) mod ext;
-pub(crate) mod read_sockaddr;
-pub(crate) mod send_recv;
-pub(crate) mod syscalls;
-pub(crate) mod types;
-pub(crate) mod write_sockaddr;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/net/read_sockaddr.rs b/vendor/rustix-0.36.5/src/backend/libc/net/read_sockaddr.rs
deleted file mode 100644
index 5a946fbeb..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/net/read_sockaddr.rs
+++ /dev/null
@@ -1,255 +0,0 @@
-use super::super::c;
-#[cfg(unix)]
-use super::addr::SocketAddrUnix;
-use super::ext::{in6_addr_s6_addr, in_addr_s_addr, sockaddr_in6_sin6_scope_id};
-#[cfg(not(windows))]
-use crate::ffi::CStr;
-use crate::io;
-use crate::net::{Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrV4, SocketAddrV6};
-#[cfg(not(windows))]
-use alloc::vec::Vec;
-use core::mem::size_of;
-
-// This must match the header of `sockaddr`.
-#[repr(C)]
-struct sockaddr_header {
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    sa_len: u8,
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    ss_family: u8,
-    #[cfg(not(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    )))]
-    ss_family: u16,
-}
-
-#[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(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        sa_len: 0_u8,
-        #[cfg(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        sa_family: 0_u8,
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        )))]
-        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 _;
-}
-
-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 {
-                Ok(SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap()))
-            } else {
-                let decode = *storage.cast::<c::sockaddr_un>();
-
-                // Trim off unused bytes from the end of `path_bytes`.
-                let path_bytes = if cfg!(target_os = "freebsd") {
-                    // FreeBSD sometimes sets the length to longer than the length
-                    // of the NUL-terminated string. Find the NUL and truncate the
-                    // string accordingly.
-                    &decode.sun_path[..decode.sun_path.iter().position(|b| *b == 0).unwrap()]
-                } else {
-                    // Otherwise, use the provided length.
-                    let provided_len = len - 1 - offsetof_sun_path;
-                    if decode.sun_path[provided_len] != b'\0' as c::c_char {
-                        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]
-                };
-
-                Ok(SocketAddrAny::Unix(
-                    SocketAddrUnix::new(path_bytes.iter().map(|c| *c as u8).collect::<Vec<u8>>())
-                        .unwrap(),
-                ))
-            }
-        }
-        _ => Err(io::Errno::INVAL),
-    }
-}
-
-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))
-    }
-}
-
-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>();
-                assert_eq!(
-                    decode.sun_path[len - 1 - offsetof_sun_path],
-                    b'\0' as c::c_char
-                );
-                let path_bytes = &decode.sun_path[..len - 1 - offsetof_sun_path];
-
-                // FreeBSD sometimes sets the length to longer than the length
-                // of the NUL-terminated string. Find the NUL and truncate the
-                // string accordingly.
-                #[cfg(target_os = "freebsd")]
-                let path_bytes = &path_bytes[..path_bytes.iter().position(|b| *b == 0).unwrap()];
-
-                SocketAddrAny::Unix(
-                    SocketAddrUnix::new(path_bytes.iter().map(|c| *c as u8).collect::<Vec<u8>>())
-                        .unwrap(),
-                )
-            }
-        }
-        other => unimplemented!("{:?}", other),
-    }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/net/send_recv.rs b/vendor/rustix-0.36.5/src/backend/libc/net/send_recv.rs
deleted file mode 100644
index 8d1cc8ab7..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/net/send_recv.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-use super::super::c;
-use bitflags::bitflags;
-
-bitflags! {
-    /// `MSG_*`
-    pub struct SendFlags: i32 {
-        /// `MSG_CONFIRM`
-        #[cfg(not(any(
-            windows,
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "solaris",
-        )))]
-        const CONFIRM = c::MSG_CONFIRM;
-        /// `MSG_DONTROUTE`
-        const DONTROUTE = c::MSG_DONTROUTE;
-        /// `MSG_DONTWAIT`
-        #[cfg(not(windows))]
-        const DONTWAIT = c::MSG_DONTWAIT;
-        /// `MSG_EOR`
-        #[cfg(not(windows))]
-        const EOT = c::MSG_EOR;
-        /// `MSG_MORE`
-        #[cfg(not(any(
-            windows,
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "solaris",
-        )))]
-        const MORE = c::MSG_MORE;
-        #[cfg(not(any(windows, target_os = "ios", target_os = "macos")))]
-        /// `MSG_NOSIGNAL`
-        const NOSIGNAL = c::MSG_NOSIGNAL;
-        /// `MSG_OOB`
-        const OOB = c::MSG_OOB;
-    }
-}
-
-bitflags! {
-    /// `MSG_*`
-    pub struct RecvFlags: i32 {
-        #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "ios", target_os = "macos", target_os = "solaris")))]
-        /// `MSG_CMSG_CLOEXEC`
-        const CMSG_CLOEXEC = c::MSG_CMSG_CLOEXEC;
-        /// `MSG_DONTWAIT`
-        #[cfg(not(windows))]
-        const DONTWAIT = c::MSG_DONTWAIT;
-        /// `MSG_ERRQUEUE`
-        #[cfg(not(any(
-            windows,
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "solaris",
-        )))]
-        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 as c::c_int;
-        /// `MSG_WAITALL`
-        const WAITALL = c::MSG_WAITALL;
-    }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/net/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/net/syscalls.rs
deleted file mode 100644
index 3d8a849c7..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/net/syscalls.rs
+++ /dev/null
@@ -1,886 +0,0 @@
-//! libc syscalls supporting `rustix::net`.
-
-use super::super::c;
-use super::super::conv::{borrowed_fd, ret, ret_owned_fd, ret_send_recv, send_recv_len};
-#[cfg(unix)]
-use super::addr::SocketAddrUnix;
-use super::ext::{in6_addr_new, in_addr_new};
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::read_sockaddr::initialize_family_to_unspec;
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::read_sockaddr::{maybe_read_sockaddr_os, read_sockaddr_os};
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::send_recv::{RecvFlags, SendFlags};
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::types::{AcceptFlags, AddressFamily, Protocol, Shutdown, SocketFlags, SocketType};
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use super::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6};
-use crate::fd::{BorrowedFd, OwnedFd};
-use crate::io;
-use crate::net::{SocketAddrAny, SocketAddrV4, SocketAddrV6};
-use crate::utils::as_ptr;
-use core::convert::TryInto;
-use core::mem::{size_of, MaybeUninit};
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-use core::ptr::null_mut;
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn recv(fd: BorrowedFd<'_>, buf: &mut [u8], flags: RecvFlags) -> io::Result<usize> {
-    let nrecv = unsafe {
-        ret_send_recv(c::recv(
-            borrowed_fd(fd),
-            buf.as_mut_ptr().cast(),
-            send_recv_len(buf.len()),
-            flags.bits(),
-        ))?
-    };
-    Ok(nrecv as usize)
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn send(fd: BorrowedFd<'_>, buf: &[u8], flags: SendFlags) -> io::Result<usize> {
-    let nwritten = unsafe {
-        ret_send_recv(c::send(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            send_recv_len(buf.len()),
-            flags.bits(),
-        ))?
-    };
-    Ok(nwritten as usize)
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn recvfrom(
-    fd: BorrowedFd<'_>,
-    buf: &mut [u8],
-    flags: RecvFlags,
-) -> io::Result<(usize, Option<SocketAddrAny>)> {
-    unsafe {
-        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());
-
-        let nread = ret_send_recv(c::recvfrom(
-            borrowed_fd(fd),
-            buf.as_mut_ptr().cast(),
-            send_recv_len(buf.len()),
-            flags.bits(),
-            storage.as_mut_ptr().cast(),
-            &mut len,
-        ))?;
-        Ok((
-            nread as usize,
-            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> {
-    let nwritten = unsafe {
-        ret_send_recv(c::sendto(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            send_recv_len(buf.len()),
-            flags.bits(),
-            as_ptr(&encode_sockaddr_v4(addr)).cast::<c::sockaddr>(),
-            size_of::<SocketAddrV4>() as _,
-        ))?
-    };
-    Ok(nwritten as usize)
-}
-
-#[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> {
-    let nwritten = unsafe {
-        ret_send_recv(c::sendto(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            send_recv_len(buf.len()),
-            flags.bits(),
-            as_ptr(&encode_sockaddr_v6(addr)).cast::<c::sockaddr>(),
-            size_of::<SocketAddrV6>() as _,
-        ))?
-    };
-    Ok(nwritten as usize)
-}
-
-#[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> {
-    let nwritten = unsafe {
-        ret_send_recv(c::sendto(
-            borrowed_fd(fd),
-            buf.as_ptr().cast(),
-            send_recv_len(buf.len()),
-            flags.bits(),
-            as_ptr(&addr.unix).cast(),
-            addr.addr_len(),
-        ))?
-    };
-    Ok(nwritten as usize)
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn socket(
-    domain: AddressFamily,
-    type_: SocketType,
-    protocol: Protocol,
-) -> io::Result<OwnedFd> {
-    unsafe {
-        ret_owned_fd(c::socket(
-            domain.0 as c::c_int,
-            type_.0 as c::c_int,
-            protocol.0,
-        ))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) fn socket_with(
-    domain: AddressFamily,
-    type_: SocketType,
-    flags: SocketFlags,
-    protocol: Protocol,
-) -> io::Result<OwnedFd> {
-    unsafe {
-        ret_owned_fd(c::socket(
-            domain.0 as c::c_int,
-            type_.0 as c::c_int | flags.bits(),
-            protocol.0,
-        ))
-    }
-}
-
-#[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 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 = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-pub(crate) fn accept_with(sockfd: BorrowedFd<'_>, flags: AcceptFlags) -> io::Result<OwnedFd> {
-    unsafe {
-        let owned_fd = ret_owned_fd(c::accept4(
-            borrowed_fd(sockfd),
-            null_mut(),
-            null_mut(),
-            flags.bits(),
-        ))?;
-        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(
-    windows,
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-pub(crate) fn acceptfrom_with(
-    sockfd: BorrowedFd<'_>,
-    flags: AcceptFlags,
-) -> 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(),
-        ))?;
-        Ok((
-            owned_fd,
-            maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()),
-        ))
-    }
-}
-
-/// Darwin lacks `accept4`, but does have `accept`. We define
-/// `AcceptFlags` to have no flags, so we can discard it here.
-#[cfg(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos"))]
-pub(crate) fn accept_with(sockfd: BorrowedFd<'_>, _flags: AcceptFlags) -> io::Result<OwnedFd> {
-    accept(sockfd)
-}
-
-/// Darwin lacks `accept4`, but does have `accept`. We define
-/// `AcceptFlags` to have no flags, so we can discard it here.
-#[cfg(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos"))]
-pub(crate) fn acceptfrom_with(
-    sockfd: BorrowedFd<'_>,
-    _flags: AcceptFlags,
-) -> 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: Protocol,
-) -> io::Result<(OwnedFd, OwnedFd)> {
-    unsafe {
-        let mut fds = MaybeUninit::<[OwnedFd; 2]>::uninit();
-        ret(c::socketpair(
-            c::c_int::from(domain.0),
-            type_.0 as c::c_int | flags.bits(),
-            protocol.0,
-            fds.as_mut_ptr().cast::<c::c_int>(),
-        ))?;
-
-        let [fd0, fd1] = fds.assume_init();
-        Ok((fd0, fd1))
-    }
-}
-
-#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
-pub(crate) mod sockopt {
-    use super::{c, in6_addr_new, in_addr_new, BorrowedFd};
-    use crate::io;
-    use crate::net::sockopt::Timeout;
-    use crate::net::{Ipv4Addr, Ipv6Addr, SocketType};
-    use crate::utils::as_mut_ptr;
-    use core::convert::TryInto;
-    use core::time::Duration;
-    #[cfg(windows)]
-    use windows_sys::Win32::Foundation::BOOL;
-
-    // TODO: With Rust 1.53 we can use `Duration::ZERO` instead.
-    const DURATION_ZERO: Duration = Duration::from_secs(0);
-
-    #[inline]
-    fn getsockopt<T: Copy>(fd: BorrowedFd<'_>, level: i32, optname: i32) -> io::Result<T> {
-        use super::*;
-
-        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"
-        );
-
-        unsafe {
-            let mut value = core::mem::zeroed::<T>();
-            ret(c::getsockopt(
-                borrowed_fd(fd),
-                level,
-                optname,
-                as_mut_ptr(&mut value).cast(),
-                &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"
-            );
-            Ok(value)
-        }
-    }
-
-    #[inline]
-    fn setsockopt<T: Copy>(
-        fd: BorrowedFd<'_>,
-        level: i32,
-        optname: i32,
-        value: T,
-    ) -> io::Result<()> {
-        use super::*;
-
-        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"
-        );
-
-        unsafe {
-            ret(c::setsockopt(
-                borrowed_fd(fd),
-                level,
-                optname,
-                as_ptr(&value).cast(),
-                optlen,
-            ))
-        }
-    }
-
-    #[inline]
-    pub(crate) fn get_socket_type(fd: BorrowedFd<'_>) -> io::Result<SocketType> {
-        getsockopt(fd, c::SOL_SOCKET as _, c::SO_TYPE)
-    }
-
-    #[inline]
-    pub(crate) fn set_socket_reuseaddr(fd: BorrowedFd<'_>, reuseaddr: bool) -> io::Result<()> {
-        setsockopt(
-            fd,
-            c::SOL_SOCKET as _,
-            c::SO_REUSEADDR,
-            from_bool(reuseaddr),
-        )
-    }
-
-    #[inline]
-    pub(crate) fn set_socket_broadcast(fd: BorrowedFd<'_>, broadcast: bool) -> io::Result<()> {
-        setsockopt(
-            fd,
-            c::SOL_SOCKET as _,
-            c::SO_BROADCAST,
-            from_bool(broadcast),
-        )
-    }
-
-    #[inline]
-    pub(crate) fn get_socket_broadcast(fd: BorrowedFd<'_>) -> io::Result<bool> {
-        getsockopt(fd, c::SOL_SOCKET as _, 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 {
-            let mut l_linger = linger.as_secs();
-            if linger.subsec_nanos() != 0 {
-                l_linger = l_linger.checked_add(1).ok_or(io::Errno::INVAL)?;
-            }
-            l_linger.try_into().map_err(|_e| io::Errno::INVAL)?
-        } else {
-            0
-        };
-        let linger = c::linger {
-            l_onoff: linger.is_some() as _,
-            l_linger,
-        };
-        setsockopt(fd, c::SOL_SOCKET as _, 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 as _, c::SO_LINGER)?;
-        // TODO: With Rust 1.50, this could use `.then`.
-        Ok(if linger.l_onoff != 0 {
-            Some(Duration::from_secs(linger.l_linger as u64))
-        } else {
-            None
-        })
-    }
-
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[inline]
-    pub(crate) fn set_socket_passcred(fd: BorrowedFd<'_>, passcred: bool) -> io::Result<()> {
-        setsockopt(fd, c::SOL_SOCKET as _, c::SO_PASSCRED, from_bool(passcred))
-    }
-
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[inline]
-    pub(crate) fn get_socket_passcred(fd: BorrowedFd<'_>) -> io::Result<bool> {
-        getsockopt(fd, c::SOL_SOCKET as _, 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);
-                }
-
-                let tv_sec = timeout.as_secs().try_into();
-                #[cfg(not(all(target_arch = "x86_64", target_pointer_width = "32")))]
-                let tv_sec = tv_sec.unwrap_or(c::c_long::MAX);
-                #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))]
-                let tv_sec = tv_sec.unwrap_or(i64::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)))
-            }
-        }
-    }
-
-    #[inline]
-    pub(crate) fn set_ip_ttl(fd: BorrowedFd<'_>, ttl: u32) -> io::Result<()> {
-        setsockopt(fd, c::IPPROTO_IP as _, c::IP_TTL, ttl)
-    }
-
-    #[inline]
-    pub(crate) fn get_ip_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> {
-        getsockopt(fd, c::IPPROTO_IP as _, c::IP_TTL)
-    }
-
-    #[inline]
-    pub(crate) fn set_ipv6_v6only(fd: BorrowedFd<'_>, only_v6: bool) -> io::Result<()> {
-        setsockopt(fd, c::IPPROTO_IPV6 as _, c::IPV6_V6ONLY, from_bool(only_v6))
-    }
-
-    #[inline]
-    pub(crate) fn get_ipv6_v6only(fd: BorrowedFd<'_>) -> io::Result<bool> {
-        getsockopt(fd, c::IPPROTO_IPV6 as _, 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 as _,
-            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 as _, 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 as _, c::IP_MULTICAST_TTL, multicast_ttl)
-    }
-
-    #[inline]
-    pub(crate) fn get_ip_multicast_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> {
-        getsockopt(fd, c::IPPROTO_IP as _, c::IP_MULTICAST_TTL)
-    }
-
-    #[inline]
-    pub(crate) fn set_ipv6_multicast_loop(
-        fd: BorrowedFd<'_>,
-        multicast_loop: bool,
-    ) -> io::Result<()> {
-        setsockopt(
-            fd,
-            c::IPPROTO_IPV6 as _,
-            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 as _, 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 as _,
-            c::IPV6_MULTICAST_LOOP,
-            multicast_hops,
-        )
-    }
-
-    #[inline]
-    pub(crate) fn get_ipv6_multicast_hops(fd: BorrowedFd<'_>) -> io::Result<u32> {
-        getsockopt(fd, c::IPPROTO_IP as _, c::IPV6_MULTICAST_LOOP)
-    }
-
-    #[inline]
-    pub(crate) fn set_ip_add_membership(
-        fd: BorrowedFd<'_>,
-        multiaddr: &Ipv4Addr,
-        interface: &Ipv4Addr,
-    ) -> io::Result<()> {
-        let mreq = to_imr(multiaddr, interface);
-        setsockopt(fd, c::IPPROTO_IP as _, c::IP_ADD_MEMBERSHIP, mreq)
-    }
-
-    #[inline]
-    pub(crate) fn set_ipv6_add_membership(
-        fd: BorrowedFd<'_>,
-        multiaddr: &Ipv6Addr,
-        interface: u32,
-    ) -> io::Result<()> {
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "l4re",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "solaris",
-        )))]
-        use c::IPV6_ADD_MEMBERSHIP;
-        #[cfg(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "l4re",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "solaris",
-        ))]
-        use c::IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP;
-
-        let mreq = to_ipv6mr(multiaddr, interface);
-        setsockopt(fd, c::IPPROTO_IPV6 as _, IPV6_ADD_MEMBERSHIP, mreq)
-    }
-
-    #[inline]
-    pub(crate) fn set_ip_drop_membership(
-        fd: BorrowedFd<'_>,
-        multiaddr: &Ipv4Addr,
-        interface: &Ipv4Addr,
-    ) -> io::Result<()> {
-        let mreq = to_imr(multiaddr, interface);
-        setsockopt(fd, c::IPPROTO_IP as _, c::IP_DROP_MEMBERSHIP, mreq)
-    }
-
-    #[inline]
-    pub(crate) fn set_ipv6_drop_membership(
-        fd: BorrowedFd<'_>,
-        multiaddr: &Ipv6Addr,
-        interface: u32,
-    ) -> io::Result<()> {
-        #[cfg(not(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "l4re",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "solaris",
-        )))]
-        use c::IPV6_DROP_MEMBERSHIP;
-        #[cfg(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "illumos",
-            target_os = "ios",
-            target_os = "l4re",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-            target_os = "solaris",
-        ))]
-        use c::IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP;
-
-        let mreq = to_ipv6mr(multiaddr, interface);
-        setsockopt(fd, c::IPPROTO_IPV6 as _, IPV6_DROP_MEMBERSHIP, mreq)
-    }
-
-    #[inline]
-    pub(crate) fn set_tcp_nodelay(fd: BorrowedFd<'_>, nodelay: bool) -> io::Result<()> {
-        setsockopt(fd, c::IPPROTO_TCP as _, c::TCP_NODELAY, from_bool(nodelay))
-    }
-
-    #[inline]
-    pub(crate) fn get_tcp_nodelay(fd: BorrowedFd<'_>) -> io::Result<bool> {
-        getsockopt(fd, c::IPPROTO_TCP as _, c::TCP_NODELAY).map(to_bool)
-    }
-
-    #[inline]
-    fn to_imr(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_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 as _)
-    }
-
-    // Convert from a `SocketBool` to a `bool`.
-    #[inline]
-    fn to_bool(value: SocketBool) -> bool {
-        value.0 != 0
-    }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/net/types.rs b/vendor/rustix-0.36.5/src/backend/libc/net/types.rs
deleted file mode 100644
index 19d97e7c7..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/net/types.rs
+++ /dev/null
@@ -1,687 +0,0 @@
-use super::super::c;
-use bitflags::bitflags;
-
-/// A type for holding raw integer socket types.
-#[doc(hidden)]
-pub type RawSocketType = u32;
-
-/// `SOCK_*` constants for use with [`socket`].
-///
-/// [`socket`]: crate::net::socket
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct SocketType(pub(crate) RawSocketType);
-
-#[rustfmt::skip]
-impl SocketType {
-    /// `SOCK_STREAM`
-    pub const STREAM: Self = Self(c::SOCK_STREAM as u32);
-
-    /// `SOCK_DGRAM`
-    pub const DGRAM: Self = Self(c::SOCK_DGRAM as u32);
-
-    /// `SOCK_SEQPACKET`
-    pub const SEQPACKET: Self = Self(c::SOCK_SEQPACKET as u32);
-
-    /// `SOCK_RAW`
-    pub const RAW: Self = Self(c::SOCK_RAW as u32);
-
-    /// `SOCK_RDM`
-    #[cfg(not(target_os = "haiku"))]
-    pub const RDM: Self = Self(c::SOCK_RDM as u32);
-
-    /// Constructs a `SocketType` from a raw integer.
-    #[inline]
-    pub const fn from_raw(raw: RawSocketType) -> Self {
-        Self(raw)
-    }
-
-    /// Returns the raw integer for this `SocketType`.
-    #[inline]
-    pub const fn as_raw(self) -> RawSocketType {
-        self.0
-    }
-}
-
-/// A type for holding raw integer address families.
-#[doc(hidden)]
-pub type RawAddressFamily = c::sa_family_t;
-
-/// `AF_*` constants.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct AddressFamily(pub(crate) RawAddressFamily);
-
-#[rustfmt::skip]
-impl AddressFamily {
-    /// `AF_UNSPEC`
-    pub const UNSPEC: Self = Self(c::AF_UNSPEC as _);
-    /// `AF_INET`
-    pub const INET: Self = Self(c::AF_INET as _);
-    /// `AF_INET6`
-    pub const INET6: Self = Self(c::AF_INET6 as _);
-    /// `AF_NETLINK`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const NETLINK: Self = Self(c::AF_NETLINK as _);
-    /// `AF_UNIX`, aka `AF_LOCAL`
-    #[doc(alias = "LOCAL")]
-    pub const UNIX: Self = Self(c::AF_UNIX as _);
-    /// `AF_AX25`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const AX25: Self = Self(c::AF_AX25 as _);
-    /// `AF_IPX`
-    pub const IPX: Self = Self(c::AF_IPX as _);
-    /// `AF_APPLETALK`
-    pub const APPLETALK: Self = Self(c::AF_APPLETALK as _);
-    /// `AF_NETROM`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const NETROM: Self = Self(c::AF_NETROM as _);
-    /// `AF_BRIDGE`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const BRIDGE: Self = Self(c::AF_BRIDGE as _);
-    /// `AF_ATMPVC`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const ATMPVC: Self = Self(c::AF_ATMPVC as _);
-    /// `AF_X25`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    )))]
-    pub const X25: Self = Self(c::AF_X25 as _);
-    /// `AF_ROSE`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const ROSE: Self = Self(c::AF_ROSE as _);
-    /// `AF_DECnet`
-    #[allow(non_upper_case_globals)]
-    #[cfg(not(target_os = "haiku"))]
-    pub const DECnet: Self = Self(c::AF_DECnet as _);
-    /// `AF_NETBEUI`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const NETBEUI: Self = Self(c::AF_NETBEUI as _);
-    /// `AF_SECURITY`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const SECURITY: Self = Self(c::AF_SECURITY as _);
-    /// `AF_KEY`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    )))]
-    pub const KEY: Self = Self(c::AF_KEY as _);
-    /// `AF_PACKET`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    )))]
-    pub const PACKET: Self = Self(c::AF_PACKET as _);
-    /// `AF_ASH`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const ASH: Self = Self(c::AF_ASH as _);
-    /// `AF_ECONET`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const ECONET: Self = Self(c::AF_ECONET as _);
-    /// `AF_ATMSVC`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const ATMSVC: Self = Self(c::AF_ATMSVC as _);
-    /// `AF_RDS`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const RDS: Self = Self(c::AF_RDS as _);
-    /// `AF_SNA`
-    #[cfg(not(target_os = "haiku"))]
-    pub const SNA: Self = Self(c::AF_SNA as _);
-    /// `AF_IRDA`
-    #[cfg(not(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const IRDA: Self = Self(c::AF_IRDA as _);
-    /// `AF_PPPOX`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const PPPOX: Self = Self(c::AF_PPPOX as _);
-    /// `AF_WANPIPE`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const WANPIPE: Self = Self(c::AF_WANPIPE as _);
-    /// `AF_LLC`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const LLC: Self = Self(c::AF_LLC as _);
-    /// `AF_CAN`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const CAN: Self = Self(c::AF_CAN as _);
-    /// `AF_TIPC`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const TIPC: Self = Self(c::AF_TIPC as _);
-    /// `AF_BLUETOOTH`
-    #[cfg(not(any(windows, target_os = "illumos", target_os = "ios", target_os = "macos", target_os = "solaris")))]
-    pub const BLUETOOTH: Self = Self(c::AF_BLUETOOTH as _);
-    /// `AF_IUCV`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const IUCV: Self = Self(c::AF_IUCV as _);
-    /// `AF_RXRPC`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const RXRPC: Self = Self(c::AF_RXRPC as _);
-    /// `AF_ISDN`
-    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const ISDN: Self = Self(c::AF_ISDN as _);
-    /// `AF_PHONET`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const PHONET: Self = Self(c::AF_PHONET as _);
-    /// `AF_IEEE802154`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const IEEE802154: Self = Self(c::AF_IEEE802154 as _);
-
-    /// Constructs a `AddressFamily` from a raw integer.
-    #[inline]
-    pub const fn from_raw(raw: RawAddressFamily) -> Self {
-        Self(raw)
-    }
-
-    /// Returns the raw integer for this `AddressFamily`.
-    #[inline]
-    pub const fn as_raw(self) -> RawAddressFamily {
-        self.0
-    }
-}
-
-/// A type for holding raw integer protocols.
-#[doc(hidden)]
-pub type RawProtocol = i32;
-
-/// `IPPROTO_*`
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct Protocol(pub(crate) RawProtocol);
-
-#[rustfmt::skip]
-impl Protocol {
-    /// `IPPROTO_IP`
-    pub const IP: Self = Self(c::IPPROTO_IP as _);
-    /// `IPPROTO_ICMP`
-    pub const ICMP: Self = Self(c::IPPROTO_ICMP as _);
-    /// `IPPROTO_IGMP`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const IGMP: Self = Self(c::IPPROTO_IGMP as _);
-    /// `IPPROTO_IPIP`
-    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const IPIP: Self = Self(c::IPPROTO_IPIP as _);
-    /// `IPPROTO_TCP`
-    pub const TCP: Self = Self(c::IPPROTO_TCP as _);
-    /// `IPPROTO_EGP`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const EGP: Self = Self(c::IPPROTO_EGP as _);
-    /// `IPPROTO_PUP`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const PUP: Self = Self(c::IPPROTO_PUP as _);
-    /// `IPPROTO_UDP`
-    pub const UDP: Self = Self(c::IPPROTO_UDP as _);
-    /// `IPPROTO_IDP`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const IDP: Self = Self(c::IPPROTO_IDP as _);
-    /// `IPPROTO_TP`
-    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const TP: Self = Self(c::IPPROTO_TP as _);
-    /// `IPPROTO_DCCP`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const DCCP: Self = Self(c::IPPROTO_DCCP as _);
-    /// `IPPROTO_IPV6`
-    pub const IPV6: Self = Self(c::IPPROTO_IPV6 as _);
-    /// `IPPROTO_RSVP`
-    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const RSVP: Self = Self(c::IPPROTO_RSVP as _);
-    /// `IPPROTO_GRE`
-    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const GRE: Self = Self(c::IPPROTO_GRE as _);
-    /// `IPPROTO_ESP`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const ESP: Self = Self(c::IPPROTO_ESP as _);
-    /// `IPPROTO_AH`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const AH: Self = Self(c::IPPROTO_AH as _);
-    /// `IPPROTO_MTP`
-    #[cfg(not(any(
-        windows,
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const MTP: Self = Self(c::IPPROTO_MTP as _);
-    /// `IPPROTO_BEETPH`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const BEETPH: Self = Self(c::IPPROTO_BEETPH as _);
-    /// `IPPROTO_ENCAP`
-    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const ENCAP: Self = Self(c::IPPROTO_ENCAP as _);
-    /// `IPPROTO_PIM`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const PIM: Self = Self(c::IPPROTO_PIM as _);
-    /// `IPPROTO_COMP`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const COMP: Self = Self(c::IPPROTO_COMP as _);
-    /// `IPPROTO_SCTP`
-    #[cfg(not(any(target_os = "dragonfly", target_os = "haiku", target_os = "illumos", target_os = "openbsd", target_os = "solaris")))]
-    pub const SCTP: Self = Self(c::IPPROTO_SCTP as _);
-    /// `IPPROTO_UDPLITE`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const UDPLITE: Self = Self(c::IPPROTO_UDPLITE as _);
-    /// `IPPROTO_MPLS`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "solaris",
-    )))]
-    pub const MPLS: Self = Self(c::IPPROTO_MPLS as _);
-    /// `IPPROTO_RAW`
-    pub const RAW: Self = Self(c::IPPROTO_RAW as _);
-    /// `IPPROTO_MPTCP`
-    #[cfg(not(any(
-        windows,
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "emscripten",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const MPTCP: Self = Self(c::IPPROTO_MPTCP as _);
-    /// `IPPROTO_FRAGMENT`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const FRAGMENT: Self = Self(c::IPPROTO_FRAGMENT as _);
-    /// `IPPROTO_ICMPV6`
-    pub const ICMPV6: Self = Self(c::IPPROTO_ICMPV6 as _);
-    /// `IPPROTO_MH`
-    #[cfg(not(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    pub const MH: Self = Self(c::IPPROTO_MH as _);
-    /// `IPPROTO_ROUTING`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    pub const ROUTING: Self = Self(c::IPPROTO_ROUTING as _);
-
-    /// Constructs a `Protocol` from a raw integer.
-    #[inline]
-    pub const fn from_raw(raw: RawProtocol) -> Self {
-        Self(raw)
-    }
-
-    /// Returns the raw integer for this `Protocol`.
-    #[inline]
-    pub const fn as_raw(self) -> RawProtocol {
-        self.0
-    }
-}
-
-/// `SHUT_*` constants for use with [`shutdown`].
-///
-/// [`shutdown`]: crate::net::shutdown
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum Shutdown {
-    /// `SHUT_RD`—Disable further read operations.
-    Read = c::SHUT_RD,
-    /// `SHUT_WR`—Disable further write operations.
-    Write = c::SHUT_WR,
-    /// `SHUT_RDWR`—Disable further read and write operations.
-    ReadWrite = c::SHUT_RDWR,
-}
-
-bitflags! {
-    /// `SOCK_*` constants for use with [`accept_with`] and [`acceptfrom_with`].
-    ///
-    /// [`accept_with`]: crate::net::accept_with
-    /// [`acceptfrom_with`]: crate::net::acceptfrom_with
-    pub struct AcceptFlags: c::c_int {
-        /// `SOCK_NONBLOCK`
-        #[cfg(not(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos")))]
-        const NONBLOCK = c::SOCK_NONBLOCK;
-
-        /// `SOCK_CLOEXEC`
-        #[cfg(not(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos")))]
-        const CLOEXEC = c::SOCK_CLOEXEC;
-    }
-}
-
-bitflags! {
-    /// `SOCK_*` constants for use with [`socket`].
-    ///
-    /// [`socket`]: crate::net::socket
-    pub struct SocketFlags: c::c_int {
-        /// `SOCK_NONBLOCK`
-        #[cfg(not(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos")))]
-        const NONBLOCK = c::SOCK_NONBLOCK;
-
-        /// `SOCK_CLOEXEC`
-        #[cfg(not(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos")))]
-        const CLOEXEC = c::SOCK_CLOEXEC;
-    }
-}
-
-/// Timeout identifier for use with [`set_socket_timeout`] and
-/// [`get_socket_timeout`].
-///
-/// [`set_socket_timeout`]: crate::net::sockopt::set_socket_timeout.
-/// [`get_socket_timeout`]: crate::net::sockopt::get_socket_timeout.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum Timeout {
-    /// `SO_RCVTIMEO`—Timeout for receiving.
-    Recv = c::SO_RCVTIMEO,
-
-    /// `SO_SNDTIMEO`—Timeout for sending.
-    Send = c::SO_SNDTIMEO,
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/net/write_sockaddr.rs b/vendor/rustix-0.36.5/src/backend/libc/net/write_sockaddr.rs
deleted file mode 100644
index f44284a0b..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/net/write_sockaddr.rs
+++ /dev/null
@@ -1,102 +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::super::c;
-use super::addr::SocketAddrStorage;
-#[cfg(unix)]
-use super::addr::SocketAddrUnix;
-use super::ext::{in6_addr_new, in_addr_new, sockaddr_in6_new};
-use crate::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) unsafe fn encode_sockaddr_v4(v4: &SocketAddrV4) -> c::sockaddr_in {
-    c::sockaddr_in {
-        #[cfg(any(
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "haiku",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd",
-        ))]
-        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(target_os = "haiku"))]
-        sin_zero: [0; 8_usize],
-        #[cfg(target_os = "haiku")]
-        sin_zero: [0; 24_usize],
-    }
-}
-
-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) unsafe fn encode_sockaddr_v6(v6: &SocketAddrV6) -> c::sockaddr_in6 {
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    {
-        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(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    )))]
-    {
-        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-0.36.5/src/backend/libc/offset.rs b/vendor/rustix-0.36.5/src/backend/libc/offset.rs
deleted file mode 100644
index 8aae9d073..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/offset.rs
+++ /dev/null
@@ -1,406 +0,0 @@
-//! Automatically enable “large file” support features.
-
-#[cfg(not(windows))]
-use super::c;
-
-#[cfg(not(any(
-    windows,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "l4re",
-    target_os = "linux",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use c::{
-    fstat as libc_fstat, fstatat as libc_fstatat, ftruncate as libc_ftruncate, lseek as libc_lseek,
-    off_t as libc_off_t,
-};
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "l4re",
-    target_os = "linux",
-))]
-#[cfg(feature = "fs")]
-pub(super) use c::{
-    fstat64 as libc_fstat, fstatat64 as libc_fstatat, ftruncate64 as libc_ftruncate,
-    lseek64 as libc_lseek, off64_t as libc_off_t,
-};
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "l4re",
-    target_os = "linux",
-))]
-pub(super) use c::rlimit64 as libc_rlimit;
-
-#[cfg(not(any(
-    windows,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "l4re",
-    target_os = "linux",
-    target_os = "wasi",
-)))]
-#[cfg(feature = "mm")]
-pub(super) use c::mmap as libc_mmap;
-
-#[cfg(not(any(
-    windows,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "l4re",
-    target_os = "linux",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-pub(super) use c::{rlimit as libc_rlimit, RLIM_INFINITY as LIBC_RLIM_INFINITY};
-
-#[cfg(not(any(
-    windows,
-    target_os = "android",
-    target_os = "fuchsia",
-    target_os = "emscripten",
-    target_os = "l4re",
-    target_os = "linux",
-    target_os = "wasi",
-)))]
-pub(super) use c::{getrlimit as libc_getrlimit, setrlimit as libc_setrlimit};
-
-// TODO: Add `RLIM64_INFINITY` to upstream libc.
-#[cfg(any(
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-    target_os = "l4re",
-))]
-pub(super) const LIBC_RLIM_INFINITY: u64 = !0_u64;
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-    target_os = "l4re",
-))]
-pub(super) use c::{getrlimit64 as libc_getrlimit, setrlimit64 as libc_setrlimit};
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-    target_os = "l4re",
-))]
-#[cfg(feature = "mm")]
-pub(super) use c::mmap64 as libc_mmap;
-
-// `prlimit64` wasn't supported in glibc until 2.13.
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-weak_or_syscall! {
-    fn prlimit64(
-        pid: c::pid_t,
-        resource: c::__rlimit_resource_t,
-        new_limit: *const c::rlimit64,
-        old_limit: *mut c::rlimit64
-    ) via SYS_prlimit64 -> c::c_int
-}
-#[cfg(all(target_os = "linux", target_env = "musl"))]
-weak_or_syscall! {
-    fn prlimit64(
-        pid: c::pid_t,
-        resource: c::c_int,
-        new_limit: *const c::rlimit64,
-        old_limit: *mut c::rlimit64
-    ) via SYS_prlimit64 -> c::c_int
-}
-#[cfg(target_os = "android")]
-weak_or_syscall! {
-    fn prlimit64(
-        pid: c::pid_t,
-        resource: c::c_int,
-        new_limit: *const c::rlimit64,
-        old_limit: *mut c::rlimit64
-    ) via SYS_prlimit64 -> c::c_int
-}
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-pub(super) unsafe fn libc_prlimit(
-    pid: c::pid_t,
-    resource: c::__rlimit_resource_t,
-    new_limit: *const c::rlimit64,
-    old_limit: *mut c::rlimit64,
-) -> c::c_int {
-    prlimit64(pid, resource, new_limit, old_limit)
-}
-#[cfg(all(target_os = "linux", target_env = "musl"))]
-pub(super) unsafe fn libc_prlimit(
-    pid: c::pid_t,
-    resource: c::c_int,
-    new_limit: *const c::rlimit64,
-    old_limit: *mut c::rlimit64,
-) -> c::c_int {
-    prlimit64(pid, resource, new_limit, old_limit)
-}
-#[cfg(target_os = "android")]
-pub(super) unsafe fn libc_prlimit(
-    pid: c::pid_t,
-    resource: c::c_int,
-    new_limit: *const c::rlimit64,
-    old_limit: *mut c::rlimit64,
-) -> c::c_int {
-    prlimit64(pid, resource, new_limit, old_limit)
-}
-
-#[cfg(not(any(
-    windows,
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-    target_os = "l4re",
-    target_os = "redox",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use c::openat as libc_openat;
-#[cfg(any(
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-    target_os = "l4re",
-))]
-#[cfg(feature = "fs")]
-pub(super) use c::openat64 as libc_openat;
-
-#[cfg(target_os = "fuchsia")]
-#[cfg(feature = "fs")]
-pub(super) use c::fallocate as libc_fallocate;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[cfg(feature = "fs")]
-pub(super) use c::fallocate64 as libc_fallocate;
-#[cfg(not(any(
-    windows,
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "linux",
-    target_os = "l4re",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use c::posix_fadvise as libc_posix_fadvise;
-#[cfg(any(
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "linux",
-    target_os = "l4re",
-))]
-#[cfg(feature = "fs")]
-pub(super) use c::posix_fadvise64 as libc_posix_fadvise;
-
-#[cfg(all(not(any(
-    windows,
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-))))]
-pub(super) use c::{pread as libc_pread, pwrite as libc_pwrite};
-#[cfg(any(target_os = "android", target_os = "linux", target_os = "emscripten"))]
-pub(super) use c::{pread64 as libc_pread, pwrite64 as libc_pwrite};
-#[cfg(any(target_os = "linux", target_os = "emscripten"))]
-pub(super) use c::{preadv64 as libc_preadv, pwritev64 as libc_pwritev};
-#[cfg(target_os = "android")]
-mod readwrite_pv64 {
-    use super::c;
-
-    // 64-bit offsets on 32-bit platforms are passed in endianness-specific
-    // lo/hi pairs. See src/backend/linux_raw/conv.rs for details.
-    #[cfg(all(target_endian = "little", target_pointer_width = "32"))]
-    fn lo(x: u64) -> usize {
-        (x >> 32) as usize
-    }
-    #[cfg(all(target_endian = "little", target_pointer_width = "32"))]
-    fn hi(x: u64) -> usize {
-        (x & 0xffff_ffff) as usize
-    }
-    #[cfg(all(target_endian = "big", target_pointer_width = "32"))]
-    fn lo(x: u64) -> usize {
-        (x & 0xffff_ffff) as usize
-    }
-    #[cfg(all(target_endian = "big", target_pointer_width = "32"))]
-    fn hi(x: u64) -> usize {
-        (x >> 32) as usize
-    }
-
-    pub(in super::super) unsafe fn preadv64(
-        fd: c::c_int,
-        iov: *const c::iovec,
-        iovcnt: c::c_int,
-        offset: c::off64_t,
-    ) -> c::ssize_t {
-        // Older Android libc lacks `preadv64`, so use the `weak!` mechanism to
-        // test for it, and call back to `c::syscall`. We don't use
-        // `weak_or_syscall` here because we need to pass the 64-bit offset
-        // specially.
-        weak! {
-            fn preadv64(c::c_int, *const c::iovec, c::c_int, c::off64_t) -> c::ssize_t
-        }
-        if let Some(fun) = preadv64.get() {
-            fun(fd, iov, iovcnt, offset)
-        } else {
-            #[cfg(target_pointer_width = "32")]
-            {
-                c::syscall(
-                    c::SYS_preadv,
-                    fd,
-                    iov,
-                    iovcnt,
-                    hi(offset as u64),
-                    lo(offset as u64),
-                ) as c::ssize_t
-            }
-            #[cfg(target_pointer_width = "64")]
-            {
-                c::syscall(c::SYS_preadv, fd, iov, iovcnt, offset) as c::ssize_t
-            }
-        }
-    }
-    pub(in super::super) unsafe fn pwritev64(
-        fd: c::c_int,
-        iov: *const c::iovec,
-        iovcnt: c::c_int,
-        offset: c::off64_t,
-    ) -> c::ssize_t {
-        // See the comments in `preadv64`.
-        weak! {
-            fn pwritev64(c::c_int, *const c::iovec, c::c_int, c::off64_t) -> c::ssize_t
-        }
-        if let Some(fun) = pwritev64.get() {
-            fun(fd, iov, iovcnt, offset)
-        } else {
-            #[cfg(target_pointer_width = "32")]
-            {
-                c::syscall(
-                    c::SYS_pwritev,
-                    fd,
-                    iov,
-                    iovcnt,
-                    hi(offset as u64),
-                    lo(offset as u64),
-                ) as c::ssize_t
-            }
-            #[cfg(target_pointer_width = "64")]
-            {
-                c::syscall(c::SYS_pwritev, fd, iov, iovcnt, offset) as c::ssize_t
-            }
-        }
-    }
-}
-#[cfg(not(any(
-    windows,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "linux",
-    target_os = "macos",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub(super) use c::{preadv as libc_preadv, pwritev as libc_pwritev};
-#[cfg(target_os = "android")]
-pub(super) use readwrite_pv64::{preadv64 as libc_preadv, pwritev64 as libc_pwritev};
-// macOS added preadv and pwritev in version 11.0
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-mod readwrite_pv {
-    use super::c;
-
-    weakcall! {
-        pub(in super::super) fn preadv(
-            fd: c::c_int,
-            iov: *const c::iovec,
-            iovcnt: c::c_int,
-            offset: c::off_t
-        ) -> c::ssize_t
-    }
-    weakcall! {
-        pub(in super::super) fn pwritev(
-            fd: c::c_int,
-            iov: *const c::iovec,
-            iovcnt: c::c_int, offset: c::off_t
-        ) -> c::ssize_t
-    }
-}
-#[cfg(all(target_os = "linux", target_env = "gnu"))]
-pub(super) use c::{preadv64v2 as libc_preadv2, pwritev64v2 as libc_pwritev2};
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-pub(super) use readwrite_pv::{preadv as libc_preadv, pwritev as libc_pwritev};
-
-#[cfg(not(any(
-    windows,
-    target_os = "aix",
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "linux",
-    target_os = "l4re",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use c::posix_fallocate as libc_posix_fallocate;
-#[cfg(target_os = "l4re")]
-#[cfg(feature = "fs")]
-pub(super) use c::posix_fallocate64 as libc_posix_fallocate;
-#[cfg(not(any(
-    windows,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "linux",
-    target_os = "l4re",
-    target_os = "netbsd",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use {c::fstatfs as libc_fstatfs, c::statfs as libc_statfs};
-#[cfg(not(any(
-    windows,
-    target_os = "android",
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "linux",
-    target_os = "l4re",
-    target_os = "redox",
-    target_os = "solaris",
-    target_os = "wasi",
-)))]
-#[cfg(feature = "fs")]
-pub(super) use {c::fstatvfs as libc_fstatvfs, c::statvfs as libc_statvfs};
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "linux",
-    target_os = "emscripten",
-    target_os = "l4re",
-))]
-#[cfg(feature = "fs")]
-pub(super) use {
-    c::fstatfs64 as libc_fstatfs, c::fstatvfs64 as libc_fstatvfs, c::statfs64 as libc_statfs,
-    c::statvfs64 as libc_statvfs,
-};
diff --git a/vendor/rustix-0.36.5/src/backend/libc/param/auxv.rs b/vendor/rustix-0.36.5/src/backend/libc/param/auxv.rs
deleted file mode 100644
index a770c60d8..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/param/auxv.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use super::super::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(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-0.36.5/src/backend/libc/param/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/param/mod.rs
deleted file mode 100644
index 2cb2fe78a..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/param/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod auxv;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/process/cpu_set.rs b/vendor/rustix-0.36.5/src/backend/libc/process/cpu_set.rs
deleted file mode 100644
index 14ad8d208..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/process/cpu_set.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![allow(non_snake_case)]
-
-use super::super::c;
-use super::types::{RawCpuSet, CPU_SETSIZE};
-
-#[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(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) fn CPU_COUNT(cpuset: &RawCpuSet) -> u32 {
-    use core::convert::TryInto;
-    unsafe { c::CPU_COUNT(cpuset).try_into().unwrap() }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/process/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/process/mod.rs
deleted file mode 100644
index 8675c1af9..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/process/mod.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-pub(crate) mod cpu_set;
-#[cfg(not(windows))]
-pub(crate) mod syscalls;
-pub(crate) mod types;
-#[cfg(not(target_os = "wasi"))]
-pub(crate) mod wait;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/process/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/process/syscalls.rs
deleted file mode 100644
index 6f4e85916..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/process/syscalls.rs
+++ /dev/null
@@ -1,465 +0,0 @@
-//! libc syscalls supporting `rustix::process`.
-
-use super::super::c;
-#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))]
-use super::super::conv::borrowed_fd;
-#[cfg(not(target_os = "wasi"))]
-use super::super::conv::ret_pid_t;
-use super::super::conv::{c_str, ret, ret_c_int, ret_discarded_char_ptr};
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::{syscall_ret, syscall_ret_u32};
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-use super::types::RawCpuSet;
-#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))]
-use crate::fd::BorrowedFd;
-use crate::ffi::CStr;
-use crate::io;
-use core::mem::MaybeUninit;
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
-use {
-    super::super::conv::ret_infallible,
-    super::super::offset::{libc_getrlimit, libc_rlimit, libc_setrlimit, LIBC_RLIM_INFINITY},
-    crate::process::{Resource, Rlimit},
-    core::convert::TryInto,
-};
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use {
-    super::super::offset::libc_prlimit,
-    crate::process::{Cpuid, MembarrierCommand, MembarrierQuery},
-};
-#[cfg(not(target_os = "wasi"))]
-use {
-    super::types::RawUname,
-    crate::process::{Gid, Pid, RawNonZeroPid, RawPid, Signal, Uid, WaitOptions, WaitStatus},
-};
-
-#[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 = "wasi", target_os = "fuchsia")))]
-pub(crate) fn fchdir(dirfd: BorrowedFd<'_>) -> io::Result<()> {
-    unsafe { ret(c::fchdir(borrowed_fd(dirfd))) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn getcwd(buf: &mut [u8]) -> io::Result<()> {
-    unsafe { ret_discarded_char_ptr(c::getcwd(buf.as_mut_ptr().cast(), buf.len())) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-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 syscall_ret_u32(c::syscall(c::SYS_membarrier, MEMBARRIER_CMD_QUERY, 0)) {
-            Ok(query) => MembarrierQuery::from_bits_unchecked(query),
-            Err(_) => MembarrierQuery::empty(),
-        }
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn membarrier(cmd: MembarrierCommand) -> io::Result<()> {
-    unsafe { syscall_ret(c::syscall(c::SYS_membarrier, cmd as u32, 0)) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub(crate) fn membarrier_cpu(cmd: MembarrierCommand, cpu: Cpuid) -> io::Result<()> {
-    const MEMBARRIER_CMD_FLAG_CPU: u32 = 1;
-    unsafe {
-        syscall_ret(c::syscall(
-            c::SYS_membarrier,
-            cmd as u32,
-            MEMBARRIER_CMD_FLAG_CPU,
-            cpu.as_raw(),
-        ))
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getuid() -> Uid {
-    unsafe {
-        let uid = c::getuid();
-        Uid::from_raw(uid)
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn geteuid() -> Uid {
-    unsafe {
-        let uid = c::geteuid();
-        Uid::from_raw(uid)
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getgid() -> Gid {
-    unsafe {
-        let gid = c::getgid();
-        Gid::from_raw(gid)
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getegid() -> Gid {
-    unsafe {
-        let gid = c::getegid();
-        Gid::from_raw(gid)
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getpid() -> Pid {
-    unsafe {
-        let pid = c::getpid();
-        debug_assert_ne!(pid, 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid))
-    }
-}
-
-#[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 _))?;
-        debug_assert_ne!(pgid, 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pgid)))
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn getpgrp() -> Pid {
-    unsafe {
-        let pgid = c::getpgrp();
-        debug_assert_ne!(pgid, 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pgid))
-    }
-}
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-#[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(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-#[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"))]
-#[inline]
-pub(crate) fn uname() -> RawUname {
-    let mut uname = MaybeUninit::<RawUname>::uninit();
-    unsafe {
-        ret(c::uname(uname.as_mut_ptr())).unwrap();
-        uname.assume_init()
-    }
-}
-
-#[cfg(not(any(target_os = "fuchsia", 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 = "fuchsia", target_os = "redox", 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 = "fuchsia", target_os = "redox", 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 = "fuchsia", target_os = "redox", 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 = "fuchsia", target_os = "redox", target_os = "wasi")))]
-#[inline]
-pub(crate) fn setpriority_user(uid: Uid, priority: i32) -> io::Result<()> {
-    unsafe { ret(c::setpriority(c::PRIO_USER, uid.as_raw() as _, priority)) }
-}
-
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
-#[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 = "fuchsia", target_os = "redox", 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 = "fuchsia", target_os = "redox", target_os = "wasi")))]
-#[inline]
-pub(crate) fn getrlimit(limit: Resource) -> Rlimit {
-    let mut result = MaybeUninit::<libc_rlimit>::uninit();
-    unsafe {
-        ret_infallible(libc_getrlimit(limit as _, result.as_mut_ptr()));
-        rlimit_from_libc(result.assume_init())
-    }
-}
-
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
-#[inline]
-pub(crate) fn setrlimit(limit: Resource, new: Rlimit) -> io::Result<()> {
-    let lim = rlimit_to_libc(new)?;
-    unsafe { ret(libc_setrlimit(limit as _, &lim)) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) fn prlimit(pid: Option<Pid>, limit: Resource, new: Rlimit) -> io::Result<Rlimit> {
-    let lim = rlimit_to_libc(new)?;
-    let mut result = MaybeUninit::<libc_rlimit>::uninit();
-    unsafe {
-        ret(libc_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 `libc_rlimit`.
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
-fn rlimit_from_libc(lim: libc_rlimit) -> Rlimit {
-    let current = if lim.rlim_cur == LIBC_RLIM_INFINITY {
-        None
-    } else {
-        Some(lim.rlim_cur.try_into().unwrap())
-    };
-    let maximum = if lim.rlim_max == LIBC_RLIM_INFINITY {
-        None
-    } else {
-        Some(lim.rlim_max.try_into().unwrap())
-    };
-    Rlimit { current, maximum }
-}
-
-/// Convert a C `libc_rlimit` to a Rust `Rlimit`.
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))]
-fn rlimit_to_libc(lim: Rlimit) -> io::Result<libc_rlimit> {
-    let Rlimit { current, maximum } = lim;
-    let rlim_cur = match current {
-        Some(r) => r.try_into().map_err(|_e| io::Errno::INVAL)?,
-        None => LIBC_RLIM_INFINITY as _,
-    };
-    let rlim_max = match maximum {
-        Some(r) => r.try_into().map_err(|_e| io::Errno::INVAL)?,
-        None => LIBC_RLIM_INFINITY as _,
-    };
-    Ok(libc_rlimit { rlim_cur, rlim_max })
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn wait(waitopts: WaitOptions) -> io::Result<Option<(Pid, WaitStatus)>> {
-    _waitpid(!0, waitopts)
-}
-
-#[cfg(not(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(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(RawNonZeroPid::new(pid).map(|non_zero| {
-            (
-                Pid::from_raw_nonzero(non_zero),
-                WaitStatus::new(status as _),
-            )
-        }))
-    }
-}
-
-#[inline]
-pub(crate) fn exit_group(code: c::c_int) -> ! {
-    // `_exit` and `_Exit` are the same; it's just a matter of which ones
-    // the libc bindings expose.
-    #[cfg(any(target_os = "wasi", target_os = "solid"))]
-    unsafe {
-        c::_Exit(code)
-    }
-    #[cfg(unix)]
-    unsafe {
-        c::_exit(code)
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn setsid() -> io::Result<Pid> {
-    unsafe {
-        let pid = ret_c_int(c::setsid())?;
-        debug_assert_ne!(pid, 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid)))
-    }
-}
-
-#[cfg(not(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(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(target_os = "wasi"))]
-#[inline]
-pub(crate) fn kill_current_process_group(sig: Signal) -> io::Result<()> {
-    unsafe { ret(c::kill(0, sig as i32)) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) unsafe fn prctl(
-    option: c::c_int,
-    arg2: *mut c::c_void,
-    arg3: *mut c::c_void,
-    arg4: *mut c::c_void,
-    arg5: *mut c::c_void,
-) -> io::Result<c::c_int> {
-    ret_c_int(c::prctl(option, arg2, arg3, arg4, arg5))
-}
-
-#[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
-#[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))
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/process/types.rs b/vendor/rustix-0.36.5/src/backend/libc/process/types.rs
deleted file mode 100644
index f8e3b8bf4..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/process/types.rs
+++ /dev/null
@@ -1,414 +0,0 @@
-use super::super::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
-// TODO: These are not yet exposed through libc, so we define the
-// constants ourselves.
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
-#[repr(u32)]
-pub enum MembarrierCommand {
-    /// `MEMBARRIER_CMD_GLOBAL`
-    #[doc(alias = "Shared")]
-    #[doc(alias = "MEMBARRIER_CMD_SHARED")]
-    Global = 1,
-    /// `MEMBARRIER_CMD_GLOBAL_EXPEDITED`
-    GlobalExpedited = 2,
-    /// `MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED`
-    RegisterGlobalExpedited = 4,
-    /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED`
-    PrivateExpedited = 8,
-    /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED`
-    RegisterPrivateExpedited = 16,
-    /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE`
-    PrivateExpeditedSyncCore = 32,
-    /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE`
-    RegisterPrivateExpeditedSyncCore = 64,
-    /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)
-    PrivateExpeditedRseq = 128,
-    /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10)
-    RegisterPrivateExpeditedRseq = 256,
-}
-
-/// 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 = "fuchsia", target_os = "redox", target_os = "wasi")))]
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[repr(i32)]
-pub enum Resource {
-    /// `RLIMIT_CPU`
-    Cpu = c::RLIMIT_CPU as c::c_int,
-    /// `RLIMIT_FSIZE`
-    Fsize = c::RLIMIT_FSIZE as c::c_int,
-    /// `RLIMIT_DATA`
-    Data = c::RLIMIT_DATA as c::c_int,
-    /// `RLIMIT_STACK`
-    Stack = c::RLIMIT_STACK as c::c_int,
-    /// `RLIMIT_CORE`
-    #[cfg(not(target_os = "haiku"))]
-    Core = c::RLIMIT_CORE as c::c_int,
-    /// `RLIMIT_RSS`
-    #[cfg(not(any(
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "solaris",
-    )))]
-    Rss = c::RLIMIT_RSS as c::c_int,
-    /// `RLIMIT_NPROC`
-    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
-    Nproc = c::RLIMIT_NPROC as c::c_int,
-    /// `RLIMIT_NOFILE`
-    Nofile = c::RLIMIT_NOFILE as c::c_int,
-    /// `RLIMIT_MEMLOCK`
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "solaris"
-    )))]
-    Memlock = c::RLIMIT_MEMLOCK as c::c_int,
-    /// `RLIMIT_AS`
-    #[cfg(not(target_os = "openbsd"))]
-    As = c::RLIMIT_AS as c::c_int,
-    /// `RLIMIT_LOCKS`
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    Locks = c::RLIMIT_LOCKS as c::c_int,
-    /// `RLIMIT_SIGPENDING`
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    Sigpending = c::RLIMIT_SIGPENDING as c::c_int,
-    /// `RLIMIT_MSGQUEUE`
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    Msgqueue = c::RLIMIT_MSGQUEUE as c::c_int,
-    /// `RLIMIT_NICE`
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    Nice = c::RLIMIT_NICE as c::c_int,
-    /// `RLIMIT_RTPRIO`
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    Rtprio = c::RLIMIT_RTPRIO as c::c_int,
-    /// `RLIMIT_RTTIME`
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "emscripten",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-    )))]
-    Rttime = c::RLIMIT_RTTIME as c::c_int,
-}
-
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-impl Resource {
-    /// `RLIMIT_RSS`
-    #[allow(non_upper_case_globals)]
-    pub const Rss: Self = Self::As;
-}
-
-/// A signal number for use with [`kill_process`], [`kill_process_group`],
-/// and [`kill_current_process_group`].
-///
-/// [`kill_process`]: crate::process::kill_process
-/// [`kill_process_group`]: crate::process::kill_process_group
-/// [`kill_current_process_group`]: crate::process::kill_current_process_group
-#[cfg(not(target_os = "wasi"))]
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-#[repr(i32)]
-pub enum Signal {
-    /// `SIGHUP`
-    Hup = c::SIGHUP,
-    /// `SIGINT`
-    Int = c::SIGINT,
-    /// `SIGQUIT`
-    Quit = c::SIGQUIT,
-    /// `SIGILL`
-    Ill = c::SIGILL,
-    /// `SIGTRAP`
-    Trap = c::SIGTRAP,
-    /// `SIGABRT`, aka `SIGIOT`
-    #[doc(alias = "Iot")]
-    #[doc(alias = "Abrt")]
-    Abort = c::SIGABRT,
-    /// `SIGBUS`
-    Bus = c::SIGBUS,
-    /// `SIGFPE`
-    Fpe = c::SIGFPE,
-    /// `SIGKILL`
-    Kill = c::SIGKILL,
-    /// `SIGUSR1`
-    Usr1 = c::SIGUSR1,
-    /// `SIGSEGV`
-    Segv = c::SIGSEGV,
-    /// `SIGUSR2`
-    Usr2 = c::SIGUSR2,
-    /// `SIGPIPE`
-    Pipe = c::SIGPIPE,
-    /// `SIGALRM`
-    #[doc(alias = "Alrm")]
-    Alarm = c::SIGALRM,
-    /// `SIGTERM`
-    Term = c::SIGTERM,
-    /// `SIGSTKFLT`
-    #[cfg(not(any(
-        target_os = "aix",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "illumos",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "solaris",
-        all(
-            any(target_os = "android", target_os = "linux"),
-            any(
-                target_arch = "mips",
-                target_arch = "mips64",
-                target_arch = "sparc",
-                target_arch = "sparc64"
-            ),
-        )
-    )))]
-    Stkflt = c::SIGSTKFLT,
-    /// `SIGCHLD`
-    #[doc(alias = "Chld")]
-    Child = c::SIGCHLD,
-    /// `SIGCONT`
-    Cont = c::SIGCONT,
-    /// `SIGSTOP`
-    Stop = c::SIGSTOP,
-    /// `SIGTSTP`
-    Tstp = c::SIGTSTP,
-    /// `SIGTTIN`
-    Ttin = c::SIGTTIN,
-    /// `SIGTTOU`
-    Ttou = c::SIGTTOU,
-    /// `SIGURG`
-    Urg = c::SIGURG,
-    /// `SIGXCPU`
-    Xcpu = c::SIGXCPU,
-    /// `SIGXFSZ`
-    Xfsz = c::SIGXFSZ,
-    /// `SIGVTALRM`
-    #[doc(alias = "Vtalrm")]
-    Vtalarm = c::SIGVTALRM,
-    /// `SIGPROF`
-    Prof = c::SIGPROF,
-    /// `SIGWINCH`
-    Winch = c::SIGWINCH,
-    /// `SIGIO`, aka `SIGPOLL`
-    #[doc(alias = "Poll")]
-    #[cfg(not(target_os = "haiku"))]
-    Io = c::SIGIO,
-    /// `SIGPWR`
-    #[cfg(not(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    )))]
-    #[doc(alias = "Pwr")]
-    Power = c::SIGPWR,
-    /// `SIGSYS`, aka `SIGUNUSED`
-    #[doc(alias = "Unused")]
-    Sys = c::SIGSYS,
-}
-
-#[cfg(not(target_os = "wasi"))]
-impl Signal {
-    /// Convert a raw signal number into a `Signal`, if possible.
-    pub fn from_raw(sig: i32) -> Option<Self> {
-        match sig as _ {
-            c::SIGHUP => Some(Self::Hup),
-            c::SIGINT => Some(Self::Int),
-            c::SIGQUIT => Some(Self::Quit),
-            c::SIGILL => Some(Self::Ill),
-            c::SIGTRAP => Some(Self::Trap),
-            c::SIGABRT => Some(Self::Abort),
-            c::SIGBUS => Some(Self::Bus),
-            c::SIGFPE => Some(Self::Fpe),
-            c::SIGKILL => Some(Self::Kill),
-            c::SIGUSR1 => Some(Self::Usr1),
-            c::SIGSEGV => Some(Self::Segv),
-            c::SIGUSR2 => Some(Self::Usr2),
-            c::SIGPIPE => Some(Self::Pipe),
-            c::SIGALRM => Some(Self::Alarm),
-            c::SIGTERM => Some(Self::Term),
-            #[cfg(not(any(
-                target_os = "aix",
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "haiku",
-                target_os = "illumos",
-                target_os = "ios",
-                target_os = "macos",
-                target_os = "netbsd",
-                target_os = "openbsd",
-                target_os = "solaris",
-                all(
-                    any(target_os = "android", target_os = "linux"),
-                    any(
-                        target_arch = "mips",
-                        target_arch = "mips64",
-                        target_arch = "sparc",
-                        target_arch = "sparc64"
-                    ),
-                )
-            )))]
-            c::SIGSTKFLT => Some(Self::Stkflt),
-            c::SIGCHLD => Some(Self::Child),
-            c::SIGCONT => Some(Self::Cont),
-            c::SIGSTOP => Some(Self::Stop),
-            c::SIGTSTP => Some(Self::Tstp),
-            c::SIGTTIN => Some(Self::Ttin),
-            c::SIGTTOU => Some(Self::Ttou),
-            c::SIGURG => Some(Self::Urg),
-            c::SIGXCPU => Some(Self::Xcpu),
-            c::SIGXFSZ => Some(Self::Xfsz),
-            c::SIGVTALRM => Some(Self::Vtalarm),
-            c::SIGPROF => Some(Self::Prof),
-            c::SIGWINCH => Some(Self::Winch),
-            #[cfg(not(target_os = "haiku"))]
-            c::SIGIO => Some(Self::Io),
-            #[cfg(not(any(
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "haiku",
-                target_os = "ios",
-                target_os = "macos",
-                target_os = "netbsd",
-                target_os = "openbsd",
-            )))]
-            c::SIGPWR => Some(Self::Power),
-            c::SIGSYS => Some(Self::Sys),
-            _ => None,
-        }
-    }
-}
-
-pub const EXIT_SUCCESS: c::c_int = c::EXIT_SUCCESS;
-pub const EXIT_FAILURE: c::c_int = c::EXIT_FAILURE;
-#[cfg(not(target_os = "wasi"))]
-pub const EXIT_SIGNALED_SIGABRT: c::c_int = 128 + c::SIGABRT;
-
-/// A process identifier as a raw integer.
-#[cfg(not(target_os = "wasi"))]
-pub type RawPid = c::pid_t;
-/// A non-zero process identifier as a raw non-zero integer.
-#[cfg(not(target_os = "wasi"))]
-pub type RawNonZeroPid = core::num::NonZeroI32;
-/// A group identifier as a raw integer.
-#[cfg(not(target_os = "wasi"))]
-pub type RawGid = c::gid_t;
-/// A user identifier as a raw integer.
-#[cfg(not(target_os = "wasi"))]
-pub type RawUid = c::uid_t;
-/// A CPU identifier as a raw integer.
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub type RawCpuid = u32;
-#[cfg(target_os = "freebsd")]
-pub type RawId = c::id_t;
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) type RawUname = c::utsname;
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-pub(crate) type RawCpuSet = c::cpu_set_t;
-
-#[cfg(any(
-    target_os = "android",
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "linux",
-))]
-#[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(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-pub(crate) const CPU_SETSIZE: usize = c::CPU_SETSIZE as usize;
-#[cfg(target_os = "dragonfly")]
-pub(crate) const CPU_SETSIZE: usize = 256;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/process/wait.rs b/vendor/rustix-0.36.5/src/backend/libc/process/wait.rs
deleted file mode 100644
index 6de79955d..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/process/wait.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use super::super::c;
-
-pub(crate) use c::{
-    WCONTINUED, WEXITSTATUS, WIFCONTINUED, WIFEXITED, WIFSIGNALED, WIFSTOPPED, WNOHANG, WSTOPSIG,
-    WTERMSIG, WUNTRACED,
-};
diff --git a/vendor/rustix-0.36.5/src/backend/libc/rand/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/rand/mod.rs
deleted file mode 100644
index 1e0181a99..000000000
--- a/vendor/rustix-0.36.5/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-0.36.5/src/backend/libc/rand/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/rand/syscalls.rs
deleted file mode 100644
index 1c4286235..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/rand/syscalls.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! libc syscalls supporting `rustix::rand`.
-
-#[cfg(target_os = "linux")]
-use {super::super::c, super::super::conv::ret_ssize_t, crate::io, crate::rand::GetRandomFlags};
-
-#[cfg(target_os = "linux")]
-pub(crate) fn getrandom(buf: &mut [u8], 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
-    }
-
-    let nread =
-        unsafe { ret_ssize_t(getrandom(buf.as_mut_ptr().cast(), buf.len(), flags.bits()))? };
-    Ok(nread as usize)
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/rand/types.rs b/vendor/rustix-0.36.5/src/backend/libc/rand/types.rs
deleted file mode 100644
index 2ba3f1119..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/rand/types.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#[cfg(target_os = "linux")]
-use super::super::c;
-#[cfg(target_os = "linux")]
-use bitflags::bitflags;
-
-#[cfg(target_os = "linux")]
-bitflags! {
-    /// `GRND_*` flags for use with [`getrandom`].
-    ///
-    /// [`getrandom`]: crate::rand::getrandom
-    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;
-    }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/termios/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/termios/mod.rs
deleted file mode 100644
index c82c95958..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/termios/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub(crate) mod syscalls;
-#[cfg(not(target_os = "wasi"))]
-pub(crate) mod types;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/termios/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/termios/syscalls.rs
deleted file mode 100644
index f54e9a6f3..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/termios/syscalls.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-//! libc syscalls supporting `rustix::termios`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend::syscalls` module documentation for details.
-
-use super::super::c;
-use super::super::conv::{borrowed_fd, ret, ret_pid_t};
-use crate::fd::BorrowedFd;
-#[cfg(feature = "procfs")]
-#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
-use crate::ffi::CStr;
-#[cfg(not(target_os = "wasi"))]
-use crate::io;
-#[cfg(not(target_os = "wasi"))]
-use crate::process::{Pid, RawNonZeroPid};
-#[cfg(not(target_os = "wasi"))]
-use crate::termios::{Action, OptionalActions, QueueSelector, Speed, Termios, Winsize};
-use core::mem::MaybeUninit;
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn tcgetattr(fd: BorrowedFd<'_>) -> io::Result<Termios> {
-    let mut result = MaybeUninit::<Termios>::uninit();
-    unsafe {
-        ret(c::tcgetattr(borrowed_fd(fd), result.as_mut_ptr()))?;
-        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)))?;
-        debug_assert_ne!(pid, 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_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(target_os = "wasi"))]
-pub(crate) fn tcsetattr(
-    fd: BorrowedFd,
-    optional_actions: OptionalActions,
-    termios: &Termios,
-) -> io::Result<()> {
-    unsafe {
-        ret(c::tcsetattr(
-            borrowed_fd(fd),
-            optional_actions as _,
-            termios,
-        ))
-    }
-}
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn tcsendbreak(fd: BorrowedFd) -> io::Result<()> {
-    unsafe { ret(c::tcsendbreak(borrowed_fd(fd), 0)) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-pub(crate) fn tcdrain(fd: BorrowedFd) -> io::Result<()> {
-    unsafe { ret(c::tcdrain(borrowed_fd(fd))) }
-}
-
-#[cfg(not(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(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)))?;
-        debug_assert_ne!(pid, 0);
-        Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid)))
-    }
-}
-
-#[cfg(not(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(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(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn cfgetospeed(termios: &Termios) -> Speed {
-    unsafe { c::cfgetospeed(termios) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-#[must_use]
-pub(crate) fn cfgetispeed(termios: &Termios) -> Speed {
-    unsafe { c::cfgetispeed(termios) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn cfmakeraw(termios: &mut Termios) {
-    unsafe { c::cfmakeraw(termios) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn cfsetospeed(termios: &mut Termios, speed: Speed) -> io::Result<()> {
-    unsafe { ret(c::cfsetospeed(termios, speed)) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn cfsetispeed(termios: &mut Termios, speed: Speed) -> io::Result<()> {
-    unsafe { ret(c::cfsetispeed(termios, speed)) }
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[inline]
-pub(crate) fn cfsetspeed(termios: &mut Termios, speed: Speed) -> io::Result<()> {
-    unsafe { ret(c::cfsetspeed(termios, speed)) }
-}
-
-pub(crate) fn 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
-    // `BorrrowedFd` 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(feature = "procfs")]
-#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))]
-pub(crate) fn ttyname(dirfd: BorrowedFd<'_>, buf: &mut [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-0.36.5/src/backend/libc/termios/types.rs b/vendor/rustix-0.36.5/src/backend/libc/termios/types.rs
deleted file mode 100644
index 6dda70064..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/termios/types.rs
+++ /dev/null
@@ -1,1046 +0,0 @@
-use super::super::c;
-
-/// `TCSA*` values for use with [`tcsetattr`].
-///
-/// [`tcsetattr`]: crate::termios::tcsetattr
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum OptionalActions {
-    /// `TCSANOW`—Make the change immediately.
-    Now = c::TCSANOW,
-
-    /// `TCSADRAIN`—Make the change after all output has been transmitted.
-    Drain = c::TCSADRAIN,
-
-    /// `TCSAFLUSH`—Discard any pending input and then make the change
-    /// after all output has been transmitted.
-    Flush = c::TCSAFLUSH,
-}
-
-/// `TC*` values for use with [`tcflush`].
-///
-/// [`tcflush`]: crate::termios::tcflush
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum QueueSelector {
-    /// `TCIFLUSH`—Flush data received but not read.
-    IFlush = c::TCIFLUSH,
-
-    /// `TCOFLUSH`—Flush data written but not transmitted.
-    OFlush = c::TCOFLUSH,
-
-    /// `TCIOFLUSH`—`IFlush` and `OFlush` combined.
-    IOFlush = c::TCIOFLUSH,
-}
-
-/// `TC*` values for use with [`tcflow`].
-///
-/// [`tcflow`]: crate::termios::tcflow
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[repr(i32)]
-pub enum Action {
-    /// `TCOOFF`—Suspend output.
-    OOff = c::TCOOFF,
-
-    /// `TCOON`—Restart suspended output.
-    OOn = c::TCOON,
-
-    /// `TCIOFF`—Transmits a STOP byte.
-    IOff = c::TCIOFF,
-
-    /// `TCION`—Transmits a START byte.
-    IOn = c::TCION,
-}
-
-/// `struct termios` for use with [`tcgetattr`].
-///
-/// [`tcgetattr`]: crate::termios::tcgetattr
-pub type Termios = c::termios;
-
-/// `struct winsize` for use with [`tcgetwinsize`].
-///
-/// [`tcgetwinsize`]: crate::termios::tcgetwinsize
-pub type Winsize = c::winsize;
-
-/// `tcflag_t`—A type for the flags fields of [`Termios`].
-pub type Tcflag = c::tcflag_t;
-
-/// `speed_t`—A return type for [`cfsetspeed`] and similar.
-///
-/// [`cfsetspeed`]: crate::termios::cfsetspeed
-pub type Speed = c::speed_t;
-
-/// `VINTR`
-pub const VINTR: usize = c::VINTR as usize;
-
-/// `VQUIT`
-pub const VQUIT: usize = c::VQUIT as usize;
-
-/// `VERASE`
-pub const VERASE: usize = c::VERASE as usize;
-
-/// `VKILL`
-pub const VKILL: usize = c::VKILL as usize;
-
-/// `VEOF`
-pub const VEOF: usize = c::VEOF as usize;
-
-/// `VTIME`
-pub const VTIME: usize = c::VTIME as usize;
-
-/// `VMIN`
-pub const VMIN: usize = c::VMIN as usize;
-
-/// `VSWTC`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const VSWTC: usize = c::VSWTC as usize;
-
-/// `VSTART`
-pub const VSTART: usize = c::VSTART as usize;
-
-/// `VSTOP`
-pub const VSTOP: usize = c::VSTOP as usize;
-
-/// `VSUSP`
-pub const VSUSP: usize = c::VSUSP as usize;
-
-/// `VEOL`
-pub const VEOL: usize = c::VEOL as usize;
-
-/// `VREPRINT`
-#[cfg(not(target_os = "haiku"))]
-pub const VREPRINT: usize = c::VREPRINT as usize;
-
-/// `VDISCARD`
-#[cfg(not(target_os = "haiku"))]
-pub const VDISCARD: usize = c::VDISCARD as usize;
-
-/// `VWERASE`
-#[cfg(not(target_os = "haiku"))]
-pub const VWERASE: usize = c::VWERASE as usize;
-
-/// `VLNEXT`
-#[cfg(not(target_os = "haiku"))]
-pub const VLNEXT: usize = c::VLNEXT as usize;
-
-/// `VEOL2`
-pub const VEOL2: usize = c::VEOL2 as usize;
-
-/// `IGNBRK`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const IGNBRK: c::c_uint = c::IGNBRK;
-
-/// `BRKINT`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const BRKINT: c::c_uint = c::BRKINT;
-
-/// `IGNPAR`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const IGNPAR: c::c_uint = c::IGNPAR;
-
-/// `PARMRK`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const PARMRK: c::c_uint = c::PARMRK;
-
-/// `INPCK`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const INPCK: c::c_uint = c::INPCK;
-
-/// `ISTRIP`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ISTRIP: c::c_uint = c::ISTRIP;
-
-/// `INLCR`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const INLCR: c::c_uint = c::INLCR;
-
-/// `IGNCR`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const IGNCR: c::c_uint = c::IGNCR;
-
-/// `ICRNL`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ICRNL: c::c_uint = c::ICRNL;
-
-/// `IUCLC`
-#[cfg(any(target_os = "haiku", target_os = "illumos", target_os = "solaris"))]
-pub const IUCLC: c::c_uint = c::IUCLC;
-
-/// `IXON`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const IXON: c::c_uint = c::IXON;
-
-/// `IXANY`
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
-pub const IXANY: c::c_uint = c::IXANY;
-
-/// `IXOFF`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const IXOFF: c::c_uint = c::IXOFF;
-
-/// `IMAXBEL`
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox"
-)))]
-pub const IMAXBEL: c::c_uint = c::IMAXBEL;
-
-/// `IUTF8`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const IUTF8: c::c_uint = c::IUTF8;
-
-/// `OPOST`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const OPOST: c::c_uint = c::OPOST;
-
-/// `OLCUC`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "redox",
-)))]
-pub const OLCUC: c::c_uint = c::OLCUC;
-
-/// `ONLCR`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ONLCR: c::c_uint = c::ONLCR;
-
-/// `OCRNL`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const OCRNL: c::c_uint = c::OCRNL;
-
-/// `ONOCR`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ONOCR: c::c_uint = c::ONOCR;
-
-/// `ONLRET`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ONLRET: c::c_uint = c::ONLRET;
-
-/// `OFILL`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-)))]
-pub const OFILL: c::c_uint = c::OFILL;
-
-/// `OFDEL`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-)))]
-pub const OFDEL: c::c_uint = c::OFDEL;
-
-/// `NLDLY`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const NLDLY: c::c_uint = c::NLDLY;
-
-/// `NL0`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const NL0: c::c_uint = c::NL0;
-
-/// `NL1`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const NL1: c::c_uint = c::NL1;
-
-/// `CRDLY`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const CRDLY: c::c_uint = c::CRDLY;
-
-/// `CR0`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const CR0: c::c_uint = c::CR0;
-
-/// `CR1`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const CR1: c::c_uint = c::CR1;
-
-/// `CR2`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const CR2: c::c_uint = c::CR2;
-
-/// `CR3`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const CR3: c::c_uint = c::CR3;
-
-/// `TABDLY`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const TABDLY: c::c_uint = c::TABDLY;
-
-/// `TAB0`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const TAB0: c::c_uint = c::TAB0;
-
-/// `TAB1`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const TAB1: c::c_uint = c::TAB1;
-
-/// `TAB2`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const TAB2: c::c_uint = c::TAB2;
-
-/// `TAB3`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const TAB3: c::c_uint = c::TAB3;
-
-/// `BSDLY`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const BSDLY: c::c_uint = c::BSDLY;
-
-/// `BS0`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const BS0: c::c_uint = c::BS0;
-
-/// `BS1`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "emscripten",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const BS1: c::c_uint = c::BS1;
-
-/// `FFDLY`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const FFDLY: c::c_uint = c::FFDLY;
-
-/// `FF0`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const FF0: c::c_uint = c::FF0;
-
-/// `FF1`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const FF1: c::c_uint = c::FF1;
-
-/// `VTDLY`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const VTDLY: c::c_uint = c::VTDLY;
-
-/// `VT0`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const VT0: c::c_uint = c::VT0;
-
-/// `VT1`
-#[cfg(not(any(
-    target_env = "musl",
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "fuchsia",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const VT1: c::c_uint = c::VT1;
-
-/// `B0`
-pub const B0: Speed = c::B0;
-
-/// `B50`
-pub const B50: Speed = c::B50;
-
-/// `B75`
-pub const B75: Speed = c::B75;
-
-/// `B110`
-pub const B110: Speed = c::B110;
-
-/// `B134`
-pub const B134: Speed = c::B134;
-
-/// `B150`
-pub const B150: Speed = c::B150;
-
-/// `B200`
-pub const B200: Speed = c::B200;
-
-/// `B300`
-pub const B300: Speed = c::B300;
-
-/// `B600`
-pub const B600: Speed = c::B600;
-
-/// `B1200`
-pub const B1200: Speed = c::B1200;
-
-/// `B1800`
-pub const B1800: Speed = c::B1800;
-
-/// `B2400`
-pub const B2400: Speed = c::B2400;
-
-/// `B4800`
-pub const B4800: Speed = c::B4800;
-
-/// `B9600`
-pub const B9600: Speed = c::B9600;
-
-/// `B19200`
-pub const B19200: Speed = c::B19200;
-
-/// `B38400`
-pub const B38400: Speed = c::B38400;
-
-/// `B57600`
-pub const B57600: Speed = c::B57600;
-
-/// `B115200`
-pub const B115200: Speed = c::B115200;
-
-/// `B230400`
-pub const B230400: Speed = c::B230400;
-
-/// `B460800`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "openbsd"
-)))]
-pub const B460800: Speed = c::B460800;
-
-/// `B500000`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B500000: Speed = c::B500000;
-
-/// `B576000`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B576000: Speed = c::B576000;
-
-/// `B921600`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "openbsd"
-)))]
-pub const B921600: Speed = c::B921600;
-
-/// `B1000000`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B1000000: Speed = c::B1000000;
-
-/// `B1152000`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B1152000: Speed = c::B1152000;
-
-/// `B1500000`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B1500000: Speed = c::B1500000;
-
-/// `B2000000`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B2000000: Speed = c::B2000000;
-
-/// `B2500000`
-#[cfg(not(any(
-    target_arch = "sparc",
-    target_arch = "sparc64",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B2500000: Speed = c::B2500000;
-
-/// `B3000000`
-#[cfg(not(any(
-    target_arch = "sparc",
-    target_arch = "sparc64",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B3000000: Speed = c::B3000000;
-
-/// `B3500000`
-#[cfg(not(any(
-    target_arch = "sparc",
-    target_arch = "sparc64",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B3500000: Speed = c::B3500000;
-
-/// `B4000000`
-#[cfg(not(any(
-    target_arch = "sparc",
-    target_arch = "sparc64",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "solaris",
-)))]
-pub const B4000000: Speed = c::B4000000;
-
-/// `CSIZE`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const CSIZE: c::c_uint = c::CSIZE;
-
-/// `CS5`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const CS5: c::c_uint = c::CS5;
-
-/// `CS6`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const CS6: c::c_uint = c::CS6;
-
-/// `CS7`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const CS7: c::c_uint = c::CS7;
-
-/// `CS8`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const CS8: c::c_uint = c::CS8;
-
-/// `CSTOPB`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const CSTOPB: c::c_uint = c::CSTOPB;
-
-/// `CREAD`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const CREAD: c::c_uint = c::CREAD;
-
-/// `PARENB`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const PARENB: c::c_uint = c::PARENB;
-
-/// `PARODD`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const PARODD: c::c_uint = c::PARODD;
-
-/// `HUPCL`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const HUPCL: c::c_uint = c::HUPCL;
-
-/// `CLOCAL`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const CLOCAL: c::c_uint = c::CLOCAL;
-
-/// `ISIG`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ISIG: c::c_uint = c::ISIG;
-
-/// `ICANON`—A flag for the `c_lflag` field of [`Termios`] indicating
-/// canonical mode.
-pub const ICANON: Tcflag = c::ICANON;
-
-/// `ECHO`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ECHO: c::c_uint = c::ECHO;
-
-/// `ECHOE`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ECHOE: c::c_uint = c::ECHOE;
-
-/// `ECHOK`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ECHOK: c::c_uint = c::ECHOK;
-
-/// `ECHONL`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const ECHONL: c::c_uint = c::ECHONL;
-
-/// `NOFLSH`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const NOFLSH: c::c_uint = c::NOFLSH;
-
-/// `TOSTOP`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const TOSTOP: c::c_uint = c::TOSTOP;
-
-/// `IEXTEN`
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub const IEXTEN: c::c_uint = c::IEXTEN;
-
-/// `EXTA`
-#[cfg(not(any(
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const EXTA: c::c_uint = c::EXTA;
-
-/// `EXTB`
-#[cfg(not(any(
-    target_os = "emscripten",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const EXTB: c::c_uint = c::EXTB;
-
-/// `CBAUD`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-)))]
-pub const CBAUD: c::c_uint = c::CBAUD;
-
-/// `CBAUDEX`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const CBAUDEX: c::c_uint = c::CBAUDEX;
-
-/// `CIBAUD`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_arch = "powerpc",
-    target_arch = "powerpc64",
-)))]
-pub const CIBAUD: c::tcflag_t = c::CIBAUD;
-
-/// `CIBAUD`
-// TODO: Upstream this.
-#[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
-pub const CIBAUD: c::tcflag_t = 0o77600000;
-
-/// `CMSPAR`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const CMSPAR: c::c_uint = c::CMSPAR;
-
-/// `CRTSCTS`
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
-pub const CRTSCTS: c::c_uint = c::CRTSCTS;
-
-/// `XCASE`
-#[cfg(any(target_arch = "s390x", target_os = "haiku"))]
-pub const XCASE: c::c_uint = c::XCASE;
-
-/// `ECHOCTL`
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
-pub const ECHOCTL: c::c_uint = c::ECHOCTL;
-
-/// `ECHOPRT`
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
-pub const ECHOPRT: c::c_uint = c::ECHOPRT;
-
-/// `ECHOKE`
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
-pub const ECHOKE: c::c_uint = c::ECHOKE;
-
-/// `FLUSHO`
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
-pub const FLUSHO: c::c_uint = c::FLUSHO;
-
-/// `PENDIN`
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
-pub const PENDIN: c::c_uint = c::PENDIN;
-
-/// `EXTPROC`
-#[cfg(not(any(
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "redox"
-)))]
-pub const EXTPROC: c::c_uint = c::EXTPROC;
-
-/// `XTABS`
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "illumos",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "solaris",
-)))]
-pub const XTABS: c::c_uint = c::XTABS;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/thread/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/thread/mod.rs
deleted file mode 100644
index 40e0d1135..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/thread/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-#[cfg(not(windows))]
-pub(crate) mod syscalls;
diff --git a/vendor/rustix-0.36.5/src/backend/libc/thread/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/thread/syscalls.rs
deleted file mode 100644
index 4f69b8f63..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/thread/syscalls.rs
+++ /dev/null
@@ -1,301 +0,0 @@
-//! libc syscalls supporting `rustix::thread`.
-
-use super::super::c;
-use super::super::conv::ret;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use super::super::conv::{borrowed_fd, ret_c_int};
-use super::super::time::types::LibcTimespec;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::fd::BorrowedFd;
-use crate::io;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::process::{Pid, RawNonZeroPid};
-#[cfg(not(target_os = "redox"))]
-use crate::thread::{NanosleepRelativeResult, Timespec};
-use core::mem::MaybeUninit;
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd",
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-use {crate::thread::ClockId, core::ptr::null_mut};
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-weak!(fn __clock_nanosleep_time64(c::clockid_t, c::c_int, *const LibcTimespec, *mut LibcTimespec) -> c::c_int);
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-weak!(fn __nanosleep64(*const LibcTimespec, *mut LibcTimespec) -> c::c_int);
-
-#[cfg(not(any(
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd", // FreeBSD 12 has clock_nanosleep, but libc targets FreeBSD 11.
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-#[inline]
-pub(crate) fn clock_nanosleep_relative(id: ClockId, request: &Timespec) -> NanosleepRelativeResult {
-    let mut remain = MaybeUninit::<LibcTimespec>::uninit();
-    let flags = 0;
-
-    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe by
-    // default.
-    #[cfg(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    ))]
-    unsafe {
-        if let Some(libc_clock_nanosleep) = __clock_nanosleep_time64.get() {
-            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)),
-            }
-        } else {
-            clock_nanosleep_relative_old(id, request)
-        }
-    }
-
-    // Main version: libc is y2038 safe and has `clock_nanosleep`.
-    #[cfg(not(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    )))]
-    unsafe {
-        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(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-unsafe fn clock_nanosleep_relative_old(id: ClockId, request: &Timespec) -> NanosleepRelativeResult {
-    use core::convert::TryInto;
-    let tv_sec = match request.tv_sec.try_into() {
-        Ok(tv_sec) => tv_sec,
-        Err(_) => return NanosleepRelativeResult::Err(io::Errno::OVERFLOW),
-    };
-    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;
-
-    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(
-    target_os = "dragonfly",
-    target_os = "emscripten",
-    target_os = "freebsd", // FreeBSD 12 has clock_nanosleep, but libc targets FreeBSD 11.
-    target_os = "haiku",
-    target_os = "ios",
-    target_os = "macos",
-    target_os = "openbsd",
-    target_os = "redox",
-    target_os = "wasi",
-)))]
-#[inline]
-pub(crate) fn clock_nanosleep_absolute(id: ClockId, request: &Timespec) -> io::Result<()> {
-    let flags = c::TIMER_ABSTIME;
-
-    // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe by
-    // default.
-    #[cfg(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    ))]
-    {
-        if let Some(libc_clock_nanosleep) = __clock_nanosleep_time64.get() {
-            match unsafe {
-                libc_clock_nanosleep(
-                    id as c::clockid_t,
-                    flags,
-                    &request.clone().into(),
-                    null_mut(),
-                )
-            } {
-                0 => Ok(()),
-                err => Err(io::Errno(err)),
-            }
-        } else {
-            clock_nanosleep_absolute_old(id, request)
-        }
-    }
-
-    // Main version: libc is y2038 safe and has `clock_nanosleep`.
-    #[cfg(not(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    )))]
-    match unsafe { c::clock_nanosleep(id as c::clockid_t, flags, request, null_mut()) } {
-        0 => Ok(()),
-        err => Err(io::Errno(err)),
-    }
-}
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-fn clock_nanosleep_absolute_old(id: ClockId, request: &Timespec) -> io::Result<()> {
-    use core::convert::TryInto;
-
-    let flags = c::TIMER_ABSTIME;
-
-    let old_request = c::timespec {
-        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 {
-    let mut remain = MaybeUninit::<LibcTimespec>::uninit();
-
-    // 32-bit gnu version: libc has `nanosleep` but it is not y2038 safe by
-    // default.
-    #[cfg(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    ))]
-    unsafe {
-        if let Some(libc_nanosleep) = __nanosleep64.get() {
-            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),
-            }
-        } else {
-            nanosleep_old(request)
-        }
-    }
-
-    // Main version: libc is y2038 safe and has `nanosleep`.
-    #[cfg(not(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    )))]
-    unsafe {
-        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(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-unsafe fn nanosleep_old(request: &Timespec) -> NanosleepRelativeResult {
-    use core::convert::TryInto;
-    let tv_sec = match request.tv_sec.try_into() {
-        Ok(tv_sec) => tv_sec,
-        Err(_) => return NanosleepRelativeResult::Err(io::Errno::OVERFLOW),
-    };
-    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();
-
-    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(any(target_os = "android", target_os = "linux"))]
-#[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();
-        debug_assert_ne!(tid, 0);
-        Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(tid))
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) fn setns(fd: BorrowedFd, nstype: c::c_int) -> io::Result<c::c_int> {
-    unsafe { ret_c_int(c::setns(borrowed_fd(fd), nstype)) }
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[inline]
-pub(crate) fn unshare(flags: crate::thread::UnshareFlags) -> io::Result<()> {
-    unsafe { ret(c::unshare(flags.bits() as i32)) }
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/time/mod.rs b/vendor/rustix-0.36.5/src/backend/libc/time/mod.rs
deleted file mode 100644
index bff7fd564..000000000
--- a/vendor/rustix-0.36.5/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-0.36.5/src/backend/libc/time/syscalls.rs b/vendor/rustix-0.36.5/src/backend/libc/time/syscalls.rs
deleted file mode 100644
index c9e075e53..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/time/syscalls.rs
+++ /dev/null
@@ -1,414 +0,0 @@
-//! libc syscalls supporting `rustix::time`.
-
-use super::super::c;
-use super::super::conv::ret;
-#[cfg(feature = "time")]
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-use super::super::time::types::LibcItimerspec;
-use super::super::time::types::LibcTimespec;
-use super::types::Timespec;
-#[cfg(not(target_os = "wasi"))]
-use super::types::{ClockId, DynamicClockId};
-use crate::io;
-use core::mem::MaybeUninit;
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(feature = "time")]
-use {
-    super::super::conv::{borrowed_fd, ret_owned_fd},
-    crate::fd::{BorrowedFd, OwnedFd},
-    crate::time::{Itimerspec, TimerfdClockId, TimerfdFlags, TimerfdTimerFlags},
-};
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-weak!(fn __clock_gettime64(c::clockid_t, *mut LibcTimespec) -> c::c_int);
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-weak!(fn __clock_getres64(c::clockid_t, *mut LibcTimespec) -> c::c_int);
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[cfg(feature = "time")]
-weak!(fn __timerfd_gettime64(c::c_int, *mut LibcItimerspec) -> c::c_int);
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[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 {
-    let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
-
-    // 32-bit gnu version: libc has `clock_getres` but it is not y2038 safe by
-    // default.
-    #[cfg(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    ))]
-    unsafe {
-        if let Some(libc_clock_getres) = __clock_getres64.get() {
-            ret(libc_clock_getres(id as c::clockid_t, timespec.as_mut_ptr())).unwrap();
-            timespec.assume_init().into()
-        } else {
-            clock_getres_old(id)
-        }
-    }
-
-    // Main version: libc is y2038 safe and has `clock_getres`.
-    #[cfg(not(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    )))]
-    unsafe {
-        let _ = c::clock_getres(id as c::clockid_t, timespec.as_mut_ptr());
-        timespec.assume_init()
-    }
-}
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[must_use]
-unsafe fn clock_getres_old(id: ClockId) -> Timespec {
-    let mut old_timespec = MaybeUninit::<c::timespec>::uninit();
-    ret(c::clock_getres(
-        id as c::clockid_t,
-        old_timespec.as_mut_ptr(),
-    ))
-    .unwrap();
-    let old_timespec = 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 {
-    let mut timespec = MaybeUninit::<LibcTimespec>::uninit();
-
-    #[cfg(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    ))]
-    unsafe {
-        if let Some(libc_clock_gettime) = __clock_gettime64.get() {
-            ret(libc_clock_gettime(
-                id as c::clockid_t,
-                timespec.as_mut_ptr(),
-            ))
-            .unwrap();
-            timespec.assume_init().into()
-        } else {
-            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(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    )))]
-    unsafe {
-        ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr())).unwrap();
-        timespec.assume_init()
-    }
-}
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[must_use]
-unsafe fn clock_gettime_old(id: ClockId) -> Timespec {
-    let mut old_timespec = MaybeUninit::<c::timespec>::uninit();
-    ret(c::clock_gettime(
-        id as c::clockid_t,
-        old_timespec.as_mut_ptr(),
-    ))
-    .unwrap();
-    let old_timespec = 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 mut timespec = MaybeUninit::<LibcTimespec>::uninit();
-    unsafe {
-        let id: c::clockid_t = match id {
-            DynamicClockId::Known(id) => id as c::clockid_t,
-
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            DynamicClockId::Dynamic(fd) => {
-                use crate::fd::AsRawFd;
-                const CLOCKFD: i32 = 3;
-                (!fd.as_raw_fd() << 3) | CLOCKFD
-            }
-
-            #[cfg(not(any(target_os = "android", target_os = "linux")))]
-            DynamicClockId::Dynamic(_fd) => {
-                // Dynamic clocks are not supported on this platform.
-                return Err(io::Errno::INVAL);
-            }
-
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            DynamicClockId::RealtimeAlarm => c::CLOCK_REALTIME_ALARM,
-
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            DynamicClockId::Tai => c::CLOCK_TAI,
-
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            DynamicClockId::Boottime => c::CLOCK_BOOTTIME,
-
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            DynamicClockId::BoottimeAlarm => c::CLOCK_BOOTTIME_ALARM,
-        };
-
-        #[cfg(all(
-            any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-            target_env = "gnu",
-        ))]
-        {
-            if let Some(libc_clock_gettime) = __clock_gettime64.get() {
-                ret(libc_clock_gettime(
-                    id as c::clockid_t,
-                    timespec.as_mut_ptr(),
-                ))?;
-
-                Ok(timespec.assume_init().into())
-            } else {
-                clock_gettime_dynamic_old(id)
-            }
-        }
-
-        #[cfg(not(all(
-            any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-            target_env = "gnu",
-        )))]
-        {
-            ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr()))?;
-
-            Ok(timespec.assume_init())
-        }
-    }
-}
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[inline]
-unsafe fn clock_gettime_dynamic_old(id: c::clockid_t) -> io::Result<Timespec> {
-    let mut old_timespec = MaybeUninit::<c::timespec>::uninit();
-
-    ret(c::clock_gettime(
-        id as c::clockid_t,
-        old_timespec.as_mut_ptr(),
-    ))?;
-
-    let old_timespec = old_timespec.assume_init();
-    Ok(Timespec {
-        tv_sec: old_timespec.tv_sec.into(),
-        tv_nsec: old_timespec.tv_nsec.into(),
-    })
-}
-
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(feature = "time")]
-pub(crate) fn timerfd_create(id: TimerfdClockId, flags: TimerfdFlags) -> io::Result<OwnedFd> {
-    unsafe { ret_owned_fd(c::timerfd_create(id as c::clockid_t, flags.bits())) }
-}
-
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(feature = "time")]
-pub(crate) fn timerfd_settime(
-    fd: BorrowedFd<'_>,
-    flags: TimerfdTimerFlags,
-    new_value: &Itimerspec,
-) -> io::Result<Itimerspec> {
-    let mut result = MaybeUninit::<LibcItimerspec>::uninit();
-
-    #[cfg(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    ))]
-    unsafe {
-        if let Some(libc_timerfd_settime) = __timerfd_settime64.get() {
-            ret(libc_timerfd_settime(
-                borrowed_fd(fd),
-                flags.bits(),
-                &new_value.clone().into(),
-                result.as_mut_ptr(),
-            ))?;
-            Ok(result.assume_init().into())
-        } else {
-            timerfd_settime_old(fd, flags, new_value)
-        }
-    }
-
-    #[cfg(not(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    )))]
-    unsafe {
-        ret(c::timerfd_settime(
-            borrowed_fd(fd),
-            flags.bits(),
-            new_value,
-            result.as_mut_ptr(),
-        ))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[cfg(feature = "time")]
-unsafe fn timerfd_settime_old(
-    fd: BorrowedFd<'_>,
-    flags: TimerfdTimerFlags,
-    new_value: &Itimerspec,
-) -> io::Result<Itimerspec> {
-    use core::convert::TryInto;
-
-    let mut old_result = MaybeUninit::<c::itimerspec>::uninit();
-
-    // Convert `new_value` to the old `itimerspec` format.
-    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)?,
-        },
-    };
-
-    ret(c::timerfd_settime(
-        borrowed_fd(fd),
-        flags.bits(),
-        &old_new_value,
-        old_result.as_mut_ptr(),
-    ))?;
-
-    let old_result = 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(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(feature = "time")]
-pub(crate) fn timerfd_gettime(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> {
-    let mut result = MaybeUninit::<LibcItimerspec>::uninit();
-
-    #[cfg(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    ))]
-    unsafe {
-        if let Some(libc_timerfd_gettime) = __timerfd_gettime64.get() {
-            ret(libc_timerfd_gettime(borrowed_fd(fd), result.as_mut_ptr()))?;
-            Ok(result.assume_init().into())
-        } else {
-            timerfd_gettime_old(fd)
-        }
-    }
-
-    #[cfg(not(all(
-        any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-        target_env = "gnu",
-    )))]
-    unsafe {
-        ret(c::timerfd_gettime(borrowed_fd(fd), result.as_mut_ptr()))?;
-        Ok(result.assume_init())
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[cfg(feature = "time")]
-unsafe fn timerfd_gettime_old(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> {
-    use core::convert::TryInto;
-
-    let mut old_result = MaybeUninit::<c::itimerspec>::uninit();
-
-    ret(c::timerfd_gettime(borrowed_fd(fd), old_result.as_mut_ptr()))?;
-
-    let old_result = 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-0.36.5/src/backend/libc/time/types.rs b/vendor/rustix-0.36.5/src/backend/libc/time/types.rs
deleted file mode 100644
index 080f64431..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/time/types.rs
+++ /dev/null
@@ -1,364 +0,0 @@
-use super::super::c;
-#[cfg(not(target_os = "wasi"))]
-use crate::fd::BorrowedFd;
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-use bitflags::bitflags;
-
-/// `struct timespec`
-#[cfg(not(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-)))]
-pub type Timespec = c::timespec;
-
-/// `struct timespec`
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[derive(Debug, Clone)]
-#[repr(C)]
-pub struct Timespec {
-    /// Seconds.
-    pub tv_sec: Secs,
-
-    /// Nanoseconds. Must be less than 1_000_000_000.
-    pub tv_nsec: Nsecs,
-}
-
-/// A type for the `tv_sec` field of [`Timespec`].
-#[cfg(not(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-)))]
-#[allow(deprecated)]
-pub type Secs = c::time_t;
-
-/// A type for the `tv_sec` field of [`Timespec`].
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-pub type Secs = i64;
-
-/// A type for the `tv_nsec` field of [`Timespec`].
-#[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))]
-pub type Nsecs = i64;
-
-/// A type for the `tv_nsec` field of [`Timespec`].
-#[cfg(not(all(target_arch = "x86_64", target_pointer_width = "32")))]
-pub type Nsecs = c::c_long;
-
-/// On most platforms, `LibcTimespec` is just `Timespec`.
-#[cfg(not(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-)))]
-pub(crate) type LibcTimespec = Timespec;
-
-/// On 32-bit glibc platforms, `timespec` has anonymous padding fields, which
-/// Rust doesn't support yet (see `unnamed_fields`), so we define our own
-/// struct with explicit padding, with bidirectional `From` impls.
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub(crate) struct LibcTimespec {
-    pub(crate) tv_sec: Secs,
-
-    #[cfg(target_endian = "big")]
-    padding: core::mem::MaybeUninit<u32>,
-
-    pub(crate) tv_nsec: Nsecs,
-
-    #[cfg(target_endian = "little")]
-    padding: core::mem::MaybeUninit<u32>,
-}
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-impl From<LibcTimespec> for Timespec {
-    #[inline]
-    fn from(t: LibcTimespec) -> Self {
-        Self {
-            tv_sec: t.tv_sec,
-            tv_nsec: t.tv_nsec,
-        }
-    }
-}
-
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-impl From<Timespec> for LibcTimespec {
-    #[inline]
-    fn from(t: Timespec) -> Self {
-        Self {
-            tv_sec: t.tv_sec,
-            tv_nsec: t.tv_nsec,
-            padding: core::mem::MaybeUninit::uninit(),
-        }
-    }
-}
-
-/// `CLOCK_*` constants for use with [`clock_gettime`].
-///
-/// These constants are always supported at runtime so `clock_gettime` never
-/// has to fail with `INVAL` due to an unsupported clock. See
-/// [`DynamicClockId`] for a greater set of clocks, with the caveat that not
-/// all of them are always supported.
-///
-/// [`clock_gettime`]: crate::time::clock_gettime
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "wasi")))]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-#[cfg_attr(not(target_os = "dragonfly"), repr(i32))]
-#[cfg_attr(target_os = "dragonfly", repr(u64))]
-#[non_exhaustive]
-pub enum ClockId {
-    /// `CLOCK_REALTIME`
-    Realtime = c::CLOCK_REALTIME,
-
-    /// `CLOCK_MONOTONIC`
-    Monotonic = c::CLOCK_MONOTONIC,
-
-    /// `CLOCK_PROCESS_CPUTIME_ID`
-    #[cfg(not(any(
-        target_os = "illumos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "redox",
-        target_os = "solaris",
-    )))]
-    ProcessCPUTime = c::CLOCK_PROCESS_CPUTIME_ID,
-
-    /// `CLOCK_THREAD_CPUTIME_ID`
-    #[cfg(not(any(
-        target_os = "illumos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "redox",
-        target_os = "solaris",
-    )))]
-    ThreadCPUTime = c::CLOCK_THREAD_CPUTIME_ID,
-
-    /// `CLOCK_REALTIME_COARSE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    RealtimeCoarse = c::CLOCK_REALTIME_COARSE,
-
-    /// `CLOCK_MONOTONIC_COARSE`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    MonotonicCoarse = c::CLOCK_MONOTONIC_COARSE,
-
-    /// `CLOCK_MONOTONIC_RAW`
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    MonotonicRaw = c::CLOCK_MONOTONIC_RAW,
-}
-
-/// `CLOCK_*` constants for use with [`clock_gettime`].
-///
-/// These constants are always supported at runtime so `clock_gettime` never
-/// has to fail with `INVAL` due to an unsupported clock. See
-/// [`DynamicClockId`] for a greater set of clocks, with the caveat that not
-/// all of them are always supported.
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-#[repr(u32)]
-#[non_exhaustive]
-pub enum ClockId {
-    /// `CLOCK_REALTIME`
-    Realtime = c::CLOCK_REALTIME,
-
-    /// `CLOCK_MONOTONIC`
-    Monotonic = c::CLOCK_MONOTONIC,
-
-    /// `CLOCK_PROCESS_CPUTIME_ID`
-    ProcessCPUTime = c::CLOCK_PROCESS_CPUTIME_ID,
-
-    /// `CLOCK_THREAD_CPUTIME_ID`
-    ThreadCPUTime = c::CLOCK_THREAD_CPUTIME_ID,
-}
-
-/// `CLOCK_*` constants for use with [`clock_gettime_dynamic`].
-///
-/// These constants may be unsupported at runtime, depending on the OS version,
-/// and `clock_gettime_dynamic` may fail with `INVAL`. See [`ClockId`] for
-/// clocks which are always supported at runtime.
-///
-/// [`clock_gettime_dynamic`]: crate::time::clock_gettime_dynamic
-#[cfg(not(target_os = "wasi"))]
-#[derive(Debug, Copy, Clone)]
-#[non_exhaustive]
-pub enum DynamicClockId<'a> {
-    /// `ClockId` values that are always supported at runtime.
-    Known(ClockId),
-
-    /// Linux dynamic clocks.
-    Dynamic(BorrowedFd<'a>),
-
-    /// `CLOCK_REALTIME_ALARM`, available on Linux >= 3.0
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    RealtimeAlarm,
-
-    /// `CLOCK_TAI`, available on Linux >= 3.10
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    Tai,
-
-    /// `CLOCK_BOOTTIME`, available on Linux >= 2.6.39
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    Boottime,
-
-    /// `CLOCK_BOOTTIME_ALARM`, available on Linux >= 2.6.39
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    BoottimeAlarm,
-}
-
-/// `struct itimerspec`
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(not(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-)))]
-pub type Itimerspec = c::itimerspec;
-
-/// `struct itimerspec`
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[allow(missing_docs)]
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct Itimerspec {
-    pub it_interval: Timespec,
-    pub it_value: Timespec,
-}
-
-/// On most platforms, `LibcItimerspec` is just `Itimerspec`.
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(not(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-)))]
-pub(crate) type LibcItimerspec = Itimerspec;
-
-/// On 32-bit glibc platforms, `LibcTimespec` differs from `Timespec`, so we
-/// define our own struct, with bidirectional `From` impls.
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub(crate) struct LibcItimerspec {
-    pub it_interval: LibcTimespec,
-    pub it_value: LibcTimespec,
-}
-
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-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(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[cfg(all(
-    any(target_arch = "arm", target_arch = "mips", target_arch = "x86"),
-    target_env = "gnu",
-))]
-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(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-bitflags! {
-    /// `TFD_*` flags for use with [`timerfd_create`].
-    pub struct TimerfdFlags: c::c_int {
-        /// `TFD_NONBLOCK`
-        const NONBLOCK = c::TFD_NONBLOCK;
-
-        /// `TFD_CLOEXEC`
-        const CLOEXEC = c::TFD_CLOEXEC;
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-bitflags! {
-    /// `TFD_TIMER_*` flags for use with [`timerfd_settime`].
-    pub struct TimerfdTimerFlags: c::c_int {
-        /// `TFD_TIMER_ABSTIME`
-        const ABSTIME = c::TFD_TIMER_ABSTIME;
-
-        /// `TFD_TIMER_CANCEL_ON_SET`
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        const CANCEL_ON_SET = 2; // TODO: upstream TFD_TIMER_CANCEL_ON_SET
-    }
-}
-
-/// `CLOCK_*` constants for use with [`timerfd_create`].
-///
-/// [`timerfd_create`]: crate::time::timerfd_create
-#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-#[repr(i32)]
-#[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.
-    Realtime = 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.
-    Monotonic = c::CLOCK_MONOTONIC,
-
-    /// `CLOCK_BOOTTIME`—Like `Monotonic`, but advances while suspended.
-    ///
-    /// This clock is similar to `Monotonic`, but does advance while the system
-    /// is suspended.
-    Boottime = c::CLOCK_BOOTTIME,
-
-    /// `CLOCK_REALTIME_ALARM`—Like `Realtime`, but wakes a suspended system.
-    ///
-    /// This clock is like `Realtime`, but can wake up a suspended system.
-    ///
-    /// Use of this clock requires the `CAP_WAKE_ALARM` Linux capability.
-    RealtimeAlarm = c::CLOCK_REALTIME_ALARM,
-
-    /// `CLOCK_BOOTTIME_ALARM`—Like `Boottime`, but wakes a suspended system.
-    ///
-    /// This clock is like `Boottime`, but can wake up a suspended system.
-    ///
-    /// Use of this clock requires the `CAP_WAKE_ALARM` Linux capability.
-    BoottimeAlarm = c::CLOCK_BOOTTIME_ALARM,
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/weak.rs b/vendor/rustix-0.36.5/src/backend/libc/weak.rs
deleted file mode 100644
index d578038cd..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/weak.rs
+++ /dev/null
@@ -1,226 +0,0 @@
-// Implementation derived from `weak` in Rust's
-// library/std/src/sys/unix/weak.rs at revision
-// fd0cb0cdc21dd9c06025277d772108f8d42cb25f.
-
-//! Support for "weak linkage" to symbols on Unix
-//!
-//! Some I/O operations we do in libstd require newer versions of OSes but we
-//! need to maintain binary compatibility with older releases for now. In order
-//! to use the new functionality when available we use this module for
-//! detection.
-//!
-//! One option to use here is weak linkage, but that is unfortunately only
-//! really workable on Linux. Hence, use dlsym to get the symbol value at
-//! runtime. This is also done for compatibility with older versions of glibc,
-//! and to avoid creating dependencies on `GLIBC_PRIVATE` symbols. It assumes
-//! that we've been dynamically linked to the library the symbol comes from,
-//! but that is currently always the case for things like libpthread/libc.
-//!
-//! A long time ago this used weak linkage for the `__pthread_get_minstack`
-//! symbol, but that caused Debian to detect an unnecessarily strict versioned
-//! dependency on libc6 (#23628).
-
-// There are a variety of `#[cfg]`s controlling which targets are involved in
-// each instance of `weak!` and `syscall!`. Rather than trying to unify all of
-// that, we'll just allow that some unix targets don't use this module at all.
-#![allow(dead_code, unused_macros)]
-#![allow(clippy::doc_markdown)]
-
-use crate::ffi::CStr;
-use core::ffi::c_void;
-use core::ptr::null_mut;
-use core::sync::atomic::{self, AtomicPtr, Ordering};
-use core::{marker, mem};
-
-const NULL: *mut c_void = null_mut();
-const INVALID: *mut c_void = 1 as *mut c_void;
-
-macro_rules! weak {
-    ($vis:vis fn $name:ident($($t:ty),*) -> $ret:ty) => (
-        #[allow(non_upper_case_globals)]
-        $vis static $name: $crate::backend::weak::Weak<unsafe extern fn($($t),*) -> $ret> =
-            $crate::backend::weak::Weak::new(concat!(stringify!($name), '\0'));
-    )
-}
-
-pub(crate) struct Weak<F> {
-    name: &'static str,
-    addr: AtomicPtr<c_void>,
-    _marker: marker::PhantomData<F>,
-}
-
-impl<F> Weak<F> {
-    pub(crate) const fn new(name: &'static str) -> Self {
-        Self {
-            name,
-            addr: AtomicPtr::new(INVALID),
-            _marker: marker::PhantomData,
-        }
-    }
-
-    pub(crate) fn get(&self) -> Option<F> {
-        assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>());
-        unsafe {
-            // Relaxed is fine here because we fence before reading through the
-            // pointer (see the comment below).
-            match self.addr.load(Ordering::Relaxed) {
-                INVALID => self.initialize(),
-                NULL => None,
-                addr => {
-                    let func = mem::transmute_copy::<*mut c_void, F>(&addr);
-                    // The caller is presumably going to read through this value
-                    // (by calling the function we've dlsymed). This means we'd
-                    // need to have loaded it with at least C11's consume
-                    // ordering in order to be guaranteed that the data we read
-                    // from the pointer isn't from before the pointer was
-                    // stored. Rust has no equivalent to memory_order_consume,
-                    // so we use an acquire fence (sorry, ARM).
-                    //
-                    // Now, in practice this likely isn't needed even on CPUs
-                    // where relaxed and consume mean different things. The
-                    // symbols we're loading are probably present (or not) at
-                    // init, and even if they aren't the runtime dynamic loader
-                    // is extremely likely have sufficient barriers internally
-                    // (possibly implicitly, for example the ones provided by
-                    // invoking `mprotect`).
-                    //
-                    // That said, none of that's *guaranteed*, and so we fence.
-                    atomic::fence(Ordering::Acquire);
-                    Some(func)
-                }
-            }
-        }
-    }
-
-    // Cold because it should only happen during first-time initialization.
-    #[cold]
-    unsafe fn initialize(&self) -> Option<F> {
-        let val = fetch(self.name);
-        // This synchronizes with the acquire fence in `get`.
-        self.addr.store(val, Ordering::Release);
-
-        match val {
-            NULL => None,
-            addr => Some(mem::transmute_copy::<*mut c_void, F>(&addr)),
-        }
-    }
-}
-
-unsafe fn fetch(name: &str) -> *mut c_void {
-    let name = match CStr::from_bytes_with_nul(name.as_bytes()) {
-        Ok(c_str) => c_str,
-        Err(..) => return null_mut(),
-    };
-    libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr().cast())
-}
-
-#[cfg(not(any(target_os = "android", target_os = "linux")))]
-macro_rules! syscall {
-    (fn $name:ident($($arg_name:ident: $t:ty),*) via $_sys_name:ident -> $ret:ty) => (
-        unsafe fn $name($($arg_name: $t),*) -> $ret {
-            weak! { fn $name($($t),*) -> $ret }
-
-            if let Some(fun) = $name.get() {
-                fun($($arg_name),*)
-            } else {
-                libc_errno::set_errno(libc_errno::Errno(libc::ENOSYS));
-                -1
-            }
-        }
-    )
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-macro_rules! syscall {
-    (fn $name:ident($($arg_name:ident: $t:ty),*) via $sys_name:ident -> $ret:ty) => (
-        unsafe fn $name($($arg_name:$t),*) -> $ret {
-            // This looks like a hack, but concat_idents only accepts idents
-            // (not paths).
-            use libc::*;
-
-            trait AsSyscallArg {
-                type SyscallArgType;
-                fn into_syscall_arg(self) -> Self::SyscallArgType;
-            }
-
-            // Pass pointer types as pointers, to preserve provenance.
-            impl<T> AsSyscallArg for *mut T {
-                type SyscallArgType = *mut T;
-                fn into_syscall_arg(self) -> Self::SyscallArgType { self }
-            }
-            impl<T> AsSyscallArg for *const T {
-                type SyscallArgType = *const T;
-                fn into_syscall_arg(self) -> Self::SyscallArgType { self }
-            }
-
-            // Pass `BorrowedFd` values as the integer value.
-            impl AsSyscallArg for $crate::fd::BorrowedFd<'_> {
-                type SyscallArgType = c::c_long;
-                fn into_syscall_arg(self) -> Self::SyscallArgType {
-                    $crate::fd::AsRawFd::as_raw_fd(&self) as _
-                }
-            }
-
-            // Coerce integer values into `c_long`.
-            impl AsSyscallArg for i32 {
-                type SyscallArgType = c::c_long;
-                fn into_syscall_arg(self) -> Self::SyscallArgType { self as _ }
-            }
-            impl AsSyscallArg for u32 {
-                type SyscallArgType = c::c_long;
-                fn into_syscall_arg(self) -> Self::SyscallArgType { self as _ }
-            }
-            impl AsSyscallArg for usize {
-                type SyscallArgType = c::c_long;
-                fn into_syscall_arg(self) -> Self::SyscallArgType { self as _ }
-            }
-
-            // `concat_idents is unstable, so we take an extra `sys_name`
-            // parameter and have our users do the concat for us for now.
-            /*
-            syscall(
-                concat_idents!(SYS_, $name),
-                $($arg_name.into_syscall_arg()),*
-            ) as $ret
-            */
-
-            syscall($sys_name, $($arg_name.into_syscall_arg()),*) as $ret
-        }
-    )
-}
-
-macro_rules! weakcall {
-    ($vis:vis fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
-        $vis unsafe fn $name($($arg_name: $t),*) -> $ret {
-            weak! { fn $name($($t),*) -> $ret }
-
-            // Use a weak symbol from libc when possible, allowing `LD_PRELOAD`
-            // interposition, but if it's not found just fail.
-            if let Some(fun) = $name.get() {
-                fun($($arg_name),*)
-            } else {
-                libc_errno::set_errno(libc_errno::Errno(libc::ENOSYS));
-                -1
-            }
-        }
-    )
-}
-
-/// A combination of `weakcall` and `syscall`. Use the libc function if it's
-/// available, and fall back to `libc::syscall` otherwise.
-macro_rules! weak_or_syscall {
-    ($vis:vis fn $name:ident($($arg_name:ident: $t:ty),*) via $sys_name:ident -> $ret:ty) => (
-        $vis unsafe fn $name($($arg_name: $t),*) -> $ret {
-            weak! { fn $name($($t),*) -> $ret }
-
-            // Use a weak symbol from libc when possible, allowing `LD_PRELOAD`
-            // interposition, but if it's not found just fail.
-            if let Some(fun) = $name.get() {
-                fun($($arg_name),*)
-            } else {
-                syscall! { fn $name($($arg_name: $t),*) via $sys_name -> $ret }
-                $name($($arg_name),*)
-            }
-        }
-    )
-}
diff --git a/vendor/rustix-0.36.5/src/backend/libc/winsock_c.rs b/vendor/rustix-0.36.5/src/backend/libc/winsock_c.rs
deleted file mode 100644
index 7d78aef65..000000000
--- a/vendor/rustix-0.36.5/src/backend/libc/winsock_c.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-//! Adapt the Winsock2 API to resemble a POSIX-style libc API.
-
-#![allow(unused_imports)]
-#![allow(non_camel_case_types)]
-
-use windows_sys::Win32::Networking::WinSock;
-
-pub(crate) use libc::{
-    c_char, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong, c_ulonglong,
-    c_ushort, c_void, ssize_t,
-};
-pub(crate) type socklen_t = i32;
-
-// windows-sys declares these constants as unsigned. For better compatibility
-// with Unix-family APIs, redeclare them as signed. Filed upstream:
-// <https://github.com/microsoft/windows-rs/issues/1718>
-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 _;
-pub(crate) const SO_TYPE: i32 = WinSock::SO_TYPE as _;
-pub(crate) const SO_REUSEADDR: i32 = WinSock::SO_REUSEADDR as _;
-pub(crate) const SO_BROADCAST: i32 = WinSock::SO_BROADCAST as _;
-pub(crate) const SO_LINGER: i32 = WinSock::SO_LINGER as _;
-pub(crate) const SOL_SOCKET: i32 = WinSock::SOL_SOCKET as _;
-pub(crate) const SO_RCVTIMEO: i32 = WinSock::SO_RCVTIMEO as _;
-pub(crate) const SO_SNDTIMEO: i32 = WinSock::SO_SNDTIMEO as _;
-pub(crate) const IP_TTL: i32 = WinSock::IP_TTL as _;
-pub(crate) const TCP_NODELAY: i32 = WinSock::TCP_NODELAY as _;
-pub(crate) const IP_ADD_MEMBERSHIP: i32 = WinSock::IP_ADD_MEMBERSHIP as _;
-pub(crate) const IP_DROP_MEMBERSHIP: i32 = WinSock::IP_DROP_MEMBERSHIP as _;
-pub(crate) const IP_MULTICAST_TTL: i32 = WinSock::IP_MULTICAST_TTL as _;
-pub(crate) const IP_MULTICAST_LOOP: i32 = WinSock::IP_MULTICAST_LOOP as _;
-pub(crate) const IPV6_ADD_MEMBERSHIP: i32 = WinSock::IPV6_ADD_MEMBERSHIP as _;
-pub(crate) const IPV6_DROP_MEMBERSHIP: i32 = WinSock::IPV6_DROP_MEMBERSHIP as _;
-pub(crate) const IPV6_MULTICAST_LOOP: i32 = WinSock::IPV6_MULTICAST_LOOP as _;
-pub(crate) const IPV6_V6ONLY: i32 = WinSock::IPV6_V6ONLY as _;
-pub(crate) const POLLERR: i16 = WinSock::POLLERR as _;
-pub(crate) const POLLIN: i16 = WinSock::POLLIN as _;
-pub(crate) const POLLNVAL: i16 = WinSock::POLLNVAL as _;
-pub(crate) const POLLHUP: i16 = WinSock::POLLHUP as _;
-pub(crate) const POLLPRI: i16 = WinSock::POLLPRI as _;
-pub(crate) const POLLOUT: i16 = WinSock::POLLOUT as _;
-pub(crate) const POLLRDNORM: i16 = WinSock::POLLRDNORM as _;
-pub(crate) const POLLWRNORM: i16 = WinSock::POLLWRNORM as _;
-pub(crate) const POLLRDBAND: i16 = WinSock::POLLRDBAND as _;
-pub(crate) const POLLWRBAND: i16 = WinSock::POLLWRBAND as _;
-
-// As above, cast the types for better compatibility, and also rename these to
-// their Unix names.
-pub(crate) const SHUT_RDWR: i32 = WinSock::SD_BOTH as _;
-pub(crate) const SHUT_RD: i32 = WinSock::SD_RECEIVE as _;
-pub(crate) const SHUT_WR: i32 = WinSock::SD_SEND 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, 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, *,
-};