Vendor dependencies for 0.3.0 release

vendor/nix/test/sys/mod.rs

@@ -0,0 +1,98 @@
+mod test_signal;
+
+// NOTE: DragonFly lacks a kernel-level implementation of Posix AIO as of
+// this writing. There is an user-level implementation, but whether aio
+// works or not heavily depends on which pthread implementation is chosen
+// by the user at link time. For this reason we do not want to run aio test
+// cases on DragonFly.
+#[cfg(any(
+    target_os = "freebsd",
+    apple_targets,
+    all(
+        target_os = "linux",
+        not(any(target_env = "uclibc", target_env = "ohos"))
+    ),
+    target_os = "netbsd"
+))]
+mod test_aio;
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku",
+    target_os = "hurd",
+    target_os = "cygwin"
+)))]
+mod test_ioctl;
+#[cfg(not(target_os = "redox"))]
+mod test_mman;
+#[cfg(not(target_os = "redox"))]
+mod test_select;
+#[cfg(target_os = "linux")]
+mod test_signalfd;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+mod test_socket;
+#[cfg(not(any(target_os = "redox")))]
+mod test_sockopt;
+mod test_stat;
+#[cfg(linux_android)]
+mod test_sysinfo;
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
+mod test_termios;
+mod test_uio;
+mod test_wait;
+
+#[cfg(linux_android)]
+mod test_epoll;
+#[cfg(target_os = "linux")]
+mod test_fanotify;
+#[cfg(target_os = "linux")]
+mod test_inotify;
+mod test_pthread;
+
+#[cfg(any(linux_android, freebsdlike, netbsdlike, apple_targets))]
+mod test_ptrace;
+#[cfg(linux_android)]
+mod test_timerfd;
+
+#[cfg(all(
+    any(
+        target_os = "freebsd",
+        solarish,
+        target_os = "linux",
+        target_os = "netbsd"
+    ),
+    feature = "time",
+    feature = "signal"
+))]
+mod test_timer;
+
+#[cfg(bsd)]
+mod test_event;
+mod test_statvfs;
+mod test_time;
+mod test_utsname;
+
+#[cfg(any(linux_android, freebsdlike, apple_targets, target_os = "openbsd"))]
+mod test_statfs;
+
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    solarish,
+    target_os = "haiku"
+)))]
+mod test_resource;
+
+// This test module should be enabled for both linux_android and freebsd, but
+// the `memfd_create(2)` symbol is not available under Linux QEMU,
+//
+// https://github.com/nix-rust/nix/actions/runs/9427112650/job/25970870477
+//
+// and I haven't found a way to stop the linker from linking that symbol, so
+// only enable this for FreeBSD for now.
+#[cfg(target_os = "freebsd")]
+mod test_memfd;

vendor/nix/test/sys/test_aio.rs

