Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

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

50 files changed, 12958 insertions, 0 deletions

diff --git a/vendor/rustix/src/imp/libc/conv.rs b/vendor/rustix/src/imp/libc/conv.rs
new file mode 100644
index 000000000..fed15fbd1
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/conv.rs
@@ -0,0 +1,220 @@
+//! 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, RawFd};
+#[cfg(not(windows))]
+use super::offset::libc_off_t;
+#[cfg(not(windows))]
+use crate::ffi::CStr;
+use crate::io::{self, OwnedFd};
+#[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))]
+#[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/src/imp/libc/fs/dir.rs b/vendor/rustix/src/imp/libc/fs/dir.rs
new file mode 100644
index 000000000..1e6b6066f
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/fs/dir.rs
@@ -0,0 +1,402 @@
+use super::super::c;
+use super::super::conv::owned_fd;
+#[cfg(not(target_os = "illumos"))]
+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 = "illumos",
+    target_os = "netbsd",
+    target_os = "redox",
+    target_os = "wasi",
+)))] // not implemented in libc for netbsd yet
+use crate::fs::{fstatfs, StatFs};
+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 e = io::Errno::last_os_error();
+                let _ = c::close(raw);
+                Err(e)
+            }
+        }
+    }
+
+    /// `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 = "illumos",
+        target_os = "netbsd",
+        target_os = "redox",
+        target_os = "wasi",
+    )))] // not implemented in libc for netbsd yet
+    #[inline]
+    pub fn statfs(&self) -> io::Result<StatFs> {
+        fstatfs(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(target_os = "illumos"))]
+    let d_type = input.d_type;
+
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "wasi",
+    )))]
+    let d_off = input.d_off;
+
+    #[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 = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
+    let d_fileno = input.d_fileno;
+
+    #[cfg(not(target_os = "wasi"))]
+    let d_reclen = input.d_reclen;
+
+    #[cfg(any(
+        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;
+
+    // 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))]
+    let mut dirent = libc_dirent {
+        #[cfg(not(target_os = "illumos"))]
+        d_type,
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "wasi",
+        )))]
+        d_off,
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            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 = "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(),
+    };
+
+    // 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(target_os = "illumos"))]
+    #[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
+    }
+
+    /// 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/src/imp/libc/fs/makedev.rs b/vendor/rustix/src/imp/libc/fs/makedev.rs
new file mode 100644
index 000000000..d9089e7f4
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/fs/makedev.rs
@@ -0,0 +1,90 @@
+#[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 {
+    unsafe { c::makedev(maj, min) }
+}
+
+#[cfg(all(target_os = "android", not(target_pointer_width = "32")))]
+#[inline]
+pub(crate) fn makedev(maj: u32, min: u32) -> Dev {
+    // Android's `makedev` oddly has signed argument types.
+    unsafe { c::makedev(maj as i32, min as i32) }
+}
+
+#[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(unsafe { 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/src/imp/libc/fs/mod.rs b/vendor/rustix/src/imp/libc/fs/mod.rs
new file mode 100644
index 000000000..02b7b2d6a
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/fs/mod.rs
@@ -0,0 +1,18 @@
+#[cfg(not(target_os = "redox"))]
+#[cfg(any(feature = "fs", feature = "procfs"))]
+pub(crate) mod dir;
+#[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 = "wasi",
+)))]
+pub(crate) mod makedev;
+#[cfg(not(windows))]
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/imp/libc/fs/syscalls.rs b/vendor/rustix/src/imp/libc/fs/syscalls.rs
new file mode 100644
index 000000000..0317367ab
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/fs/syscalls.rs
@@ -0,0 +1,1670 @@
+//! 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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+use super::super::offset::libc_posix_fadvise;
+#[cfg(not(any(
+    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",
+)))]
+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 = "illumos",
+    target_os = "netbsd",
+    target_os = "redox",
+    target_os = "wasi",
+)))]
+use super::super::offset::{libc_fstatfs, libc_statfs};
+#[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;
+#[cfg(not(target_os = "wasi"))]
+use crate::fd::RawFd;
+use crate::ffi::CStr;
+#[cfg(any(target_os = "ios", target_os = "macos"))]
+use crate::ffi::CString;
+#[cfg(not(target_os = "illumos"))]
+use crate::fs::Access;
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+use crate::fs::Advice;
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "illumos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+use crate::fs::FallocateFlags;
+#[cfg(not(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 = "illumos",
+    target_os = "netbsd",
+    target_os = "redox",
+    target_os = "wasi",
+)))]
+// not implemented in libc for netbsd yet
+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::{FdFlags, Mode, OFlags, Stat, Timestamps};
+use crate::io::{self, OwnedFd, 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::imp::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 = "illumos",
+    target_os = "netbsd",
+    target_os = "redox",
+    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(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) => return statx_to_stat(x),
+            Err(io::Errno::NOSYS) => statat_old(dirfd, path, flags),
+            Err(e) => return Err(e),
+        }
+    }
+
+    // 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")))]
+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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+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_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())) }
+}
+
+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())) }
+}
+
+#[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)) }
+}
+
+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(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) => return statx_to_stat(x),
+            Err(io::Errno::NOSYS) => fstat_old(fd),
+            Err(e) => return Err(e),
+        }
+    }
+
+    // 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 = "illumos",
+    target_os = "netbsd",
+    target_os = "redox",
+    target_os = "wasi",
+)))] // not implemented in libc for netbsd yet
+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())
+    }
+}
+
+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 = "dragonfly",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+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_else(|| 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 = "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> {
+    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 = 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/src/imp/libc/fs/types.rs b/vendor/rustix/src/imp/libc/fs/types.rs
new file mode 100644
index 000000000..9d892daf0
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/fs/types.rs
@@ -0,0 +1,1028 @@
+use super::super::c;
+use bitflags::bitflags;
+
+bitflags! {
+    /// `FD_*` constants for use with [`fcntl_getfd`] and [`fcntl_setfd`].
+    ///
+    /// [`fcntl_getfd`]: crate::fs::fcntl_getfd
+    /// [`fcntl_setfd`]: crate::fs::fcntl_setfd
+    pub struct FdFlags: c::c_int {
+        /// `FD_CLOEXEC`
+        const CLOEXEC = c::FD_CLOEXEC;
+    }
+}
+
+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 = "illumos", target_os = "redox")))]
+    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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+#[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 = "illumos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+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 = "dragonfly",
+            target_os = "freebsd",
+            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 = "dragonfly",
+            target_os = "freebsd",
+            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 = "dragonfly",
+            target_os = "freebsd",
+            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 = "dragonfly",
+            target_os = "freebsd",
+            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 = "dragonfly",
+            target_os = "freebsd",
+            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 = "dragonfly",
+            target_os = "freebsd",
+            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 = "dragonfly",
+            target_os = "freebsd",
+            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;
+    }
+}
+
+/// `LOCK_*` constants for use with [`flock`]
+///
+/// [`flock`]: crate::fs::flock
+#[cfg(not(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 [`fstatfs`].
+///
+/// [`fstatfs`]: crate::fs::fstatfs
+#[cfg(not(any(
+    target_os = "android",
+    target_os = "emscripten",
+    target_os = "illumos",
+    target_os = "linux",
+    target_os = "l4re",
+    target_os = "netbsd",
+    target_os = "redox",
+    target_os = "wasi",
+)))]
+#[allow(clippy::module_name_repetitions)]
+pub type StatFs = c::statfs;
+
+/// `struct statfs` for use with [`fstatfs`].
+///
+/// [`fstatfs`]: crate::fs::fstatfs
+#[cfg(any(
+    target_os = "android",
+    target_os = "linux",
+    target_os = "emscripten",
+    target_os = "l4re",
+))]
+pub type StatFs = c::statfs64;
+
+/// `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/src/imp/libc/io/epoll.rs b/vendor/rustix/src/imp/libc/io/epoll.rs
new file mode 100644
index 000000000..a95e6b5cd
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io/epoll.rs
@@ -0,0 +1,568 @@
+//! 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, RawFd};
+#[cfg(not(feature = "rustc-dep-of-std"))]
+use crate::fd::{FromFd, FromRawFd, IntoFd, IntoRawFd};
+use crate::io::{self, OwnedFd};
+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 `IntoFd` and `FromFd`.
+///
+/// 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: IntoFd + FromFd> {
+    _phantom: PhantomData<&'context T>,
+}
+
+#[cfg(not(feature = "rustc-dep-of-std"))]
+impl<'context, T: IntoFd + FromFd> 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 + IntoFd + FromFd> 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 raw_fd = data.into_fd().into_raw_fd();
+        // Safety: `epoll` will assign ownership of the file descriptor to the
+        // kernel epoll object. We use `IntoFd`+`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_fd(io_lifetimes::OwnedFd::from_raw_fd(raw_fd)) }
+    }
+}
+
+/// 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 + IntoFd + FromFd> 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 + IntoFd + FromFd> 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 + IntoFd + FromFd> 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 + IntoFd + FromFd> 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 + IntoFd + FromFd> 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 + IntoFd + FromFd> 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/src/imp/libc/io/errno.rs b/vendor/rustix/src/imp/libc/io/errno.rs
new file mode 100644
index 000000000..470cf205c
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io/errno.rs
@@ -0,0 +1,997 @@
+//! 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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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(any(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 = "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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        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 = "android",
+        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 = "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 = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "wasi",
+    )))]
+    pub const ISNAM: Self = Self(c::EISNAM);
+    /// `EKEYEXPIRED`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "wasi",
+    )))]
+    pub const KEYEXPIRED: Self = Self(c::EKEYEXPIRED);
+    /// `EKEYREJECTED`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "wasi",
+    )))]
+    pub const KEYREJECTED: Self = Self(c::EKEYREJECTED);
+    /// `EKEYREVOKED`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "wasi",
+    )))]
+    pub const KEYREVOKED: Self = Self(c::EKEYREVOKED);
+    /// `EL2HLT`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        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 = "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 = "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 = "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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "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 = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "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 = "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 = "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 = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "openbsd",
+        target_os = "wasi",
+    )))]
+    pub const NOSR: Self = Self(c::ENOSR);
+    /// `ENOSTR`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        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 = "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 = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "wasi",
+    )))]
+    pub const NOTNAM: Self = Self(c::ENOTNAM);
+    /// `ENOTRECOVERABLE`
+    #[cfg(not(any(windows, target_os = "dragonfly", 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 = "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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "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 = "dragonfly",
+        target_os = "freebsd",
+        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(target_os = "wasi"))]
+    pub const REMOTE: Self = Self(c::EREMOTE);
+    /// `EREMOTEIO`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "wasi",
+    )))]
+    pub const REMOTEIO: Self = Self(c::EREMOTEIO);
+    /// `ERESTART`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        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 = "android",
+        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 = "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(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 = "dragonfly",
+        target_os = "freebsd",
+        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 = "dragonfly",
+        target_os = "freebsd",
+        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(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 = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "wasi",
+    )))]
+    pub const UCLEAN: Self = Self(c::EUCLEAN);
+    /// `EUNATCH`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        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(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 = "dragonfly",
+        target_os = "freebsd",
+        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/src/imp/libc/io/io_slice.rs b/vendor/rustix/src/imp/libc/io/io_slice.rs
new file mode 100644
index 000000000..81c504d25
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io/io_slice.rs
@@ -0,0 +1,85 @@
+//! The following is derived from Rust's
+//! library/std/src/sys/unix/io.rs
+//! dca3f1b786efd27be3b325ed1e01e247aa589c3b.
+
+use super::super::c;
+use core::marker::PhantomData;
+use core::slice;
+
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct IoSlice<'a> {
+    vec: c::iovec,
+    _p: PhantomData<&'a [u8]>,
+}
+
+impl<'a> IoSlice<'a> {
+    #[inline]
+    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
+        IoSlice {
+            vec: c::iovec {
+                iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void,
+                iov_len: buf.len(),
+            },
+            _p: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn advance(&mut self, n: usize) {
+        if self.vec.iov_len < n {
+            panic!("advancing IoSlice beyond its length");
+        }
+
+        unsafe {
+            self.vec.iov_len -= n;
+            self.vec.iov_base = self.vec.iov_base.add(n);
+        }
+    }
+
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }
+    }
+}
+
+#[repr(transparent)]
+pub struct IoSliceMut<'a> {
+    vec: c::iovec,
+    _p: PhantomData<&'a mut [u8]>,
+}
+
+impl<'a> IoSliceMut<'a> {
+    #[inline]
+    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
+        IoSliceMut {
+            vec: c::iovec {
+                iov_base: buf.as_mut_ptr() as *mut c::c_void,
+                iov_len: buf.len(),
+            },
+            _p: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn advance(&mut self, n: usize) {
+        if self.vec.iov_len < n {
+            panic!("advancing IoSliceMut beyond its length");
+        }
+
+        unsafe {
+            self.vec.iov_len -= n;
+            self.vec.iov_base = self.vec.iov_base.add(n);
+        }
+    }
+
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) }
+    }
+
+    #[inline]
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        unsafe { slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len) }
+    }
+}
diff --git a/vendor/rustix/src/imp/libc/io/mod.rs b/vendor/rustix/src/imp/libc/io/mod.rs
new file mode 100644
index 000000000..1378adf3d
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io/mod.rs
@@ -0,0 +1,13 @@
+pub(crate) mod errno;
+#[cfg(not(windows))]
+#[cfg(not(feature = "std"))]
+pub(crate) mod io_slice;
+pub(crate) mod poll_fd;
+#[cfg(not(windows))]
+pub(crate) mod types;
+
+#[cfg_attr(windows, path = "windows_syscalls.rs")]
+pub(crate) mod syscalls;
+
+#[cfg(any(target_os = "android", target_os = "linux"))]
+pub mod epoll;
diff --git a/vendor/rustix/src/imp/libc/io/poll_fd.rs b/vendor/rustix/src/imp/libc/io/poll_fd.rs
new file mode 100644
index 000000000..c516a9309
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io/poll_fd.rs
@@ -0,0 +1,136 @@
+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/src/imp/libc/io/syscalls.rs b/vendor/rustix/src/imp/libc/io/syscalls.rs
new file mode 100644
index 000000000..4fafbfd66
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io/syscalls.rs
@@ -0,0 +1,456 @@
+//! 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(target_os = "redox"))]
+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, RawFd};
+#[cfg(not(target_os = "wasi"))]
+use crate::io::DupFlags;
+#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "wasi")))]
+use crate::io::PipeFlags;
+use crate::io::{self, IoSlice, IoSliceMut, OwnedFd, PollFd};
+#[cfg(any(target_os = "android", target_os = "linux"))]
+use crate::io::{EventfdFlags, ReadWriteFlags};
+use core::cmp::min;
+use core::convert::TryInto;
+use core::mem::MaybeUninit;
+#[cfg(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(target_os = "redox"))]
+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(target_os = "redox"))]
+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(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(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");
+}
+
+#[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 = "android",
+    target_os = "dragonfly",
+    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 = "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 = "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 = "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 = "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)
+}
diff --git a/vendor/rustix/src/imp/libc/io/types.rs b/vendor/rustix/src/imp/libc/io/types.rs
new file mode 100644
index 000000000..483f3a6af
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io/types.rs
@@ -0,0 +1,89 @@
+use super::super::c;
+#[cfg(not(target_os = "wasi"))]
+use bitflags::bitflags;
+
+#[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(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 = "illumos", target_os = "openbsd", target_os = "redox")))]
+        const DIRECT = c::O_DIRECT;
+        /// `O_NONBLOCK`
+        const NONBLOCK = c::O_NONBLOCK;
+    }
+}
+
+#[cfg(any(target_os = "android", target_os = "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 = "illumos", target_os = "redox", target_os = "wasi")))]
+pub const PIPE_BUF: usize = c::PIPE_BUF;
+
+#[cfg(not(any(windows, target_os = "redox")))]
+pub(crate) const AT_FDCWD: c::c_int = c::AT_FDCWD;
+#[cfg(not(windows))]
+pub(crate) const STDIN_FILENO: c::c_int = c::STDIN_FILENO;
+#[cfg(not(windows))]
+pub(crate) const STDOUT_FILENO: c::c_int = c::STDOUT_FILENO;
+#[cfg(not(windows))]
+pub(crate) const STDERR_FILENO: c::c_int = c::STDERR_FILENO;
diff --git a/vendor/rustix/src/imp/libc/io/windows_syscalls.rs b/vendor/rustix/src/imp/libc/io/windows_syscalls.rs
new file mode 100644
index 000000000..4c6e86f94
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io/windows_syscalls.rs
@@ -0,0 +1,39 @@
+//! 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/src/imp/libc/io_lifetimes.rs b/vendor/rustix/src/imp/libc/io_lifetimes.rs
new file mode 100644
index 000000000..b0b14b7c8
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io_lifetimes.rs
@@ -0,0 +1,109 @@
+//! `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, FromSocket, IntoSocket};
+
+/// 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()
+    }
+}
+
+/// A version of [`IntoFd`] for use with Winsock2 API.
+///
+/// [`IntoFd`]: https://docs.rs/io-lifetimes/latest/io_lifetimes/trait.IntoFd.html
+pub trait IntoFd {
+    /// A version of [`into_fd`] for use with Winsock2 API.
+    ///
+    /// [`into_fd`]: https://docs.rs/io-lifetimes/latest/io_lifetimes/trait.IntoFd.html#tymethod.into_fd
+    fn into_fd(self) -> OwnedFd;
+}
+impl<T: IntoSocket> IntoFd for T {
+    #[inline]
+    fn into_fd(self) -> OwnedFd {
+        self.into_socket()
+    }
+}
+
+/// A version of [`FromFd`] for use with Winsock2 API.
+///
+/// [`FromFd`]: https://docs.rs/io-lifetimes/latest/io_lifetimes/trait.FromFd.html
+pub trait FromFd {
+    /// A version of [`from_fd`] for use with Winsock2 API.
+    ///
+    /// [`from_fd`]: https://docs.rs/io-lifetimes/latest/io_lifetimes/trait.FromFd.html#tymethod.from_fd
+    fn from_fd(fd: OwnedFd) -> Self;
+}
+impl<T: FromSocket> FromFd for T {
+    #[inline]
+    fn from_fd(fd: OwnedFd) -> Self {
+        Self::from_socket(fd)
+    }
+}
diff --git a/vendor/rustix/src/imp/libc/io_uring/mod.rs b/vendor/rustix/src/imp/libc/io_uring/mod.rs
new file mode 100644
index 000000000..ef944f04d
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io_uring/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/imp/libc/io_uring/syscalls.rs b/vendor/rustix/src/imp/libc/io_uring/syscalls.rs
new file mode 100644
index 000000000..d1e68363c
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/io_uring/syscalls.rs
@@ -0,0 +1,55 @@
+//! 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;
+use crate::io::{self, OwnedFd};
+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/src/imp/libc/mm/mod.rs b/vendor/rustix/src/imp/libc/mm/mod.rs
new file mode 100644
index 000000000..1e0181a99
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/mm/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/imp/libc/mm/syscalls.rs b/vendor/rustix/src/imp/libc/mm/syscalls.rs
new file mode 100644
index 000000000..ee670b5bf
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/mm/syscalls.rs
@@ -0,0 +1,218 @@
+//! 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;
+use crate::io;
+#[cfg(any(target_os = "android", target_os = "linux"))]
+use crate::io::OwnedFd;
+
+#[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/src/imp/libc/mm/types.rs b/vendor/rustix/src/imp/libc/mm/types.rs
new file mode 100644
index 000000000..385b6c0e6
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/mm/types.rs
@@ -0,0 +1,397 @@
+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 = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "redox",
+        )))]
+        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 = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "redox",
+        )))]
+        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 = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "redox",
+        )))]
+        const FIXED_NOREPLACE = c::MAP_FIXED_NOREPLACE;
+        /// `MAP_GROWSDOWN`
+        #[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",
+        )))]
+        const GROWSDOWN = c::MAP_GROWSDOWN;
+        /// `MAP_HUGETLB`
+        #[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",
+        )))]
+        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 = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "redox",
+        )))]
+        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 = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "redox",
+        )))]
+        const HUGE_1GB = c::MAP_HUGE_1GB;
+        /// `MAP_LOCKED`
+        #[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",
+        )))]
+        const LOCKED = c::MAP_LOCKED;
+        /// `MAP_NORESERVE`
+        #[cfg(not(any(target_os = "dragonfly", target_os = "freebsd", target_os = "redox")))]
+        const NORESERVE = c::MAP_NORESERVE;
+        /// `MAP_POPULATE`
+        #[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",
+        )))]
+        const POPULATE = c::MAP_POPULATE;
+        /// `MAP_STACK`
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            target_os = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "redox",
+        )))]
+        const STACK = c::MAP_STACK;
+        /// `MAP_SYNC`
+        #[cfg(not(any(
+            target_os = "android",
+            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",
+            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(target_os = "android"))]
+    Normal = c::POSIX_MADV_NORMAL,
+
+    /// `POSIX_MADV_NORMAL`
+    #[cfg(target_os = "android")]
+    Normal = c::MADV_NORMAL,
+
+    /// `POSIX_MADV_SEQUENTIAL`
+    #[cfg(not(target_os = "android"))]
+    Sequential = c::POSIX_MADV_SEQUENTIAL,
+
+    /// `POSIX_MADV_SEQUENTIAL`
+    #[cfg(target_os = "android")]
+    Sequential = c::MADV_SEQUENTIAL,
+
+    /// `POSIX_MADV_RANDOM`
+    #[cfg(not(target_os = "android"))]
+    Random = c::POSIX_MADV_RANDOM,
+
+    /// `POSIX_MADV_RANDOM`
+    #[cfg(target_os = "android")]
+    Random = c::MADV_RANDOM,
+
+    /// `POSIX_MADV_WILLNEED`
+    #[cfg(not(target_os = "android"))]
+    WillNeed = c::POSIX_MADV_WILLNEED,
+
+    /// `POSIX_MADV_WILLNEED`
+    #[cfg(target_os = "android")]
+    WillNeed = c::MADV_WILLNEED,
+
+    /// `POSIX_MADV_DONTNEED`
+    #[cfg(not(any(target_os = "android", target_os = "emscripten")))]
+    DontNeed = c::POSIX_MADV_DONTNEED,
+
+    /// `POSIX_MADV_DONTNEED`
+    #[cfg(target_os = "android")]
+    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/src/imp/libc/mod.rs b/vendor/rustix/src/imp/libc/mod.rs
new file mode 100644
index 000000000..e99a323ce
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/mod.rs
@@ -0,0 +1,111 @@
+//! 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")] // TODO: Enable this once `OwnedFd` moves out of the tree.
+pub(crate) mod fs;
+pub(crate) mod io;
+#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(feature = "io_uring")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "io_uring")))]
+pub(crate) mod io_uring;
+#[cfg(not(any(windows, target_os = "wasi")))]
+#[cfg(any(feature = "mm", feature = "time", target_arch = "x86"))] // vdso.rs uses `madvise`
+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(any(windows, target_os = "wasi")))]
+#[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
+    // imp/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/src/imp/libc/net/addr.rs b/vendor/rustix/src/imp/libc/net/addr.rs
new file mode 100644
index 000000000..1aeda5e5d
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/net/addr.rs
@@ -0,0 +1,320 @@
+//! 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 = "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 = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd",
+            )))]
+            sun_path: [0; 108],
+        }
+    }
+
+    /// For a filesystem path address, return the path.
+    #[inline]
+    pub fn path(&self) -> Option<&CStr> {
+        let len = self.len();
+        if len != 0 && self.unix.sun_path[0] != 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 = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sun_len: 0_u8,
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            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 = "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 = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        sun_path: [0; 108],
+    };
+    (crate::utils::as_ptr(&z.sun_path) as usize) - (crate::utils::as_ptr(&z) as usize)
+}
diff --git a/vendor/rustix/src/imp/libc/net/ext.rs b/vendor/rustix/src/imp/libc/net/ext.rs
new file mode 100644
index 000000000..7b5313c51
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/net/ext.rs
@@ -0,0 +1,223 @@
+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(feature = "std"))]
+#[cfg(not(windows))]
+#[inline]
+pub(crate) fn sockaddr_in6_sin6_scope_id_mut(addr: &mut c::sockaddr_in6) -> &mut u32 {
+    &mut addr.sin6_scope_id
+}
+
+#[cfg(not(feature = "std"))]
+#[cfg(windows)]
+#[inline]
+pub(crate) fn sockaddr_in6_sin6_scope_id_mut(addr: &mut c::sockaddr_in6) -> &mut u32 {
+    let addr: &mut sockaddr_in6 = unsafe { core::mem::transmute(addr) };
+    &mut 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 = "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 = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sin6_len,
+        sin6_family,
+        sin6_port,
+        sin6_flowinfo,
+        sin6_addr,
+        sin6_scope_id,
+        #[cfg(target_os = "illumos")]
+        __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/src/imp/libc/net/mod.rs b/vendor/rustix/src/imp/libc/net/mod.rs
new file mode 100644
index 000000000..f7196ae4f
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/net/mod.rs
@@ -0,0 +1,7 @@
+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/src/imp/libc/net/read_sockaddr.rs b/vendor/rustix/src/imp/libc/net/read_sockaddr.rs
new file mode 100644
index 000000000..cb76b296c
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/net/read_sockaddr.rs
@@ -0,0 +1,249 @@
+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 = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sa_len: 0_u8,
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            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 = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        sa_family: 0_u16,
+        sa_data: [0; 14],
+    };
+
+    (*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/src/imp/libc/net/send_recv.rs b/vendor/rustix/src/imp/libc/net/send_recv.rs
new file mode 100644
index 000000000..9ab908d62
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/net/send_recv.rs
@@ -0,0 +1,77 @@
+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 = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        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 = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        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 = "illumos", target_os = "ios", target_os = "macos")))]
+        /// `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 = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        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/src/imp/libc/net/syscalls.rs b/vendor/rustix/src/imp/libc/net/syscalls.rs
new file mode 100644
index 000000000..b0bab2e31
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/net/syscalls.rs
@@ -0,0 +1,866 @@
+//! 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;
+use crate::io::{self, OwnedFd};
+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 = "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 = "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 = "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 = "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_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/src/imp/libc/net/types.rs b/vendor/rustix/src/imp/libc/net/types.rs
new file mode 100644
index 000000000..63e3a317e
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/net/types.rs
@@ -0,0 +1,621 @@
+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`
+    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 = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    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 = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    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 = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const NETROM: Self = Self(c::AF_NETROM as _);
+    /// `AF_BRIDGE`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const BRIDGE: Self = Self(c::AF_BRIDGE as _);
+    /// `AF_ATMPVC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const ATMPVC: Self = Self(c::AF_ATMPVC as _);
+    /// `AF_X25`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        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 = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const ROSE: Self = Self(c::AF_ROSE as _);
+    /// `AF_DECnet`
+    #[allow(non_upper_case_globals)]
+    pub const DECnet: Self = Self(c::AF_DECnet as _);
+    /// `AF_NETBEUI`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const NETBEUI: Self = Self(c::AF_NETBEUI as _);
+    /// `AF_SECURITY`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const SECURITY: Self = Self(c::AF_SECURITY as _);
+    /// `AF_KEY`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        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 = "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 = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const ASH: Self = Self(c::AF_ASH as _);
+    /// `AF_ECONET`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const ECONET: Self = Self(c::AF_ECONET as _);
+    /// `AF_ATMSVC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const ATMSVC: Self = Self(c::AF_ATMSVC as _);
+    /// `AF_RDS`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const RDS: Self = Self(c::AF_RDS as _);
+    /// `AF_SNA`
+    pub const SNA: Self = Self(c::AF_SNA as _);
+    /// `AF_IRDA`
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const IRDA: Self = Self(c::AF_IRDA as _);
+    /// `AF_PPPOX`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const PPPOX: Self = Self(c::AF_PPPOX as _);
+    /// `AF_WANPIPE`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const WANPIPE: Self = Self(c::AF_WANPIPE as _);
+    /// `AF_LLC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const LLC: Self = Self(c::AF_LLC as _);
+    /// `AF_CAN`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const CAN: Self = Self(c::AF_CAN as _);
+    /// `AF_TIPC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const TIPC: Self = Self(c::AF_TIPC as _);
+    /// `AF_BLUETOOTH`
+    #[cfg(not(any(windows, target_os = "illumos", target_os = "ios", target_os = "macos")))]
+    pub const BLUETOOTH: Self = Self(c::AF_BLUETOOTH as _);
+    /// `AF_IUCV`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const IUCV: Self = Self(c::AF_IUCV as _);
+    /// `AF_RXRPC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const RXRPC: Self = Self(c::AF_RXRPC as _);
+    /// `AF_ISDN`
+    #[cfg(not(any(windows, target_os = "illumos")))]
+    pub const ISDN: Self = Self(c::AF_ISDN as _);
+    /// `AF_PHONET`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const PHONET: Self = Self(c::AF_PHONET as _);
+    /// `AF_IEEE802154`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    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(target_os = "illumos"))]
+    pub const IGMP: Self = Self(c::IPPROTO_IGMP as _);
+    /// `IPPROTO_IPIP`
+    #[cfg(not(any(windows, target_os = "illumos")))]
+    pub const IPIP: Self = Self(c::IPPROTO_IPIP as _);
+    /// `IPPROTO_TCP`
+    pub const TCP: Self = Self(c::IPPROTO_TCP as _);
+    /// `IPPROTO_EGP`
+    #[cfg(not(target_os = "illumos"))]
+    pub const EGP: Self = Self(c::IPPROTO_EGP as _);
+    /// `IPPROTO_PUP`
+    #[cfg(not(target_os = "illumos"))]
+    pub const PUP: Self = Self(c::IPPROTO_PUP as _);
+    /// `IPPROTO_UDP`
+    pub const UDP: Self = Self(c::IPPROTO_UDP as _);
+    /// `IPPROTO_IDP`
+    #[cfg(not(target_os = "illumos"))]
+    pub const IDP: Self = Self(c::IPPROTO_IDP as _);
+    /// `IPPROTO_TP`
+    #[cfg(not(any(windows, target_os = "illumos")))]
+    pub const TP: Self = Self(c::IPPROTO_TP as _);
+    /// `IPPROTO_DCCP`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "openbsd",
+    )))]
+    pub const DCCP: Self = Self(c::IPPROTO_DCCP as _);
+    /// `IPPROTO_IPV6`
+    pub const IPV6: Self = Self(c::IPPROTO_IPV6 as _);
+    /// `IPPROTO_RSVP`
+    #[cfg(not(any(windows, target_os = "illumos")))]
+    pub const RSVP: Self = Self(c::IPPROTO_RSVP as _);
+    /// `IPPROTO_GRE`
+    #[cfg(not(any(windows, target_os = "illumos")))]
+    pub const GRE: Self = Self(c::IPPROTO_GRE as _);
+    /// `IPPROTO_ESP`
+    #[cfg(not(target_os = "illumos"))]
+    pub const ESP: Self = Self(c::IPPROTO_ESP as _);
+    /// `IPPROTO_AH`
+    #[cfg(not(target_os = "illumos"))]
+    pub const AH: Self = Self(c::IPPROTO_AH as _);
+    /// `IPPROTO_MTP`
+    #[cfg(not(any(
+        windows,
+        target_os = "illumos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const MTP: Self = Self(c::IPPROTO_MTP as _);
+    /// `IPPROTO_BEETPH`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const BEETPH: Self = Self(c::IPPROTO_BEETPH as _);
+    /// `IPPROTO_ENCAP`
+    #[cfg(not(any(windows, target_os = "illumos")))]
+    pub const ENCAP: Self = Self(c::IPPROTO_ENCAP as _);
+    /// `IPPROTO_PIM`
+    #[cfg(not(target_os = "illumos"))]
+    pub const PIM: Self = Self(c::IPPROTO_PIM as _);
+    /// `IPPROTO_COMP`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const COMP: Self = Self(c::IPPROTO_COMP as _);
+    /// `IPPROTO_SCTP`
+    #[cfg(not(any(target_os = "dragonfly", target_os = "illumos", target_os = "openbsd")))]
+    pub const SCTP: Self = Self(c::IPPROTO_SCTP as _);
+    /// `IPPROTO_UDPLITE`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const UDPLITE: Self = Self(c::IPPROTO_UDPLITE as _);
+    /// `IPPROTO_MPLS`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+    )))]
+    pub const MPLS: Self = Self(c::IPPROTO_MPLS as _);
+    /// `IPPROTO_RAW`
+    pub const RAW: Self = Self(c::IPPROTO_RAW as _);
+    /// `IPPROTO_MPTCP`
+    #[cfg(not(any(
+        windows,
+        target_os = "android",
+        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",
+    )))]
+    pub const MPTCP: Self = Self(c::IPPROTO_MPTCP as _);
+    /// `IPPROTO_FRAGMENT`
+    #[cfg(not(target_os = "illumos"))]
+    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 = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const MH: Self = Self(c::IPPROTO_MH as _);
+    /// `IPPROTO_ROUTING`
+    #[cfg(not(target_os = "illumos"))]
+    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 = "ios", target_os = "macos")))]
+        const NONBLOCK = c::SOCK_NONBLOCK;
+
+        /// `SOCK_CLOEXEC`
+        #[cfg(not(any(windows, 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 = "ios", target_os = "macos")))]
+        const NONBLOCK = c::SOCK_NONBLOCK;
+
+        /// `SOCK_CLOEXEC`
+        #[cfg(not(any(windows, 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/src/imp/libc/net/write_sockaddr.rs b/vendor/rustix/src/imp/libc/net/write_sockaddr.rs
new file mode 100644
index 000000000..adbf7255d
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/net/write_sockaddr.rs
@@ -0,0 +1,96 @@
+//! 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 = "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())),
+        sin_zero: [0; 8_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 = "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 = "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/src/imp/libc/offset.rs b/vendor/rustix/src/imp/libc/offset.rs
new file mode 100644
index 000000000..3002e8bdd
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/offset.rs
@@ -0,0 +1,361 @@
+//! Automatically enable “large file” support features.
+
+#[cfg(not(windows))]
+use super::c;
+
+#[cfg(not(any(
+    windows,
+    target_os = "android",
+    target_os = "linux",
+    target_os = "emscripten",
+    target_os = "l4re",
+)))]
+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 = "linux",
+    target_os = "emscripten",
+    target_os = "l4re",
+))]
+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, rlimit64 as libc_rlimit,
+};
+
+#[cfg(not(any(
+    windows,
+    target_os = "android",
+    target_os = "linux",
+    target_os = "emscripten",
+    target_os = "l4re",
+    target_os = "wasi",
+)))]
+#[cfg(any(feature = "mm", feature = "time", target_arch = "x86"))] // vdso.rs uses `madvise`
+pub(super) use c::mmap as libc_mmap;
+
+#[cfg(not(any(
+    windows,
+    target_os = "android",
+    target_os = "linux",
+    target_os = "emscripten",
+    target_os = "fuchsia",
+    target_os = "l4re",
+    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(any(feature = "mm", feature = "time", target_arch = "x86"))] // vdso.rs uses `madvise`
+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",
+)))]
+pub(super) use c::openat as libc_openat;
+#[cfg(any(
+    target_os = "android",
+    target_os = "linux",
+    target_os = "emscripten",
+    target_os = "l4re",
+))]
+pub(super) use c::openat64 as libc_openat;
+
+#[cfg(target_os = "fuchsia")]
+pub(super) use c::fallocate as libc_fallocate;
+#[cfg(any(target_os = "android", target_os = "linux"))]
+pub(super) use c::fallocate64 as libc_fallocate;
+#[cfg(not(any(
+    windows,
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "emscripten",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "l4re",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+pub(super) use c::posix_fadvise as libc_posix_fadvise;
+#[cfg(any(
+    target_os = "android",
+    target_os = "emscripten",
+    target_os = "linux",
+    target_os = "l4re",
+))]
+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/imp/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 = "ios",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "redox",
+)))]
+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 = "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",
+)))]
+pub(super) use c::posix_fallocate as libc_posix_fallocate;
+#[cfg(any(target_os = "l4re"))]
+pub(super) use c::posix_fallocate64 as libc_posix_fallocate;
+#[cfg(not(any(
+    windows,
+    target_os = "android",
+    target_os = "emscripten",
+    target_os = "illumos",
+    target_os = "linux",
+    target_os = "l4re",
+    target_os = "netbsd",
+    target_os = "redox",
+    target_os = "wasi",
+)))]
+pub(super) use {c::fstatfs as libc_fstatfs, c::statfs as libc_statfs};
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "linux",
+    target_os = "emscripten",
+    target_os = "l4re",
+))]
+pub(super) use {c::fstatfs64 as libc_fstatfs, c::statfs64 as libc_statfs};
diff --git a/vendor/rustix/src/imp/libc/param/auxv.rs b/vendor/rustix/src/imp/libc/param/auxv.rs
new file mode 100644
index 000000000..584329da9
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/param/auxv.rs
@@ -0,0 +1,66 @@
+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!("")
+    }
+}
+
+/// Initialize process-wide state.
+#[cfg(any(
+    target_vendor = "mustang",
+    not(any(target_env = "gnu", target_env = "musl")),
+))]
+#[inline]
+#[doc(hidden)]
+pub(crate) unsafe fn init(_envp: *mut *mut u8) {
+    // Nothing to do. This is the libc backend, and libc does the
+    // initialization for us.
+}
diff --git a/vendor/rustix/src/imp/libc/param/mod.rs b/vendor/rustix/src/imp/libc/param/mod.rs
new file mode 100644
index 000000000..2cb2fe78a
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/param/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod auxv;
diff --git a/vendor/rustix/src/imp/libc/process/cpu_set.rs b/vendor/rustix/src/imp/libc/process/cpu_set.rs
new file mode 100644
index 000000000..14ad8d208
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/process/cpu_set.rs
@@ -0,0 +1,49 @@
+#![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/src/imp/libc/process/mod.rs b/vendor/rustix/src/imp/libc/process/mod.rs
new file mode 100644
index 000000000..8675c1af9
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/process/mod.rs
@@ -0,0 +1,12 @@
+#[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/src/imp/libc/process/syscalls.rs b/vendor/rustix/src/imp/libc/process/syscalls.rs
new file mode 100644
index 000000000..9874f617f
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/process/syscalls.rs
@@ -0,0 +1,419 @@
+//! libc syscalls supporting `rustix::process`.
+
+use super::super::c;
+#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))]
+use super::super::conv::borrowed_fd;
+use super::super::conv::{c_str, ret, ret_c_int, ret_discarded_char_ptr};
+#[cfg(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(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(),
+        ))
+        .map(|()| 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)) }
+}
diff --git a/vendor/rustix/src/imp/libc/process/types.rs b/vendor/rustix/src/imp/libc/process/types.rs
new file mode 100644
index 000000000..60d629d81
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/process/types.rs
@@ -0,0 +1,361 @@
+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`
+    Core = c::RLIMIT_CORE as c::c_int,
+    /// `RLIMIT_RSS`
+    #[cfg(not(any(target_os = "illumos", target_os = "ios", target_os = "macos")))]
+    Rss = c::RLIMIT_RSS as c::c_int,
+    /// `RLIMIT_NPROC`
+    #[cfg(not(target_os = "illumos"))]
+    Nproc = c::RLIMIT_NPROC as c::c_int,
+    /// `RLIMIT_NOFILE`
+    Nofile = c::RLIMIT_NOFILE as c::c_int,
+    /// `RLIMIT_MEMLOCK`
+    #[cfg(not(target_os = "illumos"))]
+    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 = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    Locks = c::RLIMIT_LOCKS as c::c_int,
+    /// `RLIMIT_SIGPENDING`
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    Sigpending = c::RLIMIT_SIGPENDING as c::c_int,
+    /// `RLIMIT_MSGQUEUE`
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    Msgqueue = c::RLIMIT_MSGQUEUE as c::c_int,
+    /// `RLIMIT_NICE`
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    Nice = c::RLIMIT_NICE as c::c_int,
+    /// `RLIMIT_RTPRIO`
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    Rtprio = c::RLIMIT_RTPRIO as c::c_int,
+    /// `RLIMIT_RTTIME`
+    #[cfg(not(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "emscripten",
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    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 = "freebsd",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        all(
+            any(target_os = "android", target_os = "linux"),
+            any(target_arch = "mips", target_arch = "mips64"),
+        )
+    )))]
+    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")]
+    Io = c::SIGIO,
+    /// `SIGPWR`
+    #[cfg(not(any(
+        target_os = "freebsd",
+        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 = "freebsd",
+                target_os = "illumos",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                all(
+                    any(target_os = "android", target_os = "linux"),
+                    any(target_arch = "mips", target_arch = "mips64"),
+                )
+            )))]
+            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),
+            c::SIGIO => Some(Self::Io),
+            #[cfg(not(any(
+                target_os = "freebsd",
+                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(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 = "dragonfly",
+    target_os = "fuchsia",
+    target_os = "linux",
+))]
+pub(crate) const CPU_SETSIZE: usize = c::CPU_SETSIZE as usize;
diff --git a/vendor/rustix/src/imp/libc/process/wait.rs b/vendor/rustix/src/imp/libc/process/wait.rs
new file mode 100644
index 000000000..6de79955d
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/process/wait.rs
@@ -0,0 +1,6 @@
+use super::super::c;
+
+pub(crate) use c::{
+    WCONTINUED, WEXITSTATUS, WIFCONTINUED, WIFEXITED, WIFSIGNALED, WIFSTOPPED, WNOHANG, WSTOPSIG,
+    WTERMSIG, WUNTRACED,
+};
diff --git a/vendor/rustix/src/imp/libc/rand/mod.rs b/vendor/rustix/src/imp/libc/rand/mod.rs
new file mode 100644
index 000000000..1e0181a99
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/rand/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/imp/libc/rand/syscalls.rs b/vendor/rustix/src/imp/libc/rand/syscalls.rs
new file mode 100644
index 000000000..1c4286235
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/rand/syscalls.rs
@@ -0,0 +1,16 @@
+//! 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/src/imp/libc/rand/types.rs b/vendor/rustix/src/imp/libc/rand/types.rs
new file mode 100644
index 000000000..2ba3f1119
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/rand/types.rs
@@ -0,0 +1,19 @@
+#[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/src/imp/libc/termios/mod.rs b/vendor/rustix/src/imp/libc/termios/mod.rs
new file mode 100644
index 000000000..1e0181a99
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/termios/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/imp/libc/termios/syscalls.rs b/vendor/rustix/src/imp/libc/termios/syscalls.rs
new file mode 100644
index 000000000..91b01b4a1
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/termios/syscalls.rs
@@ -0,0 +1,159 @@
+//! libc syscalls supporting `rustix::termios`.
+//!
+//! # Safety
+//!
+//! See the `rustix::imp::syscalls` module documentation for details.
+
+#![allow(unsafe_code)]
+
+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;
+use crate::io;
+use crate::process::{Pid, RawNonZeroPid};
+use crate::termios::{Action, OptionalActions, QueueSelector, Speed, Termios, Winsize};
+use core::mem::MaybeUninit;
+use libc_errno::errno;
+
+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())).map(|()| result.assume_init())
+    }
+}
+
+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)))
+    }
+}
+
+pub(crate) fn tcsetpgrp(fd: BorrowedFd<'_>, pid: Pid) -> io::Result<()> {
+    unsafe { ret(c::tcsetpgrp(borrowed_fd(fd), pid.as_raw_nonzero().get())) }
+}
+
+pub(crate) fn tcsetattr(
+    fd: BorrowedFd,
+    optional_actions: OptionalActions,
+    termios: &Termios,
+) -> io::Result<()> {
+    unsafe {
+        ret(c::tcsetattr(
+            borrowed_fd(fd),
+            optional_actions as _,
+            termios,
+        ))
+    }
+}
+
+pub(crate) fn tcsendbreak(fd: BorrowedFd) -> io::Result<()> {
+    unsafe { ret(c::tcsendbreak(borrowed_fd(fd), 0)) }
+}
+
+pub(crate) fn tcdrain(fd: BorrowedFd) -> io::Result<()> {
+    unsafe { ret(c::tcdrain(borrowed_fd(fd))) }
+}
+
+pub(crate) fn tcflush(fd: BorrowedFd, queue_selector: QueueSelector) -> io::Result<()> {
+    unsafe { ret(c::tcflush(borrowed_fd(fd), queue_selector as _)) }
+}
+
+pub(crate) fn tcflow(fd: BorrowedFd, action: Action) -> io::Result<()> {
+    unsafe { ret(c::tcflow(borrowed_fd(fd), action as _)) }
+}
+
+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)))
+    }
+}
+
+pub(crate) fn tcsetwinsize(fd: BorrowedFd, winsize: Winsize) -> io::Result<()> {
+    unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCSWINSZ, &winsize)) }
+}
+
+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())
+    }
+}
+
+#[inline]
+#[must_use]
+pub(crate) fn cfgetospeed(termios: &Termios) -> Speed {
+    unsafe { c::cfgetospeed(termios) }
+}
+
+#[inline]
+#[must_use]
+pub(crate) fn cfgetispeed(termios: &Termios) -> Speed {
+    unsafe { c::cfgetispeed(termios) }
+}
+
+#[inline]
+pub(crate) fn cfmakeraw(termios: &mut Termios) {
+    unsafe { c::cfmakeraw(termios) }
+}
+
+#[inline]
+pub(crate) fn cfsetospeed(termios: &mut Termios, speed: Speed) -> io::Result<()> {
+    unsafe { ret(c::cfsetospeed(termios, speed)) }
+}
+
+#[inline]
+pub(crate) fn cfsetispeed(termios: &mut Termios, speed: Speed) -> io::Result<()> {
+    unsafe { ret(c::cfsetispeed(termios, speed)) }
+}
+
+#[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 {
+    let res = unsafe { c::isatty(borrowed_fd(fd)) };
+    if res == 0 {
+        match errno().0 {
+            #[cfg(not(any(target_os = "android", target_os = "linux")))]
+            c::ENOTTY => false,
+
+            // Old Linux versions reportedly return `EINVAL`.
+            // <https://man7.org/linux/man-pages/man3/isatty.3.html#ERRORS>
+            #[cfg(any(target_os = "android", target_os = "linux"))]
+            c::ENOTTY | c::EINVAL => false,
+
+            // Darwin mysteriously returns `EOPNOTSUPP` sometimes.
+            #[cfg(any(target_os = "ios", target_os = "macos"))]
+            c::EOPNOTSUPP => false,
+
+            err => panic!("unexpected error from isatty: {:?}", err),
+        }
+    } else {
+        true
+    }
+}
+
+#[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/src/imp/libc/termios/types.rs b/vendor/rustix/src/imp/libc/termios/types.rs
new file mode 100644
index 000000000..7e6728755
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/termios/types.rs
@@ -0,0 +1,951 @@
+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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const VSWTC: usize = c::VSWTC as usize;
+
+/// `VSTART`
+pub const VSTART: usize = c::VSTART as usize;
+
+/// `VSTOP`
+pub const VSTOP: usize = c::VSTOP as usize;
+
+/// `VSUSP`
+pub const VSUSP: usize = c::VSUSP as usize;
+
+/// `VEOL`
+pub const VEOL: usize = c::VEOL as usize;
+
+/// `VREPRINT`
+pub const VREPRINT: usize = c::VREPRINT as usize;
+
+/// `VDISCARD`
+pub const VDISCARD: usize = c::VDISCARD as usize;
+
+/// `VWERASE`
+pub const VWERASE: usize = c::VWERASE as usize;
+
+/// `VLNEXT`
+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 = "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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+pub const CR3: c::c_uint = c::CR3;
+
+/// `TABDLY`
+#[cfg(not(any(
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "illumos",
+    target_os = "redox",
+)))]
+pub const TABDLY: c::c_uint = c::TABDLY;
+
+/// `TAB0`
+#[cfg(not(any(
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+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",
+)))]
+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",
+)))]
+pub const TAB2: c::c_uint = c::TAB2;
+
+/// `TAB3`
+#[cfg(not(any(
+    target_env = "musl",
+    target_os = "emscripten",
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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",
+)))]
+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 = "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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const B500000: Speed = c::B500000;
+
+/// `B576000`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const B576000: Speed = c::B576000;
+
+/// `B921600`
+#[cfg(not(any(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 = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const B1000000: Speed = c::B1000000;
+
+/// `B1152000`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const B1152000: Speed = c::B1152000;
+
+/// `B1500000`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const B1500000: Speed = c::B1500000;
+
+/// `B2000000`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const B2000000: Speed = c::B2000000;
+
+/// `B2500000`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const B2500000: Speed = c::B2500000;
+
+/// `B3000000`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const B3000000: Speed = c::B3000000;
+
+/// `B3500000`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+pub const B3500000: Speed = c::B3500000;
+
+/// `B4000000`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+)))]
+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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "redox",
+)))]
+pub const EXTA: c::c_uint = c::EXTA;
+
+/// `EXTB`
+#[cfg(not(any(
+    target_os = "emscripten",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "redox",
+)))]
+pub const EXTB: c::c_uint = c::EXTB;
+
+/// `CBAUD`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+pub const CBAUDEX: c::c_uint = c::CBAUDEX;
+
+/// `CIBAUD`
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "emscripten",
+    target_os = "freebsd",
+    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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+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 = "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 = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+)))]
+pub const XTABS: c::c_uint = c::XTABS;
diff --git a/vendor/rustix/src/imp/libc/thread/mod.rs b/vendor/rustix/src/imp/libc/thread/mod.rs
new file mode 100644
index 000000000..40e0d1135
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/thread/mod.rs
@@ -0,0 +1,2 @@
+#[cfg(not(windows))]
+pub(crate) mod syscalls;
diff --git a/vendor/rustix/src/imp/libc/thread/syscalls.rs b/vendor/rustix/src/imp/libc/thread/syscalls.rs
new file mode 100644
index 000000000..c885372dc
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/thread/syscalls.rs
@@ -0,0 +1,282 @@
+//! libc syscalls supporting `rustix::thread`.
+
+use super::super::c;
+use super::super::conv::ret;
+use super::super::time::types::LibcTimespec;
+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 = "freebsd",
+    target_os = "emscripten",
+    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 = "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 = "freebsd", // FreeBSD 12 has clock_nanosleep, but libc targets FreeBSD 11.
+    target_os = "emscripten",
+    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))
+    }
+}
diff --git a/vendor/rustix/src/imp/libc/time/mod.rs b/vendor/rustix/src/imp/libc/time/mod.rs
new file mode 100644
index 000000000..bff7fd564
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/time/mod.rs
@@ -0,0 +1,3 @@
+#[cfg(not(windows))]
+pub(crate) mod syscalls;
+pub(crate) mod types;
diff --git a/vendor/rustix/src/imp/libc/time/syscalls.rs b/vendor/rustix/src/imp/libc/time/syscalls.rs
new file mode 100644
index 000000000..2bbaf8ff1
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/time/syscalls.rs
@@ -0,0 +1,414 @@
+//! 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,
+    crate::io::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(),
+            ))
+            .map(|()| 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(),
+        ))
+        .map(|()| 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()))
+                .map(|()| 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())).map(|()| 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/src/imp/libc/time/types.rs b/vendor/rustix/src/imp/libc/time/types.rs
new file mode 100644
index 000000000..4aa2b22e5
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/time/types.rs
@@ -0,0 +1,362 @@
+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",
+    )))]
+    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",
+    )))]
+    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/src/imp/libc/weak.rs b/vendor/rustix/src/imp/libc/weak.rs
new file mode 100644
index 000000000..893403b1c
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/weak.rs
@@ -0,0 +1,226 @@
+// 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::imp::weak::Weak<unsafe extern fn($($t),*) -> $ret> =
+            $crate::imp::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/src/imp/libc/winsock_c.rs b/vendor/rustix/src/imp/libc/winsock_c.rs
new file mode 100644
index 000000000..1fbce416f
--- /dev/null
+++ b/vendor/rustix/src/imp/libc/winsock_c.rs
@@ -0,0 +1,82 @@
+//! 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, 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, *,
+};