@@ -0,0 +1,685 @@
+use std::{
+    io::{Read, Seek, Write},
+    ops::Deref,
+    os::unix::io::{AsFd, AsRawFd, BorrowedFd},
+    pin::Pin,
+    sync::atomic::{AtomicBool, Ordering},
+    thread, time,
+};
+
+use libc::c_int;
+use nix::{
+    errno::*,
+    sys::{
+        aio::*,
+        signal::{
+            sigaction, SaFlags, SigAction, SigHandler, SigSet, SigevNotify,
+            Signal,
+        },
+        time::{TimeSpec, TimeValLike},
+    },
+};
+use tempfile::tempfile;
+
+pub static SIGNALED: AtomicBool = AtomicBool::new(false);
+
+extern "C" fn sigfunc(_: c_int) {
+    SIGNALED.store(true, Ordering::Relaxed);
+}
+
+// Helper that polls an AioCb for completion or error
+macro_rules! poll_aio {
+    ($aiocb: expr) => {
+        loop {
+            let err = $aiocb.as_mut().error();
+            if err != Err(Errno::EINPROGRESS) {
+                break err;
+            };
+            thread::sleep(time::Duration::from_millis(10));
+        }
+    };
+}
+
+mod aio_fsync {
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let aiocb = AioFsync::new(
+            f.as_fd(),
+            AioFsyncMode::O_SYNC,
+            42,
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(AioFsyncMode::O_SYNC, aiocb.mode());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    /// `AioFsync::submit` should not modify the `AioCb` object if
+    /// `libc::aio_fsync` returns an error
+    // Skip on Linux, because Linux's AIO implementation can't detect errors
+    // synchronously
+    #[test]
+    #[cfg_attr(any(target_os = "android", target_os = "linux"), ignore)]
+    fn error() {
+        use std::mem;
+
+        const INITIAL: &[u8] = b"abcdef123456";
+        // Create an invalid AioFsyncMode
+        let mode = unsafe { mem::transmute::<i32, AioFsyncMode>(666) };
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aiof =
+            Box::pin(AioFsync::new(f.as_fd(), mode, 0, SigevNotify::SigevNone));
+        let err = aiof.as_mut().submit();
+        err.expect_err("assertion failed");
+    }
+
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aiof = Box::pin(AioFsync::new(
+            f.as_fd(),
+            AioFsyncMode::O_SYNC,
+            0,
+            SigevNotify::SigevNone,
+        ));
+        aiof.as_mut().submit().unwrap();
+        poll_aio!(&mut aiof).unwrap();
+        aiof.as_mut().aio_return().unwrap();
+    }
+}
+
+mod aio_read {
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let mut rbuf = vec![0; 4];
+        let aiocb = AioRead::new(
+            f.as_fd(),
+            2, //offset
+            &mut rbuf,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(4, aiocb.nbytes());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    // Tests AioWrite.cancel.  We aren't trying to test the OS's implementation,
+    // only our bindings.  So it's sufficient to check that cancel
+    // returned any AioCancelStat value.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn cancel() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let fd = f.as_fd();
+        let mut aior =
+            Box::pin(AioRead::new(fd, 2, &mut rbuf, 0, SigevNotify::SigevNone));
+        aior.as_mut().submit().unwrap();
+
+        aior.as_mut().cancel().unwrap();
+
+        // Wait for aiow to complete, but don't care whether it succeeded
+        let _ = poll_aio!(&mut aior);
+        let _ = aior.as_mut().aio_return();
+    }
+
+    /// `AioRead::submit` should not modify the `AioCb` object if
+    /// `libc::aio_read` returns an error
+    // Skip on Linux, because Linux's AIO implementation can't detect errors
+    // synchronously
+    #[test]
+    #[cfg(any(target_os = "freebsd", apple_targets))]
+    fn error() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aior = Box::pin(AioRead::new(
+            f.as_fd(),
+            -1, //an invalid offset
+            &mut rbuf,
+            0, //priority
+            SigevNotify::SigevNone,
+        ));
+        aior.as_mut().submit().expect_err("assertion failed");
+    }
+
+    // Test a simple aio operation with no completion notification.  We must
+    // poll for completion
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        const EXPECT: &[u8] = b"cdef";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let fd = f.as_fd();
+            let mut aior = Box::pin(AioRead::new(
+                fd,
+                2,
+                &mut rbuf,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aior.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aior);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aior.as_mut().aio_return().unwrap(), EXPECT.len());
+        }
+        assert_eq!(EXPECT, rbuf.deref());
+    }
+
+    // Like ok, but allocates the structure on the stack.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn on_stack() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        const EXPECT: &[u8] = b"cdef";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let fd = f.as_fd();
+            let mut aior =
+                AioRead::new(fd, 2, &mut rbuf, 0, SigevNotify::SigevNone);
+            let mut aior = unsafe { Pin::new_unchecked(&mut aior) };
+            aior.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aior);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aior.as_mut().aio_return().unwrap(), EXPECT.len());
+        }
+        assert_eq!(EXPECT, rbuf.deref());
+    }
+}
+
+#[cfg(target_os = "freebsd")]
+#[cfg(fbsd14)]
+mod aio_readv {
+    use std::io::IoSliceMut;
+
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let mut rbuf0 = vec![0; 4];
+        let mut rbuf1 = vec![0; 8];
+        let mut rbufs =
+            [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];
+        let aiocb = AioReadv::new(
+            f.as_fd(),
+            2, //offset
+            &mut rbufs,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(2, aiocb.iovlen());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf0 = vec![0; 4];
+        let mut rbuf1 = vec![0; 2];
+        let mut rbufs =
+            [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];
+        const EXPECT0: &[u8] = b"cdef";
+        const EXPECT1: &[u8] = b"12";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let fd = f.as_fd();
+            let mut aior = Box::pin(AioReadv::new(
+                fd,
+                2,
+                &mut rbufs,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aior.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aior);
+            assert_eq!(err, Ok(()));
+            assert_eq!(
+                aior.as_mut().aio_return().unwrap(),
+                EXPECT0.len() + EXPECT1.len()
+            );
+        }
+        assert_eq!(&EXPECT0, &rbuf0);
+        assert_eq!(&EXPECT1, &rbuf1);
+    }
+}
+
+mod aio_write {
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let wbuf = vec![0; 4];
+        let aiocb = AioWrite::new(
+            f.as_fd(),
+            2, //offset
+            &wbuf,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(4, aiocb.nbytes());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    // Tests AioWrite.cancel.  We aren't trying to test the OS's implementation,
+    // only our bindings.  So it's sufficient to check that cancel
+    // returned any AioCancelStat value.
+    #[test]
+    #[cfg_attr(target_env = "musl", ignore)]
+    fn cancel() {
+        let wbuf: &[u8] = b"CDEF";
+
+        let f = tempfile().unwrap();
+        let mut aiow = Box::pin(AioWrite::new(
+            f.as_fd(),
+            0,
+            wbuf,
+            0,
+            SigevNotify::SigevNone,
+        ));
+        aiow.as_mut().submit().unwrap();
+        let err = aiow.as_mut().error();
+        assert!(err == Ok(()) || err == Err(Errno::EINPROGRESS));
+
+        aiow.as_mut().cancel().unwrap();
+
+        // Wait for aiow to complete, but don't care whether it succeeded
+        let _ = poll_aio!(&mut aiow);
+        let _ = aiow.as_mut().aio_return();
+    }
+
+    // Test a simple aio operation with no completion notification.  We must
+    // poll for completion.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let wbuf = "CDEF".to_string().into_bytes();
+        let mut rbuf = Vec::new();
+        const EXPECT: &[u8] = b"abCDEF123456";
+
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let mut aiow = Box::pin(AioWrite::new(
+                f.as_fd(),
+                2,
+                &wbuf,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aiow.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aiow);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aiow.as_mut().aio_return().unwrap(), wbuf.len());
+        }
+
+        f.rewind().unwrap();
+        let len = f.read_to_end(&mut rbuf).unwrap();
+        assert_eq!(len, EXPECT.len());
+        assert_eq!(rbuf, EXPECT);
+    }
+
+    // Like ok, but allocates the structure on the stack.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn on_stack() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let wbuf = "CDEF".to_string().into_bytes();
+        let mut rbuf = Vec::new();
+        const EXPECT: &[u8] = b"abCDEF123456";
+
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let mut aiow = AioWrite::new(
+                f.as_fd(),
+                2, //offset
+                &wbuf,
+                0, //priority
+                SigevNotify::SigevNone,
+            );
+            let mut aiow = unsafe { Pin::new_unchecked(&mut aiow) };
+            aiow.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aiow);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aiow.as_mut().aio_return().unwrap(), wbuf.len());
+        }
+
+        f.rewind().unwrap();
+        let len = f.read_to_end(&mut rbuf).unwrap();
+        assert_eq!(len, EXPECT.len());
+        assert_eq!(rbuf, EXPECT);
+    }
+
+    /// `AioWrite::write` should not modify the `AioCb` object if
+    /// `libc::aio_write` returns an error.
+    // Skip on Linux, because Linux's AIO implementation can't detect errors
+    // synchronously
+    #[test]
+    #[cfg_attr(any(target_os = "android", target_os = "linux"), ignore)]
+    fn error() {
+        // Not I/O safe!  Deliberately create an invalid fd.
+        let fd = unsafe { BorrowedFd::borrow_raw(666) };
+        let wbuf = "CDEF".to_string().into_bytes();
+        let mut aiow = Box::pin(AioWrite::new(
+            fd,
+            0, //offset
+            &wbuf,
+            0, //priority
+            SigevNotify::SigevNone,
+        ));
+        aiow.as_mut().submit().expect_err("assertion failed");
+        // Dropping the AioWrite at this point should not panic
+    }
+}
+
+#[cfg(target_os = "freebsd")]
+#[cfg(fbsd14)]
+mod aio_writev {
+    use std::io::IoSlice;
+
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let f = tempfile().unwrap();
+        let wbuf0 = vec![0; 4];
+        let wbuf1 = vec![0; 8];
+        let wbufs = [IoSlice::new(&wbuf0), IoSlice::new(&wbuf1)];
+        let aiocb = AioWritev::new(
+            f.as_fd(),
+            2, //offset
+            &wbufs,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(f.as_raw_fd(), aiocb.fd().as_raw_fd());
+        assert_eq!(2, aiocb.iovlen());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
+
+    // Test a simple aio operation with no completion notification.  We must
+    // poll for completion.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let wbuf0 = b"BC";
+        let wbuf1 = b"DEF";
+        let wbufs = [IoSlice::new(wbuf0), IoSlice::new(wbuf1)];
+        let wlen = wbuf0.len() + wbuf1.len();
+        let mut rbuf = Vec::new();
+        const EXPECT: &[u8] = b"aBCDEF123456";
+
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let mut aiow = Box::pin(AioWritev::new(
+                f.as_fd(),
+                1,
+                &wbufs,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aiow.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aiow);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aiow.as_mut().aio_return().unwrap(), wlen);
+        }
+
+        f.rewind().unwrap();
+        let len = f.read_to_end(&mut rbuf).unwrap();
+        assert_eq!(len, EXPECT.len());
+        assert_eq!(rbuf, EXPECT);
+    }
+}
+
+// Test an aio operation with completion delivered by a signal
+#[test]
+#[cfg_attr(
+    any(
+        all(target_env = "musl", target_arch = "x86_64"),
+        target_arch = "mips",
+        target_arch = "mips32r6",
+        target_arch = "mips64",
+        target_arch = "mips64r6"
+    ),
+    ignore
+)]
+fn sigev_signal() {
+    let _m = crate::SIGNAL_MTX.lock();
+    let sa = SigAction::new(
+        SigHandler::Handler(sigfunc),
+        SaFlags::SA_RESETHAND,
+        SigSet::empty(),
+    );
+    SIGNALED.store(false, Ordering::Relaxed);
+    unsafe { sigaction(Signal::SIGUSR2, &sa) }.unwrap();
+
+    const INITIAL: &[u8] = b"abcdef123456";
+    const WBUF: &[u8] = b"CDEF";
+    let mut rbuf = Vec::new();
+    const EXPECT: &[u8] = b"abCDEF123456";
+
+    let mut f = tempfile().unwrap();
+    f.write_all(INITIAL).unwrap();
+    {
+        let mut aiow = Box::pin(AioWrite::new(
+            f.as_fd(),
+            2, //offset
+            WBUF,
+            0, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 0, //TODO: validate in sigfunc
+            },
+        ));
+        aiow.as_mut().submit().unwrap();
+        while !SIGNALED.load(Ordering::Relaxed) {
+            thread::sleep(time::Duration::from_millis(10));
+        }
+
+        assert_eq!(aiow.as_mut().aio_return().unwrap(), WBUF.len());
+    }
+
+    f.rewind().unwrap();
+    let len = f.read_to_end(&mut rbuf).unwrap();
+    assert_eq!(len, EXPECT.len());
+    assert_eq!(rbuf, EXPECT);
+}
+
+// Tests using aio_cancel_all for all outstanding IOs.
+#[test]
+#[cfg_attr(target_env = "musl", ignore)]
+fn test_aio_cancel_all() {
+    let wbuf: &[u8] = b"CDEF";
+
+    let f = tempfile().unwrap();
+    let mut aiocb = Box::pin(AioWrite::new(
+        f.as_fd(),
+        0, //offset
+        wbuf,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+    aiocb.as_mut().submit().unwrap();
+    let err = aiocb.as_mut().error();
+    assert!(err == Ok(()) || err == Err(Errno::EINPROGRESS));
+
+    aio_cancel_all(f.as_fd()).unwrap();
+
+    // Wait for aiocb to complete, but don't care whether it succeeded
+    let _ = poll_aio!(&mut aiocb);
+    let _ = aiocb.as_mut().aio_return();
+}
+
+#[test]
+fn test_aio_suspend() {
+    const INITIAL: &[u8] = b"abcdef123456";
+    const WBUF: &[u8] = b"CDEFG";
+    let timeout = TimeSpec::seconds(10);
+    let mut rbuf = vec![0; 4];
+    let rlen = rbuf.len();
+    let mut f = tempfile().unwrap();
+    f.write_all(INITIAL).unwrap();
+
+    let mut wcb = Box::pin(AioWrite::new(
+        f.as_fd(),
+        2, //offset
+        WBUF,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+
+    let mut rcb = Box::pin(AioRead::new(
+        f.as_fd(),
+        8, //offset
+        &mut rbuf,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+    wcb.as_mut().submit().unwrap();
+    rcb.as_mut().submit().unwrap();
+    loop {
+        {
+            let cbbuf = [
+                &*wcb as &dyn AsRef<libc::aiocb>,
+                &*rcb as &dyn AsRef<libc::aiocb>,
+            ];
+            let r = aio_suspend(&cbbuf[..], Some(timeout));
+            match r {
+                Err(Errno::EINTR) => continue,
+                Err(e) => panic!("aio_suspend returned {e:?}"),
+                Ok(_) => (),
+            };
+        }
+        if rcb.as_mut().error() != Err(Errno::EINPROGRESS)
+            && wcb.as_mut().error() != Err(Errno::EINPROGRESS)
+        {
+            break;
+        }
+    }
+
+    assert_eq!(wcb.as_mut().aio_return().unwrap(), WBUF.len());
+    assert_eq!(rcb.as_mut().aio_return().unwrap(), rlen);
+}
+
+/// aio_suspend relies on casting Rust Aio* struct pointers to libc::aiocb
+/// pointers.  This test ensures that such casts are valid.
+#[test]
+fn casting() {
+    let sev = SigevNotify::SigevNone;
+    // Only safe because we'll never await the futures
+    let fd = unsafe { BorrowedFd::borrow_raw(666) };
+    let aiof = AioFsync::new(fd, AioFsyncMode::O_SYNC, 0, sev);
+    assert_eq!(
+        aiof.as_ref() as *const libc::aiocb,
+        &aiof as *const AioFsync as *const libc::aiocb
+    );
+
+    let mut rbuf = [];
+    let aior = AioRead::new(fd, 0, &mut rbuf, 0, sev);
+    assert_eq!(
+        aior.as_ref() as *const libc::aiocb,
+        &aior as *const AioRead as *const libc::aiocb
+    );
+
+    let wbuf = [];
+    let aiow = AioWrite::new(fd, 0, &wbuf, 0, sev);
+    assert_eq!(
+        aiow.as_ref() as *const libc::aiocb,
+        &aiow as *const AioWrite as *const libc::aiocb
+    );
+}
+
+#[cfg(target_os = "freebsd")]
+#[test]
+fn casting_vectored() {
+    use std::io::{IoSlice, IoSliceMut};
+
+    let sev = SigevNotify::SigevNone;
+
+    let mut rbuf = [];
+    let mut rbufs = [IoSliceMut::new(&mut rbuf)];
+    // Only safe because we'll never await the futures
+    let fd = unsafe { BorrowedFd::borrow_raw(666) };
+    let aiorv = AioReadv::new(fd, 0, &mut rbufs[..], 0, sev);
+    assert_eq!(
+        aiorv.as_ref() as *const libc::aiocb,
+        &aiorv as *const AioReadv as *const libc::aiocb
+    );
+
+    let wbuf = [];
+    let wbufs = [IoSlice::new(&wbuf)];
+    let aiowv = AioWritev::new(fd, 0, &wbufs, 0, sev);
+    assert_eq!(
+        aiowv.as_ref() as *const libc::aiocb,
+        &aiowv as *const AioWritev as *const libc::aiocb
+    );
+}

vendor/nix/test/sys/test_aio_drop.rs

@@ -0,0 +1,35 @@
+// Test dropping an AioCb that hasn't yet finished.
+// This must happen in its own process, because on OSX this test seems to hose
+// the AIO subsystem and causes subsequent tests to fail
+#[test]
+#[should_panic(expected = "Dropped an in-progress AioCb")]
+#[cfg(all(
+    not(target_env = "musl"),
+    not(target_env = "uclibc"),
+    not(target_env = "ohos"),
+    any(
+        target_os = "linux",
+        apple_targets,
+        target_os = "freebsd",
+        target_os = "netbsd"
+    )
+))]
+fn test_drop() {
+    use nix::sys::aio::*;
+    use nix::sys::signal::*;
+    use std::os::unix::io::AsFd;
+    use tempfile::tempfile;
+
+    const WBUF: &[u8] = b"CDEF";
+
+    let f = tempfile().unwrap();
+    f.set_len(6).unwrap();
+    let mut aiocb = Box::pin(AioWrite::new(
+        f.as_fd(),
+        2, //offset
+        WBUF,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+    aiocb.as_mut().submit().unwrap();
+}

vendor/nix/test/sys/test_epoll.rs

@@ -0,0 +1,26 @@
+#![allow(deprecated)]
+
+use nix::errno::Errno;
+use nix::sys::epoll::{epoll_create1, epoll_ctl};
+use nix::sys::epoll::{EpollCreateFlags, EpollEvent, EpollFlags, EpollOp};
+
+#[test]
+pub fn test_epoll_errno() {
+    let efd = epoll_create1(EpollCreateFlags::empty()).unwrap();
+    let result = epoll_ctl(efd, EpollOp::EpollCtlDel, 1, None);
+    result.expect_err("assertion failed");
+    assert_eq!(result.unwrap_err(), Errno::ENOENT);
+
+    let result = epoll_ctl(efd, EpollOp::EpollCtlAdd, 1, None);
+    result.expect_err("assertion failed");
+    assert_eq!(result.unwrap_err(), Errno::EINVAL);
+}
+
+#[test]
+pub fn test_epoll_ctl() {
+    let efd = epoll_create1(EpollCreateFlags::empty()).unwrap();
+    let mut event =
+        EpollEvent::new(EpollFlags::EPOLLIN | EpollFlags::EPOLLERR, 1);
+    epoll_ctl(efd, EpollOp::EpollCtlAdd, 1, &mut event).unwrap();
+    epoll_ctl(efd, EpollOp::EpollCtlDel, 1, None).unwrap();
+}

vendor/nix/test/sys/test_event.rs

@@ -0,0 +1,41 @@
+use libc::intptr_t;
+use nix::sys::event::{EvFlags, EventFilter, FilterFlag, KEvent};
+
+#[test]
+fn test_struct_kevent() {
+    use std::mem;
+
+    let udata: intptr_t = 12345;
+    let data: intptr_t = 0x1337;
+
+    let actual = KEvent::new(
+        0xdead_beef,
+        EventFilter::EVFILT_READ,
+        EvFlags::EV_ONESHOT | EvFlags::EV_ADD,
+        FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
+        data,
+        udata,
+    );
+    assert_eq!(0xdead_beef, actual.ident());
+    assert_eq!(EventFilter::EVFILT_READ, actual.filter().unwrap());
+    assert_eq!(libc::EV_ONESHOT | libc::EV_ADD, actual.flags().bits());
+    assert_eq!(libc::NOTE_CHILD | libc::NOTE_EXIT, actual.fflags().bits());
+    assert_eq!(data, actual.data());
+    assert_eq!(udata, actual.udata());
+    assert_eq!(mem::size_of::<libc::kevent>(), mem::size_of::<KEvent>());
+}
+
+#[test]
+fn test_kevent_filter() {
+    let udata: intptr_t = 12345;
+
+    let actual = KEvent::new(
+        0xdead_beef,
+        EventFilter::EVFILT_READ,
+        EvFlags::EV_ONESHOT | EvFlags::EV_ADD,
+        FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
+        0x1337,
+        udata,
+    );
+    assert_eq!(EventFilter::EVFILT_READ, actual.filter().unwrap());
+}

vendor/nix/test/sys/test_fanotify.rs

@@ -0,0 +1,220 @@
+use crate::*;
+use nix::errno::Errno;
+use nix::fcntl::AT_FDCWD;
+use nix::sys::fanotify::{
+    EventFFlags, Fanotify, FanotifyResponse, InitFlags, MarkFlags, MaskFlags,
+    Response,
+};
+use std::fs::{read_link, read_to_string, File, OpenOptions};
+use std::io::ErrorKind;
+use std::io::{Read, Write};
+use std::os::fd::AsRawFd;
+use std::thread;
+
+#[test]
+/// Run fanotify tests sequentially to avoid tmp files races
+pub fn test_fanotify() {
+    require_capability!("test_fanotify", CAP_SYS_ADMIN);
+
+    test_fanotify_notifications();
+    test_fanotify_responses();
+    test_fanotify_overflow();
+}
+
+fn test_fanotify_notifications() {
+    let group =
+        Fanotify::init(InitFlags::FAN_CLASS_NOTIF, EventFFlags::O_RDONLY)
+            .unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+    let tempfile = tempdir.path().join("test");
+    OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&tempfile)
+        .unwrap();
+
+    group
+        .mark(
+            MarkFlags::FAN_MARK_ADD,
+            MaskFlags::FAN_OPEN | MaskFlags::FAN_MODIFY | MaskFlags::FAN_CLOSE,
+            AT_FDCWD,
+            Some(&tempfile),
+        )
+        .unwrap();
+
+    // modify test file
+    {
+        let mut f = OpenOptions::new().write(true).open(&tempfile).unwrap();
+        f.write_all(b"hello").unwrap();
+    }
+
+    let mut events = group.read_events().unwrap();
+    assert_eq!(events.len(), 1, "should have read exactly one event");
+    let event = events.pop().unwrap();
+    assert!(event.check_version());
+    assert_eq!(
+        event.mask(),
+        MaskFlags::FAN_OPEN
+            | MaskFlags::FAN_MODIFY
+            | MaskFlags::FAN_CLOSE_WRITE
+    );
+    let fd_opt = event.fd();
+    let fd = fd_opt.as_ref().unwrap();
+    let path = read_link(format!("/proc/self/fd/{}", fd.as_raw_fd())).unwrap();
+    assert_eq!(path, tempfile);
+
+    // read test file
+    {
+        let mut f = File::open(&tempfile).unwrap();
+        let mut s = String::new();
+        f.read_to_string(&mut s).unwrap();
+    }
+
+    let mut events = group.read_events().unwrap();
+    assert_eq!(events.len(), 1, "should have read exactly one event");
+    let event = events.pop().unwrap();
+    assert!(event.check_version());
+    assert_eq!(
+        event.mask(),
+        MaskFlags::FAN_OPEN | MaskFlags::FAN_CLOSE_NOWRITE
+    );
+    let fd_opt = event.fd();
+    let fd = fd_opt.as_ref().unwrap();
+    let path = read_link(format!("/proc/self/fd/{}", fd.as_raw_fd())).unwrap();
+    assert_eq!(path, tempfile);
+}
+
+fn test_fanotify_responses() {
+    let group =
+        Fanotify::init(InitFlags::FAN_CLASS_CONTENT, EventFFlags::O_RDONLY)
+            .unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+    let tempfile = tempdir.path().join("test");
+    OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&tempfile)
+        .unwrap();
+
+    group
+        .mark(
+            MarkFlags::FAN_MARK_ADD,
+            MaskFlags::FAN_OPEN_PERM,
+            AT_FDCWD,
+            Some(&tempfile),
+        )
+        .unwrap();
+
+    let file_thread = thread::spawn({
+        let tempfile = tempfile.clone();
+
+        move || {
+            // first open, should fail
+            let Err(e) = File::open(&tempfile) else {
+                panic!("The first open should fail");
+            };
+            assert_eq!(e.kind(), ErrorKind::PermissionDenied);
+
+            // second open, should succeed
+            File::open(&tempfile).unwrap();
+        }
+    });
+
+    // Deny the first open try
+    let mut events = group.read_events().unwrap();
+    assert_eq!(events.len(), 1, "should have read exactly one event");
+    let event = events.pop().unwrap();
+    assert!(event.check_version());
+    assert_eq!(event.mask(), MaskFlags::FAN_OPEN_PERM);
+    let fd_opt = event.fd();
+    let fd = fd_opt.as_ref().unwrap();
+    let path = read_link(format!("/proc/self/fd/{}", fd.as_raw_fd())).unwrap();
+    assert_eq!(path, tempfile);
+    group
+        .write_response(FanotifyResponse::new(*fd, Response::FAN_DENY))
+        .unwrap();
+
+    // Allow the second open try
+    let mut events = group.read_events().unwrap();
+    assert_eq!(events.len(), 1, "should have read exactly one event");
+    let event = events.pop().unwrap();
+    assert!(event.check_version());
+    assert_eq!(event.mask(), MaskFlags::FAN_OPEN_PERM);
+    let fd_opt = event.fd();
+    let fd = fd_opt.as_ref().unwrap();
+    let path = read_link(format!("/proc/self/fd/{}", fd.as_raw_fd())).unwrap();
+    assert_eq!(path, tempfile);
+    group
+        .write_response(FanotifyResponse::new(*fd, Response::FAN_ALLOW))
+        .unwrap();
+
+    file_thread.join().unwrap();
+}
+
+fn test_fanotify_overflow() {
+    let max_events: usize =
+        read_to_string("/proc/sys/fs/fanotify/max_queued_events")
+            .unwrap()
+            .trim()
+            .parse()
+            .unwrap();
+
+    // make sure the kernel is configured with the default value,
+    // just so this test doesn't run forever
+    assert_eq!(max_events, 16384);
+
+    let group = Fanotify::init(
+        InitFlags::FAN_CLASS_NOTIF
+            | InitFlags::FAN_REPORT_TID
+            | InitFlags::FAN_NONBLOCK,
+        EventFFlags::O_RDONLY,
+    )
+    .unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+    let tempfile = tempdir.path().join("test");
+
+    OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&tempfile)
+        .unwrap();
+
+    group
+        .mark(
+            MarkFlags::FAN_MARK_ADD,
+            MaskFlags::FAN_OPEN,
+            AT_FDCWD,
+            Some(&tempfile),
+        )
+        .unwrap();
+
+    thread::scope(|s| {
+        // perform 10 more events to demonstrate some will be dropped
+        for _ in 0..(max_events + 10) {
+            s.spawn(|| {
+                File::open(&tempfile).unwrap();
+            });
+        }
+    });
+
+    // flush the queue until it's empty
+    let mut n = 0;
+    let mut last_event = None;
+    loop {
+        match group.read_events() {
+            Ok(events) => {
+                n += events.len();
+                if let Some(event) = events.last() {
+                    last_event = Some(event.mask());
+                }
+            }
+            Err(e) if e == Errno::EWOULDBLOCK => break,
+            Err(e) => panic!("{e:?}"),
+        }
+    }
+
+    // make sure we read all we expected.
+    // the +1 is for the overflow event.
+    assert_eq!(n, max_events + 1);
+    assert_eq!(last_event, Some(MaskFlags::FAN_Q_OVERFLOW));
+}

vendor/nix/test/sys/test_inotify.rs

@@ -0,0 +1,65 @@
+use nix::errno::Errno;
+use nix::sys::inotify::{AddWatchFlags, InitFlags, Inotify};
+use std::ffi::OsString;
+use std::fs::{rename, File};
+
+#[test]
+pub fn test_inotify() {
+    let instance = Inotify::init(InitFlags::IN_NONBLOCK).unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+
+    instance
+        .add_watch(tempdir.path(), AddWatchFlags::IN_ALL_EVENTS)
+        .unwrap();
+
+    let events = instance.read_events();
+    assert_eq!(events.unwrap_err(), Errno::EAGAIN);
+
+    File::create(tempdir.path().join("test")).unwrap();
+
+    let events = instance.read_events().unwrap();
+    assert_eq!(events[0].name, Some(OsString::from("test")));
+}
+
+#[test]
+pub fn test_inotify_multi_events() {
+    let instance = Inotify::init(InitFlags::IN_NONBLOCK).unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+
+    instance
+        .add_watch(tempdir.path(), AddWatchFlags::IN_ALL_EVENTS)
+        .unwrap();
+
+    let events = instance.read_events();
+    assert_eq!(events.unwrap_err(), Errno::EAGAIN);
+
+    File::create(tempdir.path().join("test")).unwrap();
+    rename(tempdir.path().join("test"), tempdir.path().join("test2")).unwrap();
+
+    // Now there should be 5 events in queue:
+    //   - IN_CREATE on test
+    //   - IN_OPEN on test
+    //   - IN_CLOSE_WRITE on test
+    //   - IN_MOVED_FROM on test with a cookie
+    //   - IN_MOVED_TO on test2 with the same cookie
+
+    let events = instance.read_events().unwrap();
+    assert_eq!(events.len(), 5);
+
+    assert_eq!(events[0].mask, AddWatchFlags::IN_CREATE);
+    assert_eq!(events[0].name, Some(OsString::from("test")));
+
+    assert_eq!(events[1].mask, AddWatchFlags::IN_OPEN);
+    assert_eq!(events[1].name, Some(OsString::from("test")));
+
+    assert_eq!(events[2].mask, AddWatchFlags::IN_CLOSE_WRITE);
+    assert_eq!(events[2].name, Some(OsString::from("test")));
+
+    assert_eq!(events[3].mask, AddWatchFlags::IN_MOVED_FROM);
+    assert_eq!(events[3].name, Some(OsString::from("test")));
+
+    assert_eq!(events[4].mask, AddWatchFlags::IN_MOVED_TO);
+    assert_eq!(events[4].name, Some(OsString::from("test2")));
+
+    assert_eq!(events[3].cookie, events[4].cookie);
+}

vendor/nix/test/sys/test_ioctl.rs

@@ -0,0 +1,383 @@
+#![allow(dead_code)]
+
+// Simple tests to ensure macro generated fns compile
+ioctl_none_bad!(do_bad, 0x1234);
+ioctl_read_bad!(do_bad_read, 0x1234, u16);
+ioctl_write_int_bad!(do_bad_write_int, 0x1234);
+ioctl_write_ptr_bad!(do_bad_write_ptr, 0x1234, u8);
+ioctl_readwrite_bad!(do_bad_readwrite, 0x1234, u32);
+ioctl_none!(do_none, 0, 0);
+ioctl_read!(read_test, 0, 0, u32);
+ioctl_write_int!(write_ptr_int, 0, 0);
+ioctl_write_ptr!(write_ptr_u8, 0, 0, u8);
+ioctl_write_ptr!(write_ptr_u32, 0, 0, u32);
+ioctl_write_ptr!(write_ptr_u64, 0, 0, u64);
+ioctl_readwrite!(readwrite_test, 0, 0, u64);
+ioctl_read_buf!(readbuf_test, 0, 0, u32);
+const SPI_IOC_MAGIC: u8 = b'k';
+const SPI_IOC_MESSAGE: u8 = 0;
+ioctl_write_buf!(writebuf_test_consts, SPI_IOC_MAGIC, SPI_IOC_MESSAGE, u8);
+ioctl_write_buf!(writebuf_test_u8, 0, 0, u8);
+ioctl_write_buf!(writebuf_test_u32, 0, 0, u32);
+ioctl_write_buf!(writebuf_test_u64, 0, 0, u64);
+ioctl_readwrite_buf!(readwritebuf_test, 0, 0, u32);
+
+// See C code for source of values for op calculations (does NOT work for mips/powerpc):
+// https://gist.github.com/posborne/83ea6880770a1aef332e
+//
+// TODO:  Need a way to compute these constants at test time.  Using precomputed
+// values is fragile and needs to be maintained.
+
+#[cfg(linux_android)]
+mod linux {
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
+    #[test]
+    fn test_op_none() {
+        if cfg!(any(
+            target_arch = "mips",
+            target_arch = "mips32r6",
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(request_code_none!(b'q', 10) as u32, 0x2000_710A);
+            assert_eq!(request_code_none!(b'a', 255) as u32, 0x2000_61FF);
+        } else {
+            assert_eq!(request_code_none!(b'q', 10) as u32, 0x0000_710A);
+            assert_eq!(request_code_none!(b'a', 255) as u32, 0x0000_61FF);
+        }
+    }
+
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
+    #[test]
+    fn test_op_write() {
+        if cfg!(any(
+            target_arch = "mips",
+            target_arch = "mips32r6",
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(request_code_write!(b'z', 10, 1) as u32, 0x8001_7A0A);
+            assert_eq!(request_code_write!(b'z', 10, 512) as u32, 0x8200_7A0A);
+        } else {
+            assert_eq!(request_code_write!(b'z', 10, 1) as u32, 0x4001_7A0A);
+            assert_eq!(request_code_write!(b'z', 10, 512) as u32, 0x4200_7A0A);
+        }
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_write_64() {
+        if cfg!(any(
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(
+                request_code_write!(b'z', 10, 1u64 << 32) as u32,
+                0x8000_7A0A
+            );
+        } else {
+            assert_eq!(
+                request_code_write!(b'z', 10, 1u64 << 32) as u32,
+                0x4000_7A0A
+            );
+        }
+    }
+
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
+    #[test]
+    fn test_op_read() {
+        if cfg!(any(
+            target_arch = "mips",
+            target_arch = "mips32r6",
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(request_code_read!(b'z', 10, 1) as u32, 0x4001_7A0A);
+            assert_eq!(request_code_read!(b'z', 10, 512) as u32, 0x4200_7A0A);
+        } else {
+            assert_eq!(request_code_read!(b'z', 10, 1) as u32, 0x8001_7A0A);
+            assert_eq!(request_code_read!(b'z', 10, 512) as u32, 0x8200_7A0A);
+        }
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_read_64() {
+        if cfg!(any(
+            target_arch = "mips64",
+            target_arch = "mips64r6",
+            target_arch = "powerpc64"
+        )) {
+            assert_eq!(
+                request_code_read!(b'z', 10, 1u64 << 32) as u32,
+                0x4000_7A0A
+            );
+        } else {
+            assert_eq!(
+                request_code_read!(b'z', 10, 1u64 << 32) as u32,
+                0x8000_7A0A
+            );
+        }
+    }
+
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
+    #[test]
+    fn test_op_read_write() {
+        assert_eq!(request_code_readwrite!(b'z', 10, 1) as u32, 0xC001_7A0A);
+        assert_eq!(request_code_readwrite!(b'z', 10, 512) as u32, 0xC200_7A0A);
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_read_write_64() {
+        assert_eq!(
+            request_code_readwrite!(b'z', 10, 1u64 << 32) as u32,
+            0xC000_7A0A
+        );
+    }
+}
+
+#[cfg(bsd)]
+mod bsd {
+    #[test]
+    fn test_op_none() {
+        assert_eq!(request_code_none!(b'q', 10), 0x2000_710A);
+        assert_eq!(request_code_none!(b'a', 255), 0x2000_61FF);
+    }
+
+    #[cfg(freebsdlike)]
+    #[test]
+    fn test_op_write_int() {
+        assert_eq!(request_code_write_int!(b'v', 4), 0x2004_7604);
+        assert_eq!(request_code_write_int!(b'p', 2), 0x2004_7002);
+    }
+
+    #[test]
+    fn test_op_write() {
+        assert_eq!(request_code_write!(b'z', 10, 1), 0x8001_7A0A);
+        assert_eq!(request_code_write!(b'z', 10, 512), 0x8200_7A0A);
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_write_64() {
+        assert_eq!(request_code_write!(b'z', 10, 1u64 << 32), 0x8000_7A0A);
+    }
+
+    #[test]
+    fn test_op_read() {
+        assert_eq!(request_code_read!(b'z', 10, 1), 0x4001_7A0A);
+        assert_eq!(request_code_read!(b'z', 10, 512), 0x4200_7A0A);
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_read_64() {
+        assert_eq!(request_code_read!(b'z', 10, 1u64 << 32), 0x4000_7A0A);
+    }
+
+    #[test]
+    fn test_op_read_write() {
+        assert_eq!(request_code_readwrite!(b'z', 10, 1), 0xC001_7A0A);
+        assert_eq!(request_code_readwrite!(b'z', 10, 512), 0xC200_7A0A);
+    }
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_op_read_write_64() {
+        assert_eq!(request_code_readwrite!(b'z', 10, 1u64 << 32), 0xC000_7A0A);
+    }
+}
+
+#[cfg(linux_android)]
+mod linux_ioctls {
+    use std::mem;
+    use std::os::unix::io::AsRawFd;
+
+    use libc::{termios, TCGETS, TCSBRK, TCSETS, TIOCNXCL};
+    use tempfile::tempfile;
+
+    use nix::errno::Errno;
+
+    ioctl_none_bad!(tiocnxcl, TIOCNXCL);
+    #[test]
+    fn test_ioctl_none_bad() {
+        let file = tempfile().unwrap();
+        let res = unsafe { tiocnxcl(file.as_raw_fd()) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_read_bad!(tcgets, TCGETS, termios);
+    #[test]
+    fn test_ioctl_read_bad() {
+        let file = tempfile().unwrap();
+        let mut termios = unsafe { mem::zeroed() };
+        let res = unsafe { tcgets(file.as_raw_fd(), &mut termios) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_write_int_bad!(tcsbrk, TCSBRK);
+    #[test]
+    fn test_ioctl_write_int_bad() {
+        let file = tempfile().unwrap();
+        let res = unsafe { tcsbrk(file.as_raw_fd(), 0) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_write_ptr_bad!(tcsets, TCSETS, termios);
+    #[test]
+    fn test_ioctl_write_ptr_bad() {
+        let file = tempfile().unwrap();
+        let termios: termios = unsafe { mem::zeroed() };
+        let res = unsafe { tcsets(file.as_raw_fd(), &termios) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    // FIXME: Find a suitable example for `ioctl_readwrite_bad`
+
+    // From linux/videodev2.h
+    ioctl_none!(log_status, b'V', 70);
+    #[test]
+    fn test_ioctl_none() {
+        let file = tempfile().unwrap();
+        let res = unsafe { log_status(file.as_raw_fd()) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    #[repr(C)]
+    pub struct v4l2_audio {
+        index: u32,
+        name: [u8; 32],
+        capability: u32,
+        mode: u32,
+        reserved: [u32; 2],
+    }
+
+    // From linux/videodev2.h
+    ioctl_write_ptr!(s_audio, b'V', 34, v4l2_audio);
+    #[test]
+    fn test_ioctl_write_ptr() {
+        let file = tempfile().unwrap();
+        let data: v4l2_audio = unsafe { mem::zeroed() };
+        let res = unsafe { s_audio(file.as_raw_fd(), &data) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // From linux/net/bluetooth/hci_sock.h
+    const HCI_IOC_MAGIC: u8 = b'H';
+    const HCI_IOC_HCIDEVUP: u8 = 201;
+    ioctl_write_int!(hcidevup, HCI_IOC_MAGIC, HCI_IOC_HCIDEVUP);
+    #[test]
+    fn test_ioctl_write_int() {
+        let file = tempfile().unwrap();
+        let res = unsafe { hcidevup(file.as_raw_fd(), 0) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // From linux/videodev2.h
+    ioctl_read!(g_audio, b'V', 33, v4l2_audio);
+    #[test]
+    fn test_ioctl_read() {
+        let file = tempfile().unwrap();
+        let mut data: v4l2_audio = unsafe { mem::zeroed() };
+        let res = unsafe { g_audio(file.as_raw_fd(), &mut data) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // From linux/videodev2.h
+    ioctl_readwrite!(enum_audio, b'V', 65, v4l2_audio);
+    #[test]
+    fn test_ioctl_readwrite() {
+        let file = tempfile().unwrap();
+        let mut data: v4l2_audio = unsafe { mem::zeroed() };
+        let res = unsafe { enum_audio(file.as_raw_fd(), &mut data) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // FIXME: Find a suitable example for `ioctl_read_buf`.
+
+    #[repr(C)]
+    pub struct spi_ioc_transfer {
+        tx_buf: u64,
+        rx_buf: u64,
+        len: u32,
+        speed_hz: u32,
+        delay_usecs: u16,
+        bits_per_word: u8,
+        cs_change: u8,
+        tx_nbits: u8,
+        rx_nbits: u8,
+        pad: u16,
+    }
+
+    // From linux/spi/spidev.h
+    ioctl_write_buf!(
+        spi_ioc_message,
+        super::SPI_IOC_MAGIC,
+        super::SPI_IOC_MESSAGE,
+        spi_ioc_transfer
+    );
+    #[test]
+    fn test_ioctl_write_buf() {
+        let file = tempfile().unwrap();
+        let data: [spi_ioc_transfer; 4] = unsafe { mem::zeroed() };
+        let res = unsafe { spi_ioc_message(file.as_raw_fd(), &data[..]) };
+        assert!(res == Err(Errno::ENOTTY) || res == Err(Errno::ENOSYS));
+    }
+
+    // FIXME: Find a suitable example for `ioctl_readwrite_buf`.
+}
+
+#[cfg(target_os = "freebsd")]
+mod freebsd_ioctls {
+    use std::mem;
+    use std::os::unix::io::AsRawFd;
+
+    use libc::termios;
+    use tempfile::tempfile;
+
+    use nix::errno::Errno;
+
+    // From sys/sys/ttycom.h
+    const TTY_IOC_MAGIC: u8 = b't';
+    const TTY_IOC_TYPE_NXCL: u8 = 14;
+    const TTY_IOC_TYPE_GETA: u8 = 19;
+    const TTY_IOC_TYPE_SETA: u8 = 20;
+
+    ioctl_none!(tiocnxcl, TTY_IOC_MAGIC, TTY_IOC_TYPE_NXCL);
+    #[test]
+    fn test_ioctl_none() {
+        let file = tempfile().unwrap();
+        let res = unsafe { tiocnxcl(file.as_raw_fd()) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_read!(tiocgeta, TTY_IOC_MAGIC, TTY_IOC_TYPE_GETA, termios);
+    #[test]
+    fn test_ioctl_read() {
+        let file = tempfile().unwrap();
+        let mut termios = unsafe { mem::zeroed() };
+        let res = unsafe { tiocgeta(file.as_raw_fd(), &mut termios) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+
+    ioctl_write_ptr!(tiocseta, TTY_IOC_MAGIC, TTY_IOC_TYPE_SETA, termios);
+    #[test]
+    fn test_ioctl_write_ptr() {
+        let file = tempfile().unwrap();
+        let termios: termios = unsafe { mem::zeroed() };
+        let res = unsafe { tiocseta(file.as_raw_fd(), &termios) };
+        assert_eq!(res, Err(Errno::ENOTTY));
+    }
+}

vendor/nix/test/sys/test_memfd.rs

@@ -0,0 +1,20 @@
+#[test]
+fn test_memfd_create() {
+    use nix::sys::memfd::memfd_create;
+    use nix::sys::memfd::MFdFlags;
+    use nix::unistd::lseek;
+    use nix::unistd::read;
+    use nix::unistd::{write, Whence};
+
+    let fd =
+        memfd_create("test_memfd_create_name", MFdFlags::MFD_CLOEXEC).unwrap();
+    let contents = b"hello";
+    assert_eq!(write(&fd, contents).unwrap(), 5);
+
+    lseek(&fd, 0, Whence::SeekSet).unwrap();
+
+    let mut buf = vec![0_u8; contents.len()];
+    assert_eq!(read(&fd, &mut buf).unwrap(), 5);
+
+    assert_eq!(contents, buf.as_slice());
+}

vendor/nix/test/sys/test_mman.rs

@@ -0,0 +1,200 @@
+#![allow(clippy::redundant_slicing)]
+
+use nix::sys::mman::{mmap_anonymous, MapFlags, ProtFlags};
+use std::num::NonZeroUsize;
+
+#[test]
+fn test_mmap_anonymous() {
+    unsafe {
+        let mut ptr = mmap_anonymous(
+            None,
+            NonZeroUsize::new(1).unwrap(),
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_PRIVATE,
+        )
+        .unwrap()
+        .cast::<u8>();
+        assert_eq!(*ptr.as_ref(), 0x00u8);
+        *ptr.as_mut() = 0xffu8;
+        assert_eq!(*ptr.as_ref(), 0xffu8);
+    }
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "netbsd"))]
+fn test_mremap_grow() {
+    use nix::libc::size_t;
+    use nix::sys::mman::{mremap, MRemapFlags};
+    use std::ptr::NonNull;
+
+    const ONE_K: size_t = 1024;
+    let one_k_non_zero = NonZeroUsize::new(ONE_K).unwrap();
+
+    let slice: &mut [u8] = unsafe {
+        let mem = mmap_anonymous(
+            None,
+            one_k_non_zero,
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_PRIVATE,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem.as_ptr().cast(), ONE_K)
+    };
+    assert_eq!(slice[ONE_K - 1], 0x00);
+    slice[ONE_K - 1] = 0xFF;
+    assert_eq!(slice[ONE_K - 1], 0xFF);
+
+    let slice: &mut [u8] = unsafe {
+        #[cfg(target_os = "linux")]
+        let mem = mremap(
+            NonNull::from(&mut slice[..]).cast(),
+            ONE_K,
+            10 * ONE_K,
+            MRemapFlags::MREMAP_MAYMOVE,
+            None,
+        )
+        .unwrap();
+        #[cfg(target_os = "netbsd")]
+        let mem = mremap(
+            NonNull::from(&mut slice[..]).cast(),
+            ONE_K,
+            10 * ONE_K,
+            MRemapFlags::MAP_REMAPDUP,
+            None,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem.cast().as_ptr(), 10 * ONE_K)
+    };
+
+    // The first KB should still have the old data in it.
+    assert_eq!(slice[ONE_K - 1], 0xFF);
+
+    // The additional range should be zero-init'd and accessible.
+    assert_eq!(slice[10 * ONE_K - 1], 0x00);
+    slice[10 * ONE_K - 1] = 0xFF;
+    assert_eq!(slice[10 * ONE_K - 1], 0xFF);
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "netbsd"))]
+// Segfaults for unknown reasons under QEMU for 32-bit targets
+#[cfg_attr(all(target_pointer_width = "32", qemu), ignore)]
+fn test_mremap_shrink() {
+    use nix::libc::size_t;
+    use nix::sys::mman::{mremap, MRemapFlags};
+    use std::num::NonZeroUsize;
+    use std::ptr::NonNull;
+
+    const ONE_K: size_t = 1024;
+    let ten_one_k = NonZeroUsize::new(10 * ONE_K).unwrap();
+    let slice: &mut [u8] = unsafe {
+        let mem = mmap_anonymous(
+            None,
+            ten_one_k,
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_PRIVATE,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem.as_ptr().cast(), ONE_K)
+    };
+    assert_eq!(slice[ONE_K - 1], 0x00);
+    slice[ONE_K - 1] = 0xFF;
+    assert_eq!(slice[ONE_K - 1], 0xFF);
+
+    let slice: &mut [u8] = unsafe {
+        let mem = mremap(
+            NonNull::from(&mut slice[..]).cast(),
+            ten_one_k.into(),
+            ONE_K,
+            MRemapFlags::empty(),
+            None,
+        )
+        .unwrap();
+        // Since we didn't supply MREMAP_MAYMOVE, the address should be the
+        // same.
+        assert_eq!(mem.as_ptr(), NonNull::from(&mut slice[..]).cast().as_ptr());
+        std::slice::from_raw_parts_mut(mem.as_ptr().cast(), ONE_K)
+    };
+
+    // The first KB should still be accessible and have the old data in it.
+    assert_eq!(slice[ONE_K - 1], 0xFF);
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_mremap_dontunmap() {
+    use nix::libc::size_t;
+    use nix::sys::mman::{mremap, MRemapFlags};
+    use std::num::NonZeroUsize;
+    use std::ptr::NonNull;
+
+    const ONE_K: size_t = 1024;
+    let one_k_non_zero = NonZeroUsize::new(ONE_K).unwrap();
+
+    let slice: &mut [u8] = unsafe {
+        let mem = mmap_anonymous(
+            None,
+            one_k_non_zero,
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_PRIVATE,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem.as_ptr().cast(), ONE_K)
+    };
+
+    // because we do not unmap `slice`, `old_size` and `new_size`
+    // need to be equal or `EINVAL` is set.
+    let _new_slice: &mut [u8] = unsafe {
+        let mem = mremap(
+            NonNull::from(&mut slice[..]).cast(),
+            ONE_K,
+            ONE_K,
+            MRemapFlags::MREMAP_MAYMOVE | MRemapFlags::MREMAP_DONTUNMAP,
+            None,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem.cast().as_ptr(), 10 * ONE_K)
+    };
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_madv_wipeonfork() {
+    use nix::libc::size_t;
+    use nix::sys::mman::{madvise, MmapAdvise};
+    use nix::unistd::{fork, ForkResult};
+    use std::num::NonZeroUsize;
+
+    const ONE_K: size_t = 1024;
+    let ten_one_k = NonZeroUsize::new(10 * ONE_K).unwrap();
+    let slice: &mut [u8] = unsafe {
+        let mem = mmap_anonymous(
+            None,
+            ten_one_k,
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_PRIVATE,
+        )
+        .unwrap();
+        madvise(mem, ONE_K, MmapAdvise::MADV_WIPEONFORK)
+            .expect("madvise failed");
+        std::slice::from_raw_parts_mut(mem.as_ptr().cast(), ONE_K)
+    };
+    slice[ONE_K - 1] = 0xFF;
+    let _m = crate::FORK_MTX.lock();
+
+    unsafe {
+        let res = fork().expect("fork failed");
+        match res {
+            ForkResult::Child => {
+                // that s the whole point of MADV_WIPEONFORK
+                assert_eq!(slice[ONE_K - 1], 0x00);
+                libc::_exit(0);
+            }
+            ForkResult::Parent { child } => {
+                nix::sys::signal::kill(child, nix::sys::signal::SIGTERM)
+                    .unwrap();
+                let _ = nix::sys::wait::wait().unwrap();
+            }
+        }
+    }
+}

vendor/nix/test/sys/test_prctl.rs

@@ -0,0 +1,172 @@
+#[cfg(target_os = "linux")]
+#[cfg(feature = "process")]
+mod test_prctl {
+    use std::ffi::CStr;
+
+    use nix::sys::prctl;
+
+    #[cfg_attr(qemu, ignore)]
+    #[test]
+    fn test_get_set_subreaper() {
+        let original = prctl::get_child_subreaper().unwrap();
+
+        prctl::set_child_subreaper(true).unwrap();
+        let subreaper = prctl::get_child_subreaper().unwrap();
+        assert!(subreaper);
+
+        prctl::set_child_subreaper(original).unwrap();
+    }
+
+    #[test]
+    fn test_get_set_dumpable() {
+        let original = prctl::get_dumpable().unwrap();
+
+        prctl::set_dumpable(false).unwrap();
+        let dumpable = prctl::get_dumpable().unwrap();
+        assert!(!dumpable);
+
+        prctl::set_dumpable(original).unwrap();
+    }
+
+    #[test]
+    fn test_get_set_keepcaps() {
+        let original = prctl::get_keepcaps().unwrap();
+
+        prctl::set_keepcaps(true).unwrap();
+        let keepcaps = prctl::get_keepcaps().unwrap();
+        assert!(keepcaps);
+
+        prctl::set_keepcaps(original).unwrap();
+    }
+
+    #[test]
+    fn test_get_set_clear_mce_kill() {
+        use prctl::PrctlMCEKillPolicy::*;
+
+        prctl::set_mce_kill(PR_MCE_KILL_LATE).unwrap();
+        let mce = prctl::get_mce_kill().unwrap();
+        assert_eq!(mce, PR_MCE_KILL_LATE);
+
+        prctl::clear_mce_kill().unwrap();
+        let mce = prctl::get_mce_kill().unwrap();
+        assert_eq!(mce, PR_MCE_KILL_DEFAULT);
+    }
+
+    #[cfg_attr(qemu, ignore)]
+    #[test]
+    fn test_get_set_pdeathsig() {
+        use nix::sys::signal::Signal;
+
+        let original = prctl::get_pdeathsig().unwrap();
+
+        prctl::set_pdeathsig(Signal::SIGUSR1).unwrap();
+        let sig = prctl::get_pdeathsig().unwrap();
+        assert_eq!(sig, Some(Signal::SIGUSR1));
+
+        prctl::set_pdeathsig(original).unwrap();
+    }
+
+    #[test]
+    fn test_get_set_name() {
+        let original = prctl::get_name().unwrap();
+
+        let long_name =
+            CStr::from_bytes_with_nul(b"0123456789abcdefghijklmn\0").unwrap();
+        prctl::set_name(long_name).unwrap();
+        let res = prctl::get_name().unwrap();
+
+        // name truncated by kernel to TASK_COMM_LEN
+        assert_eq!(&long_name.to_str().unwrap()[..15], res.to_str().unwrap());
+
+        let short_name = CStr::from_bytes_with_nul(b"01234567\0").unwrap();
+        prctl::set_name(short_name).unwrap();
+        let res = prctl::get_name().unwrap();
+        assert_eq!(short_name.to_str().unwrap(), res.to_str().unwrap());
+
+        prctl::set_name(&original).unwrap();
+    }
+
+    #[cfg_attr(qemu, ignore)]
+    #[test]
+    fn test_get_set_timerslack() {
+        let original = prctl::get_timerslack().unwrap() as libc::c_ulong;
+
+        let slack = 60_000;
+        prctl::set_timerslack(slack).unwrap();
+        let res = prctl::get_timerslack().unwrap() as libc::c_ulong;
+        assert_eq!(slack, res);
+
+        prctl::set_timerslack(original).unwrap();
+    }
+
+    // Loongarch need to use a newer QEMU that disabled these PRCTL subcodes/methods.
+    // https://github.com/qemu/qemu/commit/220717a6f46a99031a5b1af964bbf4dec1310440
+    // So we should ignore them when testing in QEMU environments.
+    #[cfg_attr(all(qemu, target_arch = "loongarch64"), ignore)]
+    #[test]
+    fn test_disable_enable_perf_events() {
+        prctl::task_perf_events_disable().unwrap();
+        prctl::task_perf_events_enable().unwrap();
+    }
+
+    #[test]
+    fn test_get_set_no_new_privs() {
+        prctl::set_no_new_privs().unwrap();
+        let no_new_privs = prctl::get_no_new_privs().unwrap();
+        assert!(no_new_privs);
+    }
+
+    // Loongarch need to use a newer QEMU that disabled these PRCTL subcodes/methods
+    // https://github.com/qemu/qemu/commit/220717a6f46a99031a5b1af964bbf4dec1310440
+    // So we should ignore them when testing in QEMU environments.
+    #[cfg_attr(all(qemu, target_arch = "loongarch64"), ignore)]
+    #[test]
+    fn test_get_set_thp_disable() {
+        let original = prctl::get_thp_disable().unwrap();
+
+        prctl::set_thp_disable(true).unwrap();
+        let thp_disable = prctl::get_thp_disable().unwrap();
+        assert!(thp_disable);
+
+        prctl::set_thp_disable(original).unwrap();
+    }
+
+    // Ignore this test under QEMU, as it started failing after updating the Linux CI
+    // runner image, for reasons unknown.
+    //
+    // See: https://github.com/nix-rust/nix/issues/2418
+    #[test]
+    #[cfg_attr(qemu, ignore)]
+    fn test_set_vma_anon_name() {
+        use nix::errno::Errno;
+        use nix::sys::mman;
+        use std::num::NonZeroUsize;
+
+        const ONE_K: libc::size_t = 1024;
+        let sz = NonZeroUsize::new(ONE_K).unwrap();
+        let ptr = unsafe {
+            mman::mmap_anonymous(
+                None,
+                sz,
+                mman::ProtFlags::PROT_READ,
+                mman::MapFlags::MAP_SHARED,
+            )
+            .unwrap()
+        };
+        let err = prctl::set_vma_anon_name(
+            ptr,
+            sz,
+            Some(CStr::from_bytes_with_nul(b"[,$\0").unwrap()),
+        )
+        .unwrap_err();
+        assert_eq!(err, Errno::EINVAL);
+        // `CONFIG_ANON_VMA_NAME` kernel config might not be set
+        prctl::set_vma_anon_name(
+            ptr,
+            sz,
+            Some(CStr::from_bytes_with_nul(b"Nix\0").unwrap()),
+        )
+        .unwrap_or_default();
+        prctl::set_vma_anon_name(ptr, sz, None).unwrap_or_default();
+    }
+}

vendor/nix/test/sys/test_pthread.rs

@@ -0,0 +1,32 @@
+use nix::sys::pthread::*;
+
+#[cfg(any(
+    target_env = "musl",
+    target_os = "redox",
+    target_env = "ohos",
+    target_os = "cygwin"
+))]
+#[test]
+fn test_pthread_self() {
+    let tid = pthread_self();
+    assert!(!tid.is_null());
+}
+
+#[cfg(not(any(
+    target_env = "musl",
+    target_os = "redox",
+    target_env = "ohos",
+    target_os = "cygwin"
+)))]
+#[test]
+fn test_pthread_self() {
+    let tid = pthread_self();
+    assert_ne!(tid, 0);
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_pthread_kill_none() {
+    pthread_kill(pthread_self(), None)
+        .expect("Should be able to send signal to my thread.");
+}

vendor/nix/test/sys/test_ptrace.rs

@@ -0,0 +1,412 @@
+#[cfg(all(
+    target_os = "linux",
+    target_env = "gnu",
+    any(target_arch = "x86_64", target_arch = "x86")
+))]
+use memoffset::offset_of;
+use nix::errno::Errno;
+use nix::sys::ptrace;
+#[cfg(linux_android)]
+use nix::sys::ptrace::Options;
+use nix::unistd::getpid;
+
+#[cfg(linux_android)]
+use std::mem;
+
+use crate::*;
+
+#[test]
+fn test_ptrace() {
+    // Just make sure ptrace can be called at all, for now.
+    // FIXME: qemu-user doesn't implement ptrace on all arches, so permit ENOSYS
+    require_capability!("test_ptrace", CAP_SYS_PTRACE);
+    let err = ptrace::attach(getpid()).unwrap_err();
+    assert!(
+        err == Errno::EPERM || err == Errno::EINVAL || err == Errno::ENOSYS
+    );
+}
+
+// Just make sure ptrace_setoptions can be called at all, for now.
+#[test]
+#[cfg(linux_android)]
+fn test_ptrace_setoptions() {
+    require_capability!("test_ptrace_setoptions", CAP_SYS_PTRACE);
+    let err = ptrace::setoptions(getpid(), Options::PTRACE_O_TRACESYSGOOD)
+        .unwrap_err();
+    assert_ne!(err, Errno::EOPNOTSUPP);
+}
+
+// Just make sure ptrace_getevent can be called at all, for now.
+#[test]
+#[cfg(linux_android)]
+fn test_ptrace_getevent() {
+    require_capability!("test_ptrace_getevent", CAP_SYS_PTRACE);
+    let err = ptrace::getevent(getpid()).unwrap_err();
+    assert_ne!(err, Errno::EOPNOTSUPP);
+}
+
+// Just make sure ptrace_getsiginfo can be called at all, for now.
+#[test]
+#[cfg(linux_android)]
+fn test_ptrace_getsiginfo() {
+    require_capability!("test_ptrace_getsiginfo", CAP_SYS_PTRACE);
+    if let Err(Errno::EOPNOTSUPP) = ptrace::getsiginfo(getpid()) {
+        panic!("ptrace_getsiginfo returns Errno::EOPNOTSUPP!");
+    }
+}
+
+// Just make sure ptrace_setsiginfo can be called at all, for now.
+#[test]
+#[cfg(linux_android)]
+fn test_ptrace_setsiginfo() {
+    require_capability!("test_ptrace_setsiginfo", CAP_SYS_PTRACE);
+    let siginfo = unsafe { mem::zeroed() };
+    if let Err(Errno::EOPNOTSUPP) = ptrace::setsiginfo(getpid(), &siginfo) {
+        panic!("ptrace_setsiginfo returns Errno::EOPNOTSUPP!");
+    }
+}
+
+#[test]
+fn test_ptrace_cont() {
+    use nix::sys::ptrace;
+    use nix::sys::signal::{raise, Signal};
+    use nix::sys::wait::{waitpid, WaitPidFlag, WaitStatus};
+    use nix::unistd::fork;
+    use nix::unistd::ForkResult::*;
+
+    require_capability!("test_ptrace_cont", CAP_SYS_PTRACE);
+
+    let _m = crate::FORK_MTX.lock();
+
+    // FIXME: qemu-user doesn't implement ptrace on all architectures
+    // and returns ENOSYS in this case.
+    // We (ab)use this behavior to detect the affected platforms
+    // and skip the test then.
+    // On valid platforms the ptrace call should return Errno::EPERM, this
+    // is already tested by `test_ptrace`.
+    let err = ptrace::attach(getpid()).unwrap_err();
+    if err == Errno::ENOSYS {
+        return;
+    }
+
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            ptrace::traceme().unwrap();
+            // As recommended by ptrace(2), raise SIGTRAP to pause the child
+            // until the parent is ready to continue
+            loop {
+                raise(Signal::SIGTRAP).unwrap();
+            }
+        }
+        Parent { child } => {
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTRAP))
+            );
+            ptrace::cont(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTRAP))
+            );
+            ptrace::cont(child, Some(Signal::SIGKILL)).unwrap();
+            match waitpid(child, None) {
+                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _))
+                    if pid == child =>
+                {
+                    // FIXME It's been observed on some systems (apple) the
+                    // tracee may not be killed but remain as a zombie process
+                    // affecting other wait based tests. Add an extra kill just
+                    // to make sure there are no zombies.
+                    let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
+                    while ptrace::cont(child, Some(Signal::SIGKILL)).is_ok() {
+                        let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
+                    }
+                }
+                _ => panic!("The process should have been killed"),
+            }
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_ptrace_interrupt() {
+    use nix::sys::ptrace;
+    use nix::sys::signal::Signal;
+    use nix::sys::wait::{waitpid, WaitPidFlag, WaitStatus};
+    use nix::unistd::fork;
+    use nix::unistd::ForkResult::*;
+    use std::thread::sleep;
+    use std::time::Duration;
+
+    require_capability!("test_ptrace_interrupt", CAP_SYS_PTRACE);
+
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => loop {
+            sleep(Duration::from_millis(1000));
+        },
+        Parent { child } => {
+            ptrace::seize(child, ptrace::Options::PTRACE_O_TRACESYSGOOD)
+                .unwrap();
+            ptrace::interrupt(child).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceEvent(child, Signal::SIGTRAP, 128))
+            );
+            ptrace::syscall(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceSyscall(child))
+            );
+            ptrace::detach(child, Some(Signal::SIGKILL)).unwrap();
+            match waitpid(child, None) {
+                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _))
+                    if pid == child =>
+                {
+                    let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
+                    while ptrace::cont(child, Some(Signal::SIGKILL)).is_ok() {
+                        let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
+                    }
+                }
+                _ => panic!("The process should have been killed"),
+            }
+        }
+    }
+}
+
+// ptrace::{setoptions, getregs} are only available in these platforms
+#[cfg(all(
+    target_os = "linux",
+    any(
+        all(
+            target_env = "gnu",
+            any(
+                target_arch = "x86_64",
+                target_arch = "x86",
+                target_arch = "aarch64",
+                target_arch = "riscv64"
+            )
+        ),
+        all(target_env = "musl", target_arch = "aarch64")
+    )
+))]
+#[test]
+fn test_ptrace_syscall() {
+    use nix::sys::ptrace;
+    use nix::sys::signal::kill;
+    use nix::sys::signal::Signal;
+    use nix::sys::wait::{waitpid, WaitStatus};
+    use nix::unistd::fork;
+    use nix::unistd::getpid;
+    use nix::unistd::ForkResult::*;
+
+    require_capability!("test_ptrace_syscall", CAP_SYS_PTRACE);
+
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            ptrace::traceme().unwrap();
+            // first sigstop until parent is ready to continue
+            let pid = getpid();
+            kill(pid, Signal::SIGSTOP).unwrap();
+            kill(pid, Signal::SIGTERM).unwrap();
+            unsafe {
+                ::libc::_exit(0);
+            }
+        }
+
+        Parent { child } => {
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGSTOP))
+            );
+
+            // set this option to recognize syscall-stops
+            ptrace::setoptions(child, ptrace::Options::PTRACE_O_TRACESYSGOOD)
+                .unwrap();
+
+            #[cfg(target_arch = "x86_64")]
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().orig_rax as libc::c_long;
+
+            #[cfg(target_arch = "x86")]
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().orig_eax as libc::c_long;
+
+            #[cfg(target_arch = "aarch64")]
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().regs[8] as libc::c_long;
+
+            #[cfg(target_arch = "riscv64")]
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().a7 as libc::c_long;
+
+            // this duplicates `get_syscall_id` for the purpose of testing `ptrace::read_user`.
+            #[cfg(target_arch = "x86_64")]
+            let rax_offset = offset_of!(libc::user_regs_struct, orig_rax);
+            #[cfg(target_arch = "x86")]
+            let rax_offset = offset_of!(libc::user_regs_struct, orig_eax);
+
+            #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+            let get_syscall_from_user_area = || {
+                // Find the offset of `user.regs.rax` (or `user.regs.eax` for x86)
+                let rax_offset = offset_of!(libc::user, regs) + rax_offset;
+                ptrace::read_user(child, rax_offset as _).unwrap()
+                    as libc::c_long
+            };
+
+            // kill entry
+            ptrace::syscall(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceSyscall(child))
+            );
+            assert_eq!(get_syscall_id(), ::libc::SYS_kill);
+            #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+            assert_eq!(get_syscall_from_user_area(), ::libc::SYS_kill);
+
+            // kill exit
+            ptrace::syscall(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceSyscall(child))
+            );
+            assert_eq!(get_syscall_id(), ::libc::SYS_kill);
+            #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+            assert_eq!(get_syscall_from_user_area(), ::libc::SYS_kill);
+
+            // receive signal
+            ptrace::syscall(child, None).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTERM))
+            );
+
+            // inject signal
+            ptrace::syscall(child, Signal::SIGTERM).unwrap();
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Signaled(child, Signal::SIGTERM, false))
+            );
+        }
+    }
+}
+
+#[cfg(all(
+    target_os = "linux",
+    any(
+        all(
+            target_env = "gnu",
+            any(
+                target_arch = "x86_64",
+                target_arch = "x86",
+                target_arch = "aarch64",
+                target_arch = "riscv64"
+            )
+        ),
+        all(target_env = "musl", target_arch = "aarch64")
+    )
+))]
+#[test]
+fn test_ptrace_regsets() {
+    use nix::sys::ptrace::{self, getregset, regset, setregset};
+    use nix::sys::signal::*;
+    use nix::sys::wait::{waitpid, WaitStatus};
+    use nix::unistd::fork;
+    use nix::unistd::ForkResult::*;
+
+    require_capability!("test_ptrace_regsets", CAP_SYS_PTRACE);
+
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            ptrace::traceme().unwrap();
+            // As recommended by ptrace(2), raise SIGTRAP to pause the child
+            // until the parent is ready to continue
+            loop {
+                raise(Signal::SIGTRAP).unwrap();
+            }
+        }
+
+        Parent { child } => {
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTRAP))
+            );
+            let mut regstruct =
+                getregset::<regset::NT_PRSTATUS>(child).unwrap();
+            let mut fpregstruct =
+                getregset::<regset::NT_PRFPREG>(child).unwrap();
+
+            #[cfg(target_arch = "x86_64")]
+            let (reg, fpreg) =
+                (&mut regstruct.r15, &mut fpregstruct.st_space[5]);
+            #[cfg(target_arch = "x86")]
+            let (reg, fpreg) =
+                (&mut regstruct.edx, &mut fpregstruct.st_space[5]);
+            #[cfg(target_arch = "aarch64")]
+            let (reg, fpreg) =
+                (&mut regstruct.regs[16], &mut fpregstruct.vregs[5]);
+            #[cfg(target_arch = "riscv64")]
+            let (reg, fpreg) = (&mut regstruct.t1, &mut fpregstruct.__f[5]);
+
+            *reg = 0xdeadbeefu32 as _;
+            *fpreg = 0xfeedfaceu32 as _;
+            let _ = setregset::<regset::NT_PRSTATUS>(child, regstruct);
+            regstruct = getregset::<regset::NT_PRSTATUS>(child).unwrap();
+            let _ = setregset::<regset::NT_PRFPREG>(child, fpregstruct);
+            fpregstruct = getregset::<regset::NT_PRFPREG>(child).unwrap();
+
+            #[cfg(target_arch = "x86_64")]
+            let (reg, fpreg) = (regstruct.r15, fpregstruct.st_space[5]);
+            #[cfg(target_arch = "x86")]
+            let (reg, fpreg) = (regstruct.edx, fpregstruct.st_space[5]);
+            #[cfg(target_arch = "aarch64")]
+            let (reg, fpreg) = (regstruct.regs[16], fpregstruct.vregs[5]);
+            #[cfg(target_arch = "riscv64")]
+            let (reg, fpreg) = (regstruct.t1, fpregstruct.__f[5]);
+            assert_eq!(reg, 0xdeadbeefu32 as _);
+            assert_eq!(fpreg, 0xfeedfaceu32 as _);
+
+            ptrace::cont(child, Some(Signal::SIGKILL)).unwrap();
+            match waitpid(child, None) {
+                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _))
+                    if pid == child => {}
+                _ => panic!("The process should have been killed"),
+            }
+        }
+    }
+}
+
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+#[test]
+fn test_ptrace_syscall_info() {
+    use nix::sys::ptrace;
+    use nix::sys::wait::{waitpid, WaitStatus};
+    use nix::unistd::fork;
+    use nix::unistd::ForkResult::*;
+
+    require_capability!("test_ptrace_syscall_info", CAP_SYS_PTRACE);
+
+    let _m = crate::FORK_MTX.lock();
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            ptrace::traceme().unwrap();
+            std::thread::sleep(std::time::Duration::from_millis(1000));
+            unsafe {
+                ::libc::_exit(0);
+            }
+        }
+        Parent { child } => loop {
+            if let Ok(WaitStatus::Exited(_, 0)) = waitpid(child, None) {
+                break;
+            }
+            let si = ptrace::syscall_info(child).unwrap();
+            assert!(si.op >= libc::PTRACE_SYSCALL_INFO_ENTRY);
+        },
+    }
+}

vendor/nix/test/sys/test_resource.rs

@@ -0,0 +1,44 @@
+use nix::sys::resource::{getrlimit, setrlimit, Resource};
+use nix::sys::resource::{getrusage, UsageWho};
+
+/// Tests the RLIMIT_NOFILE functionality of getrlimit(), where the resource RLIMIT_NOFILE refers
+/// to the maximum file descriptor number that can be opened by the process (aka the maximum number
+/// of file descriptors that the process can open, since Linux 4.5).
+///
+/// We first fetch the existing file descriptor maximum values using getrlimit(), then edit the
+/// soft limit to make sure it has a new and distinct value to the hard limit. We then setrlimit()
+/// to put the new soft limit in effect, and then getrlimit() once more to ensure the limits have
+/// been updated.
+#[test]
+#[cfg_attr(target_os = "cygwin", ignore)]
+pub fn test_resource_limits_nofile() {
+    let (mut soft_limit, hard_limit) =
+        getrlimit(Resource::RLIMIT_NOFILE).unwrap();
+
+    soft_limit -= 1;
+    assert_ne!(soft_limit, hard_limit);
+    setrlimit(Resource::RLIMIT_NOFILE, soft_limit, hard_limit).unwrap();
+
+    let (new_soft_limit, _) = getrlimit(Resource::RLIMIT_NOFILE).unwrap();
+    assert_eq!(new_soft_limit, soft_limit);
+}
+
+#[test]
+pub fn test_self_cpu_time() {
+    // Make sure some CPU time is used.
+    let mut numbers: Vec<i32> = (1..1_000_000).collect();
+    numbers.iter_mut().for_each(|item| *item *= 2);
+
+    // FIXME: this is here to help ensure the compiler does not optimize the whole
+    // thing away. Replace the assert with test::black_box once stabilized.
+    assert_eq!(numbers[100..200].iter().sum::<i32>(), 30_100);
+
+    let usage = getrusage(UsageWho::RUSAGE_SELF)
+        .expect("Failed to call getrusage for SELF");
+    let rusage = usage.as_ref();
+
+    let user = usage.user_time();
+    assert!(user.tv_sec() > 0 || user.tv_usec() > 0);
+    assert_eq!(user.tv_sec(), rusage.ru_utime.tv_sec);
+    assert_eq!(user.tv_usec(), rusage.ru_utime.tv_usec);
+}

vendor/nix/test/sys/test_select.rs

@@ -0,0 +1,293 @@
+use nix::sys::select::*;
+use nix::sys::signal::SigSet;
+use nix::sys::time::{TimeSpec, TimeVal, TimeValLike};
+use nix::unistd::{pipe, write};
+use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+
+#[test]
+pub fn test_pselect() {
+    let _mtx = crate::SIGNAL_MTX.lock();
+
+    let (r1, w1) = pipe().unwrap();
+    write(&w1, b"hi!").unwrap();
+    let (r2, _w2) = pipe().unwrap();
+
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let timeout = TimeSpec::seconds(10);
+    let sigmask = SigSet::empty();
+    assert_eq!(
+        1,
+        pselect(None, &mut fd_set, None, None, &timeout, &sigmask).unwrap()
+    );
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}
+
+#[test]
+pub fn test_pselect_nfds2() {
+    let (r1, w1) = pipe().unwrap();
+    write(&w1, b"hi!").unwrap();
+    let (r2, _w2) = pipe().unwrap();
+
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let timeout = TimeSpec::seconds(10);
+    assert_eq!(
+        1,
+        pselect(
+            std::cmp::max(r1.as_raw_fd(), r2.as_raw_fd()) + 1,
+            &mut fd_set,
+            None,
+            None,
+            &timeout,
+            None
+        )
+        .unwrap()
+    );
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}
+
+macro_rules! generate_fdset_bad_fd_tests {
+    ($fd:expr, $($method:ident),* $(,)?) => {
+        $(
+            #[test]
+            #[should_panic]
+            fn $method() {
+                let bad_fd = unsafe{BorrowedFd::borrow_raw($fd)};
+                FdSet::new().$method(bad_fd);
+            }
+        )*
+    }
+}
+
+mod test_fdset_too_large_fd {
+    use super::*;
+    generate_fdset_bad_fd_tests!(
+        FD_SETSIZE.try_into().unwrap(),
+        insert,
+        remove,
+        contains,
+    );
+}
+
+#[test]
+fn fdset_insert() {
+    let mut fd_set = FdSet::new();
+
+    for i in 0..FD_SETSIZE {
+        let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
+        assert!(!fd_set.contains(borrowed_i));
+    }
+
+    let fd_seven = unsafe { BorrowedFd::borrow_raw(7) };
+    fd_set.insert(fd_seven);
+
+    assert!(fd_set.contains(fd_seven));
+}
+
+#[test]
+fn fdset_remove() {
+    let mut fd_set = FdSet::new();
+
+    for i in 0..FD_SETSIZE {
+        let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
+        assert!(!fd_set.contains(borrowed_i));
+    }
+
+    let fd_seven = unsafe { BorrowedFd::borrow_raw(7) };
+    fd_set.insert(fd_seven);
+    fd_set.remove(fd_seven);
+
+    for i in 0..FD_SETSIZE {
+        let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
+        assert!(!fd_set.contains(borrowed_i));
+    }
+}
+
+#[test]
+#[allow(non_snake_case)]
+fn fdset_clear() {
+    let mut fd_set = FdSet::new();
+    let fd_one = unsafe { BorrowedFd::borrow_raw(1) };
+    let fd_FD_SETSIZE_divided_by_two =
+        unsafe { BorrowedFd::borrow_raw((FD_SETSIZE / 2) as RawFd) };
+    let fd_FD_SETSIZE_minus_one =
+        unsafe { BorrowedFd::borrow_raw((FD_SETSIZE - 1) as RawFd) };
+    fd_set.insert(fd_one);
+    fd_set.insert(fd_FD_SETSIZE_divided_by_two);
+    fd_set.insert(fd_FD_SETSIZE_minus_one);
+
+    fd_set.clear();
+
+    for i in 0..FD_SETSIZE {
+        let borrowed_i = unsafe { BorrowedFd::borrow_raw(i as RawFd) };
+        assert!(!fd_set.contains(borrowed_i));
+    }
+}
+
+#[test]
+fn fdset_highest() {
+    let mut set = FdSet::new();
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        None
+    );
+    let fd_zero = unsafe { BorrowedFd::borrow_raw(0) };
+    let fd_ninety = unsafe { BorrowedFd::borrow_raw(90) };
+    set.insert(fd_zero);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        Some(0)
+    );
+    set.insert(fd_ninety);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        Some(90)
+    );
+    set.remove(fd_zero);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        Some(90)
+    );
+    set.remove(fd_ninety);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        None
+    );
+
+    let fd_four = unsafe { BorrowedFd::borrow_raw(4) };
+    let fd_five = unsafe { BorrowedFd::borrow_raw(5) };
+    let fd_seven = unsafe { BorrowedFd::borrow_raw(7) };
+    set.insert(fd_four);
+    set.insert(fd_five);
+    set.insert(fd_seven);
+    assert_eq!(
+        set.highest().map(|borrowed_fd| borrowed_fd.as_raw_fd()),
+        Some(7)
+    );
+}
+
+#[test]
+fn fdset_fds() {
+    let mut set = FdSet::new();
+    let fd_zero = unsafe { BorrowedFd::borrow_raw(0) };
+    let fd_ninety = unsafe { BorrowedFd::borrow_raw(90) };
+    assert_eq!(
+        set.fds(None)
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![]
+    );
+    set.insert(fd_zero);
+    assert_eq!(
+        set.fds(None)
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![0]
+    );
+    set.insert(fd_ninety);
+    assert_eq!(
+        set.fds(None)
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![0, 90]
+    );
+
+    // highest limit
+    assert_eq!(
+        set.fds(Some(89))
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![0]
+    );
+    assert_eq!(
+        set.fds(Some(90))
+            .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+            .collect::<Vec<_>>(),
+        vec![0, 90]
+    );
+}
+
+#[test]
+fn test_select() {
+    let (r1, w1) = pipe().unwrap();
+    let (r2, _w2) = pipe().unwrap();
+
+    write(&w1, b"hi!").unwrap();
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let mut timeout = TimeVal::seconds(10);
+    assert_eq!(
+        1,
+        select(None, &mut fd_set, None, None, &mut timeout).unwrap()
+    );
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}
+
+#[test]
+fn test_select_nfds() {
+    let (r1, w1) = pipe().unwrap();
+    let (r2, _w2) = pipe().unwrap();
+
+    write(&w1, b"hi!").unwrap();
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let mut timeout = TimeVal::seconds(10);
+    {
+        assert_eq!(
+            1,
+            select(
+                Some(
+                    fd_set
+                        .highest()
+                        .map(|borrowed_fd| borrowed_fd.as_raw_fd())
+                        .unwrap()
+                        + 1
+                ),
+                &mut fd_set,
+                None,
+                None,
+                &mut timeout
+            )
+            .unwrap()
+        );
+    }
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}
+
+#[test]
+fn test_select_nfds2() {
+    let (r1, w1) = pipe().unwrap();
+    write(&w1, b"hi!").unwrap();
+    let (r2, _w2) = pipe().unwrap();
+    let mut fd_set = FdSet::new();
+    fd_set.insert(r1.as_fd());
+    fd_set.insert(r2.as_fd());
+
+    let mut timeout = TimeVal::seconds(10);
+    assert_eq!(
+        1,
+        select(
+            std::cmp::max(r1.as_raw_fd(), r2.as_raw_fd()) + 1,
+            &mut fd_set,
+            None,
+            None,
+            &mut timeout
+        )
+        .unwrap()
+    );
+    assert!(fd_set.contains(r1.as_fd()));
+    assert!(!fd_set.contains(r2.as_fd()));
+}

vendor/nix/test/sys/test_signal.rs

@@ -0,0 +1,456 @@
+use nix::errno::Errno;
+use nix::sys::signal::*;
+use nix::unistd::*;
+use std::hash::{Hash, Hasher};
+use std::sync::atomic::{AtomicBool, Ordering};
+#[cfg(not(target_os = "redox"))]
+use std::thread;
+
+#[test]
+fn test_kill_none() {
+    kill(getpid(), None).expect("Should be able to send signal to myself.");
+}
+
+#[test]
+#[cfg(not(target_os = "fuchsia"))]
+fn test_killpg_none() {
+    killpg(getpgrp(), None)
+        .expect("Should be able to send signal to my process group.");
+}
+
+#[test]
+fn test_old_sigaction_flags() {
+    let _m = crate::SIGNAL_MTX.lock();
+
+    extern "C" fn handler(_: ::libc::c_int) {}
+    let act = SigAction::new(
+        SigHandler::Handler(handler),
+        SaFlags::empty(),
+        SigSet::empty(),
+    );
+    let oact = unsafe { sigaction(SIGINT, &act) }.unwrap();
+    let _flags = oact.flags();
+    let oact = unsafe { sigaction(SIGINT, &act) }.unwrap();
+    let _flags = oact.flags();
+}
+
+#[test]
+fn test_sigprocmask_noop() {
+    sigprocmask(SigmaskHow::SIG_BLOCK, None, None)
+        .expect("this should be an effective noop");
+}
+
+#[test]
+fn test_sigprocmask() {
+    let _m = crate::SIGNAL_MTX.lock();
+
+    // This needs to be a signal that rust doesn't use in the test harness.
+    const SIGNAL: Signal = Signal::SIGCHLD;
+
+    let mut old_signal_set = SigSet::empty();
+    sigprocmask(SigmaskHow::SIG_BLOCK, None, Some(&mut old_signal_set))
+        .expect("expect to be able to retrieve old signals");
+
+    // Make sure the old set doesn't contain the signal, otherwise the following
+    // test don't make sense.
+    assert!(
+        !old_signal_set.contains(SIGNAL),
+        "the {SIGNAL:?} signal is already blocked, please change to a \
+             different one"
+    );
+
+    // Now block the signal.
+    let mut signal_set = SigSet::empty();
+    signal_set.add(SIGNAL);
+    sigprocmask(SigmaskHow::SIG_BLOCK, Some(&signal_set), None)
+        .expect("expect to be able to block signals");
+
+    // And test it again, to make sure the change was effective.
+    old_signal_set.clear();
+    sigprocmask(SigmaskHow::SIG_BLOCK, None, Some(&mut old_signal_set))
+        .expect("expect to be able to retrieve old signals");
+    assert!(
+        old_signal_set.contains(SIGNAL),
+        "expected the {SIGNAL:?} to be blocked"
+    );
+
+    // Reset the signal.
+    sigprocmask(SigmaskHow::SIG_UNBLOCK, Some(&signal_set), None)
+        .expect("expect to be able to block signals");
+}
+
+static SIGNALED: AtomicBool = AtomicBool::new(false);
+
+extern "C" fn test_sigaction_handler(signal: libc::c_int) {
+    let signal = Signal::try_from(signal).unwrap();
+    SIGNALED.store(signal == Signal::SIGINT, Ordering::Relaxed);
+}
+
+#[cfg(not(target_os = "redox"))]
+extern "C" fn test_sigaction_action(
+    _: libc::c_int,
+    _: *mut libc::siginfo_t,
+    _: *mut libc::c_void,
+) {
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_signal_sigaction() {
+    let _m = crate::SIGNAL_MTX.lock();
+
+    let action_handler = SigHandler::SigAction(test_sigaction_action);
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, action_handler) }.unwrap_err(),
+        Errno::ENOTSUP
+    );
+}
+
+#[test]
+fn test_signal() {
+    let _m = crate::SIGNAL_MTX.lock();
+
+    unsafe { signal(Signal::SIGINT, SigHandler::SigIgn) }.unwrap();
+    raise(Signal::SIGINT).unwrap();
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
+        SigHandler::SigIgn
+    );
+
+    let handler = SigHandler::Handler(test_sigaction_handler);
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, handler) }.unwrap(),
+        SigHandler::SigDfl
+    );
+    raise(Signal::SIGINT).unwrap();
+    assert!(SIGNALED.load(Ordering::Relaxed));
+
+    #[cfg(not(solarish))]
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
+        handler
+    );
+
+    // System V based OSes (e.g. illumos and Solaris) always resets the
+    // disposition to SIG_DFL prior to calling the signal handler
+    #[cfg(solarish)]
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
+        SigHandler::SigDfl
+    );
+
+    // Restore default signal handler
+    unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap();
+}
+
+#[test]
+fn test_contains() {
+    let mut mask = SigSet::empty();
+    mask.add(SIGUSR1);
+
+    assert!(mask.contains(SIGUSR1));
+    assert!(!mask.contains(SIGUSR2));
+
+    let all = SigSet::all();
+    assert!(all.contains(SIGUSR1));
+    assert!(all.contains(SIGUSR2));
+}
+
+#[test]
+fn test_clear() {
+    let mut set = SigSet::all();
+    set.clear();
+    for signal in Signal::iterator() {
+        assert!(!set.contains(signal));
+    }
+}
+
+#[test]
+fn test_from_str_round_trips() {
+    for signal in Signal::iterator() {
+        assert_eq!(signal.as_ref().parse::<Signal>().unwrap(), signal);
+        assert_eq!(signal.to_string().parse::<Signal>().unwrap(), signal);
+    }
+}
+
+#[test]
+fn test_from_str_invalid_value() {
+    let errval = Err(Errno::EINVAL);
+    assert_eq!("NOSIGNAL".parse::<Signal>(), errval);
+    assert_eq!("kill".parse::<Signal>(), errval);
+    assert_eq!("9".parse::<Signal>(), errval);
+}
+
+#[test]
+fn test_extend() {
+    let mut one_signal = SigSet::empty();
+    one_signal.add(SIGUSR1);
+
+    let mut two_signals = SigSet::empty();
+    two_signals.add(SIGUSR2);
+    two_signals.extend(&one_signal);
+
+    assert!(two_signals.contains(SIGUSR1));
+    assert!(two_signals.contains(SIGUSR2));
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_thread_signal_set_mask() {
+    thread::spawn(|| {
+        let prev_mask = SigSet::thread_get_mask()
+            .expect("Failed to get existing signal mask!");
+
+        let mut test_mask = prev_mask;
+        test_mask.add(SIGUSR1);
+
+        test_mask.thread_set_mask().expect("assertion failed");
+        let new_mask =
+            SigSet::thread_get_mask().expect("Failed to get new mask!");
+
+        assert!(new_mask.contains(SIGUSR1));
+        assert!(!new_mask.contains(SIGUSR2));
+
+        prev_mask
+            .thread_set_mask()
+            .expect("Failed to revert signal mask!");
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_thread_signal_block() {
+    thread::spawn(|| {
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+
+        mask.thread_block().expect("assertion failed");
+
+        assert!(SigSet::thread_get_mask().unwrap().contains(SIGUSR1));
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_thread_signal_unblock() {
+    thread::spawn(|| {
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+
+        mask.thread_unblock().expect("assertion failed");
+
+        assert!(!SigSet::thread_get_mask().unwrap().contains(SIGUSR1));
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_thread_signal_swap() {
+    thread::spawn(|| {
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+        mask.thread_block().unwrap();
+
+        assert!(SigSet::thread_get_mask().unwrap().contains(SIGUSR1));
+
+        let mut mask2 = SigSet::empty();
+        mask2.add(SIGUSR2);
+
+        let oldmask = mask2.thread_swap_mask(SigmaskHow::SIG_SETMASK).unwrap();
+
+        assert!(oldmask.contains(SIGUSR1));
+        assert!(!oldmask.contains(SIGUSR2));
+
+        assert!(SigSet::thread_get_mask().unwrap().contains(SIGUSR2));
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+fn test_from_and_into_iterator() {
+    let sigset = SigSet::from_iter(vec![Signal::SIGUSR1, Signal::SIGUSR2]);
+    let signals = sigset.into_iter().collect::<Vec<Signal>>();
+    assert_eq!(signals, [Signal::SIGUSR1, Signal::SIGUSR2]);
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_sigaction() {
+    let _m = crate::SIGNAL_MTX.lock();
+    thread::spawn(|| {
+        extern "C" fn test_sigaction_handler(_: libc::c_int) {}
+        extern "C" fn test_sigaction_action(
+            _: libc::c_int,
+            _: *mut libc::siginfo_t,
+            _: *mut libc::c_void,
+        ) {
+        }
+
+        let handler_sig = SigHandler::Handler(test_sigaction_handler);
+
+        let flags =
+            SaFlags::SA_ONSTACK | SaFlags::SA_RESTART | SaFlags::SA_SIGINFO;
+
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+
+        let action_sig = SigAction::new(handler_sig, flags, mask);
+
+        assert_eq!(
+            action_sig.flags(),
+            SaFlags::SA_ONSTACK | SaFlags::SA_RESTART
+        );
+        assert_eq!(action_sig.handler(), handler_sig);
+
+        mask = action_sig.mask();
+        assert!(mask.contains(SIGUSR1));
+        assert!(!mask.contains(SIGUSR2));
+
+        let handler_act = SigHandler::SigAction(test_sigaction_action);
+        let action_act = SigAction::new(handler_act, flags, mask);
+        assert_eq!(action_act.handler(), handler_act);
+
+        let action_dfl = SigAction::new(SigHandler::SigDfl, flags, mask);
+        assert_eq!(action_dfl.handler(), SigHandler::SigDfl);
+
+        let action_ign = SigAction::new(SigHandler::SigIgn, flags, mask);
+        assert_eq!(action_ign.handler(), SigHandler::SigIgn);
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_sigwait() {
+    thread::spawn(|| {
+        let mut mask = SigSet::empty();
+        mask.add(SIGUSR1);
+        mask.add(SIGUSR2);
+        mask.thread_block().unwrap();
+
+        raise(SIGUSR1).unwrap();
+        assert_eq!(mask.wait().unwrap(), SIGUSR1);
+    })
+    .join()
+    .unwrap();
+}
+
+#[cfg(any(
+    bsd,
+    linux_android,
+    solarish,
+    target_os = "haiku",
+    target_os = "hurd",
+    target_os = "aix",
+    target_os = "fuchsia"
+))]
+#[test]
+fn test_sigsuspend() {
+    // This test change signal handler
+    let _m = crate::SIGNAL_MTX.lock();
+    static SIGNAL_RECIEVED: AtomicBool = AtomicBool::new(false);
+    extern "C" fn test_sigsuspend_handler(_: libc::c_int) {
+        assert!(!SIGNAL_RECIEVED.swap(true, Ordering::SeqCst));
+    }
+    thread::spawn(|| {
+        const SIGNAL: Signal = Signal::SIGUSR1;
+
+        // Add signal mask to this thread
+        let mut signal_set = SigSet::empty();
+        signal_set.add(SIGNAL);
+        signal_set.thread_block().unwrap();
+
+        // Set signal handler and save old one.
+        let act = SigAction::new(
+            SigHandler::Handler(test_sigsuspend_handler),
+            SaFlags::empty(),
+            SigSet::empty(),
+        );
+        let old_act = unsafe { sigaction(SIGNAL, &act) }
+            .expect("expect to be able to set new action and get old action");
+
+        raise(SIGNAL).expect("expect be able to send signal");
+        // Now `SIGNAL` was sended but it is blocked.
+        let mut not_wait_set = SigSet::all();
+        not_wait_set.remove(SIGNAL);
+        // signal handler must run in SigSet::suspend()
+        assert!(!SIGNAL_RECIEVED.load(Ordering::SeqCst));
+        not_wait_set.suspend().unwrap();
+        assert!(SIGNAL_RECIEVED.load(Ordering::SeqCst));
+
+        // Restore the signal handler.
+        unsafe { sigaction(SIGNAL, &old_act) }
+            .expect("expect to be able to restore old action ");
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+fn test_from_sigset_t_unchecked() {
+    let src_set = SigSet::empty();
+    let set = unsafe { SigSet::from_sigset_t_unchecked(*src_set.as_ref()) };
+
+    for signal in Signal::iterator() {
+        assert!(!set.contains(signal));
+    }
+
+    let src_set = SigSet::all();
+    let set = unsafe { SigSet::from_sigset_t_unchecked(*src_set.as_ref()) };
+
+    for signal in Signal::iterator() {
+        assert!(set.contains(signal));
+    }
+}
+
+#[test]
+fn test_eq_empty() {
+    let set0 = SigSet::empty();
+    let set1 = SigSet::empty();
+    assert_eq!(set0, set1);
+}
+
+#[test]
+fn test_eq_all() {
+    let set0 = SigSet::all();
+    let set1 = SigSet::all();
+    assert_eq!(set0, set1);
+}
+
+#[test]
+fn test_hash_empty() {
+    use std::collections::hash_map::DefaultHasher;
+
+    let set0 = SigSet::empty();
+    let mut h0 = DefaultHasher::new();
+    set0.hash(&mut h0);
+
+    let set1 = SigSet::empty();
+    let mut h1 = DefaultHasher::new();
+    set1.hash(&mut h1);
+
+    assert_eq!(h0.finish(), h1.finish());
+}
+
+#[test]
+fn test_hash_all() {
+    use std::collections::hash_map::DefaultHasher;
+
+    let set0 = SigSet::all();
+    let mut h0 = DefaultHasher::new();
+    set0.hash(&mut h0);
+
+    let set1 = SigSet::all();
+    let mut h1 = DefaultHasher::new();
+    set1.hash(&mut h1);
+
+    assert_eq!(h0.finish(), h1.finish());
+}

vendor/nix/test/sys/test_signalfd.rs

@@ -0,0 +1,90 @@
+use std::convert::TryFrom;
+
+#[test]
+fn create_signalfd() {
+    use nix::sys::{signal::SigSet, signalfd::SignalFd};
+
+    let mask = SigSet::empty();
+    SignalFd::new(&mask).unwrap();
+}
+
+#[test]
+fn create_signalfd_with_opts() {
+    use nix::sys::{
+        signal::SigSet,
+        signalfd::{SfdFlags, SignalFd},
+    };
+
+    let mask = SigSet::empty();
+    SignalFd::with_flags(&mask, SfdFlags::SFD_CLOEXEC | SfdFlags::SFD_NONBLOCK)
+        .unwrap();
+}
+
+#[test]
+fn read_empty_signalfd() {
+    use nix::sys::{
+        signal::SigSet,
+        signalfd::{SfdFlags, SignalFd},
+    };
+
+    let mask = SigSet::empty();
+    let fd = SignalFd::with_flags(&mask, SfdFlags::SFD_NONBLOCK).unwrap();
+
+    let res = fd.read_signal();
+    assert!(res.unwrap().is_none());
+}
+
+#[test]
+fn test_signalfd() {
+    use nix::sys::signal::{self, raise, SigSet, Signal};
+    use nix::sys::signalfd::SignalFd;
+
+    // Grab the mutex for altering signals so we don't interfere with other tests.
+    let _m = crate::SIGNAL_MTX.lock();
+
+    // Block the SIGUSR1 signal from automatic processing for this thread
+    let mut mask = SigSet::empty();
+    mask.add(signal::SIGUSR1);
+    mask.thread_block().unwrap();
+
+    let fd = SignalFd::new(&mask).unwrap();
+
+    // Send a SIGUSR1 signal to the current process. Note that this uses `raise` instead of `kill`
+    // because `kill` with `getpid` isn't correct during multi-threaded execution like during a
+    // cargo test session. Instead use `raise` which does the correct thing by default.
+    raise(signal::SIGUSR1).expect("Error: raise(SIGUSR1) failed");
+
+    // And now catch that same signal.
+    let res = fd.read_signal().unwrap().unwrap();
+    let signo = Signal::try_from(res.ssi_signo as i32).unwrap();
+    assert_eq!(signo, signal::SIGUSR1);
+}
+
+/// Update the signal mask of an already existing signalfd.
+#[test]
+fn test_signalfd_setmask() {
+    use nix::sys::signal::{self, raise, SigSet, Signal};
+    use nix::sys::signalfd::SignalFd;
+
+    // Grab the mutex for altering signals so we don't interfere with other tests.
+    let _m = crate::SIGNAL_MTX.lock();
+
+    // Block the SIGUSR1 signal from automatic processing for this thread
+    let mut mask = SigSet::empty();
+
+    let fd = SignalFd::new(&mask).unwrap();
+
+    mask.add(signal::SIGUSR1);
+    mask.thread_block().unwrap();
+    fd.set_mask(&mask).unwrap();
+
+    // Send a SIGUSR1 signal to the current process. Note that this uses `raise` instead of `kill`
+    // because `kill` with `getpid` isn't correct during multi-threaded execution like during a
+    // cargo test session. Instead use `raise` which does the correct thing by default.
+    raise(signal::SIGUSR1).expect("Error: raise(SIGUSR1) failed");
+
+    // And now catch that same signal.
+    let res = fd.read_signal().unwrap().unwrap();
+    let signo = Signal::try_from(res.ssi_signo as i32).unwrap();
+    assert_eq!(signo, signal::SIGUSR1);
+}

vendor/nix/test/sys/test_stat.rs

@@ -0,0 +1,508 @@
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use std::fs;
+use std::fs::File;
+#[cfg(not(target_os = "redox"))]
+use std::os::unix::fs::symlink;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use std::os::unix::fs::PermissionsExt;
+#[cfg(not(target_os = "redox"))]
+use std::path::Path;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use std::time::{Duration, UNIX_EPOCH};
+
+use libc::mode_t;
+#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
+use libc::{S_IFLNK, S_IFMT};
+
+#[cfg(not(target_os = "redox"))]
+use nix::errno::Errno;
+#[cfg(not(target_os = "redox"))]
+use nix::fcntl;
+#[cfg(any(
+    target_os = "linux",
+    apple_targets,
+    target_os = "freebsd",
+    target_os = "netbsd"
+))]
+use nix::sys::stat::lutimes;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use nix::sys::stat::utimensat;
+#[cfg(not(target_os = "redox"))]
+use nix::sys::stat::FchmodatFlags;
+use nix::sys::stat::Mode;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use nix::sys::stat::UtimensatFlags;
+#[cfg(not(target_os = "redox"))]
+use nix::sys::stat::{self};
+use nix::sys::stat::{fchmod, stat};
+#[cfg(not(target_os = "redox"))]
+use nix::sys::stat::{fchmodat, mkdirat};
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use nix::sys::stat::{futimens, utimes};
+
+#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
+use nix::sys::stat::FileStat;
+
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use nix::sys::time::{TimeSpec, TimeVal, TimeValLike};
+#[cfg(not(target_os = "redox"))]
+use nix::unistd::chdir;
+
+#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
+use nix::Result;
+
+#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
+fn assert_stat_results(stat_result: Result<FileStat>) {
+    let stats = stat_result.expect("stat call failed");
+    assert!(stats.st_dev > 0); // must be positive integer, exact number machine dependent
+    assert!(stats.st_ino > 0); // inode is positive integer, exact number machine dependent
+    assert!(stats.st_mode > 0); // must be positive integer
+    assert_eq!(stats.st_nlink, 1); // there links created, must be 1
+    assert_eq!(stats.st_size, 0); // size is 0 because we did not write anything to the file
+    assert!(stats.st_blksize > 0); // must be positive integer, exact number machine dependent
+    assert!(stats.st_blocks <= 16); // Up to 16 blocks can be allocated for a blank file
+}
+
+#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
+// (Android's st_blocks is ulonglong which is always non-negative.)
+#[cfg_attr(target_os = "android", allow(unused_comparisons))]
+#[allow(clippy::absurd_extreme_comparisons)] // Not absurd on all OSes
+fn assert_lstat_results(stat_result: Result<FileStat>) {
+    let stats = stat_result.expect("stat call failed");
+    assert!(stats.st_dev > 0); // must be positive integer, exact number machine dependent
+    assert!(stats.st_ino > 0); // inode is positive integer, exact number machine dependent
+    assert!(stats.st_mode > 0); // must be positive integer
+
+    // st_mode is c_uint (u32 on Android) while S_IFMT is mode_t
+    // (u16 on Android), and that will be a compile error.
+    // On other platforms they are the same (either both are u16 or u32).
+    assert_eq!(
+        (stats.st_mode as usize) & (S_IFMT as usize),
+        S_IFLNK as usize
+    ); // should be a link
+    assert_eq!(stats.st_nlink, 1); // there links created, must be 1
+    assert!(stats.st_size > 0); // size is > 0 because it points to another file
+    assert!(stats.st_blksize > 0); // must be positive integer, exact number machine dependent
+
+    // st_blocks depends on whether the machine's file system uses fast
+    // or slow symlinks, so just make sure it's not negative
+    assert!(stats.st_blocks >= 0);
+}
+
+#[test]
+#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
+fn test_stat_and_fstat() {
+    use nix::sys::stat::fstat;
+
+    let tempdir = tempfile::tempdir().unwrap();
+    let filename = tempdir.path().join("foo.txt");
+    let file = File::create(&filename).unwrap();
+
+    let stat_result = stat(&filename);
+    assert_stat_results(stat_result);
+
+    let fstat_result = fstat(&file);
+    assert_stat_results(fstat_result);
+}
+
+#[test]
+#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
+fn test_fstatat() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let filename = tempdir.path().join("foo.txt");
+    File::create(&filename).unwrap();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
+
+    let result = stat::fstatat(&dirfd, &filename, fcntl::AtFlags::empty());
+    assert_stat_results(result);
+}
+
+#[test]
+#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
+fn test_stat_fstat_lstat() {
+    use nix::sys::stat::{fstat, lstat};
+
+    let tempdir = tempfile::tempdir().unwrap();
+    let filename = tempdir.path().join("bar.txt");
+    let linkname = tempdir.path().join("barlink");
+
+    File::create(&filename).unwrap();
+    symlink("bar.txt", &linkname).unwrap();
+    let link = File::open(&linkname).unwrap();
+
+    // should be the same result as calling stat,
+    // since it's a regular file
+    let stat_result = stat(&filename);
+    assert_stat_results(stat_result);
+
+    let lstat_result = lstat(&linkname);
+    assert_lstat_results(lstat_result);
+
+    let fstat_result = fstat(&link);
+    assert_stat_results(fstat_result);
+}
+
+#[test]
+fn test_fchmod() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let filename = tempdir.path().join("foo.txt");
+    let file = File::create(&filename).unwrap();
+
+    let mut mode1 = Mode::empty();
+    mode1.insert(Mode::S_IRUSR);
+    mode1.insert(Mode::S_IWUSR);
+    fchmod(&file, mode1).unwrap();
+
+    let file_stat1 = stat(&filename).unwrap();
+    assert_eq!(file_stat1.st_mode as mode_t & 0o7777, mode1.bits());
+
+    let mut mode2 = Mode::empty();
+    mode2.insert(Mode::S_IROTH);
+    fchmod(&file, mode2).unwrap();
+
+    let file_stat2 = stat(&filename).unwrap();
+    assert_eq!(file_stat2.st_mode as mode_t & 0o7777, mode2.bits());
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_fchmodat() {
+    let _dr = crate::DirRestore::new();
+    let tempdir = tempfile::tempdir().unwrap();
+    let filename = "foo.txt";
+    let fullpath = tempdir.path().join(filename);
+    File::create(&fullpath).unwrap();
+
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
+
+    let mut mode1 = Mode::empty();
+    mode1.insert(Mode::S_IRUSR);
+    mode1.insert(Mode::S_IWUSR);
+    fchmodat(&dirfd, filename, mode1, FchmodatFlags::FollowSymlink).unwrap();
+
+    let file_stat1 = stat(&fullpath).unwrap();
+    assert_eq!(file_stat1.st_mode as mode_t & 0o7777, mode1.bits());
+
+    chdir(tempdir.path()).unwrap();
+
+    let mut mode2 = Mode::empty();
+    mode2.insert(Mode::S_IROTH);
+    fchmodat(
+        fcntl::AT_FDCWD,
+        filename,
+        mode2,
+        FchmodatFlags::FollowSymlink,
+    )
+    .unwrap();
+
+    let file_stat2 = stat(&fullpath).unwrap();
+    assert_eq!(file_stat2.st_mode as mode_t & 0o7777, mode2.bits());
+}
+
+/// Asserts that the atime and mtime in a file's metadata match expected values.
+///
+/// The atime and mtime are expressed with a resolution of seconds because some file systems
+/// (like macOS's HFS+) do not have higher granularity.
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn assert_times_eq(
+    exp_atime_sec: u64,
+    exp_mtime_sec: u64,
+    attr: &fs::Metadata,
+) {
+    assert_eq!(
+        Duration::new(exp_atime_sec, 0),
+        attr.accessed().unwrap().duration_since(UNIX_EPOCH).unwrap()
+    );
+    assert_eq!(
+        Duration::new(exp_mtime_sec, 0),
+        attr.modified().unwrap().duration_since(UNIX_EPOCH).unwrap()
+    );
+}
+
+#[test]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn test_utimes() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let fullpath = tempdir.path().join("file");
+    drop(File::create(&fullpath).unwrap());
+
+    utimes(&fullpath, &TimeVal::seconds(9990), &TimeVal::seconds(5550))
+        .unwrap();
+    assert_times_eq(9990, 5550, &fs::metadata(&fullpath).unwrap());
+}
+
+#[test]
+#[cfg(any(
+    target_os = "linux",
+    apple_targets,
+    target_os = "freebsd",
+    target_os = "netbsd"
+))]
+fn test_lutimes() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let target = tempdir.path().join("target");
+    let fullpath = tempdir.path().join("symlink");
+    drop(File::create(&target).unwrap());
+    symlink(&target, &fullpath).unwrap();
+
+    let exp_target_metadata = fs::symlink_metadata(&target).unwrap();
+    lutimes(&fullpath, &TimeVal::seconds(4560), &TimeVal::seconds(1230))
+        .unwrap();
+    assert_times_eq(4560, 1230, &fs::symlink_metadata(&fullpath).unwrap());
+
+    let target_metadata = fs::symlink_metadata(&target).unwrap();
+    assert_eq!(
+        exp_target_metadata.accessed().unwrap(),
+        target_metadata.accessed().unwrap(),
+        "atime of symlink target was unexpectedly modified"
+    );
+    assert_eq!(
+        exp_target_metadata.modified().unwrap(),
+        target_metadata.modified().unwrap(),
+        "mtime of symlink target was unexpectedly modified"
+    );
+}
+
+#[test]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn test_futimens() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let fullpath = tempdir.path().join("file");
+    drop(File::create(&fullpath).unwrap());
+
+    let fd = fcntl::open(&fullpath, fcntl::OFlag::empty(), stat::Mode::empty())
+        .unwrap();
+
+    futimens(&fd, &TimeSpec::seconds(10), &TimeSpec::seconds(20)).unwrap();
+    assert_times_eq(10, 20, &fs::metadata(&fullpath).unwrap());
+}
+
+#[test]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn test_utimensat() {
+    let _dr = crate::DirRestore::new();
+    let tempdir = tempfile::tempdir().unwrap();
+    let filename = "foo.txt";
+    let fullpath = tempdir.path().join(filename);
+    drop(File::create(&fullpath).unwrap());
+
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
+
+    utimensat(
+        &dirfd,
+        filename,
+        &TimeSpec::seconds(12345),
+        &TimeSpec::seconds(678),
+        UtimensatFlags::FollowSymlink,
+    )
+    .unwrap();
+    assert_times_eq(12345, 678, &fs::metadata(&fullpath).unwrap());
+
+    chdir(tempdir.path()).unwrap();
+
+    utimensat(
+        fcntl::AT_FDCWD,
+        filename,
+        &TimeSpec::seconds(500),
+        &TimeSpec::seconds(800),
+        UtimensatFlags::FollowSymlink,
+    )
+    .unwrap();
+    assert_times_eq(500, 800, &fs::metadata(&fullpath).unwrap());
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_mkdirat_success_path() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let filename = "example_subdir";
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
+    mkdirat(&dirfd, filename, Mode::S_IRWXU).expect("mkdirat failed");
+    assert!(Path::exists(&tempdir.path().join(filename)));
+}
+
+#[test]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn test_mkdirat_success_mode() {
+    let expected_bits =
+        stat::SFlag::S_IFDIR.bits() | stat::Mode::S_IRWXU.bits();
+    let tempdir = tempfile::tempdir().unwrap();
+    let filename = "example_subdir";
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
+    mkdirat(&dirfd, filename, Mode::S_IRWXU).expect("mkdirat failed");
+    let permissions = fs::metadata(tempdir.path().join(filename))
+        .unwrap()
+        .permissions();
+    let mode = permissions.mode();
+    assert_eq!(mode as mode_t, expected_bits)
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_mkdirat_fail() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let not_dir_filename = "example_not_dir";
+    let filename = "example_subdir_dir";
+    let dirfd = fcntl::open(
+        &tempdir.path().join(not_dir_filename),
+        fcntl::OFlag::O_CREAT,
+        stat::Mode::empty(),
+    )
+    .unwrap();
+    let result = mkdirat(dirfd, filename, Mode::S_IRWXU).unwrap_err();
+    assert_eq!(result, Errno::ENOTDIR);
+}
+
+#[test]
+#[cfg(not(any(
+    freebsdlike,
+    apple_targets,
+    target_os = "haiku",
+    target_os = "redox",
+    target_os = "solaris"
+)))]
+fn test_mknod() {
+    use stat::{lstat, mknod, SFlag};
+
+    let file_name = "test_file";
+    let tempdir = tempfile::tempdir().unwrap();
+    let target = tempdir.path().join(file_name);
+    mknod(&target, SFlag::S_IFREG, Mode::S_IRWXU, 0).unwrap();
+    let mode = lstat(&target).unwrap().st_mode as mode_t;
+    assert_eq!(mode & libc::S_IFREG, libc::S_IFREG);
+    assert_eq!(mode & libc::S_IRWXU, libc::S_IRWXU);
+}
+
+#[test]
+#[cfg(not(any(
+    solarish,
+    freebsdlike,
+    apple_targets,
+    target_os = "haiku",
+    target_os = "redox"
+)))]
+fn test_mknodat() {
+    use fcntl::{AtFlags, OFlag};
+    use nix::dir::Dir;
+    use stat::{fstatat, mknodat, SFlag};
+
+    let file_name = "test_file";
+    let tempdir = tempfile::tempdir().unwrap();
+    let target_dir =
+        Dir::open(tempdir.path(), OFlag::O_DIRECTORY, Mode::S_IRWXU).unwrap();
+    mknodat(&target_dir, file_name, SFlag::S_IFREG, Mode::S_IRWXU, 0).unwrap();
+    let mode = fstatat(&target_dir, file_name, AtFlags::AT_SYMLINK_NOFOLLOW)
+        .unwrap()
+        .st_mode as mode_t;
+    assert_eq!(mode & libc::S_IFREG, libc::S_IFREG);
+    assert_eq!(mode & libc::S_IRWXU, libc::S_IRWXU);
+}
+
+#[test]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn test_futimens_unchanged() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let fullpath = tempdir.path().join("file");
+    drop(File::create(&fullpath).unwrap());
+    let fd = fcntl::open(&fullpath, fcntl::OFlag::empty(), stat::Mode::empty())
+        .unwrap();
+
+    let old_atime = fs::metadata(fullpath.as_path())
+        .unwrap()
+        .accessed()
+        .unwrap();
+    let old_mtime = fs::metadata(fullpath.as_path())
+        .unwrap()
+        .modified()
+        .unwrap();
+
+    futimens(&fd, &TimeSpec::UTIME_OMIT, &TimeSpec::UTIME_OMIT).unwrap();
+
+    let new_atime = fs::metadata(fullpath.as_path())
+        .unwrap()
+        .accessed()
+        .unwrap();
+    let new_mtime = fs::metadata(fullpath.as_path())
+        .unwrap()
+        .modified()
+        .unwrap();
+    assert_eq!(old_atime, new_atime);
+    assert_eq!(old_mtime, new_mtime);
+}
+
+#[test]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn test_utimensat_unchanged() {
+    let _dr = crate::DirRestore::new();
+    let tempdir = tempfile::tempdir().unwrap();
+    let filename = "foo.txt";
+    let fullpath = tempdir.path().join(filename);
+    drop(File::create(&fullpath).unwrap());
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
+
+    let old_atime = fs::metadata(fullpath.as_path())
+        .unwrap()
+        .accessed()
+        .unwrap();
+    let old_mtime = fs::metadata(fullpath.as_path())
+        .unwrap()
+        .modified()
+        .unwrap();
+    utimensat(
+        &dirfd,
+        filename,
+        &TimeSpec::UTIME_OMIT,
+        &TimeSpec::UTIME_OMIT,
+        UtimensatFlags::NoFollowSymlink,
+    )
+    .unwrap();
+    let new_atime = fs::metadata(fullpath.as_path())
+        .unwrap()
+        .accessed()
+        .unwrap();
+    let new_mtime = fs::metadata(fullpath.as_path())
+        .unwrap()
+        .modified()
+        .unwrap();
+    assert_eq!(old_atime, new_atime);
+    assert_eq!(old_mtime, new_mtime);
+}
+
+// The conversion is not useless on all platforms.
+#[allow(clippy::useless_conversion)]
+#[cfg(target_os = "freebsd")]
+#[test]
+fn test_chflags() {
+    use nix::{
+        sys::stat::{fstat, FileFlag},
+        unistd::chflags,
+    };
+    use tempfile::NamedTempFile;
+
+    let f = NamedTempFile::new().unwrap();
+
+    let initial =
+        FileFlag::from_bits_truncate(fstat(&f).unwrap().st_flags.into());
+    // UF_OFFLINE is preserved by all FreeBSD file systems, but not interpreted
+    // in any way, so it's handy for testing.
+    let commanded = initial ^ FileFlag::UF_OFFLINE;
+
+    chflags(f.path(), commanded).unwrap();
+
+    let changed =
+        FileFlag::from_bits_truncate(fstat(&f).unwrap().st_flags.into());
+
+    assert_eq!(commanded, changed);
+}

vendor/nix/test/sys/test_statfs.rs

@@ -0,0 +1,98 @@
+use nix::sys::statfs::*;
+use nix::sys::statvfs::*;
+use std::fs::File;
+use std::path::Path;
+
+fn check_fstatfs(path: &str) {
+    if !Path::new(path).exists() {
+        return;
+    }
+    let vfs = statvfs(path.as_bytes()).unwrap();
+    let file = File::open(path).unwrap();
+    let fs = fstatfs(&file).unwrap();
+    assert_fs_equals(fs, vfs);
+}
+
+fn check_statfs(path: &str) {
+    if !Path::new(path).exists() {
+        return;
+    }
+    let vfs = statvfs(path.as_bytes()).unwrap();
+    let fs = statfs(path.as_bytes()).unwrap();
+    assert_fs_equals(fs, vfs);
+}
+
+fn check_fstatfs_strict(path: &str) {
+    if !Path::new(path).exists() {
+        return;
+    }
+    let vfs = statvfs(path.as_bytes());
+    let file = File::open(path).unwrap();
+    let fs = fstatfs(&file);
+    assert_fs_equals_strict(fs.unwrap(), vfs.unwrap())
+}
+
+fn check_statfs_strict(path: &str) {
+    if !Path::new(path).exists() {
+        return;
+    }
+    let vfs = statvfs(path.as_bytes());
+    let fs = statfs(path.as_bytes());
+    assert_fs_equals_strict(fs.unwrap(), vfs.unwrap())
+}
+
+// The cast is not unnecessary on all platforms.
+#[allow(clippy::unnecessary_cast)]
+fn assert_fs_equals(fs: Statfs, vfs: Statvfs) {
+    assert_eq!(fs.blocks() as u64, vfs.blocks() as u64);
+    assert_eq!(fs.block_size() as u64, vfs.fragment_size() as u64);
+}
+
+#[test]
+fn statfs_call() {
+    check_statfs("/tmp");
+    check_statfs("/dev");
+    check_statfs("/run");
+    check_statfs("/");
+}
+
+#[test]
+fn fstatfs_call() {
+    check_fstatfs("/tmp");
+    check_fstatfs("/dev");
+    check_fstatfs("/run");
+    check_fstatfs("/");
+}
+
+// This test is ignored because files_free/blocks_free can change after statvfs call and before
+// statfs call.
+#[test]
+#[ignore]
+fn statfs_call_strict() {
+    check_statfs_strict("/tmp");
+    check_statfs_strict("/dev");
+    check_statfs_strict("/run");
+    check_statfs_strict("/");
+}
+
+// This test is ignored because files_free/blocks_free can change after statvfs call and before
+// fstatfs call.
+#[test]
+#[ignore]
+fn fstatfs_call_strict() {
+    check_fstatfs_strict("/tmp");
+    check_fstatfs_strict("/dev");
+    check_fstatfs_strict("/run");
+    check_fstatfs_strict("/");
+}
+
+// The cast is not unnecessary on all platforms.
+#[allow(clippy::unnecessary_cast)]
+fn assert_fs_equals_strict(fs: Statfs, vfs: Statvfs) {
+    assert_eq!(fs.files_free() as u64, vfs.files_free() as u64);
+    assert_eq!(fs.blocks_free() as u64, vfs.blocks_free() as u64);
+    assert_eq!(fs.blocks_available() as u64, vfs.blocks_available() as u64);
+    assert_eq!(fs.files() as u64, vfs.files() as u64);
+    assert_eq!(fs.blocks() as u64, vfs.blocks() as u64);
+    assert_eq!(fs.block_size() as u64, vfs.fragment_size() as u64);
+}

vendor/nix/test/sys/test_statvfs.rs

@@ -0,0 +1,13 @@
+use nix::sys::statvfs::*;
+use std::fs::File;
+
+#[test]
+fn statvfs_call() {
+    statvfs(&b"/"[..]).unwrap();
+}
+
+#[test]
+fn fstatvfs_call() {
+    let root = File::open("/").unwrap();
+    fstatvfs(&root).unwrap();
+}

vendor/nix/test/sys/test_sysinfo.rs

@@ -0,0 +1,20 @@
+use nix::sys::sysinfo::*;
+
+#[test]
+fn sysinfo_works() {
+    let info = sysinfo().unwrap();
+
+    let (l1, l5, l15) = info.load_average();
+    assert!(l1 >= 0.0);
+    assert!(l5 >= 0.0);
+    assert!(l15 >= 0.0);
+
+    info.uptime(); // just test Duration construction
+
+    assert!(
+        info.swap_free() <= info.swap_total(),
+        "more swap available than installed (free: {}, total: {})",
+        info.swap_free(),
+        info.swap_total()
+    );
+}

vendor/nix/test/sys/test_termios.rs

@@ -0,0 +1,117 @@
+use std::os::unix::io::AsFd;
+use tempfile::tempfile;
+
+use nix::errno::Errno;
+use nix::fcntl;
+use nix::pty::openpty;
+use nix::sys::termios::{self, tcgetattr, BaudRate, LocalFlags, OutputFlags};
+use nix::unistd::{read, write};
+
+/// Helper function analogous to `std::io::Write::write_all`, but for `Fd`s
+fn write_all<Fd: AsFd>(f: Fd, buf: &[u8]) {
+    let mut len = 0;
+    while len < buf.len() {
+        len += write(f.as_fd(), &buf[len..]).unwrap();
+    }
+}
+
+#[test]
+fn test_baudrate_try_from() {
+    assert_eq!(Ok(BaudRate::B0), BaudRate::try_from(libc::B0));
+    #[cfg(not(target_os = "haiku"))]
+    BaudRate::try_from(999999999).expect_err("assertion failed");
+    #[cfg(target_os = "haiku")]
+    BaudRate::try_from(99).expect_err("assertion failed");
+}
+
+// Test tcgetattr on a terminal
+#[test]
+fn test_tcgetattr_pty() {
+    // openpty uses ptname(3) internally
+    let _m = crate::PTSNAME_MTX.lock();
+
+    let pty = openpty(None, None).expect("openpty failed");
+    termios::tcgetattr(&pty.slave).unwrap();
+}
+
+// Test tcgetattr on something that isn't a terminal
+#[test]
+fn test_tcgetattr_enotty() {
+    let file = tempfile().unwrap();
+    assert_eq!(termios::tcgetattr(&file).err(), Some(Errno::ENOTTY));
+}
+
+// Test modifying output flags
+#[test]
+fn test_output_flags() {
+    // openpty uses ptname(3) internally
+    let _m = crate::PTSNAME_MTX.lock();
+
+    // Open one pty to get attributes for the second one
+    let mut termios = {
+        let pty = openpty(None, None).expect("openpty failed");
+        tcgetattr(&pty.slave).expect("tcgetattr failed")
+    };
+
+    // Make sure postprocessing '\r' isn't specified by default or this test is useless.
+    assert!(!termios
+        .output_flags
+        .contains(OutputFlags::OPOST | OutputFlags::OCRNL));
+
+    // Specify that '\r' characters should be transformed to '\n'
+    // OPOST is specified to enable post-processing
+    termios
+        .output_flags
+        .insert(OutputFlags::OPOST | OutputFlags::OCRNL);
+
+    // Open a pty
+    let pty = openpty(None, &termios).unwrap();
+
+    // Write into the master
+    let string = "foofoofoo\r";
+    write_all(&pty.master, string.as_bytes());
+
+    // Read from the slave verifying that the output has been properly transformed
+    let mut buf = [0u8; 10];
+    crate::read_exact(&pty.slave, &mut buf);
+    let transformed_string = "foofoofoo\n";
+    assert_eq!(&buf, transformed_string.as_bytes());
+}
+
+// Test modifying local flags
+#[test]
+#[cfg(not(target_os = "solaris"))]
+fn test_local_flags() {
+    // openpty uses ptname(3) internally
+    let _m = crate::PTSNAME_MTX.lock();
+
+    // Open one pty to get attributes for the second one
+    let mut termios = {
+        let pty = openpty(None, None).unwrap();
+        tcgetattr(&pty.slave).unwrap()
+    };
+
+    // Make sure echo is specified by default or this test is useless.
+    assert!(termios.local_flags.contains(LocalFlags::ECHO));
+
+    // Disable local echo
+    termios.local_flags.remove(LocalFlags::ECHO);
+
+    // Open a new pty with our modified termios settings
+    let pty = openpty(None, &termios).unwrap();
+
+    // Set the master is in nonblocking mode or reading will never return.
+    let flags = fcntl::fcntl(&pty.master, fcntl::F_GETFL).unwrap();
+    let new_flags =
+        fcntl::OFlag::from_bits_truncate(flags) | fcntl::OFlag::O_NONBLOCK;
+    fcntl::fcntl(pty.master.as_fd(), fcntl::F_SETFL(new_flags)).unwrap();
+
+    // Write into the master
+    let string = "foofoofoo\r";
+    write_all(&pty.master, string.as_bytes());
+
+    // Try to read from the master, which should not have anything as echoing was disabled.
+    let mut buf = [0u8; 10];
+    let read = read(&pty.master, &mut buf).unwrap_err();
+    assert_eq!(read, Errno::EAGAIN);
+}

vendor/nix/test/sys/test_time.rs

@@ -0,0 +1,91 @@
+use nix::sys::time::{TimeSpec, TimeVal, TimeValLike};
+use std::time::Duration;
+
+#[test]
+pub fn test_timespec() {
+    assert_ne!(TimeSpec::seconds(1), TimeSpec::zero());
+    assert_eq!(
+        TimeSpec::seconds(1) + TimeSpec::seconds(2),
+        TimeSpec::seconds(3)
+    );
+    assert_eq!(
+        TimeSpec::minutes(3) + TimeSpec::seconds(2),
+        TimeSpec::seconds(182)
+    );
+}
+
+#[test]
+pub fn test_timespec_from() {
+    let duration = Duration::new(123, 123_456_789);
+    let timespec = TimeSpec::nanoseconds(123_123_456_789);
+
+    assert_eq!(TimeSpec::from(duration), timespec);
+    assert_eq!(Duration::from(timespec), duration);
+}
+
+#[test]
+pub fn test_timespec_neg() {
+    let a = TimeSpec::seconds(1) + TimeSpec::nanoseconds(123);
+    let b = TimeSpec::seconds(-1) + TimeSpec::nanoseconds(-123);
+
+    assert_eq!(a, -b);
+}
+
+#[test]
+pub fn test_timespec_ord() {
+    assert_eq!(TimeSpec::seconds(1), TimeSpec::nanoseconds(1_000_000_000));
+    assert!(TimeSpec::seconds(1) < TimeSpec::nanoseconds(1_000_000_001));
+    assert!(TimeSpec::seconds(1) > TimeSpec::nanoseconds(999_999_999));
+    assert!(TimeSpec::seconds(-1) < TimeSpec::nanoseconds(-999_999_999));
+    assert!(TimeSpec::seconds(-1) > TimeSpec::nanoseconds(-1_000_000_001));
+}
+
+#[test]
+pub fn test_timespec_fmt() {
+    assert_eq!(TimeSpec::zero().to_string(), "0 seconds");
+    assert_eq!(TimeSpec::seconds(42).to_string(), "42 seconds");
+    assert_eq!(TimeSpec::milliseconds(42).to_string(), "0.042 seconds");
+    assert_eq!(TimeSpec::microseconds(42).to_string(), "0.000042 seconds");
+    assert_eq!(TimeSpec::nanoseconds(42).to_string(), "0.000000042 seconds");
+    assert_eq!(TimeSpec::seconds(-86401).to_string(), "-86401 seconds");
+}
+
+#[test]
+pub fn test_timeval() {
+    assert_ne!(TimeVal::seconds(1), TimeVal::zero());
+    assert_eq!(
+        TimeVal::seconds(1) + TimeVal::seconds(2),
+        TimeVal::seconds(3)
+    );
+    assert_eq!(
+        TimeVal::minutes(3) + TimeVal::seconds(2),
+        TimeVal::seconds(182)
+    );
+}
+
+#[test]
+pub fn test_timeval_ord() {
+    assert_eq!(TimeVal::seconds(1), TimeVal::microseconds(1_000_000));
+    assert!(TimeVal::seconds(1) < TimeVal::microseconds(1_000_001));
+    assert!(TimeVal::seconds(1) > TimeVal::microseconds(999_999));
+    assert!(TimeVal::seconds(-1) < TimeVal::microseconds(-999_999));
+    assert!(TimeVal::seconds(-1) > TimeVal::microseconds(-1_000_001));
+}
+
+#[test]
+pub fn test_timeval_neg() {
+    let a = TimeVal::seconds(1) + TimeVal::microseconds(123);
+    let b = TimeVal::seconds(-1) + TimeVal::microseconds(-123);
+
+    assert_eq!(a, -b);
+}
+
+#[test]
+pub fn test_timeval_fmt() {
+    assert_eq!(TimeVal::zero().to_string(), "0 seconds");
+    assert_eq!(TimeVal::seconds(42).to_string(), "42 seconds");
+    assert_eq!(TimeVal::milliseconds(42).to_string(), "0.042 seconds");
+    assert_eq!(TimeVal::microseconds(42).to_string(), "0.000042 seconds");
+    assert_eq!(TimeVal::nanoseconds(1402).to_string(), "0.000001 seconds");
+    assert_eq!(TimeVal::seconds(-86401).to_string(), "-86401 seconds");
+}

vendor/nix/test/sys/test_timer.rs

@@ -0,0 +1,102 @@
+use nix::sys::signal::{
+    sigaction, SaFlags, SigAction, SigEvent, SigHandler, SigSet, SigevNotify,
+    Signal,
+};
+use nix::sys::timer::{Expiration, Timer, TimerSetTimeFlags};
+use nix::time::ClockId;
+use std::convert::TryFrom;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::thread;
+use std::time::{Duration, Instant};
+
+const SIG: Signal = Signal::SIGALRM;
+static ALARM_CALLED: AtomicBool = AtomicBool::new(false);
+
+pub extern "C" fn handle_sigalarm(raw_signal: libc::c_int) {
+    let signal = Signal::try_from(raw_signal).unwrap();
+    if signal == SIG {
+        ALARM_CALLED.store(true, Ordering::Release);
+    }
+}
+
+#[test]
+fn alarm_fires() {
+    // Avoid interfering with other signal using tests by taking a mutex shared
+    // among other tests in this crate.
+    let _m = crate::SIGNAL_MTX.lock();
+    const TIMER_PERIOD: Duration = Duration::from_millis(100);
+
+    //
+    // Setup
+    //
+
+    // Create a handler for the test signal, `SIG`. The handler is responsible
+    // for flipping `ALARM_CALLED`.
+    let handler = SigHandler::Handler(handle_sigalarm);
+    let signal_action =
+        SigAction::new(handler, SaFlags::SA_RESTART, SigSet::empty());
+    let old_handler = unsafe {
+        sigaction(SIG, &signal_action)
+            .expect("unable to set signal handler for alarm")
+    };
+
+    // Create the timer. We use the monotonic clock here, though any would do
+    // really. The timer is set to fire every 250 milliseconds with no delay for
+    // the initial firing.
+    let clockid = ClockId::CLOCK_MONOTONIC;
+    let sigevent = SigEvent::new(SigevNotify::SigevSignal {
+        signal: SIG,
+        si_value: 0,
+    });
+    let mut timer =
+        Timer::new(clockid, sigevent).expect("failed to create timer");
+    let expiration = Expiration::Interval(TIMER_PERIOD.into());
+    let flags = TimerSetTimeFlags::empty();
+    timer.set(expiration, flags).expect("could not set timer");
+
+    //
+    // Test
+    //
+
+    // Determine that there's still an expiration tracked by the
+    // timer. Depending on when this runs either an `Expiration::Interval` or
+    // `Expiration::IntervalDelayed` will be present. That is, if the timer has
+    // not fired yet we'll get our original `expiration`, else the one that
+    // represents a delay to the next expiration. We're only interested in the
+    // timer still being extant.
+    match timer.get() {
+        Ok(Some(exp)) => assert!(matches!(
+            exp,
+            Expiration::Interval(..) | Expiration::IntervalDelayed(..)
+        )),
+        _ => panic!("timer lost its expiration"),
+    }
+
+    // Wait for 2 firings of the alarm before checking that it has fired and
+    // been handled at least the once. If we wait for 3 seconds and the handler
+    // is never called something has gone sideways and the test fails.
+    let starttime = Instant::now();
+    loop {
+        thread::sleep(2 * TIMER_PERIOD);
+        if ALARM_CALLED.load(Ordering::Acquire) {
+            break;
+        }
+        if starttime.elapsed() > Duration::from_secs(3) {
+            panic!("Timeout waiting for SIGALRM");
+        }
+    }
+
+    // Cleanup:
+    // 1) deregister the OS's timer.
+    // 2) Wait for a full timer period, since POSIX does not require that
+    //    disabling the timer will clear pending signals, and on NetBSD at least
+    //    it does not.
+    // 2) Replace the old signal handler now that we've completed the test. If
+    //    the test fails this process panics, so the fact we might not get here
+    //    is okay.
+    drop(timer);
+    thread::sleep(TIMER_PERIOD);
+    unsafe {
+        sigaction(SIG, &old_handler).expect("unable to reset signal handler");
+    }
+}

vendor/nix/test/sys/test_timerfd.rs

@@ -0,0 +1,69 @@
+use nix::sys::time::{TimeSpec, TimeValLike};
+use nix::sys::timerfd::{
+    ClockId, Expiration, TimerFd, TimerFlags, TimerSetTimeFlags,
+};
+use std::time::Instant;
+
+#[test]
+pub fn test_timerfd_oneshot() {
+    let timer =
+        TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
+
+    let before = Instant::now();
+
+    timer
+        .set(
+            Expiration::OneShot(TimeSpec::seconds(1)),
+            TimerSetTimeFlags::empty(),
+        )
+        .unwrap();
+
+    timer.wait().unwrap();
+
+    let millis = before.elapsed().as_millis();
+    assert!(millis > 900);
+}
+
+#[test]
+pub fn test_timerfd_interval() {
+    let timer =
+        TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
+
+    let before = Instant::now();
+    timer
+        .set(
+            Expiration::IntervalDelayed(
+                TimeSpec::seconds(1),
+                TimeSpec::seconds(2),
+            ),
+            TimerSetTimeFlags::empty(),
+        )
+        .unwrap();
+
+    timer.wait().unwrap();
+
+    let start_delay = before.elapsed().as_millis();
+    assert!(start_delay > 900);
+
+    timer.wait().unwrap();
+
+    let interval_delay = before.elapsed().as_millis();
+    assert!(interval_delay > 2900);
+}
+
+#[test]
+pub fn test_timerfd_unset() {
+    let timer =
+        TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
+
+    timer
+        .set(
+            Expiration::OneShot(TimeSpec::seconds(1)),
+            TimerSetTimeFlags::empty(),
+        )
+        .unwrap();
+
+    timer.unset().unwrap();
+
+    assert!(timer.get().unwrap().is_none());
+}

vendor/nix/test/sys/test_uio.rs

@@ -0,0 +1,277 @@
+use nix::sys::uio::*;
+use nix::unistd::*;
+use rand::distr::Alphanumeric;
+use rand::{rng, Rng};
+use std::fs::OpenOptions;
+use std::io::IoSlice;
+use std::{cmp, iter};
+
+#[cfg(not(target_os = "redox"))]
+use std::io::IoSliceMut;
+
+use tempfile::tempdir;
+#[cfg(not(target_os = "redox"))]
+use tempfile::tempfile;
+
+#[test]
+// On Solaris sometimes wrtitev() returns EINVAL.
+#[cfg(not(target_os = "solaris"))]
+fn test_writev() {
+    let mut to_write = Vec::with_capacity(16 * 128);
+    for _ in 0..16 {
+        let s: String = rng()
+            .sample_iter(&Alphanumeric)
+            .map(char::from)
+            .take(128)
+            .collect();
+        let b = s.as_bytes();
+        to_write.extend(b.iter().cloned());
+    }
+    // Allocate and fill iovecs
+    let mut iovecs = Vec::new();
+    let mut consumed = 0;
+    while consumed < to_write.len() {
+        let left = to_write.len() - consumed;
+        let slice_len = if left <= 64 {
+            left
+        } else {
+            rng().random_range(64..cmp::min(256, left))
+        };
+        let b = &to_write[consumed..consumed + slice_len];
+        iovecs.push(IoSlice::new(b));
+        consumed += slice_len;
+    }
+    let (reader, writer) = pipe().expect("Couldn't create pipe");
+    // FileDesc will close its filedesc (reader).
+    let mut read_buf: Vec<u8> = iter::repeat(0u8).take(128 * 16).collect();
+
+    // Blocking io, should write all data.
+    let write_res = writev(&writer, &iovecs);
+    let written = write_res.expect("couldn't write");
+    // Check whether we written all data
+    assert_eq!(to_write.len(), written);
+    let read_res = read(&reader, &mut read_buf[..]);
+    let read = read_res.expect("couldn't read");
+    // Check we have read as much as we written
+    assert_eq!(read, written);
+    // Check equality of written and read data
+    assert_eq!(&to_write, &read_buf);
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_readv() {
+    let s: String = rng()
+        .sample_iter(&Alphanumeric)
+        .map(char::from)
+        .take(128)
+        .collect();
+    let to_write = s.as_bytes().to_vec();
+    let mut storage = Vec::new();
+    let mut allocated = 0;
+    while allocated < to_write.len() {
+        let left = to_write.len() - allocated;
+        let vec_len = if left <= 64 {
+            left
+        } else {
+            rng().random_range(64..cmp::min(256, left))
+        };
+        let v: Vec<u8> = iter::repeat(0u8).take(vec_len).collect();
+        storage.push(v);
+        allocated += vec_len;
+    }
+    let mut iovecs = Vec::with_capacity(storage.len());
+    for v in &mut storage {
+        iovecs.push(IoSliceMut::new(&mut v[..]));
+    }
+    let (reader, writer) = pipe().expect("couldn't create pipe");
+    // Blocking io, should write all data.
+    write(writer, &to_write).expect("write failed");
+
+    let read = readv(&reader, &mut iovecs[..]).expect("read failed");
+    // Check whether we've read all data
+    assert_eq!(to_write.len(), read);
+    // Cccumulate data from iovecs
+    let mut read_buf = Vec::with_capacity(to_write.len());
+    for iovec in &iovecs {
+        read_buf.extend(iovec.iter().cloned());
+    }
+    // Check whether iovecs contain all written data
+    assert_eq!(read_buf.len(), to_write.len());
+    // Check equality of written and read data
+    assert_eq!(&read_buf, &to_write);
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_pwrite() {
+    use std::io::Read;
+
+    let mut file = tempfile().unwrap();
+    let buf = [1u8; 8];
+    assert_eq!(Ok(8), pwrite(&file, &buf, 8));
+    let mut file_content = Vec::new();
+    file.read_to_end(&mut file_content).unwrap();
+    let mut expected = vec![0u8; 8];
+    expected.extend(vec![1; 8]);
+    assert_eq!(file_content, expected);
+}
+
+#[test]
+fn test_pread() {
+    use std::io::Write;
+
+    let tempdir = tempdir().unwrap();
+
+    let path = tempdir.path().join("pread_test_file");
+    let mut file = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+        .unwrap();
+    let file_content: Vec<u8> = (0..64).collect();
+    file.write_all(&file_content).unwrap();
+
+    let mut buf = [0u8; 16];
+    assert_eq!(Ok(16), pread(&file, &mut buf, 16));
+    let expected: Vec<_> = (16..32).collect();
+    assert_eq!(&buf[..], &expected[..]);
+}
+
+#[test]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "haiku",
+    target_os = "solaris",
+    target_os = "cygwin"
+)))]
+fn test_pwritev() {
+    use std::io::Read;
+
+    let to_write: Vec<u8> = (0..128).collect();
+    let expected: Vec<u8> = [vec![0; 100], to_write.clone()].concat();
+
+    let iovecs = [
+        IoSlice::new(&to_write[0..17]),
+        IoSlice::new(&to_write[17..64]),
+        IoSlice::new(&to_write[64..128]),
+    ];
+
+    let tempdir = tempdir().unwrap();
+
+    // pwritev them into a temporary file
+    let path = tempdir.path().join("pwritev_test_file");
+    let mut file = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+        .unwrap();
+
+    let written = pwritev(&file, &iovecs, 100).ok().unwrap();
+    assert_eq!(written, to_write.len());
+
+    // Read the data back and make sure it matches
+    let mut contents = Vec::new();
+    file.read_to_end(&mut contents).unwrap();
+    assert_eq!(contents, expected);
+}
+
+#[test]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "haiku",
+    target_os = "solaris",
+    target_os = "cygwin"
+)))]
+fn test_preadv() {
+    use std::io::Write;
+
+    let to_write: Vec<u8> = (0..200).collect();
+    let expected: Vec<u8> = (100..200).collect();
+
+    let tempdir = tempdir().unwrap();
+
+    let path = tempdir.path().join("preadv_test_file");
+
+    let mut file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+        .unwrap();
+    file.write_all(&to_write).unwrap();
+
+    let mut buffers: Vec<Vec<u8>> = vec![vec![0; 24], vec![0; 1], vec![0; 75]];
+
+    {
+        // Borrow the buffers into IoVecs and preadv into them
+        let mut iovecs: Vec<_> = buffers
+            .iter_mut()
+            .map(|buf| IoSliceMut::new(&mut buf[..]))
+            .collect();
+        assert_eq!(Ok(100), preadv(&file, &mut iovecs, 100));
+    }
+
+    let all = buffers.concat();
+    assert_eq!(all, expected);
+}
+
+#[test]
+#[cfg(all(target_os = "linux", not(target_env = "uclibc")))]
+// uclibc doesn't implement process_vm_readv
+// qemu-user doesn't implement process_vm_readv/writev on most arches
+#[cfg_attr(qemu, ignore)]
+fn test_process_vm_readv() {
+    use crate::*;
+    use nix::sys::signal::*;
+    use nix::sys::wait::*;
+    use nix::unistd::ForkResult::*;
+
+    require_capability!("test_process_vm_readv", CAP_SYS_PTRACE);
+    let _m = crate::FORK_MTX.lock();
+
+    // Pre-allocate memory in the child, since allocation isn't safe
+    // post-fork (~= async-signal-safe)
+    let mut vector = vec![1u8, 2, 3, 4, 5];
+
+    let (r, w) = pipe().unwrap();
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Parent { child } => {
+            drop(w);
+            // wait for child
+            read(&r, &mut [0u8]).unwrap();
+            drop(r);
+
+            let ptr = vector.as_ptr() as usize;
+            let remote_iov = RemoteIoVec { base: ptr, len: 5 };
+            let mut buf = vec![0u8; 5];
+
+            let ret = process_vm_readv(
+                child,
+                &mut [IoSliceMut::new(&mut buf)],
+                &[remote_iov],
+            );
+
+            kill(child, SIGTERM).unwrap();
+            waitpid(child, None).unwrap();
+
+            assert_eq!(Ok(5), ret);
+            assert_eq!(20u8, buf.iter().sum());
+        }
+        Child => {
+            drop(r);
+            for i in &mut vector {
+                *i += 1;
+            }
+            let _ = write(w, b"\0");
+            loop {
+                pause();
+            }
+        }
+    }
+}

vendor/nix/test/sys/test_utsname.rs

@@ -0,0 +1,17 @@
+#[cfg(target_os = "linux")]
+#[test]
+pub fn test_uname_linux() {
+    assert_eq!(nix::sys::utsname::uname().unwrap().sysname(), "Linux");
+}
+
+#[cfg(apple_targets)]
+#[test]
+pub fn test_uname_darwin() {
+    assert_eq!(nix::sys::utsname::uname().unwrap().sysname(), "Darwin");
+}
+
+#[cfg(target_os = "freebsd")]
+#[test]
+pub fn test_uname_freebsd() {
+    assert_eq!(nix::sys::utsname::uname().unwrap().sysname(), "FreeBSD");
+}

vendor/nix/test/sys/test_wait.rs

@@ -0,0 +1,267 @@
+use libc::_exit;
+use nix::errno::Errno;
+use nix::sys::signal::*;
+use nix::sys::wait::*;
+use nix::unistd::ForkResult::*;
+use nix::unistd::*;
+
+#[test]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn test_wait_signal() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: The child only calls `pause` and/or `_exit`, which are async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            pause();
+            unsafe { _exit(123) }
+        }
+        Parent { child } => {
+            kill(child, Some(SIGKILL)).expect("Error: Kill Failed");
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Signaled(child, SIGKILL, false))
+            );
+        }
+    }
+}
+
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    //target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+#[cfg(not(any(
+    target_arch = "mips",
+    target_arch = "mips32r6",
+    target_arch = "mips64",
+    target_arch = "mips64r6"
+)))]
+fn test_waitid_signal() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: The child only calls `pause` and/or `_exit`, which are async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            pause();
+            unsafe { _exit(123) }
+        }
+        Parent { child } => {
+            kill(child, Some(SIGKILL)).expect("Error: Kill Failed");
+            assert_eq!(
+                waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+                Ok(WaitStatus::Signaled(child, SIGKILL, false)),
+            );
+        }
+    }
+}
+
+#[test]
+fn test_wait_exit() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: Child only calls `_exit`, which is async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => unsafe {
+            _exit(12);
+        },
+        Parent { child } => {
+            assert_eq!(waitpid(child, None), Ok(WaitStatus::Exited(child, 12)));
+        }
+    }
+}
+
+#[cfg(not(target_os = "haiku"))]
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+#[cfg(not(any(
+    target_arch = "mips",
+    target_arch = "mips32r6",
+    target_arch = "mips64",
+    target_arch = "mips64r6"
+)))]
+fn test_waitid_exit() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: Child only calls `_exit`, which is async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => unsafe {
+            _exit(12);
+        },
+        Parent { child } => {
+            assert_eq!(
+                waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+                Ok(WaitStatus::Exited(child, 12)),
+            );
+        }
+    }
+}
+
+#[test]
+fn test_waitstatus_from_raw() {
+    let pid = Pid::from_raw(1);
+    assert_eq!(
+        WaitStatus::from_raw(pid, 0x0002),
+        Ok(WaitStatus::Signaled(pid, Signal::SIGINT, false))
+    );
+    assert_eq!(
+        WaitStatus::from_raw(pid, 0x0200),
+        Ok(WaitStatus::Exited(pid, 2))
+    );
+    assert_eq!(WaitStatus::from_raw(pid, 0x7f7f), Err(Errno::EINVAL));
+}
+
+#[test]
+fn test_waitstatus_pid() {
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.unwrap() {
+        Child => unsafe { _exit(0) },
+        Parent { child } => {
+            let status = waitpid(child, None).unwrap();
+            assert_eq!(status.pid(), Some(child));
+        }
+    }
+}
+
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+fn test_waitid_pid() {
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.unwrap() {
+        Child => unsafe { _exit(0) },
+        Parent { child } => {
+            let status = waitid(Id::Pid(child), WaitPidFlag::WEXITED).unwrap();
+            assert_eq!(status.pid(), Some(child));
+        }
+    }
+}
+
+#[cfg(linux_android)]
+// FIXME: qemu-user doesn't implement ptrace on most arches
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+mod ptrace {
+    use crate::*;
+    use libc::_exit;
+    use nix::sys::ptrace::{self, Event, Options};
+    use nix::sys::signal::*;
+    use nix::sys::wait::*;
+    use nix::unistd::ForkResult::*;
+    use nix::unistd::*;
+
+    fn ptrace_child() -> ! {
+        ptrace::traceme().unwrap();
+        // As recommended by ptrace(2), raise SIGTRAP to pause the child
+        // until the parent is ready to continue
+        raise(SIGTRAP).unwrap();
+        unsafe { _exit(0) }
+    }
+
+    fn ptrace_wait_parent(child: Pid) {
+        // Wait for the raised SIGTRAP
+        assert_eq!(
+            waitpid(child, None),
+            Ok(WaitStatus::Stopped(child, SIGTRAP))
+        );
+        // We want to test a syscall stop and a PTRACE_EVENT stop
+        ptrace::setoptions(
+            child,
+            Options::PTRACE_O_TRACESYSGOOD | Options::PTRACE_O_TRACEEXIT,
+        )
+        .expect("setoptions failed");
+
+        // First, stop on the next system call, which will be exit()
+        ptrace::syscall(child, None).expect("syscall failed");
+        assert_eq!(waitpid(child, None), Ok(WaitStatus::PtraceSyscall(child)));
+        // Then get the ptrace event for the process exiting
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(
+            waitpid(child, None),
+            Ok(WaitStatus::PtraceEvent(
+                child,
+                SIGTRAP,
+                Event::PTRACE_EVENT_EXIT as i32
+            ))
+        );
+        // Finally get the normal wait() result, now that the process has exited
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(waitpid(child, None), Ok(WaitStatus::Exited(child, 0)));
+    }
+
+    #[cfg(not(target_env = "uclibc"))]
+    fn ptrace_waitid_parent(child: Pid) {
+        // Wait for the raised SIGTRAP
+        //
+        // Unlike waitpid(), waitid() can distinguish trap events from regular
+        // stop events, so unlike ptrace_wait_parent(), we get a PtraceEvent here
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::PtraceEvent(child, SIGTRAP, 0)),
+        );
+        // We want to test a syscall stop and a PTRACE_EVENT stop
+        ptrace::setoptions(
+            child,
+            Options::PTRACE_O_TRACESYSGOOD | Options::PTRACE_O_TRACEEXIT,
+        )
+        .expect("setopts failed");
+
+        // First, stop on the next system call, which will be exit()
+        ptrace::syscall(child, None).expect("syscall failed");
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::PtraceSyscall(child)),
+        );
+        // Then get the ptrace event for the process exiting
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::PtraceEvent(
+                child,
+                SIGTRAP,
+                Event::PTRACE_EVENT_EXIT as i32
+            )),
+        );
+        // Finally get the normal wait() result, now that the process has exited
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::Exited(child, 0)),
+        );
+    }
+
+    #[test]
+    fn test_wait_ptrace() {
+        require_capability!("test_wait_ptrace", CAP_SYS_PTRACE);
+        let _m = crate::FORK_MTX.lock();
+
+        match unsafe { fork() }.expect("Error: Fork Failed") {
+            Child => ptrace_child(),
+            Parent { child } => ptrace_wait_parent(child),
+        }
+    }
+
+    #[test]
+    #[cfg(not(target_env = "uclibc"))]
+    fn test_waitid_ptrace() {
+        require_capability!("test_waitid_ptrace", CAP_SYS_PTRACE);
+        let _m = crate::FORK_MTX.lock();
+
+        match unsafe { fork() }.expect("Error: Fork Failed") {
+            Child => ptrace_child(),
+            Parent { child } => ptrace_waitid_parent(child),
+        }
+    }
+}