diff options
Diffstat (limited to 'vendor/rustix-0.37.6/src/backend/libc')
52 files changed, 0 insertions, 13011 deletions
diff --git a/vendor/rustix-0.37.6/src/backend/libc/c.rs b/vendor/rustix-0.37.6/src/backend/libc/c.rs deleted file mode 100644 index 35d24d893..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/c.rs +++ /dev/null @@ -1,9 +0,0 @@ -pub(crate) use libc::*; - -/// `PROC_SUPER_MAGIC`—The magic number for the procfs filesystem. -#[cfg(all(any(target_os = "android", target_os = "linux"), target_env = "musl"))] -pub(crate) const PROC_SUPER_MAGIC: u32 = 0x0000_9fa0; - -/// `NFS_SUPER_MAGIC`—The magic number for the NFS filesystem. -#[cfg(all(any(target_os = "android", target_os = "linux"), target_env = "musl"))] -pub(crate) const NFS_SUPER_MAGIC: u32 = 0x0000_6969; diff --git a/vendor/rustix-0.37.6/src/backend/libc/conv.rs b/vendor/rustix-0.37.6/src/backend/libc/conv.rs deleted file mode 100644 index 1e74ea9ba..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/conv.rs +++ /dev/null @@ -1,222 +0,0 @@ -//! Libc call arguments and return values are often things like `c_int`, -//! `c_uint`, or libc-specific pointer types. This module provides functions -//! for converting between rustix's types and libc types. - -#![allow(dead_code)] - -use super::c; -use super::fd::{AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, LibcFd, OwnedFd, RawFd}; -#[cfg(not(windows))] -#[cfg(feature = "fs")] -use super::offset::libc_off_t; -#[cfg(not(windows))] -use crate::ffi::CStr; -use crate::io; -#[cfg(windows)] -use core::convert::TryInto; - -#[cfg(not(windows))] -#[inline] -pub(super) fn c_str(c: &CStr) -> *const c::c_char { - c.as_ptr() -} - -#[cfg(not(windows))] -#[inline] -pub(super) fn no_fd() -> LibcFd { - -1 -} - -#[inline] -pub(super) fn borrowed_fd(fd: BorrowedFd<'_>) -> LibcFd { - fd.as_raw_fd() as LibcFd -} - -#[inline] -pub(super) fn owned_fd(fd: OwnedFd) -> LibcFd { - fd.into_raw_fd() as LibcFd -} - -#[inline] -pub(super) fn ret(raw: c::c_int) -> io::Result<()> { - if raw == 0 { - Ok(()) - } else { - Err(io::Errno::last_os_error()) - } -} - -#[inline] -pub(super) fn syscall_ret(raw: c::c_long) -> io::Result<()> { - if raw == 0 { - Ok(()) - } else { - Err(io::Errno::last_os_error()) - } -} - -#[inline] -pub(super) fn nonnegative_ret(raw: c::c_int) -> io::Result<()> { - if raw >= 0 { - Ok(()) - } else { - Err(io::Errno::last_os_error()) - } -} - -#[inline] -pub(super) unsafe fn ret_infallible(raw: c::c_int) { - debug_assert_eq!(raw, 0, "unexpected error: {:?}", io::Errno::last_os_error()); -} - -#[inline] -pub(super) fn ret_c_int(raw: c::c_int) -> io::Result<c::c_int> { - if raw == -1 { - Err(io::Errno::last_os_error()) - } else { - Ok(raw) - } -} - -#[inline] -pub(super) fn ret_u32(raw: c::c_int) -> io::Result<u32> { - if raw == -1 { - Err(io::Errno::last_os_error()) - } else { - Ok(raw as u32) - } -} - -#[inline] -pub(super) fn ret_ssize_t(raw: c::ssize_t) -> io::Result<c::ssize_t> { - if raw == -1 { - Err(io::Errno::last_os_error()) - } else { - Ok(raw) - } -} - -#[inline] -pub(super) fn syscall_ret_ssize_t(raw: c::c_long) -> io::Result<c::ssize_t> { - if raw == -1 { - Err(io::Errno::last_os_error()) - } else { - Ok(raw as c::ssize_t) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(super) fn syscall_ret_u32(raw: c::c_long) -> io::Result<u32> { - if raw == -1 { - Err(io::Errno::last_os_error()) - } else { - let r32 = raw as u32; - - // Converting `raw` to `u32` should be lossless. - debug_assert_eq!(r32 as c::c_long, raw); - - Ok(r32) - } -} - -#[cfg(not(windows))] -#[cfg(feature = "fs")] -#[inline] -pub(super) fn ret_off_t(raw: libc_off_t) -> io::Result<libc_off_t> { - if raw == -1 { - Err(io::Errno::last_os_error()) - } else { - Ok(raw) - } -} - -#[cfg(not(windows))] -#[inline] -pub(super) fn ret_pid_t(raw: c::pid_t) -> io::Result<c::pid_t> { - if raw == -1 { - Err(io::Errno::last_os_error()) - } else { - Ok(raw) - } -} - -/// Convert a `c_int` returned from a libc function to an `OwnedFd`, if valid. -/// -/// # Safety -/// -/// The caller must ensure that this is the return value of a libc function -/// which returns an owned file descriptor. -#[inline] -pub(super) unsafe fn ret_owned_fd(raw: LibcFd) -> io::Result<OwnedFd> { - if raw == !0 { - Err(io::Errno::last_os_error()) - } else { - Ok(OwnedFd::from_raw_fd(raw as RawFd)) - } -} - -#[inline] -pub(super) fn ret_discarded_fd(raw: LibcFd) -> io::Result<()> { - if raw == !0 { - Err(io::Errno::last_os_error()) - } else { - Ok(()) - } -} - -#[inline] -pub(super) fn ret_discarded_char_ptr(raw: *mut c::c_char) -> io::Result<()> { - if raw.is_null() { - Err(io::Errno::last_os_error()) - } else { - Ok(()) - } -} - -/// Convert a `c_long` returned from `syscall` to an `OwnedFd`, if valid. -/// -/// # Safety -/// -/// The caller must ensure that this is the return value of a `syscall` call -/// which returns an owned file descriptor. -#[cfg(not(windows))] -#[inline] -pub(super) unsafe fn syscall_ret_owned_fd(raw: c::c_long) -> io::Result<OwnedFd> { - if raw == -1 { - Err(io::Errno::last_os_error()) - } else { - Ok(OwnedFd::from_raw_fd(raw as RawFd)) - } -} - -/// Convert the buffer-length argument value of a `send` or `recv` call. -#[cfg(not(windows))] -#[inline] -pub(super) fn send_recv_len(len: usize) -> usize { - len -} - -/// Convert the buffer-length argument value of a `send` or `recv` call. -#[cfg(windows)] -#[inline] -pub(super) fn send_recv_len(len: usize) -> i32 { - // On Windows, the length argument has type `i32`; saturate the length, - // since `send` and `recv` are allowed to send and recv less data than - // requested. - len.try_into().unwrap_or(i32::MAX) -} - -/// Convert the return value of a `send` or `recv` call. -#[cfg(not(windows))] -#[inline] -pub(super) fn ret_send_recv(len: isize) -> io::Result<c::ssize_t> { - ret_ssize_t(len) -} - -/// Convert the return value of a `send` or `recv` call. -#[cfg(windows)] -#[inline] -pub(super) fn ret_send_recv(len: i32) -> io::Result<c::ssize_t> { - ret_ssize_t(len as isize) -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/fs/dir.rs b/vendor/rustix-0.37.6/src/backend/libc/fs/dir.rs deleted file mode 100644 index d1c901323..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/fs/dir.rs +++ /dev/null @@ -1,405 +0,0 @@ -use super::super::c; -use super::super::conv::owned_fd; -#[cfg(not(any(solarish, target_os = "haiku")))] -use super::types::FileType; -use crate::fd::{AsFd, BorrowedFd}; -use crate::ffi::CStr; -#[cfg(target_os = "wasi")] -use crate::ffi::CString; -use crate::fs::{fcntl_getfl, fstat, openat, Mode, OFlags, Stat}; -#[cfg(not(any( - solarish, - target_os = "haiku", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", -)))] -use crate::fs::{fstatfs, StatFs}; -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -use crate::fs::{fstatvfs, StatVfs}; -use crate::io; -#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))] -use crate::process::fchdir; -#[cfg(target_os = "wasi")] -use alloc::borrow::ToOwned; -#[cfg(not(any(linux_like, target_os = "openbsd")))] -use c::dirent as libc_dirent; -#[cfg(not(linux_like))] -use c::readdir as libc_readdir; -#[cfg(linux_like)] -use c::{dirent64 as libc_dirent, readdir64 as libc_readdir}; -use core::fmt; -use core::mem::zeroed; -use core::ptr::NonNull; -use libc_errno::{errno, set_errno, Errno}; - -/// `DIR*` -#[repr(transparent)] -pub struct Dir(NonNull<c::DIR>); - -impl Dir { - /// Construct a `Dir` that reads entries from the given directory - /// file descriptor. - #[inline] - pub fn read_from<Fd: AsFd>(fd: Fd) -> io::Result<Self> { - Self::_read_from(fd.as_fd()) - } - - #[inline] - fn _read_from(fd: BorrowedFd<'_>) -> io::Result<Self> { - // Given an arbitrary `OwnedFd`, it's impossible to know whether the - // user holds a `dup`'d copy which could continue to modify the - // file description state, which would cause Undefined Behavior after - // our call to `fdopendir`. To prevent this, we obtain an independent - // `OwnedFd`. - let flags = fcntl_getfl(fd)?; - let fd_for_dir = openat(fd, cstr!("."), flags | OFlags::CLOEXEC, Mode::empty())?; - - let raw = owned_fd(fd_for_dir); - unsafe { - let libc_dir = c::fdopendir(raw); - - if let Some(libc_dir) = NonNull::new(libc_dir) { - Ok(Self(libc_dir)) - } else { - let err = io::Errno::last_os_error(); - let _ = c::close(raw); - Err(err) - } - } - } - - /// `rewinddir(self)` - #[inline] - pub fn rewind(&mut self) { - unsafe { c::rewinddir(self.0.as_ptr()) } - } - - /// `readdir(self)`, where `None` means the end of the directory. - pub fn read(&mut self) -> Option<io::Result<DirEntry>> { - set_errno(Errno(0)); - let dirent_ptr = unsafe { libc_readdir(self.0.as_ptr()) }; - if dirent_ptr.is_null() { - let curr_errno = errno().0; - if curr_errno == 0 { - // We successfully reached the end of the stream. - None - } else { - // `errno` is unknown or non-zero, so an error occurred. - Some(Err(io::Errno(curr_errno))) - } - } else { - // We successfully read an entry. - unsafe { - // We have our own copy of OpenBSD's dirent; check that the - // layout minimally matches libc's. - #[cfg(target_os = "openbsd")] - check_dirent_layout(&*dirent_ptr); - - let result = DirEntry { - dirent: read_dirent(&*dirent_ptr.cast()), - - #[cfg(target_os = "wasi")] - name: CStr::from_ptr((*dirent_ptr).d_name.as_ptr()).to_owned(), - }; - - Some(Ok(result)) - } - } - } - - /// `fstat(self)` - #[inline] - pub fn stat(&self) -> io::Result<Stat> { - fstat(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.0.as_ptr())) }) - } - - /// `fstatfs(self)` - #[cfg(not(any( - solarish, - target_os = "haiku", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", - )))] - #[inline] - pub fn statfs(&self) -> io::Result<StatFs> { - fstatfs(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.0.as_ptr())) }) - } - - /// `fstatvfs(self)` - #[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] - #[inline] - pub fn statvfs(&self) -> io::Result<StatVfs> { - fstatvfs(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.0.as_ptr())) }) - } - - /// `fchdir(self)` - #[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))] - #[inline] - pub fn chdir(&self) -> io::Result<()> { - fchdir(unsafe { BorrowedFd::borrow_raw(c::dirfd(self.0.as_ptr())) }) - } -} - -// A `dirent` pointer returned from `readdir` may not point to a full `dirent` -// struct, as the name is NUL-terminated and memory may not be allocated for -// the full extent of the struct. Copy the fields one at a time. -unsafe fn read_dirent(input: &libc_dirent) -> libc_dirent { - #[cfg(not(any(solarish, target_os = "aix", target_os = "haiku")))] - let d_type = input.d_type; - - #[cfg(not(any( - apple, - freebsdlike, - target_os = "aix", - target_os = "haiku", - target_os = "netbsd", - target_os = "wasi", - )))] - let d_off = input.d_off; - - #[cfg(target_os = "aix")] - let d_offset = input.d_offset; - - #[cfg(not(any(freebsdlike, netbsdlike)))] - let d_ino = input.d_ino; - - #[cfg(any(freebsdlike, netbsdlike))] - let d_fileno = input.d_fileno; - - #[cfg(not(any(target_os = "dragonfly", target_os = "wasi")))] - let d_reclen = input.d_reclen; - - #[cfg(any(bsd, target_os = "aix"))] - let d_namlen = input.d_namlen; - - #[cfg(apple)] - let d_seekoff = input.d_seekoff; - - #[cfg(target_os = "haiku")] - let d_dev = input.d_dev; - #[cfg(target_os = "haiku")] - let d_pdev = input.d_pdev; - #[cfg(target_os = "haiku")] - let d_pino = input.d_pino; - - // Construct the input. Rust will give us an error if any OS has a input - // with a field that we missed here. And we can avoid blindly copying the - // whole `d_name` field, which may not be entirely allocated. - #[cfg_attr(target_os = "wasi", allow(unused_mut))] - #[cfg(not(freebsdlike))] - let mut dirent = libc_dirent { - #[cfg(not(any(solarish, target_os = "aix", target_os = "haiku")))] - d_type, - #[cfg(not(any( - apple, - target_os = "aix", - target_os = "freebsd", // Until FreeBSD 12 - target_os = "haiku", - target_os = "netbsd", - target_os = "wasi", - )))] - d_off, - #[cfg(target_os = "aix")] - d_offset, - #[cfg(not(any(netbsdlike, target_os = "freebsd")))] - d_ino, - #[cfg(any(netbsdlike, target_os = "freebsd"))] - d_fileno, - #[cfg(not(target_os = "wasi"))] - d_reclen, - #[cfg(any(apple, netbsdlike, target_os = "aix", target_os = "freebsd"))] - d_namlen, - #[cfg(apple)] - d_seekoff, - // The `d_name` field is NUL-terminated, and we need to be careful not - // to read bytes past the NUL, even though they're within the nominal - // extent of the `struct dirent`, because they may not be allocated. So - // don't read it from `dirent_ptr`. - // - // In theory this could use `MaybeUninit::uninit().assume_init()`, but - // that [invokes undefined behavior]. - // - // [invokes undefined behavior]: https://doc.rust-lang.org/stable/core/mem/union.MaybeUninit.html#initialization-invariant - d_name: zeroed(), - #[cfg(target_os = "openbsd")] - __d_padding: zeroed(), - #[cfg(target_os = "haiku")] - d_dev, - #[cfg(target_os = "haiku")] - d_pdev, - #[cfg(target_os = "haiku")] - d_pino, - }; - /* - pub d_ino: ino_t, - pub d_pino: i64, - pub d_reclen: ::c_ushort, - pub d_name: [::c_char; 1024], // Max length is _POSIX_PATH_MAX - */ - - // On dragonfly and FreeBSD 12, `dirent` has some non-public padding fields - // so we can't directly initialize it. - #[cfg(freebsdlike)] - let mut dirent = { - let mut dirent: libc_dirent = zeroed(); - dirent.d_fileno = d_fileno; - dirent.d_namlen = d_namlen; - dirent.d_type = d_type; - #[cfg(target_os = "freebsd")] - { - dirent.d_reclen = d_reclen; - } - dirent - }; - - // Copy from d_name, reading up to and including the first NUL. - #[cfg(not(target_os = "wasi"))] - { - let name_len = CStr::from_ptr(input.d_name.as_ptr()) - .to_bytes_with_nul() - .len(); - dirent.d_name[..name_len].copy_from_slice(&input.d_name[..name_len]); - } - - dirent -} - -/// `Dir` implements `Send` but not `Sync`, because we use `readdir` which is -/// not guaranteed to be thread-safe. Users can wrap this in a `Mutex` if they -/// need `Sync`, which is effectively what'd need to do to implement `Sync` -/// ourselves. -unsafe impl Send for Dir {} - -impl Drop for Dir { - #[inline] - fn drop(&mut self) { - unsafe { c::closedir(self.0.as_ptr()) }; - } -} - -impl Iterator for Dir { - type Item = io::Result<DirEntry>; - - #[inline] - fn next(&mut self) -> Option<Self::Item> { - Self::read(self) - } -} - -impl fmt::Debug for Dir { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("Dir") - .field("fd", unsafe { &c::dirfd(self.0.as_ptr()) }) - .finish() - } -} - -/// `struct dirent` -#[derive(Debug)] -pub struct DirEntry { - dirent: libc_dirent, - - #[cfg(target_os = "wasi")] - name: CString, -} - -impl DirEntry { - /// Returns the file name of this directory entry. - #[inline] - pub fn file_name(&self) -> &CStr { - #[cfg(not(target_os = "wasi"))] - unsafe { - CStr::from_ptr(self.dirent.d_name.as_ptr()) - } - - #[cfg(target_os = "wasi")] - &self.name - } - - /// Returns the type of this directory entry. - #[cfg(not(any(solarish, target_os = "aix", target_os = "haiku")))] - #[inline] - pub fn file_type(&self) -> FileType { - FileType::from_dirent_d_type(self.dirent.d_type) - } - - /// Return the inode number of this directory entry. - #[cfg(not(any(freebsdlike, netbsdlike)))] - #[inline] - pub fn ino(&self) -> u64 { - self.dirent.d_ino as u64 - } - - /// Return the inode number of this directory entry. - #[cfg(any(freebsdlike, netbsdlike))] - #[inline] - pub fn ino(&self) -> u64 { - #[allow(clippy::useless_conversion)] - self.dirent.d_fileno.into() - } -} - -/// libc's OpenBSD `dirent` has a private field so we can't construct it -/// directly, so we declare it ourselves to make all fields accessible. -#[cfg(target_os = "openbsd")] -#[repr(C)] -#[derive(Debug)] -struct libc_dirent { - d_fileno: c::ino_t, - d_off: c::off_t, - d_reclen: u16, - d_type: u8, - d_namlen: u8, - __d_padding: [u8; 4], - d_name: [c::c_char; 256], -} - -/// We have our own copy of OpenBSD's dirent; check that the layout -/// minimally matches libc's. -#[cfg(target_os = "openbsd")] -fn check_dirent_layout(dirent: &c::dirent) { - use crate::utils::as_ptr; - use core::mem::{align_of, size_of}; - - // Check that the basic layouts match. - assert_eq!(size_of::<libc_dirent>(), size_of::<c::dirent>()); - assert_eq!(align_of::<libc_dirent>(), align_of::<c::dirent>()); - - // Check that the field offsets match. - assert_eq!( - { - let z = libc_dirent { - d_fileno: 0_u64, - d_off: 0_i64, - d_reclen: 0_u16, - d_type: 0_u8, - d_namlen: 0_u8, - __d_padding: [0_u8; 4], - d_name: [0 as c::c_char; 256], - }; - let base = as_ptr(&z) as usize; - ( - (as_ptr(&z.d_fileno) as usize) - base, - (as_ptr(&z.d_off) as usize) - base, - (as_ptr(&z.d_reclen) as usize) - base, - (as_ptr(&z.d_type) as usize) - base, - (as_ptr(&z.d_namlen) as usize) - base, - (as_ptr(&z.d_name) as usize) - base, - ) - }, - { - let z = dirent; - let base = as_ptr(z) as usize; - ( - (as_ptr(&z.d_fileno) as usize) - base, - (as_ptr(&z.d_off) as usize) - base, - (as_ptr(&z.d_reclen) as usize) - base, - (as_ptr(&z.d_type) as usize) - base, - (as_ptr(&z.d_namlen) as usize) - base, - (as_ptr(&z.d_name) as usize) - base, - ) - } - ); -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/fs/inotify.rs b/vendor/rustix-0.37.6/src/backend/libc/fs/inotify.rs deleted file mode 100644 index 8a42e0583..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/fs/inotify.rs +++ /dev/null @@ -1,121 +0,0 @@ -//! inotify support for working with inotifies - -use super::super::c; -use super::super::conv::{borrowed_fd, c_str, ret, ret_c_int, ret_owned_fd}; -use crate::fd::{BorrowedFd, OwnedFd}; -use crate::io; -use bitflags::bitflags; - -bitflags! { - /// `IN_*` for use with [`inotify_init`]. - /// - /// [`inotify_init`]: crate::fs::inotify::inotify_init - pub struct CreateFlags: c::c_int { - /// `IN_CLOEXEC` - const CLOEXEC = c::IN_CLOEXEC; - /// `IN_NONBLOCK` - const NONBLOCK = c::IN_NONBLOCK; - } -} - -bitflags! { - /// `IN*` for use with [`inotify_add_watch`]. - /// - /// [`inotify_add_watch`]: crate::fs::inotify::inotify_add_watch - #[derive(Default)] - pub struct WatchFlags: u32 { - /// `IN_ACCESS` - const ACCESS = c::IN_ACCESS; - /// `IN_ATTRIB` - const ATTRIB = c::IN_ATTRIB; - /// `IN_CLOSE_NOWRITE` - const CLOSE_NOWRITE = c::IN_CLOSE_NOWRITE; - /// `IN_CLOSE_WRITE` - const CLOSE_WRITE = c::IN_CLOSE_WRITE; - /// `IN_CREATE ` - const CREATE = c::IN_CREATE; - /// `IN_DELETE` - const DELETE = c::IN_DELETE; - /// `IN_DELETE_SELF` - const DELETE_SELF = c::IN_DELETE_SELF; - /// `IN_MODIFY` - const MODIFY = c::IN_MODIFY; - /// `IN_MOVE_SELF` - const MOVE_SELF = c::IN_MOVE_SELF; - /// `IN_MOVED_FROM` - const MOVED_FROM = c::IN_MOVED_FROM; - /// `IN_MOVED_TO` - const MOVED_TO = c::IN_MOVED_TO; - /// `IN_OPEN` - const OPEN = c::IN_OPEN; - - /// `IN_CLOSE` - const CLOSE = c::IN_CLOSE; - /// `IN_MOVE` - const MOVE = c::IN_MOVE; - /// `IN_ALL_EVENTS` - const ALL_EVENTS = c::IN_ALL_EVENTS; - - /// `IN_DONT_FOLLOW` - const DONT_FOLLOW = c::IN_DONT_FOLLOW; - /// `IN_EXCL_UNLINK` - const EXCL_UNLINK = 1; - /// `IN_MASK_ADD` - const MASK_ADD = 1; - /// `IN_MASK_CREATE` - const MASK_CREATE = 1; - /// `IN_ONESHOT` - const ONESHOT = c::IN_ONESHOT; - /// `IN_ONLYDIR` - const ONLYDIR = c::IN_ONLYDIR; - } -} - -/// `inotify_init1(flags)`—Creates a new inotify object. -/// -/// Use the [`CreateFlags::CLOEXEC`] flag to prevent the resulting file -/// descriptor from being implicitly passed across `exec` boundaries. -#[doc(alias = "inotify_init1")] -pub fn inotify_init(flags: CreateFlags) -> io::Result<OwnedFd> { - // SAFETY: `inotify_init1` has no safety preconditions. - unsafe { ret_owned_fd(c::inotify_init1(flags.bits())) } -} - -/// `inotify_add_watch(self, path, flags)`—Adds a watch to inotify -/// -/// This registers or updates a watch for the filesystem path `path` -/// and returns a watch descriptor corresponding to this watch. -/// -/// Note: Due to the existence of hardlinks, providing two -/// different paths to this method may result in it returning -/// the same watch descriptor. An application should keep track of this -/// externally to avoid logic errors. -pub fn inotify_add_watch<P: crate::path::Arg>( - inot: BorrowedFd<'_>, - path: P, - flags: WatchFlags, -) -> io::Result<i32> { - let path = path.as_cow_c_str().unwrap(); - // SAFETY: The fd and path we are passing is guaranteed valid by the type - // system. - unsafe { - ret_c_int(c::inotify_add_watch( - borrowed_fd(inot), - c_str(&path), - flags.bits(), - )) - } -} - -/// `inotify_rm_watch(self, wd)`—Removes a watch from this inotify -/// -/// The watch descriptor provided should have previously been returned -/// by [`inotify_add_watch`] and not previously have been removed. -#[doc(alias = "inotify_rm_watch")] -pub fn inotify_remove_watch(inot: BorrowedFd<'_>, wd: i32) -> io::Result<()> { - // Android's `inotify_rm_watch` takes u32 despite `inotify_add_watch` is i32. - #[cfg(target_os = "android")] - let wd = wd as u32; - // SAFETY: The fd is valid and closing an arbitrary wd is valid. - unsafe { ret(c::inotify_rm_watch(borrowed_fd(inot), wd)) } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/fs/makedev.rs b/vendor/rustix-0.37.6/src/backend/libc/fs/makedev.rs deleted file mode 100644 index afe942a59..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/fs/makedev.rs +++ /dev/null @@ -1,120 +0,0 @@ -#[cfg(not(all(target_os = "android", target_pointer_width = "32")))] -use super::super::c; -use crate::fs::Dev; - -#[cfg(not(any( - apple, - target_os = "aix", - target_os = "android", - target_os = "emscripten", -)))] -#[inline] -pub(crate) fn makedev(maj: u32, min: u32) -> Dev { - c::makedev(maj, min) -} - -#[cfg(all(target_os = "android", not(target_pointer_width = "32")))] -#[inline] -pub(crate) fn makedev(maj: u32, min: u32) -> Dev { - c::makedev(maj, min) -} - -#[cfg(all(target_os = "android", target_pointer_width = "32"))] -#[inline] -pub(crate) fn makedev(maj: u32, min: u32) -> Dev { - // 32-bit Android's `dev_t` is 32-bit, but its `st_dev` is 64-bit, - // so we do it ourselves. - ((u64::from(maj) & 0xffff_f000_u64) << 32) - | ((u64::from(maj) & 0x0000_0fff_u64) << 8) - | ((u64::from(min) & 0xffff_ff00_u64) << 12) - | (u64::from(min) & 0x0000_00ff_u64) -} - -#[cfg(target_os = "emscripten")] -#[inline] -pub(crate) fn makedev(maj: u32, min: u32) -> Dev { - // Emscripten's `makedev` has a 32-bit return value. - Dev::from(c::makedev(maj, min)) -} - -#[cfg(apple)] -#[inline] -pub(crate) fn makedev(maj: u32, min: u32) -> Dev { - // Apple's `makedev` oddly has signed argument types and is `unsafe`. - unsafe { c::makedev(maj as i32, min as i32) } -} - -#[cfg(target_os = "aix")] -#[inline] -pub(crate) fn makedev(maj: u32, min: u32) -> Dev { - // AIX's `makedev` oddly is `unsafe`. - unsafe { c::makedev(maj, min) } -} - -#[cfg(not(any( - apple, - freebsdlike, - netbsdlike, - target_os = "android", - target_os = "emscripten", -)))] -#[inline] -pub(crate) fn major(dev: Dev) -> u32 { - unsafe { c::major(dev) } -} - -#[cfg(all(target_os = "android", not(target_pointer_width = "32")))] -#[inline] -pub(crate) fn major(dev: Dev) -> u32 { - // Android's `major` oddly has signed return types. - (unsafe { c::major(dev) }) as u32 -} - -#[cfg(all(target_os = "android", target_pointer_width = "32"))] -#[inline] -pub(crate) fn major(dev: Dev) -> u32 { - // 32-bit Android's `dev_t` is 32-bit, but its `st_dev` is 64-bit, - // so we do it ourselves. - (((dev >> 31 >> 1) & 0xffff_f000) | ((dev >> 8) & 0x0000_0fff)) as u32 -} - -#[cfg(target_os = "emscripten")] -#[inline] -pub(crate) fn major(dev: Dev) -> u32 { - // Emscripten's `major` has a 32-bit argument value. - unsafe { c::major(dev as u32) } -} - -#[cfg(not(any( - apple, - freebsdlike, - netbsdlike, - target_os = "android", - target_os = "emscripten", -)))] -#[inline] -pub(crate) fn minor(dev: Dev) -> u32 { - unsafe { c::minor(dev) } -} - -#[cfg(all(target_os = "android", not(target_pointer_width = "32")))] -#[inline] -pub(crate) fn minor(dev: Dev) -> u32 { - // Android's `minor` oddly has signed return types. - (unsafe { c::minor(dev) }) as u32 -} - -#[cfg(all(target_os = "android", target_pointer_width = "32"))] -#[inline] -pub(crate) fn minor(dev: Dev) -> u32 { - // 32-bit Android's `dev_t` is 32-bit, but its `st_dev` is 64-bit, - // so we do it ourselves. - (((dev >> 12) & 0xffff_ff00) | (dev & 0x0000_00ff)) as u32 -} - -#[cfg(target_os = "emscripten")] -#[inline] -pub(crate) fn minor(dev: Dev) -> u32 { - // Emscripten's `minor` has a 32-bit argument value. - unsafe { c::minor(dev as u32) } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/fs/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/fs/mod.rs deleted file mode 100644 index 54a48103c..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/fs/mod.rs +++ /dev/null @@ -1,9 +0,0 @@ -#[cfg(not(target_os = "redox"))] -pub(crate) mod dir; -#[cfg(any(target_os = "android", target_os = "linux"))] -pub mod inotify; -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -pub(crate) mod makedev; -#[cfg(not(windows))] -pub(crate) mod syscalls; -pub(crate) mod types; diff --git a/vendor/rustix-0.37.6/src/backend/libc/fs/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/fs/syscalls.rs deleted file mode 100644 index 77b49ee3e..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/fs/syscalls.rs +++ /dev/null @@ -1,1810 +0,0 @@ -//! libc syscalls supporting `rustix::fs`. - -use super::super::c; -use super::super::conv::{ - borrowed_fd, c_str, ret, ret_c_int, ret_off_t, ret_owned_fd, ret_ssize_t, -}; -#[cfg(any(target_os = "android", target_os = "linux"))] -use super::super::conv::{syscall_ret, syscall_ret_owned_fd, syscall_ret_ssize_t}; -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -use super::super::offset::libc_fallocate; -#[cfg(not(any( - apple, - netbsdlike, - solarish, - target_os = "dragonfly", - target_os = "haiku", - target_os = "redox", -)))] -use super::super::offset::libc_posix_fadvise; -#[cfg(not(any( - apple, - netbsdlike, - solarish, - target_os = "aix", - target_os = "android", - target_os = "dragonfly", - target_os = "fuchsia", - target_os = "linux", - target_os = "redox", -)))] -use super::super::offset::libc_posix_fallocate; -use super::super::offset::{libc_fstat, libc_fstatat, libc_ftruncate, libc_lseek, libc_off_t}; -#[cfg(not(any( - solarish, - target_os = "haiku", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", -)))] -use super::super::offset::{libc_fstatfs, libc_statfs}; -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -use super::super::offset::{libc_fstatvfs, libc_statvfs}; -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -use super::super::time::types::LibcTimespec; -use crate::fd::{BorrowedFd, OwnedFd}; -use crate::ffi::CStr; -#[cfg(apple)] -use crate::ffi::CString; -#[cfg(not(solarish))] -use crate::fs::Access; -#[cfg(not(any( - apple, - netbsdlike, - solarish, - target_os = "dragonfly", - target_os = "haiku", - target_os = "redox", -)))] -use crate::fs::Advice; -#[cfg(not(any( - netbsdlike, - solarish, - target_os = "aix", - target_os = "dragonfly", - target_os = "redox", -)))] -use crate::fs::FallocateFlags; -#[cfg(not(target_os = "wasi"))] -use crate::fs::FlockOperation; -#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))] -use crate::fs::MemfdFlags; -#[cfg(any( - target_os = "android", - target_os = "freebsd", - target_os = "fuchsia", - target_os = "linux", -))] -use crate::fs::SealFlags; -#[cfg(not(any( - solarish, - target_os = "haiku", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", -)))] -use crate::fs::StatFs; -#[cfg(any(target_os = "android", target_os = "linux"))] -use crate::fs::{cwd, RenameFlags, ResolveFlags, Statx, StatxFlags}; -#[cfg(not(any(apple, target_os = "redox", target_os = "wasi")))] -use crate::fs::{Dev, FileType}; -use crate::fs::{Mode, OFlags, Stat, Timestamps}; -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -use crate::fs::{StatVfs, StatVfsMountFlags}; -use crate::io::{self, SeekFrom}; -#[cfg(not(target_os = "wasi"))] -use crate::process::{Gid, Uid}; -#[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -)))] -use crate::utils::as_ptr; -use core::convert::TryInto; -#[cfg(any(apple, target_os = "android", target_os = "linux"))] -use core::mem::size_of; -use core::mem::MaybeUninit; -#[cfg(any(target_os = "android", target_os = "linux"))] -use core::ptr::null; -#[cfg(any(apple, target_os = "android", target_os = "linux"))] -use core::ptr::null_mut; -#[cfg(apple)] -use { - super::super::conv::nonnegative_ret, - crate::fs::{copyfile_state_t, CloneFlags, CopyfileFlags}, -}; -#[cfg(not(target_os = "redox"))] -use {super::super::offset::libc_openat, crate::fs::AtFlags}; - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -weak!(fn __utimensat64(c::c_int, *const c::c_char, *const LibcTimespec, c::c_int) -> c::c_int); -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -weak!(fn __futimens64(c::c_int, *const LibcTimespec) -> c::c_int); - -/// Use a direct syscall (via libc) for `openat`. -/// -/// This is only currently necessary as a workaround for old glibc; see below. -#[cfg(all(unix, target_env = "gnu"))] -fn openat_via_syscall( - dirfd: BorrowedFd<'_>, - path: &CStr, - oflags: OFlags, - mode: Mode, -) -> io::Result<OwnedFd> { - unsafe { - let dirfd = borrowed_fd(dirfd); - let path = c_str(path); - let oflags = oflags.bits(); - let mode = c::c_uint::from(mode.bits()); - ret_owned_fd(c::syscall( - c::SYS_openat, - c::c_long::from(dirfd), - path, - c::c_long::from(oflags), - mode as c::c_long, - ) as c::c_int) - } -} - -#[cfg(not(target_os = "redox"))] -pub(crate) fn openat( - dirfd: BorrowedFd<'_>, - path: &CStr, - oflags: OFlags, - mode: Mode, -) -> io::Result<OwnedFd> { - // Work around <https://sourceware.org/bugzilla/show_bug.cgi?id=17523>. - // GLIBC versions before 2.25 don't handle `O_TMPFILE` correctly. - #[cfg(all(unix, target_env = "gnu"))] - if oflags.contains(OFlags::TMPFILE) && crate::backend::if_glibc_is_less_than_2_25() { - return openat_via_syscall(dirfd, path, oflags, mode); - } - unsafe { - // Pass `mode` as a `c_uint` even if `mode_t` is narrower, since - // `libc_openat` is declared as a variadic function and narrower - // arguments are promoted. - ret_owned_fd(libc_openat( - borrowed_fd(dirfd), - c_str(path), - oflags.bits(), - c::c_uint::from(mode.bits()), - )) - } -} - -#[cfg(not(any( - solarish, - target_os = "haiku", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", -)))] -#[inline] -pub(crate) fn statfs(filename: &CStr) -> io::Result<StatFs> { - unsafe { - let mut result = MaybeUninit::<StatFs>::uninit(); - ret(libc_statfs(c_str(filename), result.as_mut_ptr()))?; - Ok(result.assume_init()) - } -} - -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -#[inline] -pub(crate) fn statvfs(filename: &CStr) -> io::Result<StatVfs> { - unsafe { - let mut result = MaybeUninit::<libc_statvfs>::uninit(); - ret(libc_statvfs(c_str(filename), result.as_mut_ptr()))?; - Ok(libc_statvfs_to_statvfs(result.assume_init())) - } -} - -#[cfg(not(target_os = "redox"))] -#[inline] -pub(crate) fn readlinkat(dirfd: BorrowedFd<'_>, path: &CStr, buf: &mut [u8]) -> io::Result<usize> { - unsafe { - ret_ssize_t(c::readlinkat( - borrowed_fd(dirfd), - c_str(path), - buf.as_mut_ptr().cast::<c::c_char>(), - buf.len(), - )) - .map(|nread| nread as usize) - } -} - -#[cfg(not(target_os = "redox"))] -pub(crate) fn mkdirat(dirfd: BorrowedFd<'_>, path: &CStr, mode: Mode) -> io::Result<()> { - unsafe { - ret(c::mkdirat( - borrowed_fd(dirfd), - c_str(path), - mode.bits() as c::mode_t, - )) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn getdents_uninit( - fd: BorrowedFd<'_>, - buf: &mut [MaybeUninit<u8>], -) -> io::Result<usize> { - unsafe { - syscall_ret_ssize_t(c::syscall( - c::SYS_getdents64, - fd, - buf.as_mut_ptr().cast::<c::c_char>(), - buf.len(), - )) - } - .map(|nread| nread as usize) -} - -#[cfg(not(target_os = "redox"))] -pub(crate) fn linkat( - old_dirfd: BorrowedFd<'_>, - old_path: &CStr, - new_dirfd: BorrowedFd<'_>, - new_path: &CStr, - flags: AtFlags, -) -> io::Result<()> { - unsafe { - ret(c::linkat( - borrowed_fd(old_dirfd), - c_str(old_path), - borrowed_fd(new_dirfd), - c_str(new_path), - flags.bits(), - )) - } -} - -#[cfg(not(target_os = "redox"))] -pub(crate) fn unlinkat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<()> { - unsafe { ret(c::unlinkat(borrowed_fd(dirfd), c_str(path), flags.bits())) } -} - -#[cfg(not(target_os = "redox"))] -pub(crate) fn renameat( - old_dirfd: BorrowedFd<'_>, - old_path: &CStr, - new_dirfd: BorrowedFd<'_>, - new_path: &CStr, -) -> io::Result<()> { - unsafe { - ret(c::renameat( - borrowed_fd(old_dirfd), - c_str(old_path), - borrowed_fd(new_dirfd), - c_str(new_path), - )) - } -} - -#[cfg(all(target_os = "linux", target_env = "gnu"))] -pub(crate) fn renameat2( - old_dirfd: BorrowedFd<'_>, - old_path: &CStr, - new_dirfd: BorrowedFd<'_>, - new_path: &CStr, - flags: RenameFlags, -) -> io::Result<()> { - // `getrandom` wasn't supported in glibc until 2.28. - weak_or_syscall! { - fn renameat2( - olddirfd: c::c_int, - oldpath: *const c::c_char, - newdirfd: c::c_int, - newpath: *const c::c_char, - flags: c::c_uint - ) via SYS_renameat2 -> c::c_int - } - - unsafe { - ret(renameat2( - borrowed_fd(old_dirfd), - c_str(old_path), - borrowed_fd(new_dirfd), - c_str(new_path), - flags.bits(), - )) - } -} - -/// At present, `libc` only has `renameat2` defined for glibc. On other -/// ABIs, `RenameFlags` has no flags defined, and we use plain `renameat`. -#[cfg(any( - target_os = "android", - all(target_os = "linux", not(target_env = "gnu")), -))] -#[inline] -pub(crate) fn renameat2( - old_dirfd: BorrowedFd<'_>, - old_path: &CStr, - new_dirfd: BorrowedFd<'_>, - new_path: &CStr, - flags: RenameFlags, -) -> io::Result<()> { - assert!(flags.is_empty()); - renameat(old_dirfd, old_path, new_dirfd, new_path) -} - -#[cfg(not(target_os = "redox"))] -pub(crate) fn symlinkat( - old_path: &CStr, - new_dirfd: BorrowedFd<'_>, - new_path: &CStr, -) -> io::Result<()> { - unsafe { - ret(c::symlinkat( - c_str(old_path), - borrowed_fd(new_dirfd), - c_str(new_path), - )) - } -} - -#[cfg(not(target_os = "redox"))] -pub(crate) fn statat(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> { - // 32-bit and mips64 Linux: `struct stat64` is not y2038 compatible; use - // `statx`. - #[cfg(all( - any(target_os = "android", target_os = "linux"), - any(target_pointer_width = "32", target_arch = "mips64"), - ))] - { - match statx(dirfd, path, flags, StatxFlags::BASIC_STATS) { - Ok(x) => statx_to_stat(x), - Err(io::Errno::NOSYS) => statat_old(dirfd, path, flags), - Err(err) => Err(err), - } - } - - // Main version: libc is y2038 safe. Or, the platform is not y2038 safe and - // there's nothing practical we can do. - #[cfg(not(all( - any(target_os = "android", target_os = "linux"), - any(target_pointer_width = "32", target_arch = "mips64"), - )))] - unsafe { - let mut stat = MaybeUninit::<Stat>::uninit(); - ret(libc_fstatat( - borrowed_fd(dirfd), - c_str(path), - stat.as_mut_ptr(), - flags.bits(), - ))?; - Ok(stat.assume_init()) - } -} - -#[cfg(all( - any(target_os = "android", target_os = "linux"), - any(target_pointer_width = "32", target_arch = "mips64"), -))] -fn statat_old(dirfd: BorrowedFd<'_>, path: &CStr, flags: AtFlags) -> io::Result<Stat> { - unsafe { - let mut result = MaybeUninit::<c::stat64>::uninit(); - ret(libc_fstatat( - borrowed_fd(dirfd), - c_str(path), - result.as_mut_ptr(), - flags.bits(), - ))?; - stat64_to_stat(result.assume_init()) - } -} - -#[cfg(not(any(solarish, target_os = "emscripten", target_os = "redox")))] -pub(crate) fn accessat( - dirfd: BorrowedFd<'_>, - path: &CStr, - access: Access, - flags: AtFlags, -) -> io::Result<()> { - unsafe { - ret(c::faccessat( - borrowed_fd(dirfd), - c_str(path), - access.bits(), - flags.bits(), - )) - } -} - -#[cfg(target_os = "emscripten")] -pub(crate) fn accessat( - _dirfd: BorrowedFd<'_>, - _path: &CStr, - _access: Access, - _flags: AtFlags, -) -> io::Result<()> { - Ok(()) -} - -#[cfg(not(target_os = "redox"))] -pub(crate) fn utimensat( - dirfd: BorrowedFd<'_>, - path: &CStr, - times: &Timestamps, - flags: AtFlags, -) -> io::Result<()> { - // 32-bit gnu version: libc has `utimensat` but it is not y2038 safe by - // default. - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - unsafe { - if let Some(libc_utimensat) = __utimensat64.get() { - let libc_times: [LibcTimespec; 2] = [ - times.last_access.clone().into(), - times.last_modification.clone().into(), - ]; - - ret(libc_utimensat( - borrowed_fd(dirfd), - c_str(path), - libc_times.as_ptr(), - flags.bits(), - )) - } else { - utimensat_old(dirfd, path, times, flags) - } - } - - // Main version: libc is y2038 safe and has `utimensat`. Or, the platform - // is not y2038 safe and there's nothing practical we can do. - #[cfg(not(any( - apple, - all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ) - )))] - unsafe { - // Assert that `Timestamps` has the expected layout. - let _ = core::mem::transmute::<Timestamps, [c::timespec; 2]>(times.clone()); - - ret(c::utimensat( - borrowed_fd(dirfd), - c_str(path), - as_ptr(times).cast(), - flags.bits(), - )) - } - - // `utimensat` was introduced in macOS 10.13. - #[cfg(apple)] - unsafe { - // ABI details - weak! { - fn utimensat( - c::c_int, - *const c::c_char, - *const c::timespec, - c::c_int - ) -> c::c_int - } - extern "C" { - fn setattrlist( - path: *const c::c_char, - attr_list: *const Attrlist, - attr_buf: *const c::c_void, - attr_buf_size: c::size_t, - options: c::c_ulong, - ) -> c::c_int; - } - const FSOPT_NOFOLLOW: c::c_ulong = 0x0000_0001; - - // If we have `utimensat`, use it. - if let Some(have_utimensat) = utimensat.get() { - // Assert that `Timestamps` has the expected layout. - let _ = core::mem::transmute::<Timestamps, [c::timespec; 2]>(times.clone()); - - return ret(have_utimensat( - borrowed_fd(dirfd), - c_str(path), - as_ptr(times).cast(), - flags.bits(), - )); - } - - // `setattrlistat` was introduced in 10.13 along with `utimensat`, so if - // we don't have `utimensat`, we don't have `setattrlistat` either. - // Emulate it using `fork`, and `fchdir` and [`setattrlist`]. - // - // [`setattrlist`]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/setattrlist.2.html - match c::fork() { - -1 => Err(io::Errno::IO), - 0 => { - if c::fchdir(borrowed_fd(dirfd)) != 0 { - let code = match libc_errno::errno().0 { - c::EACCES => 2, - c::ENOTDIR => 3, - _ => 1, - }; - c::_exit(code); - } - - let mut flags_arg = 0; - if flags.contains(AtFlags::SYMLINK_NOFOLLOW) { - flags_arg |= FSOPT_NOFOLLOW; - } - - let (attrbuf_size, times, attrs) = times_to_attrlist(times); - - if setattrlist( - c_str(path), - &attrs, - as_ptr(×).cast(), - attrbuf_size, - flags_arg, - ) != 0 - { - // Translate expected errno codes into ad-hoc integer - // values suitable for exit statuses. - let code = match libc_errno::errno().0 { - c::EACCES => 2, - c::ENOTDIR => 3, - c::EPERM => 4, - c::EROFS => 5, - c::ELOOP => 6, - c::ENOENT => 7, - c::ENAMETOOLONG => 8, - c::EINVAL => 9, - c::ESRCH => 10, - c::ENOTSUP => 11, - _ => 1, - }; - c::_exit(code); - } - - c::_exit(0); - } - child_pid => { - let mut wstatus = 0; - let _ = ret_c_int(c::waitpid(child_pid, &mut wstatus, 0))?; - if c::WIFEXITED(wstatus) { - // Translate our ad-hoc exit statuses back to errno codes. - match c::WEXITSTATUS(wstatus) { - 0 => Ok(()), - 2 => Err(io::Errno::ACCESS), - 3 => Err(io::Errno::NOTDIR), - 4 => Err(io::Errno::PERM), - 5 => Err(io::Errno::ROFS), - 6 => Err(io::Errno::LOOP), - 7 => Err(io::Errno::NOENT), - 8 => Err(io::Errno::NAMETOOLONG), - 9 => Err(io::Errno::INVAL), - 10 => Err(io::Errno::SRCH), - 11 => Err(io::Errno::NOTSUP), - _ => Err(io::Errno::IO), - } - } else { - Err(io::Errno::IO) - } - } - } - } -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -unsafe fn utimensat_old( - dirfd: BorrowedFd<'_>, - path: &CStr, - times: &Timestamps, - flags: AtFlags, -) -> io::Result<()> { - let old_times = [ - c::timespec { - tv_sec: times - .last_access - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: times.last_access.tv_nsec, - }, - c::timespec { - tv_sec: times - .last_modification - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: times.last_modification.tv_nsec, - }, - ]; - ret(c::utimensat( - borrowed_fd(dirfd), - c_str(path), - old_times.as_ptr(), - flags.bits(), - )) -} - -#[cfg(not(any( - target_os = "android", - target_os = "linux", - target_os = "redox", - target_os = "wasi", -)))] -pub(crate) fn chmodat( - dirfd: BorrowedFd<'_>, - path: &CStr, - mode: Mode, - flags: AtFlags, -) -> io::Result<()> { - unsafe { - ret(c::fchmodat( - borrowed_fd(dirfd), - c_str(path), - mode.bits() as c::mode_t, - flags.bits(), - )) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn chmodat( - dirfd: BorrowedFd<'_>, - path: &CStr, - mode: Mode, - flags: AtFlags, -) -> io::Result<()> { - // Linux's `fchmodat` does not have a flags argument. - // - // Use `c::syscall` rather than `c::fchmodat` because some libc - // implementations, such as musl, add extra logic to `fchmod` to emulate - // support for `AT_SYMLINK_NOFOLLOW`, which uses `/proc` outside our - // control. - if flags == AtFlags::SYMLINK_NOFOLLOW { - return Err(io::Errno::OPNOTSUPP); - } - if !flags.is_empty() { - return Err(io::Errno::INVAL); - } - unsafe { - // Pass `mode` as a `c_uint` even if `mode_t` is narrower, since - // `libc_openat` is declared as a variadic function and narrower - // arguments are promoted. - syscall_ret(c::syscall( - c::SYS_fchmodat, - borrowed_fd(dirfd), - c_str(path), - c::c_uint::from(mode.bits()), - )) - } -} - -#[cfg(apple)] -pub(crate) fn fclonefileat( - srcfd: BorrowedFd<'_>, - dst_dirfd: BorrowedFd<'_>, - dst: &CStr, - flags: CloneFlags, -) -> io::Result<()> { - syscall! { - fn fclonefileat( - srcfd: BorrowedFd<'_>, - dst_dirfd: BorrowedFd<'_>, - dst: *const c::c_char, - flags: c::c_int - ) via SYS_fclonefileat -> c::c_int - } - - unsafe { ret(fclonefileat(srcfd, dst_dirfd, c_str(dst), flags.bits())) } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn chownat( - dirfd: BorrowedFd<'_>, - path: &CStr, - owner: Option<Uid>, - group: Option<Gid>, - flags: AtFlags, -) -> io::Result<()> { - unsafe { - let (ow, gr) = crate::process::translate_fchown_args(owner, group); - ret(c::fchownat( - borrowed_fd(dirfd), - c_str(path), - ow, - gr, - flags.bits(), - )) - } -} - -#[cfg(not(any(apple, target_os = "redox", target_os = "wasi")))] -pub(crate) fn mknodat( - dirfd: BorrowedFd<'_>, - path: &CStr, - file_type: FileType, - mode: Mode, - dev: Dev, -) -> io::Result<()> { - unsafe { - ret(c::mknodat( - borrowed_fd(dirfd), - c_str(path), - (mode.bits() | file_type.as_raw_mode()) as c::mode_t, - dev.try_into().map_err(|_e| io::Errno::PERM)?, - )) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn copy_file_range( - fd_in: BorrowedFd<'_>, - off_in: Option<&mut u64>, - fd_out: BorrowedFd<'_>, - off_out: Option<&mut u64>, - len: usize, -) -> io::Result<usize> { - assert_eq!(size_of::<c::loff_t>(), size_of::<u64>()); - - let mut off_in_val: c::loff_t = 0; - let mut off_out_val: c::loff_t = 0; - // Silently cast; we'll get `EINVAL` if the value is negative. - let off_in_ptr = if let Some(off_in) = &off_in { - off_in_val = (**off_in) as i64; - &mut off_in_val - } else { - null_mut() - }; - let off_out_ptr = if let Some(off_out) = &off_out { - off_out_val = (**off_out) as i64; - &mut off_out_val - } else { - null_mut() - }; - let copied = unsafe { - syscall_ret_ssize_t(c::syscall( - c::SYS_copy_file_range, - borrowed_fd(fd_in), - off_in_ptr, - borrowed_fd(fd_out), - off_out_ptr, - len, - 0, // no flags are defined yet - ))? - }; - if let Some(off_in) = off_in { - *off_in = off_in_val as u64; - } - if let Some(off_out) = off_out { - *off_out = off_out_val as u64; - } - Ok(copied as usize) -} - -#[cfg(not(any( - apple, - netbsdlike, - solarish, - target_os = "dragonfly", - target_os = "haiku", - target_os = "redox", -)))] -pub(crate) fn fadvise(fd: BorrowedFd<'_>, offset: u64, len: u64, advice: Advice) -> io::Result<()> { - let offset = offset as i64; - let len = len as i64; - - // FreeBSD returns `EINVAL` on invalid offsets; emulate the POSIX behavior. - #[cfg(target_os = "freebsd")] - let offset = if (offset as i64) < 0 { - i64::MAX - } else { - offset - }; - - // FreeBSD returns `EINVAL` on overflow; emulate the POSIX behavior. - #[cfg(target_os = "freebsd")] - let len = if len > 0 && offset.checked_add(len).is_none() { - i64::MAX - offset - } else { - len - }; - - let err = unsafe { libc_posix_fadvise(borrowed_fd(fd), offset, len, advice as c::c_int) }; - - // `posix_fadvise` returns its error status rather than using `errno`. - if err == 0 { - Ok(()) - } else { - Err(io::Errno(err)) - } -} - -pub(crate) fn fcntl_getfl(fd: BorrowedFd<'_>) -> io::Result<OFlags> { - unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETFL)).map(OFlags::from_bits_truncate) } -} - -pub(crate) fn fcntl_setfl(fd: BorrowedFd<'_>, flags: OFlags) -> io::Result<()> { - unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_SETFL, flags.bits())) } -} - -#[cfg(any( - target_os = "android", - target_os = "freebsd", - target_os = "fuchsia", - target_os = "linux", -))] -pub(crate) fn fcntl_get_seals(fd: BorrowedFd<'_>) -> io::Result<SealFlags> { - unsafe { - ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GET_SEALS)) - .map(|flags| SealFlags::from_bits_unchecked(flags)) - } -} - -#[cfg(any( - target_os = "android", - target_os = "freebsd", - target_os = "fuchsia", - target_os = "linux", -))] -pub(crate) fn fcntl_add_seals(fd: BorrowedFd<'_>, seals: SealFlags) -> io::Result<()> { - unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_ADD_SEALS, seals.bits())) } -} - -#[cfg(not(any( - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", - target_os = "wasi" -)))] -#[inline] -pub(crate) fn fcntl_lock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::Result<()> { - use c::{flock, F_RDLCK, F_SETLK, F_SETLKW, F_UNLCK, F_WRLCK, SEEK_SET}; - - let (cmd, l_type) = match operation { - FlockOperation::LockShared => (F_SETLKW, F_RDLCK), - FlockOperation::LockExclusive => (F_SETLKW, F_WRLCK), - FlockOperation::Unlock => (F_SETLKW, F_UNLCK), - FlockOperation::NonBlockingLockShared => (F_SETLK, F_RDLCK), - FlockOperation::NonBlockingLockExclusive => (F_SETLK, F_WRLCK), - FlockOperation::NonBlockingUnlock => (F_SETLK, F_UNLCK), - }; - - unsafe { - let mut lock: flock = core::mem::zeroed(); - lock.l_type = l_type as _; - - // When `l_len` is zero, this locks all the bytes from - // `l_whence`/`l_start` to the end of the file, even as the - // file grows dynamically. - lock.l_whence = SEEK_SET as _; - lock.l_start = 0; - lock.l_len = 0; - - ret(c::fcntl(borrowed_fd(fd), cmd, &lock)) - } -} - -pub(crate) fn seek(fd: BorrowedFd<'_>, pos: SeekFrom) -> io::Result<u64> { - let (whence, offset): (c::c_int, libc_off_t) = match pos { - SeekFrom::Start(pos) => { - let pos: u64 = pos; - // Silently cast; we'll get `EINVAL` if the value is negative. - (c::SEEK_SET, pos as i64) - } - SeekFrom::End(offset) => (c::SEEK_END, offset), - SeekFrom::Current(offset) => (c::SEEK_CUR, offset), - #[cfg(any(freebsdlike, target_os = "linux", target_os = "solaris"))] - SeekFrom::Data(offset) => (c::SEEK_DATA, offset), - #[cfg(any(freebsdlike, target_os = "linux", target_os = "solaris"))] - SeekFrom::Hole(offset) => (c::SEEK_HOLE, offset), - }; - let offset = unsafe { ret_off_t(libc_lseek(borrowed_fd(fd), offset, whence))? }; - Ok(offset as u64) -} - -pub(crate) fn tell(fd: BorrowedFd<'_>) -> io::Result<u64> { - let offset = unsafe { ret_off_t(libc_lseek(borrowed_fd(fd), 0, c::SEEK_CUR))? }; - Ok(offset as u64) -} - -#[cfg(not(any(target_os = "android", target_os = "linux", target_os = "wasi")))] -pub(crate) fn fchmod(fd: BorrowedFd<'_>, mode: Mode) -> io::Result<()> { - unsafe { ret(c::fchmod(borrowed_fd(fd), mode.bits())) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn fchmod(fd: BorrowedFd<'_>, mode: Mode) -> io::Result<()> { - // Use `c::syscall` rather than `c::fchmod` because some libc - // implementations, such as musl, add extra logic to `fchmod` to emulate - // support for `O_PATH`, which uses `/proc` outside our control and - // interferes with our own use of `O_PATH`. - unsafe { - syscall_ret(c::syscall( - c::SYS_fchmod, - borrowed_fd(fd), - c::c_uint::from(mode.bits()), - )) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn fchown(fd: BorrowedFd<'_>, owner: Option<Uid>, group: Option<Gid>) -> io::Result<()> { - // Use `c::syscall` rather than `c::fchown` because some libc - // implementations, such as musl, add extra logic to `fchown` to emulate - // support for `O_PATH`, which uses `/proc` outside our control and - // interferes with our own use of `O_PATH`. - unsafe { - let (ow, gr) = crate::process::translate_fchown_args(owner, group); - syscall_ret(c::syscall(c::SYS_fchown, borrowed_fd(fd), ow, gr)) - } -} - -#[cfg(not(any(target_os = "android", target_os = "linux", target_os = "wasi")))] -pub(crate) fn fchown(fd: BorrowedFd<'_>, owner: Option<Uid>, group: Option<Gid>) -> io::Result<()> { - unsafe { - let (ow, gr) = crate::process::translate_fchown_args(owner, group); - ret(c::fchown(borrowed_fd(fd), ow, gr)) - } -} - -#[cfg(not(any(target_os = "solaris", target_os = "wasi")))] -pub(crate) fn flock(fd: BorrowedFd<'_>, operation: FlockOperation) -> io::Result<()> { - unsafe { ret(c::flock(borrowed_fd(fd), operation as c::c_int)) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn syncfs(fd: BorrowedFd<'_>) -> io::Result<()> { - unsafe { ret(c::syncfs(borrowed_fd(fd))) } -} - -#[cfg(not(any(solarish, target_os = "redox", target_os = "wasi")))] -pub(crate) fn sync() { - // TODO: Remove this when upstream libc adds `sync`. - #[cfg(target_os = "android")] - unsafe { - syscall_ret(c::syscall(c::SYS_sync)).ok(); - } - - #[cfg(not(target_os = "android"))] - unsafe { - c::sync() - } -} - -pub(crate) fn fstat(fd: BorrowedFd<'_>) -> io::Result<Stat> { - // 32-bit and mips64 Linux: `struct stat64` is not y2038 compatible; use - // `statx`. - #[cfg(all( - any(target_os = "android", target_os = "linux"), - any(target_pointer_width = "32", target_arch = "mips64"), - ))] - { - match statx(fd, cstr!(""), AtFlags::EMPTY_PATH, StatxFlags::BASIC_STATS) { - Ok(x) => statx_to_stat(x), - Err(io::Errno::NOSYS) => fstat_old(fd), - Err(err) => Err(err), - } - } - - // Main version: libc is y2038 safe. Or, the platform is not y2038 safe and - // there's nothing practical we can do. - #[cfg(not(all( - any(target_os = "android", target_os = "linux"), - any(target_pointer_width = "32", target_arch = "mips64"), - )))] - unsafe { - let mut stat = MaybeUninit::<Stat>::uninit(); - ret(libc_fstat(borrowed_fd(fd), stat.as_mut_ptr()))?; - Ok(stat.assume_init()) - } -} - -#[cfg(all( - any(target_os = "android", target_os = "linux"), - any(target_pointer_width = "32", target_arch = "mips64"), -))] -fn fstat_old(fd: BorrowedFd<'_>) -> io::Result<Stat> { - unsafe { - let mut result = MaybeUninit::<c::stat64>::uninit(); - ret(libc_fstat(borrowed_fd(fd), result.as_mut_ptr()))?; - stat64_to_stat(result.assume_init()) - } -} - -#[cfg(not(any( - solarish, - target_os = "haiku", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", -)))] -pub(crate) fn fstatfs(fd: BorrowedFd<'_>) -> io::Result<StatFs> { - let mut statfs = MaybeUninit::<StatFs>::uninit(); - unsafe { - ret(libc_fstatfs(borrowed_fd(fd), statfs.as_mut_ptr()))?; - Ok(statfs.assume_init()) - } -} - -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -pub(crate) fn fstatvfs(fd: BorrowedFd<'_>) -> io::Result<StatVfs> { - let mut statvfs = MaybeUninit::<libc_statvfs>::uninit(); - unsafe { - ret(libc_fstatvfs(borrowed_fd(fd), statvfs.as_mut_ptr()))?; - Ok(libc_statvfs_to_statvfs(statvfs.assume_init())) - } -} - -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -fn libc_statvfs_to_statvfs(from: libc_statvfs) -> StatVfs { - StatVfs { - f_bsize: from.f_bsize as u64, - f_frsize: from.f_frsize as u64, - f_blocks: from.f_blocks as u64, - f_bfree: from.f_bfree as u64, - f_bavail: from.f_bavail as u64, - f_files: from.f_files as u64, - f_ffree: from.f_ffree as u64, - f_favail: from.f_ffree as u64, - f_fsid: from.f_fsid as u64, - f_flag: unsafe { StatVfsMountFlags::from_bits_unchecked(from.f_flag as u64) }, - f_namemax: from.f_namemax as u64, - } -} - -pub(crate) fn futimens(fd: BorrowedFd<'_>, times: &Timestamps) -> io::Result<()> { - // 32-bit gnu version: libc has `futimens` but it is not y2038 safe by default. - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - unsafe { - if let Some(libc_futimens) = __futimens64.get() { - let libc_times: [LibcTimespec; 2] = [ - times.last_access.clone().into(), - times.last_modification.clone().into(), - ]; - - ret(libc_futimens(borrowed_fd(fd), libc_times.as_ptr())) - } else { - futimens_old(fd, times) - } - } - - // Main version: libc is y2038 safe and has `futimens`. Or, the platform - // is not y2038 safe and there's nothing practical we can do. - #[cfg(not(any( - apple, - all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ) - )))] - unsafe { - // Assert that `Timestamps` has the expected layout. - let _ = core::mem::transmute::<Timestamps, [c::timespec; 2]>(times.clone()); - - ret(c::futimens(borrowed_fd(fd), as_ptr(times).cast())) - } - - // `futimens` was introduced in macOS 10.13. - #[cfg(apple)] - unsafe { - // ABI details. - weak! { - fn futimens(c::c_int, *const c::timespec) -> c::c_int - } - extern "C" { - fn fsetattrlist( - fd: c::c_int, - attr_list: *const Attrlist, - attr_buf: *const c::c_void, - attr_buf_size: c::size_t, - options: c::c_ulong, - ) -> c::c_int; - } - - // If we have `futimens`, use it. - if let Some(have_futimens) = futimens.get() { - // Assert that `Timestamps` has the expected layout. - let _ = core::mem::transmute::<Timestamps, [c::timespec; 2]>(times.clone()); - - return ret(have_futimens(borrowed_fd(fd), as_ptr(times).cast())); - } - - // Otherwise use `fsetattrlist`. - let (attrbuf_size, times, attrs) = times_to_attrlist(times); - - ret(fsetattrlist( - borrowed_fd(fd), - &attrs, - as_ptr(×).cast(), - attrbuf_size, - 0, - )) - } -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -unsafe fn futimens_old(fd: BorrowedFd<'_>, times: &Timestamps) -> io::Result<()> { - let old_times = [ - c::timespec { - tv_sec: times - .last_access - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: times.last_access.tv_nsec, - }, - c::timespec { - tv_sec: times - .last_modification - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: times.last_modification.tv_nsec, - }, - ]; - - ret(c::futimens(borrowed_fd(fd), old_times.as_ptr())) -} - -#[cfg(not(any( - apple, - netbsdlike, - solarish, - target_os = "aix", - target_os = "dragonfly", - target_os = "redox", -)))] -pub(crate) fn fallocate( - fd: BorrowedFd<'_>, - mode: FallocateFlags, - offset: u64, - len: u64, -) -> io::Result<()> { - // Silently cast; we'll get `EINVAL` if the value is negative. - let offset = offset as i64; - let len = len as i64; - - #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] - unsafe { - ret(libc_fallocate(borrowed_fd(fd), mode.bits(), offset, len)) - } - - #[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))] - { - assert!(mode.is_empty()); - let err = unsafe { libc_posix_fallocate(borrowed_fd(fd), offset, len) }; - - // `posix_fallocate` returns its error status rather than using `errno`. - if err == 0 { - Ok(()) - } else { - Err(io::Errno(err)) - } - } -} - -#[cfg(apple)] -pub(crate) fn fallocate( - fd: BorrowedFd<'_>, - mode: FallocateFlags, - offset: u64, - len: u64, -) -> io::Result<()> { - let offset: i64 = offset.try_into().map_err(|_e| io::Errno::INVAL)?; - let len = len as i64; - - assert!(mode.is_empty()); - - let new_len = offset.checked_add(len).ok_or(io::Errno::FBIG)?; - let mut store = c::fstore_t { - fst_flags: c::F_ALLOCATECONTIG, - fst_posmode: c::F_PEOFPOSMODE, - fst_offset: 0, - fst_length: new_len, - fst_bytesalloc: 0, - }; - unsafe { - if c::fcntl(borrowed_fd(fd), c::F_PREALLOCATE, &store) == -1 { - // Unable to allocate contiguous disk space; attempt to allocate - // non-contiguously. - store.fst_flags = c::F_ALLOCATEALL; - let _ = ret_c_int(c::fcntl(borrowed_fd(fd), c::F_PREALLOCATE, &store))?; - } - ret(c::ftruncate(borrowed_fd(fd), new_len)) - } -} - -pub(crate) fn fsync(fd: BorrowedFd<'_>) -> io::Result<()> { - unsafe { ret(c::fsync(borrowed_fd(fd))) } -} - -#[cfg(not(any( - apple, - target_os = "dragonfly", - target_os = "haiku", - target_os = "redox", -)))] -pub(crate) fn fdatasync(fd: BorrowedFd<'_>) -> io::Result<()> { - unsafe { ret(c::fdatasync(borrowed_fd(fd))) } -} - -pub(crate) fn ftruncate(fd: BorrowedFd<'_>, length: u64) -> io::Result<()> { - let length = length.try_into().map_err(|_overflow_err| io::Errno::FBIG)?; - unsafe { ret(libc_ftruncate(borrowed_fd(fd), length)) } -} - -#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))] -pub(crate) fn memfd_create(path: &CStr, flags: MemfdFlags) -> io::Result<OwnedFd> { - #[cfg(target_os = "freebsd")] - weakcall! { - fn memfd_create( - name: *const c::c_char, - flags: c::c_uint - ) -> c::c_int - } - - #[cfg(any(target_os = "android", target_os = "linux"))] - weak_or_syscall! { - fn memfd_create( - name: *const c::c_char, - flags: c::c_uint - ) via SYS_memfd_create -> c::c_int - } - - unsafe { ret_owned_fd(memfd_create(c_str(path), flags.bits())) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn openat2( - dirfd: BorrowedFd<'_>, - path: &CStr, - oflags: OFlags, - mode: Mode, - resolve: ResolveFlags, -) -> io::Result<OwnedFd> { - let oflags: i32 = oflags.bits(); - let open_how = OpenHow { - oflag: u64::from(oflags as u32), - mode: u64::from(mode.bits()), - resolve: resolve.bits(), - }; - - unsafe { - syscall_ret_owned_fd(c::syscall( - SYS_OPENAT2, - borrowed_fd(dirfd), - c_str(path), - &open_how, - SIZEOF_OPEN_HOW, - )) - } -} -#[cfg(all( - target_pointer_width = "32", - any(target_os = "android", target_os = "linux"), -))] -const SYS_OPENAT2: i32 = 437; -#[cfg(all( - target_pointer_width = "64", - any(target_os = "android", target_os = "linux"), -))] -const SYS_OPENAT2: i64 = 437; - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[repr(C)] -#[derive(Debug)] -struct OpenHow { - oflag: u64, - mode: u64, - resolve: u64, -} -#[cfg(any(target_os = "android", target_os = "linux"))] -const SIZEOF_OPEN_HOW: usize = size_of::<OpenHow>(); - -#[cfg(target_os = "linux")] -pub(crate) fn sendfile( - out_fd: BorrowedFd<'_>, - in_fd: BorrowedFd<'_>, - offset: Option<&mut u64>, - count: usize, -) -> io::Result<usize> { - unsafe { - let nsent = ret_ssize_t(c::sendfile64( - borrowed_fd(out_fd), - borrowed_fd(in_fd), - offset.map_or(null_mut(), crate::utils::as_mut_ptr).cast(), - count, - ))?; - Ok(nsent as usize) - } -} - -/// Convert from a Linux `statx` value to rustix's `Stat`. -#[cfg(all( - any(target_os = "android", target_os = "linux"), - target_pointer_width = "32", -))] -fn statx_to_stat(x: crate::fs::Statx) -> io::Result<Stat> { - Ok(Stat { - st_dev: crate::fs::makedev(x.stx_dev_major, x.stx_dev_minor).into(), - st_mode: x.stx_mode.into(), - st_nlink: x.stx_nlink.into(), - st_uid: x.stx_uid.into(), - st_gid: x.stx_gid.into(), - st_rdev: crate::fs::makedev(x.stx_rdev_major, x.stx_rdev_minor).into(), - st_size: x.stx_size.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_blksize: x.stx_blksize.into(), - st_blocks: x.stx_blocks.into(), - st_atime: x - .stx_atime - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - st_atime_nsec: x.stx_atime.tv_nsec as _, - st_mtime: x - .stx_mtime - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - st_mtime_nsec: x.stx_mtime.tv_nsec as _, - st_ctime: x - .stx_ctime - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - st_ctime_nsec: x.stx_ctime.tv_nsec as _, - st_ino: x.stx_ino.into(), - }) -} - -/// Convert from a Linux `statx` value to rustix's `Stat`. -/// -/// mips64' `struct stat64` in libc has private fields, and `stx_blocks` -#[cfg(all( - any(target_os = "android", target_os = "linux"), - target_arch = "mips64", -))] -fn statx_to_stat(x: crate::fs::Statx) -> io::Result<Stat> { - let mut result: Stat = unsafe { core::mem::zeroed() }; - - result.st_dev = crate::fs::makedev(x.stx_dev_major, x.stx_dev_minor); - result.st_mode = x.stx_mode.into(); - result.st_nlink = x.stx_nlink.into(); - result.st_uid = x.stx_uid.into(); - result.st_gid = x.stx_gid.into(); - result.st_rdev = crate::fs::makedev(x.stx_rdev_major, x.stx_rdev_minor); - result.st_size = x.stx_size.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_blksize = x.stx_blksize.into(); - result.st_blocks = x.stx_blocks.try_into().map_err(|_e| io::Errno::OVERFLOW)?; - result.st_atime = x - .stx_atime - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?; - result.st_atime_nsec = x.stx_atime.tv_nsec as _; - result.st_mtime = x - .stx_mtime - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?; - result.st_mtime_nsec = x.stx_mtime.tv_nsec as _; - result.st_ctime = x - .stx_ctime - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?; - result.st_ctime_nsec = x.stx_ctime.tv_nsec as _; - result.st_ino = x.stx_ino.into(); - - Ok(result) -} - -/// Convert from a Linux `stat64` value to rustix's `Stat`. -#[cfg(all( - any(target_os = "android", target_os = "linux"), - target_pointer_width = "32", -))] -fn stat64_to_stat(s64: c::stat64) -> io::Result<Stat> { - Ok(Stat { - st_dev: s64.st_dev.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_mode: s64.st_mode.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_nlink: s64.st_nlink.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_uid: s64.st_uid.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_gid: s64.st_gid.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_rdev: s64.st_rdev.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_size: s64.st_size.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_blksize: s64.st_blksize.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_blocks: s64.st_blocks.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_atime: s64.st_atime.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_atime_nsec: s64 - .st_atime_nsec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - st_mtime: s64.st_mtime.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_mtime_nsec: s64 - .st_mtime_nsec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - st_ctime: s64.st_ctime.try_into().map_err(|_| io::Errno::OVERFLOW)?, - st_ctime_nsec: s64 - .st_ctime_nsec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - st_ino: s64.st_ino.try_into().map_err(|_| io::Errno::OVERFLOW)?, - }) -} - -/// Convert from a Linux `stat64` value to rustix's `Stat`. -/// -/// mips64' `struct stat64` in libc has private fields, and `st_blocks` has -/// type `i64`. -#[cfg(all( - any(target_os = "android", target_os = "linux"), - target_arch = "mips64", -))] -fn stat64_to_stat(s64: c::stat64) -> io::Result<Stat> { - let mut result: Stat = unsafe { core::mem::zeroed() }; - - result.st_dev = s64.st_dev.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_mode = s64.st_mode.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_nlink = s64.st_nlink.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_uid = s64.st_uid.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_gid = s64.st_gid.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_rdev = s64.st_rdev.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_size = s64.st_size.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_blksize = s64.st_blksize.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_blocks = s64.st_blocks.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_atime = s64.st_atime.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_atime_nsec = s64 - .st_atime_nsec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?; - result.st_mtime = s64.st_mtime.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_mtime_nsec = s64 - .st_mtime_nsec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?; - result.st_ctime = s64.st_ctime.try_into().map_err(|_| io::Errno::OVERFLOW)?; - result.st_ctime_nsec = s64 - .st_ctime_nsec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?; - result.st_ino = s64.st_ino.try_into().map_err(|_| io::Errno::OVERFLOW)?; - - Ok(result) -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[allow(non_upper_case_globals)] -mod sys { - use super::{c, BorrowedFd, Statx}; - - weak_or_syscall! { - pub(super) fn statx( - dirfd_: BorrowedFd<'_>, - path: *const c::c_char, - flags: c::c_int, - mask: c::c_uint, - buf: *mut Statx - ) via SYS_statx -> c::c_int - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[allow(non_upper_case_globals)] -pub(crate) fn statx( - dirfd: BorrowedFd<'_>, - path: &CStr, - flags: AtFlags, - mask: StatxFlags, -) -> io::Result<Statx> { - // If a future Linux kernel adds more fields to `struct statx` and users - // passing flags unknown to rustix in `StatxFlags`, we could end up - // writing outside of the buffer. To prevent this possibility, we mask off - // any flags that we don't know about. - // - // This includes `STATX__RESERVED`, which has a value that we know, but - // which could take on arbitrary new meaning in the future. Linux currently - // rejects this flag with `EINVAL`, so we do the same. - // - // This doesn't rely on `STATX_ALL` because [it's deprecated] and already - // doesn't represent all the known flags. - // - // [it's deprecated]: https://patchwork.kernel.org/project/linux-fsdevel/patch/20200505095915.11275-7-mszeredi@redhat.com/ - #[cfg(not(any(target_os = "android", target_env = "musl")))] - const STATX__RESERVED: u32 = libc::STATX__RESERVED as u32; - #[cfg(any(target_os = "android", target_env = "musl"))] - const STATX__RESERVED: u32 = linux_raw_sys::general::STATX__RESERVED; - if (mask.bits() & STATX__RESERVED) == STATX__RESERVED { - return Err(io::Errno::INVAL); - } - let mask = mask & StatxFlags::all(); - - let mut statx_buf = MaybeUninit::<Statx>::uninit(); - unsafe { - ret(sys::statx( - dirfd, - c_str(path), - flags.bits(), - mask.bits(), - statx_buf.as_mut_ptr(), - ))?; - Ok(statx_buf.assume_init()) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn is_statx_available() -> bool { - unsafe { - // Call `statx` with null pointers so that if it fails for any reason - // other than `EFAULT`, we know it's not supported. - matches!( - ret(sys::statx(cwd(), null(), 0, 0, null_mut())), - Err(io::Errno::FAULT) - ) - } -} - -#[cfg(apple)] -pub(crate) unsafe fn fcopyfile( - from: BorrowedFd<'_>, - to: BorrowedFd<'_>, - state: copyfile_state_t, - flags: CopyfileFlags, -) -> io::Result<()> { - extern "C" { - fn fcopyfile( - from: c::c_int, - to: c::c_int, - state: copyfile_state_t, - flags: c::c_uint, - ) -> c::c_int; - } - - nonnegative_ret(fcopyfile( - borrowed_fd(from), - borrowed_fd(to), - state, - flags.bits(), - )) -} - -#[cfg(apple)] -pub(crate) fn copyfile_state_alloc() -> io::Result<copyfile_state_t> { - extern "C" { - fn copyfile_state_alloc() -> copyfile_state_t; - } - - let result = unsafe { copyfile_state_alloc() }; - if result.0.is_null() { - Err(io::Errno::last_os_error()) - } else { - Ok(result) - } -} - -#[cfg(apple)] -pub(crate) unsafe fn copyfile_state_free(state: copyfile_state_t) -> io::Result<()> { - extern "C" { - fn copyfile_state_free(state: copyfile_state_t) -> c::c_int; - } - - nonnegative_ret(copyfile_state_free(state)) -} - -#[cfg(apple)] -const COPYFILE_STATE_COPIED: u32 = 8; - -#[cfg(apple)] -pub(crate) unsafe fn copyfile_state_get_copied(state: copyfile_state_t) -> io::Result<u64> { - let mut copied = MaybeUninit::<u64>::uninit(); - copyfile_state_get(state, COPYFILE_STATE_COPIED, copied.as_mut_ptr().cast())?; - Ok(copied.assume_init()) -} - -#[cfg(apple)] -pub(crate) unsafe fn copyfile_state_get( - state: copyfile_state_t, - flag: u32, - dst: *mut c::c_void, -) -> io::Result<()> { - extern "C" { - fn copyfile_state_get(state: copyfile_state_t, flag: u32, dst: *mut c::c_void) -> c::c_int; - } - - nonnegative_ret(copyfile_state_get(state, flag, dst)) -} - -#[cfg(apple)] -pub(crate) fn getpath(fd: BorrowedFd<'_>) -> io::Result<CString> { - // The use of `PATH_MAX` is generally not encouraged, but it - // is inevitable in this case because macOS defines `fcntl` with - // `F_GETPATH` in terms of `MAXPATHLEN`, and there are no - // alternatives. If a better method is invented, it should be used - // instead. - let mut buf = alloc::vec![0; c::PATH_MAX as usize]; - - // From the [macOS `fcntl` man page]: - // `F_GETPATH` - Get the path of the file descriptor `Fildes`. The argument - // must be a buffer of size `MAXPATHLEN` or greater. - // - // [macOS `fcntl` man page]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fcntl.2.html - unsafe { - ret(c::fcntl(borrowed_fd(fd), c::F_GETPATH, buf.as_mut_ptr()))?; - } - - let l = buf.iter().position(|&c| c == 0).unwrap(); - buf.truncate(l); - - // TODO: On Rust 1.56, we can use `shrink_to` here. - //buf.shrink_to(l + 1); - buf.shrink_to_fit(); - - Ok(CString::new(buf).unwrap()) -} - -#[cfg(apple)] -pub(crate) fn fcntl_rdadvise(fd: BorrowedFd<'_>, offset: u64, len: u64) -> io::Result<()> { - // From the [macOS `fcntl` man page]: - // `F_RDADVISE` - Issue an advisory read async with no copy to user. - // - // The `F_RDADVISE` command operates on the following structure which holds - // information passed from the user to the system: - // - // ```c - // struct radvisory { - // off_t ra_offset; /* offset into the file */ - // int ra_count; /* size of the read */ - // }; - // ``` - // - // [macOS `fcntl` man page]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fcntl.2.html - let ra_offset = match offset.try_into() { - Ok(len) => len, - // If this conversion fails, the user is providing an offset outside - // any possible file extent, so just ignore it. - Err(_) => return Ok(()), - }; - let ra_count = match len.try_into() { - Ok(len) => len, - // If this conversion fails, the user is providing a dubiously large - // hint which is unlikely to improve performance. - Err(_) => return Ok(()), - }; - unsafe { - let radvisory = c::radvisory { - ra_offset, - ra_count, - }; - ret(c::fcntl(borrowed_fd(fd), c::F_RDADVISE, &radvisory)) - } -} - -#[cfg(apple)] -pub(crate) fn fcntl_fullfsync(fd: BorrowedFd<'_>) -> io::Result<()> { - unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_FULLFSYNC)) } -} - -/// Convert `times` from a `futimens`/`utimensat` argument into `setattrlist` -/// arguments. -#[cfg(apple)] -fn times_to_attrlist(times: &Timestamps) -> (c::size_t, [c::timespec; 2], Attrlist) { - // ABI details. - const ATTR_CMN_MODTIME: u32 = 0x0000_0400; - const ATTR_CMN_ACCTIME: u32 = 0x0000_1000; - const ATTR_BIT_MAP_COUNT: u16 = 5; - - let mut times = times.clone(); - - // If we have any `UTIME_NOW` elements, replace them with the current time. - if times.last_access.tv_nsec == c::UTIME_NOW || times.last_modification.tv_nsec == c::UTIME_NOW - { - let now = { - let mut tv = c::timeval { - tv_sec: 0, - tv_usec: 0, - }; - unsafe { - let r = c::gettimeofday(&mut tv, null_mut()); - assert_eq!(r, 0); - } - c::timespec { - tv_sec: tv.tv_sec, - tv_nsec: (tv.tv_usec * 1000) as _, - } - }; - if times.last_access.tv_nsec == c::UTIME_NOW { - times.last_access = now; - } - if times.last_modification.tv_nsec == c::UTIME_NOW { - times.last_modification = now; - } - } - - // Pack the return values following the rules for [`getattrlist`]. - // - // [`getattrlist`]: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getattrlist.2.html - let mut times_size = 0; - let mut attrs = Attrlist { - bitmapcount: ATTR_BIT_MAP_COUNT, - reserved: 0, - commonattr: 0, - volattr: 0, - dirattr: 0, - fileattr: 0, - forkattr: 0, - }; - let mut return_times = [c::timespec { - tv_sec: 0, - tv_nsec: 0, - }; 2]; - let mut times_index = 0; - if times.last_modification.tv_nsec != c::UTIME_OMIT { - attrs.commonattr |= ATTR_CMN_MODTIME; - return_times[times_index] = times.last_modification; - times_index += 1; - times_size += size_of::<c::timespec>(); - } - if times.last_access.tv_nsec != c::UTIME_OMIT { - attrs.commonattr |= ATTR_CMN_ACCTIME; - return_times[times_index] = times.last_access; - times_size += size_of::<c::timespec>(); - } - - (times_size, return_times, attrs) -} - -/// Support type for `Attrlist`. -#[cfg(apple)] -type Attrgroup = u32; - -/// Attribute list for use with `setattrlist`. -#[cfg(apple)] -#[repr(C)] -struct Attrlist { - bitmapcount: u16, - reserved: u16, - commonattr: Attrgroup, - volattr: Attrgroup, - dirattr: Attrgroup, - fileattr: Attrgroup, - forkattr: Attrgroup, -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn mount( - source: Option<&CStr>, - target: &CStr, - file_system_type: Option<&CStr>, - flags: super::types::MountFlagsArg, - data: Option<&CStr>, -) -> io::Result<()> { - unsafe { - ret(c::mount( - source.map_or_else(null, CStr::as_ptr), - target.as_ptr(), - file_system_type.map_or_else(null, CStr::as_ptr), - flags.0, - data.map_or_else(null, CStr::as_ptr).cast(), - )) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn unmount(target: &CStr, flags: super::types::UnmountFlags) -> io::Result<()> { - unsafe { ret(c::umount2(target.as_ptr(), flags.bits())) } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/fs/types.rs b/vendor/rustix-0.37.6/src/backend/libc/fs/types.rs deleted file mode 100644 index f635f2cca..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/fs/types.rs +++ /dev/null @@ -1,1150 +0,0 @@ -use super::super::c; -use bitflags::bitflags; - -bitflags! { - /// `*_OK` constants for use with [`accessat`]. - /// - /// [`accessat`]: fn.accessat.html - pub struct Access: c::c_int { - /// `R_OK` - const READ_OK = c::R_OK; - - /// `W_OK` - const WRITE_OK = c::W_OK; - - /// `X_OK` - const EXEC_OK = c::X_OK; - - /// `F_OK` - const EXISTS = c::F_OK; - } -} - -#[cfg(not(target_os = "redox"))] -bitflags! { - /// `AT_*` constants for use with [`openat`], [`statat`], and other `*at` - /// functions. - /// - /// [`openat`]: crate::fs::openat - /// [`statat`]: crate::fs::statat - pub struct AtFlags: c::c_int { - /// `AT_REMOVEDIR` - const REMOVEDIR = c::AT_REMOVEDIR; - - /// `AT_SYMLINK_FOLLOW` - const SYMLINK_FOLLOW = c::AT_SYMLINK_FOLLOW; - - /// `AT_SYMLINK_NOFOLLOW` - const SYMLINK_NOFOLLOW = c::AT_SYMLINK_NOFOLLOW; - - /// `AT_EMPTY_PATH` - #[cfg(any( - target_os = "android", - target_os = "freebsd", - target_os = "fuchsia", - target_os = "linux", - ))] - const EMPTY_PATH = c::AT_EMPTY_PATH; - - /// `AT_RESOLVE_BENEATH` - #[cfg(target_os = "freebsd")] - const RESOLVE_BENEATH = c::AT_RESOLVE_BENEATH; - - /// `AT_EACCESS` - #[cfg(not(any(target_os = "emscripten", target_os = "android")))] - const EACCESS = c::AT_EACCESS; - - /// `AT_STATX_SYNC_AS_STAT` - #[cfg(all(target_os = "linux", target_env = "gnu"))] - const STATX_SYNC_AS_STAT = c::AT_STATX_SYNC_AS_STAT; - - /// `AT_STATX_FORCE_SYNC` - #[cfg(all(target_os = "linux", target_env = "gnu"))] - const STATX_FORCE_SYNC = c::AT_STATX_FORCE_SYNC; - - /// `AT_STATX_DONT_SYNC` - #[cfg(all(target_os = "linux", target_env = "gnu"))] - const STATX_DONT_SYNC = c::AT_STATX_DONT_SYNC; - } -} - -bitflags! { - /// `S_I*` constants for use with [`openat`], [`chmodat`], and [`fchmod`]. - /// - /// [`openat`]: crate::fs::openat - /// [`chmodat`]: crate::fs::chmodat - /// [`fchmod`]: crate::fs::fchmod - pub struct Mode: RawMode { - /// `S_IRWXU` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const RWXU = c::S_IRWXU as RawMode; - - /// `S_IRUSR` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const RUSR = c::S_IRUSR as RawMode; - - /// `S_IWUSR` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const WUSR = c::S_IWUSR as RawMode; - - /// `S_IXUSR` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const XUSR = c::S_IXUSR as RawMode; - - /// `S_IRWXG` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const RWXG = c::S_IRWXG as RawMode; - - /// `S_IRGRP` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const RGRP = c::S_IRGRP as RawMode; - - /// `S_IWGRP` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const WGRP = c::S_IWGRP as RawMode; - - /// `S_IXGRP` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const XGRP = c::S_IXGRP as RawMode; - - /// `S_IRWXO` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const RWXO = c::S_IRWXO as RawMode; - - /// `S_IROTH` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const ROTH = c::S_IROTH as RawMode; - - /// `S_IWOTH` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const WOTH = c::S_IWOTH as RawMode; - - /// `S_IXOTH` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const XOTH = c::S_IXOTH as RawMode; - - /// `S_ISUID` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const SUID = c::S_ISUID as RawMode; - - /// `S_ISGID` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const SGID = c::S_ISGID as RawMode; - - /// `S_ISVTX` - #[cfg(not(target_os = "wasi"))] // WASI doesn't have Unix-style mode flags. - const SVTX = c::S_ISVTX as RawMode; - } -} - -impl Mode { - /// Construct a `Mode` from the mode bits of the `st_mode` field of - /// a `Stat`. - #[inline] - pub const fn from_raw_mode(st_mode: RawMode) -> Self { - Self::from_bits_truncate(st_mode) - } - - /// Construct an `st_mode` value from `Stat`. - #[inline] - pub const fn as_raw_mode(self) -> RawMode { - self.bits() - } -} - -impl From<RawMode> for Mode { - /// Support conversions from raw mode values to `Mode`. - /// - /// ``` - /// use rustix::fs::{Mode, RawMode}; - /// assert_eq!(Mode::from(0o700), Mode::RWXU); - /// ``` - #[inline] - fn from(st_mode: RawMode) -> Self { - Self::from_raw_mode(st_mode) - } -} - -impl From<Mode> for RawMode { - /// Support conversions from `Mode to raw mode values. - /// - /// ``` - /// use rustix::fs::{Mode, RawMode}; - /// assert_eq!(RawMode::from(Mode::RWXU), 0o700); - /// ``` - #[inline] - fn from(mode: Mode) -> Self { - mode.as_raw_mode() - } -} - -bitflags! { - /// `O_*` constants for use with [`openat`]. - /// - /// [`openat`]: crate::fs::openat - pub struct OFlags: c::c_int { - /// `O_ACCMODE` - const ACCMODE = c::O_ACCMODE; - - /// Similar to `ACCMODE`, but just includes the read/write flags, and - /// no other flags. - /// - /// Some implementations include `O_PATH` in `O_ACCMODE`, when - /// sometimes we really just want the read/write bits. Caution is - /// indicated, as the presence of `O_PATH` may mean that the read/write - /// bits don't have their usual meaning. - const RWMODE = c::O_RDONLY | c::O_WRONLY | c::O_RDWR; - - /// `O_APPEND` - const APPEND = c::O_APPEND; - - /// `O_CREAT` - #[doc(alias = "CREAT")] - const CREATE = c::O_CREAT; - - /// `O_DIRECTORY` - const DIRECTORY = c::O_DIRECTORY; - - /// `O_DSYNC` - #[cfg(not(any(target_os = "dragonfly", target_os = "redox")))] - const DSYNC = c::O_DSYNC; - - /// `O_EXCL` - const EXCL = c::O_EXCL; - - /// `O_FSYNC` - #[cfg(any( - bsd, - all(target_os = "linux", not(target_env = "musl")), - ))] - const FSYNC = c::O_FSYNC; - - /// `O_NOFOLLOW` - const NOFOLLOW = c::O_NOFOLLOW; - - /// `O_NONBLOCK` - const NONBLOCK = c::O_NONBLOCK; - - /// `O_RDONLY` - const RDONLY = c::O_RDONLY; - - /// `O_WRONLY` - const WRONLY = c::O_WRONLY; - - /// `O_RDWR` - const RDWR = c::O_RDWR; - - /// `O_NOCTTY` - #[cfg(not(target_os = "redox"))] - const NOCTTY = c::O_NOCTTY; - - /// `O_RSYNC` - #[cfg(any( - netbsdlike, - target_os = "android", - target_os = "emscripten", - target_os = "linux", - target_os = "wasi", - ))] - const RSYNC = c::O_RSYNC; - - /// `O_SYNC` - #[cfg(not(target_os = "redox"))] - const SYNC = c::O_SYNC; - - /// `O_TRUNC` - const TRUNC = c::O_TRUNC; - - /// `O_PATH` - #[cfg(any( - target_os = "android", - target_os = "emscripten", - target_os = "freebsd", - target_os = "fuchsia", - target_os = "linux", - target_os = "redox", - ))] - const PATH = c::O_PATH; - - /// `O_CLOEXEC` - const CLOEXEC = c::O_CLOEXEC; - - /// `O_TMPFILE` - #[cfg(any( - target_os = "android", - target_os = "emscripten", - target_os = "fuchsia", - target_os = "linux", - ))] - const TMPFILE = c::O_TMPFILE; - - /// `O_NOATIME` - #[cfg(any( - target_os = "android", - target_os = "fuchsia", - target_os = "linux", - ))] - const NOATIME = c::O_NOATIME; - - /// `O_DIRECT` - #[cfg(any( - target_os = "android", - target_os = "emscripten", - target_os = "freebsd", - target_os = "fuchsia", - target_os = "linux", - target_os = "netbsd", - ))] - const DIRECT = c::O_DIRECT; - - /// `O_RESOLVE_BENEATH` - #[cfg(target_os = "freebsd")] - const RESOLVE_BENEATH = c::O_RESOLVE_BENEATH; - - /// `O_EMPTY_PATH` - #[cfg(target_os = "freebsd")] - const EMPTY_PATH = c::O_EMPTY_PATH; - } -} - -#[cfg(apple)] -bitflags! { - /// `CLONE_*` constants for use with [`fclonefileat`]. - /// - /// [`fclonefileat`]: crate::fs::fclonefileat - pub struct CloneFlags: c::c_int { - /// `CLONE_NOFOLLOW` - const NOFOLLOW = 1; - - /// `CLONE_NOOWNERCOPY` - const NOOWNERCOPY = 2; - } -} - -#[cfg(apple)] -mod copyfile { - pub(super) const ACL: u32 = 1 << 0; - pub(super) const STAT: u32 = 1 << 1; - pub(super) const XATTR: u32 = 1 << 2; - pub(super) const DATA: u32 = 1 << 3; - pub(super) const SECURITY: u32 = STAT | ACL; - pub(super) const METADATA: u32 = SECURITY | XATTR; - pub(super) const ALL: u32 = METADATA | DATA; -} - -#[cfg(apple)] -bitflags! { - /// `COPYFILE_*` constants. - pub struct CopyfileFlags: c::c_uint { - /// `COPYFILE_ACL` - const ACL = copyfile::ACL; - - /// `COPYFILE_STAT` - const STAT = copyfile::STAT; - - /// `COPYFILE_XATTR` - const XATTR = copyfile::XATTR; - - /// `COPYFILE_DATA` - const DATA = copyfile::DATA; - - /// `COPYFILE_SECURITY` - const SECURITY = copyfile::SECURITY; - - /// `COPYFILE_METADATA` - const METADATA = copyfile::METADATA; - - /// `COPYFILE_ALL` - const ALL = copyfile::ALL; - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `RESOLVE_*` constants for use with [`openat2`]. - /// - /// [`openat2`]: crate::fs::openat2 - #[derive(Default)] - pub struct ResolveFlags: u64 { - /// `RESOLVE_NO_XDEV` - const NO_XDEV = 0x01; - - /// `RESOLVE_NO_MAGICLINKS` - const NO_MAGICLINKS = 0x02; - - /// `RESOLVE_NO_SYMLINKS` - const NO_SYMLINKS = 0x04; - - /// `RESOLVE_BENEATH` - const BENEATH = 0x08; - - /// `RESOLVE_IN_ROOT` - const IN_ROOT = 0x10; - - /// `RESOLVE_CACHED` (since Linux 5.12) - const CACHED = 0x20; - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `RENAME_*` constants for use with [`renameat_with`]. - /// - /// [`renameat_with`]: crate::fs::renameat_with - pub struct RenameFlags: c::c_uint { - /// `RENAME_EXCHANGE` - const EXCHANGE = c::RENAME_EXCHANGE as _; - - /// `RENAME_NOREPLACE` - const NOREPLACE = c::RENAME_NOREPLACE as _; - - /// `RENAME_WHITEOUT` - const WHITEOUT = c::RENAME_WHITEOUT as _; - } -} - -/// `S_IF*` constants for use with [`mknodat`] and [`Stat`]'s `st_mode` field. -/// -/// [`mknodat`]: crate::fs::mknodat -/// [`Stat`]: crate::fs::Stat -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum FileType { - /// `S_IFREG` - RegularFile = c::S_IFREG as isize, - - /// `S_IFDIR` - Directory = c::S_IFDIR as isize, - - /// `S_IFLNK` - Symlink = c::S_IFLNK as isize, - - /// `S_IFIFO` - #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFIFO`. - #[doc(alias = "IFO")] - Fifo = c::S_IFIFO as isize, - - /// `S_IFSOCK` - #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFSOCK`. - Socket = c::S_IFSOCK as isize, - - /// `S_IFCHR` - CharacterDevice = c::S_IFCHR as isize, - - /// `S_IFBLK` - BlockDevice = c::S_IFBLK as isize, - - /// An unknown filesystem object. - Unknown, -} - -impl FileType { - /// Construct a `FileType` from the `S_IFMT` bits of the `st_mode` field of - /// a `Stat`. - pub const fn from_raw_mode(st_mode: RawMode) -> Self { - match (st_mode as c::mode_t) & c::S_IFMT { - c::S_IFREG => Self::RegularFile, - c::S_IFDIR => Self::Directory, - c::S_IFLNK => Self::Symlink, - #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFIFO`. - c::S_IFIFO => Self::Fifo, - #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFSOCK`. - c::S_IFSOCK => Self::Socket, - c::S_IFCHR => Self::CharacterDevice, - c::S_IFBLK => Self::BlockDevice, - _ => Self::Unknown, - } - } - - /// Construct an `st_mode` value from `Stat`. - pub const fn as_raw_mode(self) -> RawMode { - match self { - Self::RegularFile => c::S_IFREG as RawMode, - Self::Directory => c::S_IFDIR as RawMode, - Self::Symlink => c::S_IFLNK as RawMode, - #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFIFO`. - Self::Fifo => c::S_IFIFO as RawMode, - #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFSOCK`. - Self::Socket => c::S_IFSOCK as RawMode, - Self::CharacterDevice => c::S_IFCHR as RawMode, - Self::BlockDevice => c::S_IFBLK as RawMode, - Self::Unknown => c::S_IFMT as RawMode, - } - } - - /// Construct a `FileType` from the `d_type` field of a `c::dirent`. - #[cfg(not(any(solarish, target_os = "haiku", target_os = "redox")))] - pub(crate) const fn from_dirent_d_type(d_type: u8) -> Self { - match d_type { - c::DT_REG => Self::RegularFile, - c::DT_DIR => Self::Directory, - c::DT_LNK => Self::Symlink, - #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `DT_SOCK`. - c::DT_SOCK => Self::Socket, - #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `DT_FIFO`. - c::DT_FIFO => Self::Fifo, - c::DT_CHR => Self::CharacterDevice, - c::DT_BLK => Self::BlockDevice, - // c::DT_UNKNOWN | - _ => Self::Unknown, - } - } -} - -/// `POSIX_FADV_*` constants for use with [`fadvise`]. -/// -/// [`fadvise`]: crate::fs::fadvise -#[cfg(not(any( - apple, - netbsdlike, - solarish, - target_os = "dragonfly", - target_os = "haiku", - target_os = "redox", -)))] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -#[repr(u32)] -pub enum Advice { - /// `POSIX_FADV_NORMAL` - Normal = c::POSIX_FADV_NORMAL as c::c_uint, - - /// `POSIX_FADV_SEQUENTIAL` - Sequential = c::POSIX_FADV_SEQUENTIAL as c::c_uint, - - /// `POSIX_FADV_RANDOM` - Random = c::POSIX_FADV_RANDOM as c::c_uint, - - /// `POSIX_FADV_NOREUSE` - NoReuse = c::POSIX_FADV_NOREUSE as c::c_uint, - - /// `POSIX_FADV_WILLNEED` - WillNeed = c::POSIX_FADV_WILLNEED as c::c_uint, - - /// `POSIX_FADV_DONTNEED` - DontNeed = c::POSIX_FADV_DONTNEED as c::c_uint, -} - -#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))] -bitflags! { - /// `MFD_*` constants for use with [`memfd_create`]. - /// - /// [`memfd_create`]: crate::fs::memfd_create - pub struct MemfdFlags: c::c_uint { - /// `MFD_CLOEXEC` - const CLOEXEC = c::MFD_CLOEXEC; - - /// `MFD_ALLOW_SEALING` - const ALLOW_SEALING = c::MFD_ALLOW_SEALING; - - /// `MFD_HUGETLB` (since Linux 4.14) - const HUGETLB = c::MFD_HUGETLB; - - /// `MFD_HUGE_64KB` - const HUGE_64KB = c::MFD_HUGE_64KB; - /// `MFD_HUGE_512JB` - const HUGE_512KB = c::MFD_HUGE_512KB; - /// `MFD_HUGE_1MB` - const HUGE_1MB = c::MFD_HUGE_1MB; - /// `MFD_HUGE_2MB` - const HUGE_2MB = c::MFD_HUGE_2MB; - /// `MFD_HUGE_8MB` - const HUGE_8MB = c::MFD_HUGE_8MB; - /// `MFD_HUGE_16MB` - const HUGE_16MB = c::MFD_HUGE_16MB; - /// `MFD_HUGE_32MB` - const HUGE_32MB = c::MFD_HUGE_32MB; - /// `MFD_HUGE_256MB` - const HUGE_256MB = c::MFD_HUGE_256MB; - /// `MFD_HUGE_512MB` - const HUGE_512MB = c::MFD_HUGE_512MB; - /// `MFD_HUGE_1GB` - const HUGE_1GB = c::MFD_HUGE_1GB; - /// `MFD_HUGE_2GB` - const HUGE_2GB = c::MFD_HUGE_2GB; - /// `MFD_HUGE_16GB` - const HUGE_16GB = c::MFD_HUGE_16GB; - } -} - -#[cfg(any( - target_os = "android", - target_os = "freebsd", - target_os = "fuchsia", - target_os = "linux", -))] -bitflags! { - /// `F_SEAL_*` constants for use with [`fcntl_add_seals`] and - /// [`fcntl_get_seals`]. - /// - /// [`fcntl_add_seals`]: crate::fs::fcntl_add_seals - /// [`fcntl_get_seals`]: crate::fs::fcntl_get_seals - pub struct SealFlags: i32 { - /// `F_SEAL_SEAL`. - const SEAL = c::F_SEAL_SEAL; - /// `F_SEAL_SHRINK`. - const SHRINK = c::F_SEAL_SHRINK; - /// `F_SEAL_GROW`. - const GROW = c::F_SEAL_GROW; - /// `F_SEAL_WRITE`. - const WRITE = c::F_SEAL_WRITE; - /// `F_SEAL_FUTURE_WRITE` (since Linux 5.1) - #[cfg(any(target_os = "android", target_os = "linux"))] - const FUTURE_WRITE = c::F_SEAL_FUTURE_WRITE; - } -} - -#[cfg(all(target_os = "linux", target_env = "gnu"))] -bitflags! { - /// `STATX_*` constants for use with [`statx`]. - /// - /// [`statx`]: crate::fs::statx - pub struct StatxFlags: u32 { - /// `STATX_TYPE` - const TYPE = c::STATX_TYPE; - - /// `STATX_MODE` - const MODE = c::STATX_MODE; - - /// `STATX_NLINK` - const NLINK = c::STATX_NLINK; - - /// `STATX_UID` - const UID = c::STATX_UID; - - /// `STATX_GID` - const GID = c::STATX_GID; - - /// `STATX_ATIME` - const ATIME = c::STATX_ATIME; - - /// `STATX_MTIME` - const MTIME = c::STATX_MTIME; - - /// `STATX_CTIME` - const CTIME = c::STATX_CTIME; - - /// `STATX_INO` - const INO = c::STATX_INO; - - /// `STATX_SIZE` - const SIZE = c::STATX_SIZE; - - /// `STATX_BLOCKS` - const BLOCKS = c::STATX_BLOCKS; - - /// `STATX_BASIC_STATS` - const BASIC_STATS = c::STATX_BASIC_STATS; - - /// `STATX_BTIME` - const BTIME = c::STATX_BTIME; - - /// `STATX_MNT_ID` (since Linux 5.8) - const MNT_ID = c::STATX_MNT_ID; - - /// `STATX_ALL` - const ALL = c::STATX_ALL; - } -} - -#[cfg(any( - target_os = "android", - all(target_os = "linux", not(target_env = "gnu")), -))] -bitflags! { - /// `STATX_*` constants for use with [`statx`]. - /// - /// [`statx`]: crate::fs::statx - pub struct StatxFlags: u32 { - /// `STATX_TYPE` - const TYPE = 0x0001; - - /// `STATX_MODE` - const MODE = 0x0002; - - /// `STATX_NLINK` - const NLINK = 0x0004; - - /// `STATX_UID` - const UID = 0x0008; - - /// `STATX_GID` - const GID = 0x0010; - - /// `STATX_ATIME` - const ATIME = 0x0020; - - /// `STATX_MTIME` - const MTIME = 0x0040; - - /// `STATX_CTIME` - const CTIME = 0x0080; - - /// `STATX_INO` - const INO = 0x0100; - - /// `STATX_SIZE` - const SIZE = 0x0200; - - /// `STATX_BLOCKS` - const BLOCKS = 0x0400; - - /// `STATX_BASIC_STATS` - const BASIC_STATS = 0x07ff; - - /// `STATX_BTIME` - const BTIME = 0x800; - - /// `STATX_MNT_ID` (since Linux 5.8) - const MNT_ID = 0x1000; - - /// `STATX_ALL` - const ALL = 0xfff; - } -} - -#[cfg(not(any(netbsdlike, solarish, target_os = "aix", target_os = "redox")))] -bitflags! { - /// `FALLOC_FL_*` constants for use with [`fallocate`]. - /// - /// [`fallocate`]: crate::fs::fallocate - pub struct FallocateFlags: i32 { - /// `FALLOC_FL_KEEP_SIZE` - #[cfg(not(any( - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - const KEEP_SIZE = c::FALLOC_FL_KEEP_SIZE; - /// `FALLOC_FL_PUNCH_HOLE` - #[cfg(not(any( - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - const PUNCH_HOLE = c::FALLOC_FL_PUNCH_HOLE; - /// `FALLOC_FL_NO_HIDE_STALE` - #[cfg(not(any( - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "linux", - target_os = "emscripten", - target_os = "fuchsia", - target_os = "wasi", - )))] - const NO_HIDE_STALE = c::FALLOC_FL_NO_HIDE_STALE; - /// `FALLOC_FL_COLLAPSE_RANGE` - #[cfg(not(any( - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "emscripten", - target_os = "wasi", - )))] - const COLLAPSE_RANGE = c::FALLOC_FL_COLLAPSE_RANGE; - /// `FALLOC_FL_ZERO_RANGE` - #[cfg(not(any( - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "emscripten", - target_os = "wasi", - )))] - const ZERO_RANGE = c::FALLOC_FL_ZERO_RANGE; - /// `FALLOC_FL_INSERT_RANGE` - #[cfg(not(any( - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "emscripten", - target_os = "wasi", - )))] - const INSERT_RANGE = c::FALLOC_FL_INSERT_RANGE; - /// `FALLOC_FL_UNSHARE_RANGE` - #[cfg(not(any( - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "emscripten", - target_os = "wasi", - )))] - const UNSHARE_RANGE = c::FALLOC_FL_UNSHARE_RANGE; - } -} - -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -bitflags! { - /// `ST_*` constants for use with [`StatVfs`]. - pub struct StatVfsMountFlags: u64 { - /// `ST_MANDLOCK` - #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))] - const MANDLOCK = libc::ST_MANDLOCK as u64; - - /// `ST_NOATIME` - #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))] - const NOATIME = libc::ST_NOATIME as u64; - - /// `ST_NODEV` - #[cfg(any(target_os = "aix", target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))] - const NODEV = libc::ST_NODEV as u64; - - /// `ST_NODIRATIME` - #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))] - const NODIRATIME = libc::ST_NODIRATIME as u64; - - /// `ST_NOEXEC` - #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))] - const NOEXEC = libc::ST_NOEXEC as u64; - - /// `ST_NOSUID` - const NOSUID = libc::ST_NOSUID as u64; - - /// `ST_RDONLY` - const RDONLY = libc::ST_RDONLY as u64; - - /// `ST_RELATIME` - #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] - const RELATIME = libc::ST_RELATIME as u64; - - /// `ST_SYNCHRONOUS` - #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "fuchsia", target_os = "linux"))] - const SYNCHRONOUS = libc::ST_SYNCHRONOUS as u64; - } -} - -/// `LOCK_*` constants for use with [`flock`] and [`fcntl_lock`]. -/// -/// [`flock`]: crate::fs::flock -/// [`fcntl_lock`]: crate::fs::fcntl_lock -#[cfg(not(target_os = "wasi"))] -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -#[repr(i32)] -pub enum FlockOperation { - /// `LOCK_SH` - LockShared = c::LOCK_SH, - /// `LOCK_EX` - LockExclusive = c::LOCK_EX, - /// `LOCK_UN` - Unlock = c::LOCK_UN, - /// `LOCK_SH | LOCK_NB` - NonBlockingLockShared = c::LOCK_SH | c::LOCK_NB, - /// `LOCK_EX | LOCK_NB` - NonBlockingLockExclusive = c::LOCK_EX | c::LOCK_NB, - /// `LOCK_UN | LOCK_NB` - NonBlockingUnlock = c::LOCK_UN | c::LOCK_NB, -} - -/// `struct stat` for use with [`statat`] and [`fstat`]. -/// -/// [`statat`]: crate::fs::statat -/// [`fstat`]: crate::fs::fstat -#[cfg(not(linux_like))] -pub type Stat = c::stat; - -/// `struct stat` for use with [`statat`] and [`fstat`]. -/// -/// [`statat`]: crate::fs::statat -/// [`fstat`]: crate::fs::fstat -#[cfg(any( - all( - any(target_os = "android", target_os = "linux"), - target_pointer_width = "64", - ), - target_os = "emscripten", - target_os = "l4re", -))] -pub type Stat = c::stat64; - -/// `struct stat` for use with [`statat`] and [`fstat`]. -/// -/// [`statat`]: crate::fs::statat -/// [`fstat`]: crate::fs::fstat -// On 32-bit, Linux's `struct stat64` has a 32-bit `st_mtime` and friends, so -// we use our own struct, populated from `statx` where possible, to avoid the -// y2038 bug. -#[cfg(all( - any(target_os = "android", target_os = "linux"), - target_pointer_width = "32", -))] -#[repr(C)] -#[derive(Debug, Copy, Clone)] -#[allow(missing_docs)] -pub struct Stat { - pub st_dev: u64, - pub st_mode: u32, - pub st_nlink: u32, - pub st_uid: u32, - pub st_gid: u32, - pub st_rdev: u64, - pub st_size: i64, - pub st_blksize: u32, - pub st_blocks: u64, - pub st_atime: u64, - pub st_atime_nsec: u32, - pub st_mtime: u64, - pub st_mtime_nsec: u32, - pub st_ctime: u64, - pub st_ctime_nsec: u32, - pub st_ino: u64, -} - -/// `struct statfs` for use with [`statfs`] and [`fstatfs`]. -/// -/// [`statfs`]: crate::fs::statfs -/// [`fstatfs`]: crate::fs::fstatfs -#[cfg(not(any( - linux_like, - solarish, - target_os = "haiku", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", -)))] -#[allow(clippy::module_name_repetitions)] -pub type StatFs = c::statfs; - -/// `struct statfs` for use with [`statfs`] and [`fstatfs`]. -/// -/// [`statfs`]: crate::fs::statfs -/// [`fstatfs`]: crate::fs::fstatfs -#[cfg(linux_like)] -pub type StatFs = c::statfs64; - -/// `struct statvfs` for use with [`statvfs`] and [`fstatvfs`]. -/// -/// [`statvfs`]: crate::fs::statvfs -/// [`fstatvfs`]: crate::fs::fstatvfs -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -#[allow(missing_docs)] -pub struct StatVfs { - pub f_bsize: u64, - pub f_frsize: u64, - pub f_blocks: u64, - pub f_bfree: u64, - pub f_bavail: u64, - pub f_files: u64, - pub f_ffree: u64, - pub f_favail: u64, - pub f_fsid: u64, - pub f_flag: StatVfsMountFlags, - pub f_namemax: u64, -} - -/// `struct statx` for use with [`statx`]. -/// -/// [`statx`]: crate::fs::statx -#[cfg(all(target_os = "linux", target_env = "gnu"))] -// Use the glibc `struct statx`. -pub type Statx = c::statx; - -/// `struct statx_timestamp` for use with [`Statx`]. -#[cfg(all(target_os = "linux", target_env = "gnu"))] -// Use the glibc `struct statx_timestamp`. -pub type StatxTimestamp = c::statx; - -/// `struct statx` for use with [`statx`]. -/// -/// [`statx`]: crate::fs::statx -// Non-glibc ABIs don't currently declare a `struct statx`, so we declare it -// ourselves. -#[cfg(any( - target_os = "android", - all(target_os = "linux", not(target_env = "gnu")), -))] -#[repr(C)] -#[allow(missing_docs)] -pub struct Statx { - pub stx_mask: u32, - pub stx_blksize: u32, - pub stx_attributes: u64, - pub stx_nlink: u32, - pub stx_uid: u32, - pub stx_gid: u32, - pub stx_mode: u16, - __statx_pad1: [u16; 1], - pub stx_ino: u64, - pub stx_size: u64, - pub stx_blocks: u64, - pub stx_attributes_mask: u64, - pub stx_atime: StatxTimestamp, - pub stx_btime: StatxTimestamp, - pub stx_ctime: StatxTimestamp, - pub stx_mtime: StatxTimestamp, - pub stx_rdev_major: u32, - pub stx_rdev_minor: u32, - pub stx_dev_major: u32, - pub stx_dev_minor: u32, - pub stx_mnt_id: u64, - __statx_pad2: u64, - __statx_pad3: [u64; 12], -} - -/// `struct statx_timestamp` for use with [`Statx`]. -// Non-glibc ABIs don't currently declare a `struct statx_timestamp`, so we -// declare it ourselves. -#[cfg(any( - target_os = "android", - all(target_os = "linux", not(target_env = "gnu")), -))] -#[repr(C)] -#[allow(missing_docs)] -pub struct StatxTimestamp { - pub tv_sec: i64, - pub tv_nsec: u32, - pub __statx_timestamp_pad1: [i32; 1], -} - -/// `mode_t` -#[cfg(not(all(target_os = "android", target_pointer_width = "32")))] -pub type RawMode = c::mode_t; - -/// `mode_t` -#[cfg(all(target_os = "android", target_pointer_width = "32"))] -pub type RawMode = c::c_uint; - -/// `dev_t` -#[cfg(not(all(target_os = "android", target_pointer_width = "32")))] -pub type Dev = c::dev_t; - -/// `dev_t` -#[cfg(all(target_os = "android", target_pointer_width = "32"))] -pub type Dev = c::c_ulonglong; - -/// `__fsword_t` -#[cfg(all( - target_os = "linux", - not(target_env = "musl"), - not(target_arch = "s390x"), -))] -pub type FsWord = c::__fsword_t; - -/// `__fsword_t` -#[cfg(all( - any(target_os = "android", all(target_os = "linux", target_env = "musl")), - target_pointer_width = "32", -))] -pub type FsWord = u32; - -/// `__fsword_t` -#[cfg(all( - any(target_os = "android", all(target_os = "linux", target_env = "musl")), - not(target_arch = "s390x"), - target_pointer_width = "64", -))] -pub type FsWord = u64; - -/// `__fsword_t` -// s390x uses `u32` for `statfs` entries, even though `__fsword_t` is `u64`. -#[cfg(all(target_os = "linux", target_arch = "s390x"))] -pub type FsWord = u32; - -/// `copyfile_state_t`—State for use with [`fcopyfile`]. -/// -/// [`fcopyfile`]: crate::fs::fcopyfile -#[cfg(apple)] -#[allow(non_camel_case_types)] -#[repr(transparent)] -#[derive(Copy, Clone)] -pub struct copyfile_state_t(pub(crate) *mut c::c_void); - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `MS_*` constants for use with [`mount`]. - /// - /// [`mount`]: crate::fs::mount - pub struct MountFlags: c::c_ulong { - /// `MS_BIND` - const BIND = c::MS_BIND; - - /// `MS_DIRSYNC` - const DIRSYNC = c::MS_DIRSYNC; - - /// `MS_LAZYTIME` - const LAZYTIME = c::MS_LAZYTIME; - - /// `MS_MANDLOCK` - #[doc(alias = "MANDLOCK")] - const PERMIT_MANDATORY_FILE_LOCKING = c::MS_MANDLOCK; - - /// `MS_NOATIME` - const NOATIME = c::MS_NOATIME; - - /// `MS_NODEV` - const NODEV = c::MS_NODEV; - - /// `MS_NODIRATIME` - const NODIRATIME = c::MS_NODIRATIME; - - /// `MS_NOEXEC` - const NOEXEC = c::MS_NOEXEC; - - /// `MS_NOSUID` - const NOSUID = c::MS_NOSUID; - - /// `MS_RDONLY` - const RDONLY = c::MS_RDONLY; - - /// `MS_REC` - const REC = c::MS_REC; - - /// `MS_RELATIME` - const RELATIME = c::MS_RELATIME; - - /// `MS_SILENT` - const SILENT = c::MS_SILENT; - - /// `MS_STRICTATIME` - const STRICTATIME = c::MS_STRICTATIME; - - /// `MS_SYNCHRONOUS` - const SYNCHRONOUS = c::MS_SYNCHRONOUS; - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `MS_*` constants for use with [`change_mount`]. - /// - /// [`change_mount`]: crate::fs::mount::change_mount. - pub struct MountPropagationFlags: c::c_ulong { - /// `MS_SHARED` - const SHARED = c::MS_SHARED; - /// `MS_PRIVATE` - const PRIVATE = c::MS_PRIVATE; - /// `MS_SLAVE` - const SLAVE = c::MS_SLAVE; - /// `MS_UNBINDABLE` - const UNBINDABLE = c::MS_UNBINDABLE; - /// `MS_REC` - const REC = c::MS_REC; - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - pub(crate) struct InternalMountFlags: c::c_ulong { - const REMOUNT = c::MS_REMOUNT; - const MOVE = c::MS_MOVE; - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) struct MountFlagsArg(pub(crate) c::c_ulong); - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `MNT_*` constants for use with [`unmount`]. - /// - /// [`unmount`]: crate::fs::mount::unmount - pub struct UnmountFlags: c::c_int { - /// `MNT_FORCE` - const FORCE = c::MNT_FORCE; - /// `MNT_DETACH` - const DETACH = c::MNT_DETACH; - /// `MNT_EXPIRE` - const EXPIRE = c::MNT_EXPIRE; - /// `UMOUNT_NOFOLLOW` - const NOFOLLOW = c::UMOUNT_NOFOLLOW; - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/io/epoll.rs b/vendor/rustix-0.37.6/src/backend/libc/io/epoll.rs deleted file mode 100644 index 62a3c742b..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io/epoll.rs +++ /dev/null @@ -1,366 +0,0 @@ -//! epoll support. -//! -//! This is an experiment, and it isn't yet clear whether epoll is the right -//! level of abstraction at which to introduce safety. But it works fairly well -//! in simple examples 🙂. -//! -//! # Examples -//! -//! ```no_run -//! # #![cfg_attr(io_lifetimes_use_std, feature(io_safety))] -//! # #[cfg(feature = "net")] -//! # fn main() -> std::io::Result<()> { -//! use io_lifetimes::AsFd; -//! use rustix::io::{epoll, ioctl_fionbio, read, write}; -//! use rustix::net::{ -//! accept, bind_v4, listen, socket, AddressFamily, Ipv4Addr, Protocol, SocketAddrV4, -//! SocketType, -//! }; -//! use std::collections::HashMap; -//! use std::os::unix::io::AsRawFd; -//! -//! // Create a socket and listen on it. -//! let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; -//! bind_v4(&listen_sock, &SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0))?; -//! listen(&listen_sock, 1)?; -//! -//! // Create an epoll object. Using `Owning` here means the epoll object will -//! // take ownership of the file descriptors registered with it. -//! let epoll = epoll::epoll_create(epoll::CreateFlags::CLOEXEC)?; -//! -//! // Register the socket with the epoll object. -//! epoll::epoll_add(&epoll, &listen_sock, 1, epoll::EventFlags::IN)?; -//! -//! // Keep track of the sockets we've opened. -//! let mut next_id = 2; -//! let mut sockets = HashMap::new(); -//! -//! // Process events. -//! let mut event_list = epoll::EventVec::with_capacity(4); -//! loop { -//! epoll::epoll_wait(&epoll, &mut event_list, -1)?; -//! for (_event_flags, target) in &event_list { -//! if target == 1 { -//! // Accept a new connection, set it to non-blocking, and -//! // register to be notified when it's ready to write to. -//! let conn_sock = accept(&listen_sock)?; -//! ioctl_fionbio(&conn_sock, true)?; -//! epoll::epoll_add( -//! &epoll, -//! &conn_sock, -//! next_id, -//! epoll::EventFlags::OUT | epoll::EventFlags::ET, -//! )?; -//! -//! // Keep track of the socket. -//! sockets.insert(next_id, conn_sock); -//! next_id += 1; -//! } else { -//! // Write a message to the stream and then unregister it. -//! let target = sockets.remove(&target).unwrap(); -//! write(&target, b"hello\n")?; -//! let _ = epoll::epoll_del(&epoll, &target)?; -//! } -//! } -//! } -//! # } -//! # #[cfg(not(feature = "net"))] -//! # fn main() {} -//! ``` - -use super::super::c; -use super::super::conv::{ret, ret_owned_fd, ret_u32}; -use crate::fd::{AsFd, AsRawFd, OwnedFd}; -use crate::io; -use alloc::vec::Vec; -use bitflags::bitflags; -use core::convert::TryInto; -use core::ptr::null_mut; - -bitflags! { - /// `EPOLL_*` for use with [`Epoll::new`]. - pub struct CreateFlags: c::c_int { - /// `EPOLL_CLOEXEC` - const CLOEXEC = c::EPOLL_CLOEXEC; - } -} - -bitflags! { - /// `EPOLL*` for use with [`Epoll::add`]. - #[derive(Default)] - pub struct EventFlags: u32 { - /// `EPOLLIN` - const IN = c::EPOLLIN as u32; - - /// `EPOLLOUT` - const OUT = c::EPOLLOUT as u32; - - /// `EPOLLPRI` - const PRI = c::EPOLLPRI as u32; - - /// `EPOLLERR` - const ERR = c::EPOLLERR as u32; - - /// `EPOLLHUP` - const HUP = c::EPOLLHUP as u32; - - /// `EPOLLRDNORM` - const RDNORM = c::EPOLLRDNORM as u32; - - /// `EPOLLRDBAND` - const RDBAND = c::EPOLLRDBAND as u32; - - /// `EPOLLWRNORM` - const WRNORM = c::EPOLLWRNORM as u32; - - /// `EPOLLWRBAND` - const WRBAND = c::EPOLLWRBAND as u32; - - /// `EPOLLMSG` - const MSG = c::EPOLLMSG as u32; - - /// `EPOLLRDHUP` - const RDHUP = c::EPOLLRDHUP as u32; - - /// `EPOLLET` - const ET = c::EPOLLET as u32; - - /// `EPOLLONESHOT` - const ONESHOT = c::EPOLLONESHOT as u32; - - /// `EPOLLWAKEUP` - const WAKEUP = c::EPOLLWAKEUP as u32; - - /// `EPOLLEXCLUSIVE` - #[cfg(not(target_os = "android"))] - const EXCLUSIVE = c::EPOLLEXCLUSIVE as u32; - } -} - -/// `epoll_create1(flags)`—Creates a new `Epoll`. -/// -/// Use the [`CreateFlags::CLOEXEC`] flag to prevent the resulting file -/// descriptor from being implicitly passed across `exec` boundaries. -#[inline] -#[doc(alias = "epoll_create1")] -pub fn epoll_create(flags: CreateFlags) -> io::Result<OwnedFd> { - // SAFETY: We're calling `epoll_create1` via FFI and we know how it - // behaves. - unsafe { ret_owned_fd(c::epoll_create1(flags.bits())) } -} - -/// `epoll_ctl(self, EPOLL_CTL_ADD, data, event)`—Adds an element to an -/// `Epoll`. -/// -/// Note that if `epoll_del` is not called on the I/O source passed into -/// this function before the I/O source is `close`d, then the `epoll` will -/// act as if the I/O source is still registered with it. This can lead to -/// spurious events being returned from `epoll_wait`. If a file descriptor -/// is an `Arc<dyn SystemResource>`, then `epoll` can be thought to maintain -/// a `Weak<dyn SystemResource>` to the file descriptor. -#[doc(alias = "epoll_ctl")] -pub fn epoll_add( - epoll: impl AsFd, - source: impl AsFd, - data: u64, - event_flags: EventFlags, -) -> io::Result<()> { - // SAFETY: We're calling `epoll_ctl` via FFI and we know how it - // behaves. - unsafe { - let raw_fd = source.as_fd().as_raw_fd(); - ret(c::epoll_ctl( - epoll.as_fd().as_raw_fd(), - c::EPOLL_CTL_ADD, - raw_fd, - &mut c::epoll_event { - events: event_flags.bits(), - r#u64: data, - }, - )) - } -} - -/// `epoll_ctl(self, EPOLL_CTL_MOD, target, event)`—Modifies an element in -/// this `Epoll`. -/// -/// This sets the events of interest with `target` to `events`. -#[doc(alias = "epoll_ctl")] -pub fn epoll_mod( - epoll: impl AsFd, - source: impl AsFd, - data: u64, - event_flags: EventFlags, -) -> io::Result<()> { - let raw_fd = source.as_fd().as_raw_fd(); - - // SAFETY: We're calling `epoll_ctl` via FFI and we know how it - // behaves. - unsafe { - ret(c::epoll_ctl( - epoll.as_fd().as_raw_fd(), - c::EPOLL_CTL_MOD, - raw_fd, - &mut c::epoll_event { - events: event_flags.bits(), - r#u64: data, - }, - )) - } -} - -/// `epoll_ctl(self, EPOLL_CTL_DEL, target, NULL)`—Removes an element in -/// this `Epoll`. -#[doc(alias = "epoll_ctl")] -pub fn epoll_del(epoll: impl AsFd, source: impl AsFd) -> io::Result<()> { - // SAFETY: We're calling `epoll_ctl` via FFI and we know how it - // behaves. - unsafe { - let raw_fd = source.as_fd().as_raw_fd(); - ret(c::epoll_ctl( - epoll.as_fd().as_raw_fd(), - c::EPOLL_CTL_DEL, - raw_fd, - null_mut(), - )) - } -} - -/// `epoll_wait(self, events, timeout)`—Waits for registered events of -/// interest. -/// -/// For each event of interest, an element is written to `events`. On -/// success, this returns the number of written elements. -pub fn epoll_wait( - epoll: impl AsFd, - event_list: &mut EventVec, - timeout: c::c_int, -) -> io::Result<()> { - // SAFETY: We're calling `epoll_wait` via FFI and we know how it - // behaves. - unsafe { - event_list.events.set_len(0); - let nfds = ret_u32(c::epoll_wait( - epoll.as_fd().as_raw_fd(), - event_list.events.as_mut_ptr().cast::<c::epoll_event>(), - event_list.events.capacity().try_into().unwrap_or(i32::MAX), - timeout, - ))?; - event_list.events.set_len(nfds as usize); - } - - Ok(()) -} - -/// An iterator over the `Event`s in an `EventVec`. -pub struct Iter<'a> { - iter: core::slice::Iter<'a, Event>, -} - -impl<'a> Iterator for Iter<'a> { - type Item = (EventFlags, u64); - - fn next(&mut self) -> Option<Self::Item> { - // SAFETY: `self.context` is guaranteed to be valid because we hold - // `'context` for it. And we know this event is associated with this - // context because `wait` sets both. - self.iter - .next() - .map(|event| (event.event_flags, event.data)) - } -} - -/// A record of an event that occurred. -#[repr(C)] -#[cfg_attr( - any( - all( - target_arch = "x86", - not(target_env = "musl"), - not(target_os = "android"), - ), - target_arch = "x86_64", - ), - repr(packed) -)] -struct Event { - // Match the layout of `c::epoll_event`. We just use a `u64` instead of - // the full union. - event_flags: EventFlags, - data: u64, -} - -/// A vector of `Event`s, plus context for interpreting them. -pub struct EventVec { - events: Vec<Event>, -} - -impl EventVec { - /// Constructs an `EventVec` with memory for `capacity` `Event`s. - #[inline] - pub fn with_capacity(capacity: usize) -> Self { - Self { - events: Vec::with_capacity(capacity), - } - } - - /// Returns the current `Event` capacity of this `EventVec`. - #[inline] - pub fn capacity(&self) -> usize { - self.events.capacity() - } - - /// Reserves enough memory for at least `additional` more `Event`s. - #[inline] - pub fn reserve(&mut self, additional: usize) { - self.events.reserve(additional); - } - - /// Reserves enough memory for exactly `additional` more `Event`s. - #[inline] - pub fn reserve_exact(&mut self, additional: usize) { - self.events.reserve_exact(additional); - } - - /// Clears all the `Events` out of this `EventVec`. - #[inline] - pub fn clear(&mut self) { - self.events.clear(); - } - - /// Shrinks the capacity of this `EventVec` as much as possible. - #[inline] - pub fn shrink_to_fit(&mut self) { - self.events.shrink_to_fit(); - } - - /// Returns an iterator over the `Event`s in this `EventVec`. - #[inline] - pub fn iter(&self) -> Iter<'_> { - Iter { - iter: self.events.iter(), - } - } - - /// Returns the number of `Event`s logically contained in this `EventVec`. - #[inline] - pub fn len(&mut self) -> usize { - self.events.len() - } - - /// Tests whether this `EventVec` is logically empty. - #[inline] - pub fn is_empty(&mut self) -> bool { - self.events.is_empty() - } -} - -impl<'a> IntoIterator for &'a EventVec { - type IntoIter = Iter<'a>; - type Item = (EventFlags, u64); - - #[inline] - fn into_iter(self) -> Self::IntoIter { - self.iter() - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/io/errno.rs b/vendor/rustix-0.37.6/src/backend/libc/io/errno.rs deleted file mode 100644 index 9e808c0b4..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io/errno.rs +++ /dev/null @@ -1,731 +0,0 @@ -//! The `rustix` `Errno` type. -//! -//! This type holds an OS error code, which conceptually corresponds to an -//! `errno` value. - -use super::super::c; -use libc_errno::errno; - -/// The error type for `rustix` APIs. -/// -/// This is similar to `std::io::Error`, but only holds an OS error code, -/// and no extra error value. -#[repr(transparent)] -#[doc(alias = "errno")] -#[derive(Eq, PartialEq, Hash, Copy, Clone)] -pub struct Errno(pub(crate) c::c_int); - -impl Errno { - /// `EACCES` - #[doc(alias = "ACCES")] - pub const ACCESS: Self = Self(c::EACCES); - /// `EADDRINUSE` - pub const ADDRINUSE: Self = Self(c::EADDRINUSE); - /// `EADDRNOTAVAIL` - pub const ADDRNOTAVAIL: Self = Self(c::EADDRNOTAVAIL); - /// `EADV` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const ADV: Self = Self(c::EADV); - /// `EAFNOSUPPORT` - pub const AFNOSUPPORT: Self = Self(c::EAFNOSUPPORT); - /// `EAGAIN` - pub const AGAIN: Self = Self(c::EAGAIN); - /// `EALREADY` - pub const ALREADY: Self = Self(c::EALREADY); - /// `EAUTH` - #[cfg(bsd)] - pub const AUTH: Self = Self(c::EAUTH); - /// `EBADE` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const BADE: Self = Self(c::EBADE); - /// `EBADF` - pub const BADF: Self = Self(c::EBADF); - /// `EBADFD` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const BADFD: Self = Self(c::EBADFD); - /// `EBADMSG` - #[cfg(not(windows))] - pub const BADMSG: Self = Self(c::EBADMSG); - /// `EBADR` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const BADR: Self = Self(c::EBADR); - /// `EBADRPC` - #[cfg(bsd)] - pub const BADRPC: Self = Self(c::EBADRPC); - /// `EBADRQC` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const BADRQC: Self = Self(c::EBADRQC); - /// `EBADSLT` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const BADSLT: Self = Self(c::EBADSLT); - /// `EBFONT` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const BFONT: Self = Self(c::EBFONT); - /// `EBUSY` - #[cfg(not(windows))] - pub const BUSY: Self = Self(c::EBUSY); - /// `ECANCELED` - pub const CANCELED: Self = Self(c::ECANCELED); - /// `ECAPMODE` - #[cfg(target_os = "freebsd")] - pub const CAPMODE: Self = Self(c::ECAPMODE); - /// `ECHILD` - #[cfg(not(windows))] - pub const CHILD: Self = Self(c::ECHILD); - /// `ECHRNG` - #[cfg(not(any(bsd, windows, target_os = "haiku", target_os = "wasi")))] - pub const CHRNG: Self = Self(c::ECHRNG); - /// `ECOMM` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const COMM: Self = Self(c::ECOMM); - /// `ECONNABORTED` - pub const CONNABORTED: Self = Self(c::ECONNABORTED); - /// `ECONNREFUSED` - pub const CONNREFUSED: Self = Self(c::ECONNREFUSED); - /// `ECONNRESET` - pub const CONNRESET: Self = Self(c::ECONNRESET); - /// `EDEADLK` - #[cfg(not(windows))] - pub const DEADLK: Self = Self(c::EDEADLK); - /// `EDEADLOCK` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "android", - target_os = "haiku", - target_os = "wasi", - )))] - pub const DEADLOCK: Self = Self(c::EDEADLOCK); - /// `EDESTADDRREQ` - pub const DESTADDRREQ: Self = Self(c::EDESTADDRREQ); - /// `EDISCON` - #[cfg(windows)] - pub const DISCON: Self = Self(c::EDISCON); - /// `EDOM` - #[cfg(not(windows))] - pub const DOM: Self = Self(c::EDOM); - /// `EDOOFUS` - #[cfg(freebsdlike)] - pub const DOOFUS: Self = Self(c::EDOOFUS); - /// `EDOTDOT` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const DOTDOT: Self = Self(c::EDOTDOT); - /// `EDQUOT` - pub const DQUOT: Self = Self(c::EDQUOT); - /// `EEXIST` - #[cfg(not(windows))] - pub const EXIST: Self = Self(c::EEXIST); - /// `EFAULT` - pub const FAULT: Self = Self(c::EFAULT); - /// `EFBIG` - #[cfg(not(windows))] - pub const FBIG: Self = Self(c::EFBIG); - /// `EFTYPE` - #[cfg(any(bsd, target_env = "newlib"))] - pub const FTYPE: Self = Self(c::EFTYPE); - /// `EHOSTDOWN` - #[cfg(not(target_os = "wasi"))] - pub const HOSTDOWN: Self = Self(c::EHOSTDOWN); - /// `EHOSTUNREACH` - pub const HOSTUNREACH: Self = Self(c::EHOSTUNREACH); - /// `EHWPOISON` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "android", - target_os = "haiku", - target_os = "redox", - target_os = "wasi", - )))] - pub const HWPOISON: Self = Self(c::EHWPOISON); - /// `EIDRM` - #[cfg(not(windows))] - pub const IDRM: Self = Self(c::EIDRM); - /// `EILSEQ` - #[cfg(not(windows))] - pub const ILSEQ: Self = Self(c::EILSEQ); - /// `EINPROGRESS` - pub const INPROGRESS: Self = Self(c::EINPROGRESS); - /// `EINTR` - /// - /// For a convenient way to retry system calls that exit with `INTR`, use - /// [`retry_on_intr`]. - /// - /// [`retry_on_intr`]: crate::io::retry_on_intr - pub const INTR: Self = Self(c::EINTR); - /// `EINVAL` - pub const INVAL: Self = Self(c::EINVAL); - /// `EINVALIDPROCTABLE` - #[cfg(windows)] - pub const INVALIDPROCTABLE: Self = Self(c::EINVALIDPROCTABLE); - /// `EINVALIDPROVIDER` - #[cfg(windows)] - pub const INVALIDPROVIDER: Self = Self(c::EINVALIDPROVIDER); - /// `EIO` - #[cfg(not(windows))] - pub const IO: Self = Self(c::EIO); - /// `EISCONN` - pub const ISCONN: Self = Self(c::EISCONN); - /// `EISDIR` - #[cfg(not(windows))] - pub const ISDIR: Self = Self(c::EISDIR); - /// `EISNAM` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const ISNAM: Self = Self(c::EISNAM); - /// `EKEYEXPIRED` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const KEYEXPIRED: Self = Self(c::EKEYEXPIRED); - /// `EKEYREJECTED` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const KEYREJECTED: Self = Self(c::EKEYREJECTED); - /// `EKEYREVOKED` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const KEYREVOKED: Self = Self(c::EKEYREVOKED); - /// `EL2HLT` - #[cfg(not(any(bsd, windows, target_os = "haiku", target_os = "wasi")))] - pub const L2HLT: Self = Self(c::EL2HLT); - /// `EL2NSYNC` - #[cfg(not(any(bsd, windows, target_os = "haiku", target_os = "wasi")))] - pub const L2NSYNC: Self = Self(c::EL2NSYNC); - /// `EL3HLT` - #[cfg(not(any(bsd, windows, target_os = "haiku", target_os = "wasi")))] - pub const L3HLT: Self = Self(c::EL3HLT); - /// `EL3RST` - #[cfg(not(any(bsd, windows, target_os = "haiku", target_os = "wasi")))] - pub const L3RST: Self = Self(c::EL3RST); - /// `ELIBACC` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const LIBACC: Self = Self(c::ELIBACC); - /// `ELIBBAD` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const LIBBAD: Self = Self(c::ELIBBAD); - /// `ELIBEXEC` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const LIBEXEC: Self = Self(c::ELIBEXEC); - /// `ELIBMAX` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const LIBMAX: Self = Self(c::ELIBMAX); - /// `ELIBSCN` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const LIBSCN: Self = Self(c::ELIBSCN); - /// `ELNRNG` - #[cfg(not(any(bsd, windows, target_os = "haiku", target_os = "wasi")))] - pub const LNRNG: Self = Self(c::ELNRNG); - /// `ELOOP` - pub const LOOP: Self = Self(c::ELOOP); - /// `EMEDIUMTYPE` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const MEDIUMTYPE: Self = Self(c::EMEDIUMTYPE); - /// `EMFILE` - pub const MFILE: Self = Self(c::EMFILE); - /// `EMLINK` - #[cfg(not(windows))] - pub const MLINK: Self = Self(c::EMLINK); - /// `EMSGSIZE` - pub const MSGSIZE: Self = Self(c::EMSGSIZE); - /// `EMULTIHOP` - #[cfg(not(any(windows, target_os = "openbsd")))] - pub const MULTIHOP: Self = Self(c::EMULTIHOP); - /// `ENAMETOOLONG` - pub const NAMETOOLONG: Self = Self(c::ENAMETOOLONG); - /// `ENAVAIL` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const NAVAIL: Self = Self(c::ENAVAIL); - /// `ENEEDAUTH` - #[cfg(bsd)] - pub const NEEDAUTH: Self = Self(c::ENEEDAUTH); - /// `ENETDOWN` - pub const NETDOWN: Self = Self(c::ENETDOWN); - /// `ENETRESET` - pub const NETRESET: Self = Self(c::ENETRESET); - /// `ENETUNREACH` - pub const NETUNREACH: Self = Self(c::ENETUNREACH); - /// `ENFILE` - #[cfg(not(windows))] - pub const NFILE: Self = Self(c::ENFILE); - /// `ENOANO` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const NOANO: Self = Self(c::ENOANO); - /// `ENOATTR` - #[cfg(any(bsd, target_os = "haiku"))] - pub const NOATTR: Self = Self(c::ENOATTR); - /// `ENOBUFS` - pub const NOBUFS: Self = Self(c::ENOBUFS); - /// `ENOCSI` - #[cfg(not(any(bsd, windows, target_os = "haiku", target_os = "wasi")))] - pub const NOCSI: Self = Self(c::ENOCSI); - /// `ENODATA` - #[cfg(not(any( - freebsdlike, - windows, - target_os = "haiku", - target_os = "openbsd", - target_os = "wasi", - )))] - pub const NODATA: Self = Self(c::ENODATA); - /// `ENODEV` - #[cfg(not(windows))] - pub const NODEV: Self = Self(c::ENODEV); - /// `ENOENT` - #[cfg(not(windows))] - pub const NOENT: Self = Self(c::ENOENT); - /// `ENOEXEC` - #[cfg(not(windows))] - pub const NOEXEC: Self = Self(c::ENOEXEC); - /// `ENOKEY` - #[cfg(not(any( - solarish, - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const NOKEY: Self = Self(c::ENOKEY); - /// `ENOLCK` - #[cfg(not(windows))] - pub const NOLCK: Self = Self(c::ENOLCK); - /// `ENOLINK` - #[cfg(not(any(windows, target_os = "openbsd")))] - pub const NOLINK: Self = Self(c::ENOLINK); - /// `ENOMEDIUM` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const NOMEDIUM: Self = Self(c::ENOMEDIUM); - /// `ENOMEM` - #[cfg(not(windows))] - pub const NOMEM: Self = Self(c::ENOMEM); - /// `ENOMORE` - #[cfg(windows)] - pub const NOMORE: Self = Self(c::ENOMORE); - /// `ENOMSG` - #[cfg(not(windows))] - pub const NOMSG: Self = Self(c::ENOMSG); - /// `ENONET` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const NONET: Self = Self(c::ENONET); - /// `ENOPKG` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const NOPKG: Self = Self(c::ENOPKG); - /// `ENOPROTOOPT` - pub const NOPROTOOPT: Self = Self(c::ENOPROTOOPT); - /// `ENOSPC` - #[cfg(not(windows))] - pub const NOSPC: Self = Self(c::ENOSPC); - /// `ENOSR` - #[cfg(not(any( - freebsdlike, - windows, - target_os = "haiku", - target_os = "openbsd", - target_os = "wasi", - )))] - pub const NOSR: Self = Self(c::ENOSR); - /// `ENOSTR` - #[cfg(not(any( - freebsdlike, - windows, - target_os = "haiku", - target_os = "openbsd", - target_os = "wasi", - )))] - pub const NOSTR: Self = Self(c::ENOSTR); - /// `ENOSYS` - #[cfg(not(windows))] - pub const NOSYS: Self = Self(c::ENOSYS); - /// `ENOTBLK` - #[cfg(not(any(windows, target_os = "haiku", target_os = "wasi")))] - pub const NOTBLK: Self = Self(c::ENOTBLK); - /// `ENOTCAPABLE` - #[cfg(any(target_os = "freebsd", target_os = "wasi"))] - pub const NOTCAPABLE: Self = Self(c::ENOTCAPABLE); - /// `ENOTCONN` - pub const NOTCONN: Self = Self(c::ENOTCONN); - /// `ENOTDIR` - #[cfg(not(windows))] - pub const NOTDIR: Self = Self(c::ENOTDIR); - /// `ENOTEMPTY` - pub const NOTEMPTY: Self = Self(c::ENOTEMPTY); - /// `ENOTNAM` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const NOTNAM: Self = Self(c::ENOTNAM); - /// `ENOTRECOVERABLE` - #[cfg(not(any(freebsdlike, netbsdlike, windows, target_os = "haiku")))] - pub const NOTRECOVERABLE: Self = Self(c::ENOTRECOVERABLE); - /// `ENOTSOCK` - pub const NOTSOCK: Self = Self(c::ENOTSOCK); - /// `ENOTSUP` - #[cfg(not(any(windows, target_os = "haiku", target_os = "redox")))] - pub const NOTSUP: Self = Self(c::ENOTSUP); - /// `ENOTTY` - #[cfg(not(windows))] - pub const NOTTY: Self = Self(c::ENOTTY); - /// `ENOTUNIQ` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const NOTUNIQ: Self = Self(c::ENOTUNIQ); - /// `ENXIO` - #[cfg(not(windows))] - pub const NXIO: Self = Self(c::ENXIO); - /// `EOPNOTSUPP` - pub const OPNOTSUPP: Self = Self(c::EOPNOTSUPP); - /// `EOVERFLOW` - #[cfg(not(windows))] - pub const OVERFLOW: Self = Self(c::EOVERFLOW); - /// `EOWNERDEAD` - #[cfg(not(any(freebsdlike, netbsdlike, windows, target_os = "haiku")))] - pub const OWNERDEAD: Self = Self(c::EOWNERDEAD); - /// `EPERM` - #[cfg(not(windows))] - pub const PERM: Self = Self(c::EPERM); - /// `EPFNOSUPPORT` - #[cfg(not(target_os = "wasi"))] - pub const PFNOSUPPORT: Self = Self(c::EPFNOSUPPORT); - /// `EPIPE` - #[cfg(not(windows))] - pub const PIPE: Self = Self(c::EPIPE); - /// `EPROCLIM` - #[cfg(bsd)] - pub const PROCLIM: Self = Self(c::EPROCLIM); - /// `EPROCUNAVAIL` - #[cfg(bsd)] - pub const PROCUNAVAIL: Self = Self(c::EPROCUNAVAIL); - /// `EPROGMISMATCH` - #[cfg(bsd)] - pub const PROGMISMATCH: Self = Self(c::EPROGMISMATCH); - /// `EPROGUNAVAIL` - #[cfg(bsd)] - pub const PROGUNAVAIL: Self = Self(c::EPROGUNAVAIL); - /// `EPROTO` - #[cfg(not(windows))] - pub const PROTO: Self = Self(c::EPROTO); - /// `EPROTONOSUPPORT` - pub const PROTONOSUPPORT: Self = Self(c::EPROTONOSUPPORT); - /// `EPROTOTYPE` - pub const PROTOTYPE: Self = Self(c::EPROTOTYPE); - /// `EPROVIDERFAILEDINIT` - #[cfg(windows)] - pub const PROVIDERFAILEDINIT: Self = Self(c::EPROVIDERFAILEDINIT); - /// `ERANGE` - #[cfg(not(windows))] - pub const RANGE: Self = Self(c::ERANGE); - /// `EREFUSED` - #[cfg(windows)] - pub const REFUSED: Self = Self(c::EREFUSED); - /// `EREMCHG` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const REMCHG: Self = Self(c::EREMCHG); - /// `EREMOTE` - #[cfg(not(any(target_os = "haiku", target_os = "wasi")))] - pub const REMOTE: Self = Self(c::EREMOTE); - /// `EREMOTEIO` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const REMOTEIO: Self = Self(c::EREMOTEIO); - /// `ERESTART` - #[cfg(not(any(bsd, windows, target_os = "haiku", target_os = "wasi")))] - pub const RESTART: Self = Self(c::ERESTART); - /// `ERFKILL` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "android", - target_os = "haiku", - target_os = "redox", - target_os = "wasi", - )))] - pub const RFKILL: Self = Self(c::ERFKILL); - /// `EROFS` - #[cfg(not(windows))] - pub const ROFS: Self = Self(c::EROFS); - /// `ERPCMISMATCH` - #[cfg(bsd)] - pub const RPCMISMATCH: Self = Self(c::ERPCMISMATCH); - /// `ESHUTDOWN` - #[cfg(not(target_os = "wasi"))] - pub const SHUTDOWN: Self = Self(c::ESHUTDOWN); - /// `ESOCKTNOSUPPORT` - #[cfg(not(any(target_os = "haiku", target_os = "wasi")))] - pub const SOCKTNOSUPPORT: Self = Self(c::ESOCKTNOSUPPORT); - /// `ESPIPE` - #[cfg(not(windows))] - pub const SPIPE: Self = Self(c::ESPIPE); - /// `ESRCH` - #[cfg(not(windows))] - pub const SRCH: Self = Self(c::ESRCH); - /// `ESRMNT` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const SRMNT: Self = Self(c::ESRMNT); - /// `ESTALE` - pub const STALE: Self = Self(c::ESTALE); - /// `ESTRPIPE` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const STRPIPE: Self = Self(c::ESTRPIPE); - /// `ETIME` - #[cfg(not(any(freebsdlike, windows, target_os = "openbsd", target_os = "wasi")))] - pub const TIME: Self = Self(c::ETIME); - /// `ETIMEDOUT` - pub const TIMEDOUT: Self = Self(c::ETIMEDOUT); - /// `E2BIG` - #[cfg(not(windows))] - #[doc(alias = "2BIG")] - pub const TOOBIG: Self = Self(c::E2BIG); - /// `ETOOMANYREFS` - #[cfg(not(any(target_os = "haiku", target_os = "wasi")))] - pub const TOOMANYREFS: Self = Self(c::ETOOMANYREFS); - /// `ETXTBSY` - #[cfg(not(windows))] - pub const TXTBSY: Self = Self(c::ETXTBSY); - /// `EUCLEAN` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const UCLEAN: Self = Self(c::EUCLEAN); - /// `EUNATCH` - #[cfg(not(any(bsd, windows, target_os = "haiku", target_os = "wasi")))] - pub const UNATCH: Self = Self(c::EUNATCH); - /// `EUSERS` - #[cfg(not(any(target_os = "haiku", target_os = "wasi")))] - pub const USERS: Self = Self(c::EUSERS); - /// `EWOULDBLOCK` - pub const WOULDBLOCK: Self = Self(c::EWOULDBLOCK); - /// `EXDEV` - #[cfg(not(windows))] - pub const XDEV: Self = Self(c::EXDEV); - /// `EXFULL` - #[cfg(not(any( - bsd, - windows, - target_os = "aix", - target_os = "haiku", - target_os = "wasi", - )))] - pub const XFULL: Self = Self(c::EXFULL); -} - -impl Errno { - /// Extract an `Errno` value from a `std::io::Error`. - /// - /// This isn't a `From` conversion because it's expected to be relatively - /// uncommon. - #[cfg(feature = "std")] - #[inline] - pub fn from_io_error(io_err: &std::io::Error) -> Option<Self> { - io_err - .raw_os_error() - .and_then(|raw| if raw != 0 { Some(Self(raw)) } else { None }) - } - - /// Extract the raw OS error number from this error. - #[inline] - pub const fn raw_os_error(self) -> i32 { - self.0 - } - - /// Construct an `Errno` from a raw OS error number. - #[inline] - pub const fn from_raw_os_error(raw: i32) -> Self { - Self(raw) - } - - pub(crate) fn last_os_error() -> Self { - Self(errno().0) - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/io/io_slice.rs b/vendor/rustix-0.37.6/src/backend/libc/io/io_slice.rs deleted file mode 100644 index de1ef434c..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io/io_slice.rs +++ /dev/null @@ -1,87 +0,0 @@ -//! The following is derived from Rust's -//! library/std/src/sys/unix/io.rs -//! dca3f1b786efd27be3b325ed1e01e247aa589c3b. - -#![allow(missing_docs)] - -use super::super::c; -use core::marker::PhantomData; -use core::slice; - -#[derive(Copy, Clone)] -#[repr(transparent)] -pub struct IoSlice<'a> { - vec: c::iovec, - _p: PhantomData<&'a [u8]>, -} - -impl<'a> IoSlice<'a> { - #[inline] - pub fn new(buf: &'a [u8]) -> IoSlice<'a> { - IoSlice { - vec: c::iovec { - iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void, - iov_len: buf.len(), - }, - _p: PhantomData, - } - } - - #[inline] - pub fn advance(&mut self, n: usize) { - if self.vec.iov_len < n { - panic!("advancing IoSlice beyond its length"); - } - - unsafe { - self.vec.iov_len -= n; - self.vec.iov_base = self.vec.iov_base.add(n); - } - } - - #[inline] - pub fn as_slice(&self) -> &[u8] { - unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) } - } -} - -#[repr(transparent)] -pub struct IoSliceMut<'a> { - vec: c::iovec, - _p: PhantomData<&'a mut [u8]>, -} - -impl<'a> IoSliceMut<'a> { - #[inline] - pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> { - IoSliceMut { - vec: c::iovec { - iov_base: buf.as_mut_ptr() as *mut c::c_void, - iov_len: buf.len(), - }, - _p: PhantomData, - } - } - - #[inline] - pub fn advance(&mut self, n: usize) { - if self.vec.iov_len < n { - panic!("advancing IoSliceMut beyond its length"); - } - - unsafe { - self.vec.iov_len -= n; - self.vec.iov_base = self.vec.iov_base.add(n); - } - } - - #[inline] - pub fn as_slice(&self) -> &[u8] { - unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len) } - } - - #[inline] - pub fn as_mut_slice(&mut self) -> &mut [u8] { - unsafe { slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len) } - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/io/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/io/mod.rs deleted file mode 100644 index 1378adf3d..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io/mod.rs +++ /dev/null @@ -1,13 +0,0 @@ -pub(crate) mod errno; -#[cfg(not(windows))] -#[cfg(not(feature = "std"))] -pub(crate) mod io_slice; -pub(crate) mod poll_fd; -#[cfg(not(windows))] -pub(crate) mod types; - -#[cfg_attr(windows, path = "windows_syscalls.rs")] -pub(crate) mod syscalls; - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub mod epoll; diff --git a/vendor/rustix-0.37.6/src/backend/libc/io/poll_fd.rs b/vendor/rustix-0.37.6/src/backend/libc/io/poll_fd.rs deleted file mode 100644 index a0568c60a..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io/poll_fd.rs +++ /dev/null @@ -1,136 +0,0 @@ -use super::super::c; -use super::super::conv::borrowed_fd; -#[cfg(windows)] -use super::super::fd::RawFd; -use super::super::fd::{AsFd, AsRawFd, BorrowedFd, LibcFd}; -use bitflags::bitflags; -use core::marker::PhantomData; -#[cfg(windows)] -use std::fmt; - -bitflags! { - /// `POLL*` flags for use with [`poll`]. - /// - /// [`poll`]: crate::io::poll - pub struct PollFlags: c::c_short { - /// `POLLIN` - const IN = c::POLLIN; - /// `POLLPRI` - #[cfg(not(target_os = "wasi"))] - const PRI = c::POLLPRI; - /// `POLLOUT` - const OUT = c::POLLOUT; - /// `POLLRDNORM` - #[cfg(not(target_os = "redox"))] - const RDNORM = c::POLLRDNORM; - /// `POLLWRNORM` - #[cfg(not(target_os = "redox"))] - const WRNORM = c::POLLWRNORM; - /// `POLLRDBAND` - #[cfg(not(any(target_os = "redox", target_os = "wasi")))] - const RDBAND = c::POLLRDBAND; - /// `POLLWRBAND` - #[cfg(not(any(target_os = "redox", target_os = "wasi")))] - const WRBAND = c::POLLWRBAND; - /// `POLLERR` - const ERR = c::POLLERR; - /// `POLLHUP` - const HUP = c::POLLHUP; - /// `POLLNVAL` - const NVAL = c::POLLNVAL; - /// `POLLRDHUP` - #[cfg(all( - any(target_os = "android", target_os = "linux"), - not(any(target_arch = "sparc", target_arch = "sparc64"))), - )] - const RDHUP = c::POLLRDHUP; - } -} - -/// `struct pollfd`—File descriptor and flags for use with [`poll`]. -/// -/// [`poll`]: crate::io::poll -#[doc(alias = "pollfd")] -#[derive(Clone)] -#[cfg_attr(not(windows), derive(Debug))] -#[repr(transparent)] -pub struct PollFd<'fd> { - pollfd: c::pollfd, - _phantom: PhantomData<BorrowedFd<'fd>>, -} - -#[cfg(windows)] -impl<'fd> fmt::Debug for PollFd<'fd> { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - fmt.debug_struct("pollfd") - .field("fd", &self.pollfd.fd) - .field("events", &self.pollfd.events) - .field("revents", &self.pollfd.revents) - .finish() - } -} - -impl<'fd> PollFd<'fd> { - /// Constructs a new `PollFd` holding `fd` and `events`. - #[inline] - pub fn new<Fd: AsFd>(fd: &'fd Fd, events: PollFlags) -> Self { - Self::from_borrowed_fd(fd.as_fd(), events) - } - - /// Sets the contained file descriptor to `fd`. - #[inline] - pub fn set_fd<Fd: AsFd>(&mut self, fd: &'fd Fd) { - self.pollfd.fd = fd.as_fd().as_raw_fd() as LibcFd; - } - - /// Clears the ready events. - #[inline] - pub fn clear_revents(&mut self) { - self.pollfd.revents = 0; - } - - /// Constructs a new `PollFd` holding `fd` and `events`. - /// - /// This is the same as `new`, but can be used to avoid borrowing the - /// `BorrowedFd`, which can be tricky in situations where the `BorrowedFd` - /// is a temporary. - #[inline] - pub fn from_borrowed_fd(fd: BorrowedFd<'fd>, events: PollFlags) -> Self { - Self { - pollfd: c::pollfd { - fd: borrowed_fd(fd), - events: events.bits(), - revents: 0, - }, - _phantom: PhantomData, - } - } - - /// Returns the ready events. - #[inline] - pub fn revents(&self) -> PollFlags { - // Use `unwrap()` here because in theory we know we know all the bits - // the OS might set here, but OS's have added extensions in the past. - PollFlags::from_bits(self.pollfd.revents).unwrap() - } -} - -#[cfg(not(windows))] -impl<'fd> AsFd for PollFd<'fd> { - #[inline] - fn as_fd(&self) -> BorrowedFd<'_> { - // SAFETY: Our constructors and `set_fd` require `pollfd.fd` to be - // valid for the `fd lifetime. - unsafe { BorrowedFd::borrow_raw(self.pollfd.fd) } - } -} - -#[cfg(windows)] -impl<'fd> io_lifetimes::AsSocket for PollFd<'fd> { - #[inline] - fn as_socket(&self) -> BorrowedFd<'_> { - // SAFETY: Our constructors and `set_fd` require `pollfd.fd` to be - // valid for the `fd lifetime. - unsafe { BorrowedFd::borrow_raw(self.pollfd.fd as RawFd) } - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/io/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/io/syscalls.rs deleted file mode 100644 index 03f9294d9..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io/syscalls.rs +++ /dev/null @@ -1,677 +0,0 @@ -//! libc syscalls supporting `rustix::io`. - -use super::super::c; -#[cfg(any(target_os = "android", target_os = "linux"))] -use super::super::conv::syscall_ret_owned_fd; -use super::super::conv::{ - borrowed_fd, ret, ret_c_int, ret_discarded_fd, ret_owned_fd, ret_ssize_t, -}; -use super::super::offset::{libc_pread, libc_pwrite}; -#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "solaris")))] -use super::super::offset::{libc_preadv, libc_pwritev}; -#[cfg(all(target_os = "linux", target_env = "gnu"))] -use super::super::offset::{libc_preadv2, libc_pwritev2}; -use crate::fd::{AsFd, BorrowedFd, OwnedFd, RawFd}; -#[cfg(bsd)] -use crate::io::kqueue::Event; -#[cfg(solarish)] -use crate::io::port::Event; -#[cfg(not(any(target_os = "aix", target_os = "wasi")))] -use crate::io::DupFlags; -#[cfg(not(any(apple, target_os = "aix", target_os = "haiku", target_os = "wasi")))] -use crate::io::PipeFlags; -use crate::io::{self, FdFlags, IoSlice, IoSliceMut, PollFd}; -#[cfg(any(target_os = "android", target_os = "linux"))] -use crate::io::{EventfdFlags, IoSliceRaw, ReadWriteFlags, SpliceFlags}; -use core::cmp::min; -use core::convert::TryInto; -use core::mem::MaybeUninit; -#[cfg(any(target_os = "android", target_os = "linux"))] -use core::ptr; -#[cfg(all(feature = "fs", feature = "net"))] -use libc_errno::errno; - -pub(crate) fn read(fd: BorrowedFd<'_>, buf: &mut [u8]) -> io::Result<usize> { - let nread = unsafe { - ret_ssize_t(c::read( - borrowed_fd(fd), - buf.as_mut_ptr().cast(), - min(buf.len(), READ_LIMIT), - ))? - }; - Ok(nread as usize) -} - -pub(crate) fn write(fd: BorrowedFd<'_>, buf: &[u8]) -> io::Result<usize> { - let nwritten = unsafe { - ret_ssize_t(c::write( - borrowed_fd(fd), - buf.as_ptr().cast(), - min(buf.len(), READ_LIMIT), - ))? - }; - Ok(nwritten as usize) -} - -pub(crate) fn pread(fd: BorrowedFd<'_>, buf: &mut [u8], offset: u64) -> io::Result<usize> { - let len = min(buf.len(), READ_LIMIT); - - // Silently cast; we'll get `EINVAL` if the value is negative. - let offset = offset as i64; - - let nread = unsafe { - ret_ssize_t(libc_pread( - borrowed_fd(fd), - buf.as_mut_ptr().cast(), - len, - offset, - ))? - }; - Ok(nread as usize) -} - -pub(crate) fn pwrite(fd: BorrowedFd<'_>, buf: &[u8], offset: u64) -> io::Result<usize> { - let len = min(buf.len(), READ_LIMIT); - - // Silently cast; we'll get `EINVAL` if the value is negative. - let offset = offset as i64; - - let nwritten = unsafe { - ret_ssize_t(libc_pwrite( - borrowed_fd(fd), - buf.as_ptr().cast(), - len, - offset, - ))? - }; - Ok(nwritten as usize) -} - -pub(crate) fn readv(fd: BorrowedFd<'_>, bufs: &mut [IoSliceMut]) -> io::Result<usize> { - let nread = unsafe { - ret_ssize_t(c::readv( - borrowed_fd(fd), - bufs.as_ptr().cast::<c::iovec>(), - min(bufs.len(), max_iov()) as c::c_int, - ))? - }; - Ok(nread as usize) -} - -pub(crate) fn writev(fd: BorrowedFd<'_>, bufs: &[IoSlice]) -> io::Result<usize> { - let nwritten = unsafe { - ret_ssize_t(c::writev( - borrowed_fd(fd), - bufs.as_ptr().cast::<c::iovec>(), - min(bufs.len(), max_iov()) as c::c_int, - ))? - }; - Ok(nwritten as usize) -} - -#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "solaris")))] -pub(crate) fn preadv( - fd: BorrowedFd<'_>, - bufs: &mut [IoSliceMut], - offset: u64, -) -> io::Result<usize> { - // Silently cast; we'll get `EINVAL` if the value is negative. - let offset = offset as i64; - let nread = unsafe { - ret_ssize_t(libc_preadv( - borrowed_fd(fd), - bufs.as_ptr().cast::<c::iovec>(), - min(bufs.len(), max_iov()) as c::c_int, - offset, - ))? - }; - Ok(nread as usize) -} - -#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "solaris")))] -pub(crate) fn pwritev(fd: BorrowedFd<'_>, bufs: &[IoSlice], offset: u64) -> io::Result<usize> { - // Silently cast; we'll get `EINVAL` if the value is negative. - let offset = offset as i64; - let nwritten = unsafe { - ret_ssize_t(libc_pwritev( - borrowed_fd(fd), - bufs.as_ptr().cast::<c::iovec>(), - min(bufs.len(), max_iov()) as c::c_int, - offset, - ))? - }; - Ok(nwritten as usize) -} - -#[cfg(all(target_os = "linux", target_env = "gnu"))] -pub(crate) fn preadv2( - fd: BorrowedFd<'_>, - bufs: &mut [IoSliceMut], - offset: u64, - flags: ReadWriteFlags, -) -> io::Result<usize> { - // Silently cast; we'll get `EINVAL` if the value is negative. - let offset = offset as i64; - let nread = unsafe { - ret_ssize_t(libc_preadv2( - borrowed_fd(fd), - bufs.as_ptr().cast::<c::iovec>(), - min(bufs.len(), max_iov()) as c::c_int, - offset, - flags.bits(), - ))? - }; - Ok(nread as usize) -} - -/// At present, `libc` only has `preadv2` defined for glibc. On other -/// ABIs, use `libc::syscall`. -#[cfg(any( - target_os = "android", - all(target_os = "linux", not(target_env = "gnu")), -))] -#[inline] -pub(crate) fn preadv2( - fd: BorrowedFd<'_>, - bufs: &mut [IoSliceMut], - offset: u64, - flags: ReadWriteFlags, -) -> io::Result<usize> { - // Silently cast; we'll get `EINVAL` if the value is negative. - let offset = offset as i64; - let nread = unsafe { - ret_ssize_t(libc::syscall( - libc::SYS_preadv2, - borrowed_fd(fd), - bufs.as_ptr().cast::<c::iovec>(), - min(bufs.len(), max_iov()) as c::c_int, - offset, - flags.bits(), - ) as c::ssize_t)? - }; - Ok(nread as usize) -} - -#[cfg(all(target_os = "linux", target_env = "gnu"))] -pub(crate) fn pwritev2( - fd: BorrowedFd<'_>, - bufs: &[IoSlice], - offset: u64, - flags: ReadWriteFlags, -) -> io::Result<usize> { - // Silently cast; we'll get `EINVAL` if the value is negative. - let offset = offset as i64; - let nwritten = unsafe { - ret_ssize_t(libc_pwritev2( - borrowed_fd(fd), - bufs.as_ptr().cast::<c::iovec>(), - min(bufs.len(), max_iov()) as c::c_int, - offset, - flags.bits(), - ))? - }; - Ok(nwritten as usize) -} - -/// At present, `libc` only has `pwritev2` defined for glibc. On other -/// ABIs, use `libc::syscall`. -#[cfg(any( - target_os = "android", - all(target_os = "linux", not(target_env = "gnu")), -))] -#[inline] -pub(crate) fn pwritev2( - fd: BorrowedFd<'_>, - bufs: &[IoSlice], - offset: u64, - flags: ReadWriteFlags, -) -> io::Result<usize> { - // Silently cast; we'll get `EINVAL` if the value is negative. - let offset = offset as i64; - let nwritten = unsafe { - ret_ssize_t(libc::syscall( - libc::SYS_pwritev2, - borrowed_fd(fd), - bufs.as_ptr().cast::<c::iovec>(), - min(bufs.len(), max_iov()) as c::c_int, - offset, - flags.bits(), - ) as c::ssize_t)? - }; - Ok(nwritten as usize) -} - -// These functions are derived from Rust's library/std/src/sys/unix/fd.rs at -// revision 326ef470a8b379a180d6dc4bbef08990698a737a. - -// The maximum read limit on most POSIX-like systems is `SSIZE_MAX`, with the -// man page quoting that if the count of bytes to read is greater than -// `SSIZE_MAX` the result is "unspecified". -// -// On macOS, however, apparently the 64-bit libc is either buggy or -// intentionally showing odd behavior by rejecting any read with a size larger -// than or equal to `INT_MAX`. To handle both of these the read size is capped -// on both platforms. -#[cfg(target_os = "macos")] -const READ_LIMIT: usize = c::c_int::MAX as usize - 1; -#[cfg(not(target_os = "macos"))] -const READ_LIMIT: usize = c::ssize_t::MAX as usize; - -#[cfg(bsd)] -const fn max_iov() -> usize { - c::IOV_MAX as usize -} - -#[cfg(any( - target_os = "android", - target_os = "emscripten", - target_os = "linux", - target_os = "nto" -))] -const fn max_iov() -> usize { - c::UIO_MAXIOV as usize -} - -#[cfg(not(any( - bsd, - target_os = "android", - target_os = "emscripten", - target_os = "linux", - target_os = "nto", - target_os = "horizon", -)))] -const fn max_iov() -> usize { - 16 // The minimum value required by POSIX. -} - -pub(crate) unsafe fn close(raw_fd: RawFd) { - let _ = c::close(raw_fd as c::c_int); -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn eventfd(initval: u32, flags: EventfdFlags) -> io::Result<OwnedFd> { - unsafe { syscall_ret_owned_fd(c::syscall(c::SYS_eventfd2, initval, flags.bits())) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn ioctl_blksszget(fd: BorrowedFd) -> io::Result<u32> { - let mut result = MaybeUninit::<c::c_uint>::uninit(); - unsafe { - ret(c::ioctl(borrowed_fd(fd), c::BLKSSZGET, result.as_mut_ptr()))?; - Ok(result.assume_init() as u32) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn ioctl_blkpbszget(fd: BorrowedFd) -> io::Result<u32> { - let mut result = MaybeUninit::<c::c_uint>::uninit(); - unsafe { - ret(c::ioctl( - borrowed_fd(fd), - c::BLKPBSZGET, - result.as_mut_ptr(), - ))?; - Ok(result.assume_init() as u32) - } -} - -#[cfg(not(target_os = "redox"))] -pub(crate) fn ioctl_fionread(fd: BorrowedFd<'_>) -> io::Result<u64> { - let mut nread = MaybeUninit::<c::c_int>::uninit(); - unsafe { - ret(c::ioctl(borrowed_fd(fd), c::FIONREAD, nread.as_mut_ptr()))?; - // `FIONREAD` returns the number of bytes silently casted to a `c_int`, - // even when this is lossy. The best we can do is convert it back to a - // `u64` without sign-extending it back first. - Ok(u64::from(nread.assume_init() as c::c_uint)) - } -} - -pub(crate) fn ioctl_fionbio(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> { - unsafe { - let data = value as c::c_int; - ret(c::ioctl(borrowed_fd(fd), c::FIONBIO, &data)) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn ioctl_ficlone(fd: BorrowedFd<'_>, src_fd: BorrowedFd<'_>) -> io::Result<()> { - // TODO: Enable `ioctl_ficlone` for android when upstream is updated. - // TODO: Enable `ioctl_ficlone` for more architectures when upstream is - // updated. - #[cfg(all( - target_os = "linux", - any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64") - ))] - unsafe { - ret(c::ioctl( - borrowed_fd(fd), - c::FICLONE as _, - borrowed_fd(src_fd), - )) - } - #[cfg(not(all( - target_os = "linux", - any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64") - )))] - { - let _ = fd; - let _ = src_fd; - Err(io::Errno::NOSYS) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[cfg(all(feature = "fs", feature = "net"))] -pub(crate) fn is_read_write(fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> { - let (mut read, mut write) = crate::fs::fd::_is_file_read_write(fd)?; - let mut not_socket = false; - if read { - // Do a `recv` with `PEEK` and `DONTWAIT` for 1 byte. A 0 indicates - // the read side is shut down; an `EWOULDBLOCK` indicates the read - // side is still open. - match unsafe { - c::recv( - borrowed_fd(fd), - MaybeUninit::<[u8; 1]>::uninit() - .as_mut_ptr() - .cast::<c::c_void>(), - 1, - c::MSG_PEEK | c::MSG_DONTWAIT, - ) - } { - 0 => read = false, - -1 => { - #[allow(unreachable_patterns)] // `EAGAIN` may equal `EWOULDBLOCK` - match errno().0 { - c::EAGAIN | c::EWOULDBLOCK => (), - c::ENOTSOCK => not_socket = true, - err => return Err(io::Errno(err)), - } - } - _ => (), - } - } - if write && !not_socket { - // Do a `send` with `DONTWAIT` for 0 bytes. An `EPIPE` indicates - // the write side is shut down. - if unsafe { c::send(borrowed_fd(fd), [].as_ptr(), 0, c::MSG_DONTWAIT) } == -1 { - #[allow(unreachable_patterns)] // `EAGAIN` may equal `EWOULDBLOCK` - match errno().0 { - c::EAGAIN | c::EWOULDBLOCK => (), - c::ENOTSOCK => (), - c::EPIPE => write = false, - err => return Err(io::Errno(err)), - } - } - } - Ok((read, write)) -} - -#[cfg(target_os = "wasi")] -#[cfg(all(feature = "fs", feature = "net"))] -pub(crate) fn is_read_write(_fd: BorrowedFd<'_>) -> io::Result<(bool, bool)> { - todo!("Implement is_read_write for WASI in terms of fd_fdstat_get"); -} - -pub(crate) fn fcntl_getfd(fd: BorrowedFd<'_>) -> io::Result<FdFlags> { - unsafe { ret_c_int(c::fcntl(borrowed_fd(fd), c::F_GETFD)).map(FdFlags::from_bits_truncate) } -} - -pub(crate) fn fcntl_setfd(fd: BorrowedFd<'_>, flags: FdFlags) -> io::Result<()> { - unsafe { ret(c::fcntl(borrowed_fd(fd), c::F_SETFD, flags.bits())) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn fcntl_dupfd_cloexec(fd: BorrowedFd<'_>, min: RawFd) -> io::Result<OwnedFd> { - unsafe { ret_owned_fd(c::fcntl(borrowed_fd(fd), c::F_DUPFD_CLOEXEC, min)) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn dup(fd: BorrowedFd<'_>) -> io::Result<OwnedFd> { - unsafe { ret_owned_fd(c::dup(borrowed_fd(fd))) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn dup2(fd: BorrowedFd<'_>, new: &mut OwnedFd) -> io::Result<()> { - unsafe { ret_discarded_fd(c::dup2(borrowed_fd(fd), borrowed_fd(new.as_fd()))) } -} - -#[cfg(not(any( - apple, - target_os = "aix", - target_os = "android", - target_os = "dragonfly", - target_os = "haiku", - target_os = "redox", - target_os = "wasi", -)))] -pub(crate) fn dup3(fd: BorrowedFd<'_>, new: &mut OwnedFd, flags: DupFlags) -> io::Result<()> { - unsafe { - ret_discarded_fd(c::dup3( - borrowed_fd(fd), - borrowed_fd(new.as_fd()), - flags.bits(), - )) - } -} - -#[cfg(any( - apple, - target_os = "android", - target_os = "dragonfly", - target_os = "haiku", - target_os = "redox", -))] -pub(crate) fn dup3(fd: BorrowedFd<'_>, new: &mut OwnedFd, _flags: DupFlags) -> io::Result<()> { - // Android 5.0 has `dup3`, but libc doesn't have bindings. Emulate it - // using `dup2`. We don't need to worry about the difference between - // `dup2` and `dup3` when the file descriptors are equal because we - // have an `&mut OwnedFd` which means `fd` doesn't alias it. - dup2(fd, new) -} - -#[cfg(apple)] -pub(crate) fn ioctl_fioclex(fd: BorrowedFd<'_>) -> io::Result<()> { - unsafe { ret(c::ioctl(borrowed_fd(fd), c::FIOCLEX)) } -} - -#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))] -pub(crate) fn ioctl_tiocexcl(fd: BorrowedFd) -> io::Result<()> { - unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCEXCL as _)) } -} - -#[cfg(not(any(target_os = "haiku", target_os = "redox", target_os = "wasi")))] -pub(crate) fn ioctl_tiocnxcl(fd: BorrowedFd) -> io::Result<()> { - unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCNXCL as _)) } -} - -#[cfg(bsd)] -pub(crate) fn kqueue() -> io::Result<OwnedFd> { - unsafe { ret_owned_fd(c::kqueue()) } -} - -#[cfg(bsd)] -pub(crate) unsafe fn kevent( - kq: BorrowedFd<'_>, - changelist: &[Event], - eventlist: &mut [MaybeUninit<Event>], - timeout: Option<&c::timespec>, -) -> io::Result<c::c_int> { - ret_c_int(c::kevent( - borrowed_fd(kq), - changelist.as_ptr() as *const _, - changelist - .len() - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - eventlist.as_mut_ptr() as *mut _, - eventlist - .len() - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - timeout.map_or(core::ptr::null(), |t| t as *const _), - )) -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn pipe() -> io::Result<(OwnedFd, OwnedFd)> { - unsafe { - let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit(); - ret(c::pipe(result.as_mut_ptr().cast::<i32>()))?; - let [p0, p1] = result.assume_init(); - Ok((p0, p1)) - } -} - -#[cfg(not(any(apple, target_os = "aix", target_os = "haiku", target_os = "wasi")))] -pub(crate) fn pipe_with(flags: PipeFlags) -> io::Result<(OwnedFd, OwnedFd)> { - unsafe { - let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit(); - ret(c::pipe2(result.as_mut_ptr().cast::<i32>(), flags.bits()))?; - let [p0, p1] = result.assume_init(); - Ok((p0, p1)) - } -} - -#[inline] -pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> { - let nfds = fds - .len() - .try_into() - .map_err(|_convert_err| io::Errno::INVAL)?; - - ret_c_int(unsafe { c::poll(fds.as_mut_ptr().cast(), nfds, timeout) }) - .map(|nready| nready as usize) -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub fn splice( - fd_in: BorrowedFd, - off_in: Option<&mut u64>, - fd_out: BorrowedFd, - off_out: Option<&mut u64>, - len: usize, - flags: SpliceFlags, -) -> io::Result<usize> { - let off_in = off_in - .map(|off| (off as *mut u64).cast()) - .unwrap_or(ptr::null_mut()); - - let off_out = off_out - .map(|off| (off as *mut u64).cast()) - .unwrap_or(ptr::null_mut()); - - ret_ssize_t(unsafe { - c::splice( - borrowed_fd(fd_in), - off_in, - borrowed_fd(fd_out), - off_out, - len, - flags.bits(), - ) - }) - .map(|spliced| spliced as usize) -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub unsafe fn vmsplice( - fd: BorrowedFd, - bufs: &[IoSliceRaw], - flags: SpliceFlags, -) -> io::Result<usize> { - ret_ssize_t(c::vmsplice( - borrowed_fd(fd), - bufs.as_ptr().cast::<c::iovec>(), - min(bufs.len(), max_iov()), - flags.bits(), - )) - .map(|spliced| spliced as usize) -} - -#[cfg(solarish)] -pub(crate) fn port_create() -> io::Result<OwnedFd> { - unsafe { ret_owned_fd(c::port_create()) } -} - -#[cfg(solarish)] -pub(crate) unsafe fn port_associate( - port: BorrowedFd<'_>, - source: c::c_int, - object: c::uintptr_t, - events: c::c_int, - user: *mut c::c_void, -) -> io::Result<()> { - ret(c::port_associate( - borrowed_fd(port), - source, - object, - events, - user, - )) -} - -#[cfg(solarish)] -pub(crate) unsafe fn port_dissociate( - port: BorrowedFd<'_>, - source: c::c_int, - object: c::uintptr_t, -) -> io::Result<()> { - ret(c::port_dissociate(borrowed_fd(port), source, object)) -} - -#[cfg(solarish)] -pub(crate) fn port_get( - port: BorrowedFd<'_>, - timeout: Option<&mut c::timespec>, -) -> io::Result<Event> { - let mut event = MaybeUninit::<c::port_event>::uninit(); - let timeout = timeout.map_or(core::ptr::null_mut(), |t| t as *mut _); - - unsafe { - ret(c::port_get(borrowed_fd(port), event.as_mut_ptr(), timeout))?; - } - - // If we're done, initialize the event and return it. - Ok(Event(unsafe { event.assume_init() })) -} - -#[cfg(solarish)] -pub(crate) fn port_getn( - port: BorrowedFd<'_>, - timeout: Option<&mut c::timespec>, - events: &mut Vec<Event>, - mut nget: u32, -) -> io::Result<()> { - let timeout = timeout.map_or(core::ptr::null_mut(), |t| t as *mut _); - unsafe { - ret(c::port_getn( - borrowed_fd(port), - events.as_mut_ptr().cast(), - events.len().try_into().unwrap(), - &mut nget, - timeout, - ))?; - } - - // Update the vector length. - unsafe { - events.set_len(nget.try_into().unwrap()); - } - - Ok(()) -} - -#[cfg(solarish)] -pub(crate) fn port_send( - port: BorrowedFd<'_>, - events: c::c_int, - userdata: *mut c::c_void, -) -> io::Result<()> { - unsafe { ret(c::port_send(borrowed_fd(port), events, userdata)) } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/io/types.rs b/vendor/rustix-0.37.6/src/backend/libc/io/types.rs deleted file mode 100644 index cbdd734b9..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io/types.rs +++ /dev/null @@ -1,153 +0,0 @@ -use super::super::c; -use bitflags::bitflags; -#[cfg(any(target_os = "android", target_os = "linux"))] -use core::marker::PhantomData; - -bitflags! { - /// `FD_*` constants for use with [`fcntl_getfd`] and [`fcntl_setfd`]. - /// - /// [`fcntl_getfd`]: crate::io::fcntl_getfd - /// [`fcntl_setfd`]: crate::io::fcntl_setfd - pub struct FdFlags: c::c_int { - /// `FD_CLOEXEC` - const CLOEXEC = c::FD_CLOEXEC; - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `RWF_*` constants for use with [`preadv2`] and [`pwritev2`]. - /// - /// [`preadv2`]: crate::io::preadv2 - /// [`pwritev2`]: crate::io::pwritev - pub struct ReadWriteFlags: c::c_int { - /// `RWF_DSYNC` (since Linux 4.7) - const DSYNC = linux_raw_sys::general::RWF_DSYNC as c::c_int; - /// `RWF_HIPRI` (since Linux 4.6) - const HIPRI = linux_raw_sys::general::RWF_HIPRI as c::c_int; - /// `RWF_SYNC` (since Linux 4.7) - const SYNC = linux_raw_sys::general::RWF_SYNC as c::c_int; - /// `RWF_NOWAIT` (since Linux 4.14) - const NOWAIT = linux_raw_sys::general::RWF_NOWAIT as c::c_int; - /// `RWF_APPEND` (since Linux 4.16) - const APPEND = linux_raw_sys::general::RWF_APPEND as c::c_int; - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `SPLICE_F_*` constants for use with [`splice`] and [`vmsplice`]. - pub struct SpliceFlags: c::c_uint { - /// `SPLICE_F_MOVE` - const MOVE = c::SPLICE_F_MOVE; - /// `SPLICE_F_NONBLOCK` - const NONBLOCK = c::SPLICE_F_NONBLOCK; - /// `SPLICE_F_MORE` - const MORE = c::SPLICE_F_MORE; - /// `SPLICE_F_GIFT` - const GIFT = c::SPLICE_F_GIFT; - } -} - -#[cfg(not(target_os = "wasi"))] -bitflags! { - /// `O_*` constants for use with [`dup2`]. - /// - /// [`dup2`]: crate::io::dup2 - pub struct DupFlags: c::c_int { - /// `O_CLOEXEC` - #[cfg(not(any( - apple, - target_os = "aix", - target_os = "android", - target_os = "redox", - )))] // Android 5.0 has dup3, but libc doesn't have bindings - const CLOEXEC = c::O_CLOEXEC; - } -} - -#[cfg(not(any(apple, target_os = "wasi")))] -bitflags! { - /// `O_*` constants for use with [`pipe_with`]. - /// - /// [`pipe_with`]: crate::io::pipe_with - pub struct PipeFlags: c::c_int { - /// `O_CLOEXEC` - const CLOEXEC = c::O_CLOEXEC; - /// `O_DIRECT` - #[cfg(not(any( - solarish, - target_os = "haiku", - target_os = "openbsd", - target_os = "redox", - )))] - const DIRECT = c::O_DIRECT; - /// `O_NONBLOCK` - const NONBLOCK = c::O_NONBLOCK; - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `EFD_*` flags for use with [`eventfd`]. - /// - /// [`eventfd`]: crate::io::eventfd - pub struct EventfdFlags: c::c_int { - /// `EFD_CLOEXEC` - const CLOEXEC = c::EFD_CLOEXEC; - /// `EFD_NONBLOCK` - const NONBLOCK = c::EFD_NONBLOCK; - /// `EFD_SEMAPHORE` - const SEMAPHORE = c::EFD_SEMAPHORE; - } -} - -/// `PIPE_BUF`—The maximum size of a write to a pipe guaranteed to be atomic. -#[cfg(not(any(solarish, target_os = "haiku", target_os = "redox", target_os = "wasi")))] -pub const PIPE_BUF: usize = c::PIPE_BUF; - -#[cfg(not(any(windows, target_os = "redox")))] -pub(crate) const AT_FDCWD: c::c_int = c::AT_FDCWD; -#[cfg(not(windows))] -pub(crate) const STDIN_FILENO: c::c_int = c::STDIN_FILENO; -#[cfg(not(windows))] -pub(crate) const STDOUT_FILENO: c::c_int = c::STDOUT_FILENO; -#[cfg(not(windows))] -pub(crate) const STDERR_FILENO: c::c_int = c::STDERR_FILENO; - -/// A buffer type used with `vmsplice`. -/// It is guaranteed to be ABI compatible with the iovec type on Unix platforms -/// and `WSABUF` on Windows. Unlike `IoSlice` and `IoSliceMut` it is -/// semantically like a raw pointer, and therefore can be shared or mutated as -/// needed. -#[cfg(any(target_os = "android", target_os = "linux"))] -#[repr(transparent)] -pub struct IoSliceRaw<'a> { - _buf: c::iovec, - _lifetime: PhantomData<&'a ()>, -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -impl<'a> IoSliceRaw<'a> { - /// Creates a new IoSlice wrapping a byte slice. - pub fn from_slice(buf: &'a [u8]) -> Self { - IoSliceRaw { - _buf: c::iovec { - iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void, - iov_len: buf.len() as _, - }, - _lifetime: PhantomData, - } - } - - /// Creates a new IoSlice wrapping a mutable byte slice. - pub fn from_slice_mut(buf: &'a mut [u8]) -> Self { - IoSliceRaw { - _buf: c::iovec { - iov_base: buf.as_mut_ptr() as *mut c::c_void, - iov_len: buf.len() as _, - }, - _lifetime: PhantomData, - } - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/io/windows_syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/io/windows_syscalls.rs deleted file mode 100644 index 4c6e86f94..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io/windows_syscalls.rs +++ /dev/null @@ -1,39 +0,0 @@ -//! Windows system calls in the `io` module. - -use super::super::c; -use super::super::conv::{borrowed_fd, ret, ret_c_int}; -use super::super::fd::LibcFd; -use crate::fd::{BorrowedFd, RawFd}; -use crate::io; -use crate::io::PollFd; -use core::convert::TryInto; -use core::mem::MaybeUninit; - -pub(crate) unsafe fn close(raw_fd: RawFd) { - let _ = c::close(raw_fd as LibcFd); -} - -pub(crate) fn ioctl_fionread(fd: BorrowedFd<'_>) -> io::Result<u64> { - let mut nread = MaybeUninit::<c::c_ulong>::uninit(); - unsafe { - ret(c::ioctl(borrowed_fd(fd), c::FIONREAD, nread.as_mut_ptr()))?; - Ok(u64::from(nread.assume_init())) - } -} - -pub(crate) fn ioctl_fionbio(fd: BorrowedFd<'_>, value: bool) -> io::Result<()> { - unsafe { - let mut data = value as c::c_uint; - ret(c::ioctl(borrowed_fd(fd), c::FIONBIO, &mut data)) - } -} - -pub(crate) fn poll(fds: &mut [PollFd<'_>], timeout: c::c_int) -> io::Result<usize> { - let nfds = fds - .len() - .try_into() - .map_err(|_convert_err| io::Errno::INVAL)?; - - ret_c_int(unsafe { c::poll(fds.as_mut_ptr().cast(), nfds, timeout) }) - .map(|nready| nready as usize) -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/io_lifetimes.rs b/vendor/rustix-0.37.6/src/backend/libc/io_lifetimes.rs deleted file mode 100644 index 993365c0c..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io_lifetimes.rs +++ /dev/null @@ -1,82 +0,0 @@ -//! `io_lifetimes` types for Windows assuming that Fd is Socket. -//! -//! We can make this assumption since `rustix` supports only `rustix::net` on -//! Windows. - -pub use io_lifetimes::{BorrowedSocket as BorrowedFd, OwnedSocket as OwnedFd}; -#[cfg(feature = "std")] -pub use std::os::windows::io::RawSocket as RawFd; -pub(crate) use windows_sys::Win32::Networking::WinSock::SOCKET as LibcFd; - -// Re-export the `Socket` traits so that users can implement them. -pub use io_lifetimes::AsSocket; - -/// A version of [`AsRawFd`] for use with Winsock2 API. -/// -/// [`AsRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsRawFd.html -pub trait AsRawFd { - /// A version of [`as_raw_fd`] for use with Winsock2 API. - /// - /// [`as_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.as_raw_fd - fn as_raw_fd(&self) -> RawFd; -} -#[cfg(feature = "std")] -impl<T: std::os::windows::io::AsRawSocket> AsRawFd for T { - #[inline] - fn as_raw_fd(&self) -> RawFd { - self.as_raw_socket() - } -} - -/// A version of [`IntoRawFd`] for use with Winsock2 API. -/// -/// [`IntoRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.IntoRawFd.html -pub trait IntoRawFd { - /// A version of [`into_raw_fd`] for use with Winsock2 API. - /// - /// [`into_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.into_raw_fd - fn into_raw_fd(self) -> RawFd; -} -#[cfg(feature = "std")] -impl<T: std::os::windows::io::IntoRawSocket> IntoRawFd for T { - #[inline] - fn into_raw_fd(self) -> RawFd { - self.into_raw_socket() - } -} - -/// A version of [`FromRawFd`] for use with Winsock2 API. -/// -/// [`FromRawFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html -pub trait FromRawFd { - /// A version of [`from_raw_fd`] for use with Winsock2 API. - /// - /// # Safety - /// - /// See the [safety requirements] for [`from_raw_fd`]. - /// - /// [`from_raw_fd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#tymethod.from_raw_fd - /// [safety requirements]: https://doc.rust-lang.org/stable/std/os/fd/trait.FromRawFd.html#safety - unsafe fn from_raw_fd(raw_fd: RawFd) -> Self; -} -#[cfg(feature = "std")] -impl<T: std::os::windows::io::FromRawSocket> FromRawFd for T { - #[inline] - unsafe fn from_raw_fd(raw_fd: RawFd) -> Self { - Self::from_raw_socket(raw_fd) - } -} - -/// A version of [`AsFd`] for use with Winsock2 API. -/// -/// [`AsFd`]: https://doc.rust-lang.org/stable/std/os/fd/trait.AsFd.html -pub trait AsFd { - /// An `as_fd` function for Winsock2, where a `Fd` is a `Socket`. - fn as_fd(&self) -> BorrowedFd; -} -impl<T: AsSocket> AsFd for T { - #[inline] - fn as_fd(&self) -> BorrowedFd { - self.as_socket() - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/io_uring/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/io_uring/mod.rs deleted file mode 100644 index ef944f04d..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io_uring/mod.rs +++ /dev/null @@ -1 +0,0 @@ -pub(crate) mod syscalls; diff --git a/vendor/rustix-0.37.6/src/backend/libc/io_uring/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/io_uring/syscalls.rs deleted file mode 100644 index 17d3eb10c..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/io_uring/syscalls.rs +++ /dev/null @@ -1,55 +0,0 @@ -//! libc syscalls supporting `rustix::io_uring`. - -use super::super::c; -use super::super::conv::{borrowed_fd, syscall_ret_owned_fd, syscall_ret_u32}; -use crate::fd::{BorrowedFd, OwnedFd}; -use crate::io; -use crate::io_uring::{io_uring_params, IoringEnterFlags, IoringRegisterOp}; -use linux_raw_sys::general::{__NR_io_uring_enter, __NR_io_uring_register, __NR_io_uring_setup}; - -#[inline] -pub(crate) fn io_uring_setup(entries: u32, params: &mut io_uring_params) -> io::Result<OwnedFd> { - unsafe { - syscall_ret_owned_fd(c::syscall( - __NR_io_uring_setup as _, - entries as usize, - params, - )) - } -} - -#[inline] -pub(crate) unsafe fn io_uring_register( - fd: BorrowedFd<'_>, - opcode: IoringRegisterOp, - arg: *const c::c_void, - nr_args: u32, -) -> io::Result<u32> { - syscall_ret_u32(c::syscall( - __NR_io_uring_register as _, - borrowed_fd(fd), - opcode as u32 as usize, - arg, - nr_args as usize, - )) -} - -#[inline] -pub(crate) unsafe fn io_uring_enter( - fd: BorrowedFd<'_>, - to_submit: u32, - min_complete: u32, - flags: IoringEnterFlags, - arg: *const c::c_void, - size: usize, -) -> io::Result<u32> { - syscall_ret_u32(c::syscall( - __NR_io_uring_enter as _, - borrowed_fd(fd), - to_submit as usize, - min_complete as usize, - flags.bits() as usize, - arg, - size, - )) -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/mm/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/mm/mod.rs deleted file mode 100644 index 1e0181a99..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/mm/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub(crate) mod syscalls; -pub(crate) mod types; diff --git a/vendor/rustix-0.37.6/src/backend/libc/mm/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/mm/syscalls.rs deleted file mode 100644 index 16636f1b9..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/mm/syscalls.rs +++ /dev/null @@ -1,218 +0,0 @@ -//! libc syscalls supporting `rustix::mm`. - -use super::super::c; -#[cfg(any(target_os = "android", target_os = "linux"))] -use super::super::conv::syscall_ret_owned_fd; -use super::super::conv::{borrowed_fd, no_fd, ret}; -use super::super::offset::libc_mmap; -#[cfg(not(target_os = "redox"))] -use super::types::Advice; -#[cfg(any(target_os = "emscripten", target_os = "linux"))] -use super::types::MremapFlags; -use super::types::{MapFlags, MprotectFlags, MsyncFlags, ProtFlags}; -#[cfg(any(target_os = "android", target_os = "linux"))] -use super::types::{MlockFlags, UserfaultfdFlags}; -use crate::fd::BorrowedFd; -#[cfg(any(target_os = "android", target_os = "linux"))] -use crate::fd::OwnedFd; -use crate::io; - -#[cfg(not(target_os = "redox"))] -pub(crate) fn madvise(addr: *mut c::c_void, len: usize, advice: Advice) -> io::Result<()> { - // On Linux platforms, `MADV_DONTNEED` has the same value as - // `POSIX_MADV_DONTNEED` but different behavior. We remap it to a different - // value, and check for it here. - #[cfg(target_os = "linux")] - if let Advice::LinuxDontNeed = advice { - return unsafe { ret(c::madvise(addr, len, c::MADV_DONTNEED)) }; - } - - #[cfg(not(target_os = "android"))] - { - let err = unsafe { c::posix_madvise(addr, len, advice as c::c_int) }; - - // `posix_madvise` returns its error status rather than using `errno`. - if err == 0 { - Ok(()) - } else { - Err(io::Errno(err)) - } - } - - #[cfg(target_os = "android")] - { - if let Advice::DontNeed = advice { - // Do nothing. Linux's `MADV_DONTNEED` isn't the same as - // `POSIX_MADV_DONTNEED`, so just discard `MADV_DONTNEED`. - Ok(()) - } else { - unsafe { ret(c::madvise(addr, len, advice as c::c_int)) } - } - } -} - -pub(crate) unsafe fn msync(addr: *mut c::c_void, len: usize, flags: MsyncFlags) -> io::Result<()> { - let err = c::msync(addr, len, flags.bits()); - - // `msync` returns its error status rather than using `errno`. - if err == 0 { - Ok(()) - } else { - Err(io::Errno(err)) - } -} - -/// # Safety -/// -/// `mmap` is primarily unsafe due to the `addr` parameter, as anything working -/// with memory pointed to by raw pointers is unsafe. -pub(crate) unsafe fn mmap( - ptr: *mut c::c_void, - len: usize, - prot: ProtFlags, - flags: MapFlags, - fd: BorrowedFd<'_>, - offset: u64, -) -> io::Result<*mut c::c_void> { - let res = libc_mmap( - ptr, - len, - prot.bits(), - flags.bits(), - borrowed_fd(fd), - offset as i64, - ); - if res == c::MAP_FAILED { - Err(io::Errno::last_os_error()) - } else { - Ok(res) - } -} - -/// # Safety -/// -/// `mmap` is primarily unsafe due to the `addr` parameter, as anything working -/// with memory pointed to by raw pointers is unsafe. -pub(crate) unsafe fn mmap_anonymous( - ptr: *mut c::c_void, - len: usize, - prot: ProtFlags, - flags: MapFlags, -) -> io::Result<*mut c::c_void> { - let res = libc_mmap( - ptr, - len, - prot.bits(), - flags.bits() | c::MAP_ANONYMOUS, - no_fd(), - 0, - ); - if res == c::MAP_FAILED { - Err(io::Errno::last_os_error()) - } else { - Ok(res) - } -} - -pub(crate) unsafe fn mprotect( - ptr: *mut c::c_void, - len: usize, - flags: MprotectFlags, -) -> io::Result<()> { - ret(c::mprotect(ptr, len, flags.bits())) -} - -pub(crate) unsafe fn munmap(ptr: *mut c::c_void, len: usize) -> io::Result<()> { - ret(c::munmap(ptr, len)) -} - -/// # Safety -/// -/// `mremap` is primarily unsafe due to the `old_address` parameter, as -/// anything working with memory pointed to by raw pointers is unsafe. -#[cfg(any(target_os = "emscripten", target_os = "linux"))] -pub(crate) unsafe fn mremap( - old_address: *mut c::c_void, - old_size: usize, - new_size: usize, - flags: MremapFlags, -) -> io::Result<*mut c::c_void> { - let res = c::mremap(old_address, old_size, new_size, flags.bits()); - if res == c::MAP_FAILED { - Err(io::Errno::last_os_error()) - } else { - Ok(res) - } -} - -/// # Safety -/// -/// `mremap_fixed` is primarily unsafe due to the `old_address` and -/// `new_address` parameters, as anything working with memory pointed to by raw -/// pointers is unsafe. -#[cfg(any(target_os = "emscripten", target_os = "linux"))] -pub(crate) unsafe fn mremap_fixed( - old_address: *mut c::c_void, - old_size: usize, - new_size: usize, - flags: MremapFlags, - new_address: *mut c::c_void, -) -> io::Result<*mut c::c_void> { - let res = c::mremap( - old_address, - old_size, - new_size, - flags.bits() | c::MAP_FIXED, - new_address, - ); - if res == c::MAP_FAILED { - Err(io::Errno::last_os_error()) - } else { - Ok(res) - } -} - -/// # Safety -/// -/// `mlock` operates on raw pointers and may round out to the nearest page -/// boundaries. -#[inline] -pub(crate) unsafe fn mlock(addr: *mut c::c_void, length: usize) -> io::Result<()> { - ret(c::mlock(addr, length)) -} - -/// # Safety -/// -/// `mlock_with` operates on raw pointers and may round out to the nearest page -/// boundaries. -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) unsafe fn mlock_with( - addr: *mut c::c_void, - length: usize, - flags: MlockFlags, -) -> io::Result<()> { - weak_or_syscall! { - fn mlock2( - addr: *const c::c_void, - len: c::size_t, - flags: c::c_int - ) via SYS_mlock2 -> c::c_int - } - - ret(mlock2(addr, length, flags.bits())) -} - -/// # Safety -/// -/// `munlock` operates on raw pointers and may round out to the nearest page -/// boundaries. -#[inline] -pub(crate) unsafe fn munlock(addr: *mut c::c_void, length: usize) -> io::Result<()> { - ret(c::munlock(addr, length)) -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) unsafe fn userfaultfd(flags: UserfaultfdFlags) -> io::Result<OwnedFd> { - syscall_ret_owned_fd(c::syscall(c::SYS_userfaultfd, flags.bits())) -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/mm/types.rs b/vendor/rustix-0.37.6/src/backend/libc/mm/types.rs deleted file mode 100644 index cd6e521d2..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/mm/types.rs +++ /dev/null @@ -1,366 +0,0 @@ -use super::super::c; -use bitflags::bitflags; - -bitflags! { - /// `PROT_*` flags for use with [`mmap`]. - /// - /// For `PROT_NONE`, use `ProtFlags::empty()`. - /// - /// [`mmap`]: crate::io::mmap - pub struct ProtFlags: c::c_int { - /// `PROT_READ` - const READ = c::PROT_READ; - /// `PROT_WRITE` - const WRITE = c::PROT_WRITE; - /// `PROT_EXEC` - const EXEC = c::PROT_EXEC; - } -} - -bitflags! { - /// `PROT_*` flags for use with [`mprotect`]. - /// - /// For `PROT_NONE`, use `MprotectFlags::empty()`. - /// - /// [`mprotect`]: crate::io::mprotect - pub struct MprotectFlags: c::c_int { - /// `PROT_READ` - const READ = c::PROT_READ; - /// `PROT_WRITE` - const WRITE = c::PROT_WRITE; - /// `PROT_EXEC` - const EXEC = c::PROT_EXEC; - /// `PROT_GROWSUP` - #[cfg(any(target_os = "android", target_os = "linux"))] - const GROWSUP = c::PROT_GROWSUP; - /// `PROT_GROWSDOWN` - #[cfg(any(target_os = "android", target_os = "linux"))] - const GROWSDOWN = c::PROT_GROWSDOWN; - } -} - -bitflags! { - /// `MAP_*` flags for use with [`mmap`]. - /// - /// For `MAP_ANONYMOUS` (aka `MAP_ANON`), see [`mmap_anonymous`]. - /// - /// [`mmap`]: crate::io::mmap - /// [`mmap_anonymous`]: crates::io::mmap_anonymous - pub struct MapFlags: c::c_int { - /// `MAP_SHARED` - const SHARED = c::MAP_SHARED; - /// `MAP_SHARED_VALIDATE` - #[cfg(not(any( - bsd, - solarish, - target_os = "android", - target_os = "emscripten", - target_os = "fuchsia", - target_os = "haiku", - target_os = "redox", - )))] - const SHARED_VALIDATE = c::MAP_SHARED_VALIDATE; - /// `MAP_PRIVATE` - const PRIVATE = c::MAP_PRIVATE; - /// `MAP_DENYWRITE` - #[cfg(not(any( - bsd, - solarish, - target_os = "haiku", - target_os = "redox", - )))] - const DENYWRITE = c::MAP_DENYWRITE; - /// `MAP_FIXED` - const FIXED = c::MAP_FIXED; - /// `MAP_FIXED_NOREPLACE` - #[cfg(not(any( - bsd, - solarish, - target_os = "android", - target_os = "emscripten", - target_os = "fuchsia", - target_os = "haiku", - target_os = "redox", - )))] - const FIXED_NOREPLACE = c::MAP_FIXED_NOREPLACE; - /// `MAP_GROWSDOWN` - #[cfg(not(any( - bsd, - solarish, - target_os = "haiku", - target_os = "redox", - )))] - const GROWSDOWN = c::MAP_GROWSDOWN; - /// `MAP_HUGETLB` - #[cfg(not(any( - bsd, - solarish, - target_os = "haiku", - target_os = "redox", - )))] - const HUGETLB = c::MAP_HUGETLB; - /// `MAP_HUGE_2MB` - #[cfg(not(any( - bsd, - solarish, - target_os = "android", - target_os = "emscripten", - target_os = "fuchsia", - target_os = "haiku", - target_os = "redox", - )))] - const HUGE_2MB = c::MAP_HUGE_2MB; - /// `MAP_HUGE_1GB` - #[cfg(not(any( - bsd, - solarish, - target_os = "android", - target_os = "emscripten", - target_os = "fuchsia", - target_os = "haiku", - target_os = "redox", - )))] - const HUGE_1GB = c::MAP_HUGE_1GB; - /// `MAP_LOCKED` - #[cfg(not(any( - bsd, - solarish, - target_os = "haiku", - target_os = "redox", - )))] - const LOCKED = c::MAP_LOCKED; - /// `MAP_NOCORE` - #[cfg(freebsdlike)] - const NOCORE = c::MAP_NOCORE; - /// `MAP_NORESERVE` - #[cfg(not(any(freebsdlike, target_os = "redox")))] - const NORESERVE = c::MAP_NORESERVE; - /// `MAP_NOSYNC` - #[cfg(freebsdlike)] - const NOSYNC = c::MAP_NOSYNC; - /// `MAP_POPULATE` - #[cfg(not(any( - bsd, - solarish, - target_os = "haiku", - target_os = "redox", - )))] - const POPULATE = c::MAP_POPULATE; - /// `MAP_STACK` - #[cfg(not(any( - apple, - solarish, - target_os = "dragonfly", - target_os = "haiku", - target_os = "netbsd", - target_os = "redox", - )))] - const STACK = c::MAP_STACK; - /// `MAP_PREFAULT_READ` - #[cfg(target_os = "freebsd")] - const PREFAULT_READ = c::MAP_PREFAULT_READ; - /// `MAP_SYNC` - #[cfg(not(any( - bsd, - solarish, - target_os = "android", - target_os = "emscripten", - target_os = "fuchsia", - target_os = "haiku", - target_os = "redox", - all( - any(target_os = "android", target_os = "linux"), - any(target_arch = "mips", target_arch = "mips64"), - ) - )))] - const SYNC = c::MAP_SYNC; - /// `MAP_UNINITIALIZED` - #[cfg(any())] - const UNINITIALIZED = c::MAP_UNINITIALIZED; - } -} - -#[cfg(any(target_os = "emscripten", target_os = "linux"))] -bitflags! { - /// `MREMAP_*` flags for use with [`mremap`]. - /// - /// For `MREMAP_FIXED`, see [`mremap_fixed`]. - /// - /// [`mremap`]: crate::io::mremap - /// [`mremap_fixed`]: crate::io::mremap_fixed - pub struct MremapFlags: i32 { - /// `MREMAP_MAYMOVE` - const MAYMOVE = c::MREMAP_MAYMOVE; - } -} - -bitflags! { - /// `MS_*` flags for use with [`msync`]. - /// - /// [`msync`]: crate::io::msync - pub struct MsyncFlags: i32 { - /// `MS_SYNC`—Requests an update and waits for it to complete. - const SYNC = c::MS_SYNC; - /// `MS_ASYNC`—Specifies that an update be scheduled, but the call - /// returns immediately. - const ASYNC = c::MS_ASYNC; - /// `MS_INVALIDATE`—Asks to invalidate other mappings of the same - /// file (so that they can be updated with the fresh values just - /// written). - const INVALIDATE = c::MS_INVALIDATE; - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `MLOCK_*` flags for use with [`mlock_with`]. - /// - /// [`mlock_with`]: crate::io::mlock_with - pub struct MlockFlags: i32 { - /// `MLOCK_ONFAULT` - const ONFAULT = c::MLOCK_ONFAULT as _; - } -} - -/// `POSIX_MADV_*` constants for use with [`madvise`]. -/// -/// [`madvise`]: crate::mm::madvise -#[cfg(not(target_os = "redox"))] -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -#[repr(i32)] -#[non_exhaustive] -pub enum Advice { - /// `POSIX_MADV_NORMAL` - #[cfg(not(any(target_os = "android", target_os = "haiku")))] - Normal = c::POSIX_MADV_NORMAL, - - /// `POSIX_MADV_NORMAL` - #[cfg(any(target_os = "android", target_os = "haiku"))] - Normal = c::MADV_NORMAL, - - /// `POSIX_MADV_SEQUENTIAL` - #[cfg(not(any(target_os = "android", target_os = "haiku")))] - Sequential = c::POSIX_MADV_SEQUENTIAL, - - /// `POSIX_MADV_SEQUENTIAL` - #[cfg(any(target_os = "android", target_os = "haiku"))] - Sequential = c::MADV_SEQUENTIAL, - - /// `POSIX_MADV_RANDOM` - #[cfg(not(any(target_os = "android", target_os = "haiku")))] - Random = c::POSIX_MADV_RANDOM, - - /// `POSIX_MADV_RANDOM` - #[cfg(any(target_os = "android", target_os = "haiku"))] - Random = c::MADV_RANDOM, - - /// `POSIX_MADV_WILLNEED` - #[cfg(not(any(target_os = "android", target_os = "haiku")))] - WillNeed = c::POSIX_MADV_WILLNEED, - - /// `POSIX_MADV_WILLNEED` - #[cfg(any(target_os = "android", target_os = "haiku"))] - WillNeed = c::MADV_WILLNEED, - - /// `POSIX_MADV_DONTNEED` - #[cfg(not(any(target_os = "android", target_os = "emscripten", target_os = "haiku")))] - DontNeed = c::POSIX_MADV_DONTNEED, - - /// `POSIX_MADV_DONTNEED` - #[cfg(any(target_os = "android", target_os = "haiku"))] - DontNeed = i32::MAX - 1, - - /// `MADV_DONTNEED` - // `MADV_DONTNEED` has the same value as `POSIX_MADV_DONTNEED`. We don't - // have a separate `posix_madvise` from `madvise`, so we expose a special - // value which we special-case. - #[cfg(target_os = "linux")] - LinuxDontNeed = i32::MAX, - - /// `MADV_DONTNEED` - #[cfg(target_os = "android")] - LinuxDontNeed = c::MADV_DONTNEED, - /// `MADV_FREE` - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxFree = c::MADV_FREE, - /// `MADV_REMOVE` - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxRemove = c::MADV_REMOVE, - /// `MADV_DONTFORK` - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxDontFork = c::MADV_DONTFORK, - /// `MADV_DOFORK` - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxDoFork = c::MADV_DOFORK, - /// `MADV_HWPOISON` - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxHwPoison = c::MADV_HWPOISON, - /// `MADV_SOFT_OFFLINE` - #[cfg(all( - any(target_os = "android", target_os = "linux"), - not(any(target_arch = "mips", target_arch = "mips64")), - ))] - LinuxSoftOffline = c::MADV_SOFT_OFFLINE, - /// `MADV_MERGEABLE` - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxMergeable = c::MADV_MERGEABLE, - /// `MADV_UNMERGEABLE` - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxUnmergeable = c::MADV_UNMERGEABLE, - /// `MADV_HUGEPAGE` (since Linux 2.6.38) - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxHugepage = c::MADV_HUGEPAGE, - /// `MADV_NOHUGEPAGE` (since Linux 2.6.38) - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxNoHugepage = c::MADV_NOHUGEPAGE, - /// `MADV_DONTDUMP` (since Linux 3.4) - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxDontDump = c::MADV_DONTDUMP, - /// `MADV_DODUMP` (since Linux 3.4) - #[cfg(any(target_os = "android", target_os = "linux"))] - LinuxDoDump = c::MADV_DODUMP, - /// `MADV_WIPEONFORK` (since Linux 4.14) - #[cfg(any(target_os = "android", target_os = "linux"))] - #[cfg(feature = "mm")] - LinuxWipeOnFork = linux_raw_sys::general::MADV_WIPEONFORK as i32, - /// `MADV_KEEPONFORK` (since Linux 4.14) - #[cfg(any(target_os = "android", target_os = "linux"))] - #[cfg(feature = "mm")] - LinuxKeepOnFork = linux_raw_sys::general::MADV_KEEPONFORK as i32, - /// `MADV_COLD` (since Linux 5.4) - #[cfg(any(target_os = "android", target_os = "linux"))] - #[cfg(feature = "mm")] - LinuxCold = linux_raw_sys::general::MADV_COLD as i32, - /// `MADV_PAGEOUT` (since Linux 5.4) - #[cfg(any(target_os = "android", target_os = "linux"))] - #[cfg(feature = "mm")] - LinuxPageOut = linux_raw_sys::general::MADV_PAGEOUT as i32, - /// `MADV_POPULATE_READ` (since Linux 5.14) - #[cfg(any(target_os = "android", target_os = "linux"))] - #[cfg(feature = "mm")] - LinuxPopulateRead = linux_raw_sys::general::MADV_POPULATE_READ as i32, - /// `MADV_POPULATE_WRITE` (since Linux 5.14) - #[cfg(any(target_os = "android", target_os = "linux"))] - #[cfg(feature = "mm")] - LinuxPopulateWrite = linux_raw_sys::general::MADV_POPULATE_WRITE as i32, -} - -#[cfg(target_os = "emscripten")] -impl Advice { - /// `POSIX_MADV_DONTNEED` - #[allow(non_upper_case_globals)] - pub const DontNeed: Self = Self::Normal; -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `O_*` flags for use with [`userfaultfd`]. - /// - /// [`userfaultfd`]: crate::io::userfaultfd - pub struct UserfaultfdFlags: c::c_int { - /// `O_CLOEXEC` - const CLOEXEC = c::O_CLOEXEC; - /// `O_NONBLOCK` - const NONBLOCK = c::O_NONBLOCK; - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/mod.rs deleted file mode 100644 index 1961d1291..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/mod.rs +++ /dev/null @@ -1,107 +0,0 @@ -//! The libc backend. -//! -//! On most platforms, this uses the `libc` crate to make system calls. On -//! Windows, this uses the Winsock2 API in `windows-sys`, which can be adapted -//! to have a very `libc`-like interface. - -// Every FFI call requires an unsafe block, and there are a lot of FFI -// calls. For now, set this to allow for the libc backend. -#![allow(clippy::undocumented_unsafe_blocks)] -// Lots of libc types vary between platforms, so we often need a `.into()` on -// one platform where it's redundant on another. -#![allow(clippy::useless_conversion)] - -#[cfg(not(any(windows, target_os = "wasi")))] -#[macro_use] -mod weak; - -mod conv; -mod offset; - -#[cfg(windows)] -mod io_lifetimes; -#[cfg(not(windows))] -#[cfg(not(feature = "std"))] -pub(crate) mod fd { - pub(crate) use super::c::c_int as LibcFd; - pub use crate::io::fd::*; -} -#[cfg(windows)] -pub(crate) mod fd { - pub use super::io_lifetimes::*; -} -#[cfg(not(windows))] -#[cfg(feature = "std")] -pub(crate) mod fd { - pub use io_lifetimes::*; - - #[cfg(target_os = "wasi")] - #[allow(unused_imports)] - pub(crate) use super::c::c_int as LibcFd; - #[cfg(unix)] - #[allow(unused_imports)] - pub(crate) use std::os::unix::io::RawFd as LibcFd; - #[cfg(unix)] - pub use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; - #[cfg(target_os = "wasi")] - pub use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; -} - -// On Windows we emulate selected libc-compatible interfaces. On non-Windows, -// we just use libc here, since this is the libc backend. -#[cfg_attr(windows, path = "winsock_c.rs")] -pub(crate) mod c; - -#[cfg(not(windows))] -#[cfg(feature = "fs")] -pub(crate) mod fs; -pub(crate) mod io; -#[cfg(any(target_os = "android", target_os = "linux"))] -#[cfg(feature = "io_uring")] -pub(crate) mod io_uring; -#[cfg(not(any(windows, target_os = "wasi")))] -#[cfg(feature = "mm")] -pub(crate) mod mm; -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[cfg(feature = "net")] -pub(crate) mod net; -#[cfg(not(windows))] -#[cfg(any( - feature = "param", - feature = "runtime", - feature = "time", - target_arch = "x86", -))] -pub(crate) mod param; -#[cfg(not(windows))] -pub(crate) mod process; -#[cfg(not(windows))] -#[cfg(feature = "rand")] -pub(crate) mod rand; -#[cfg(not(windows))] -#[cfg(feature = "termios")] -pub(crate) mod termios; -#[cfg(not(windows))] -#[cfg(feature = "thread")] -pub(crate) mod thread; -#[cfg(not(windows))] -pub(crate) mod time; - -/// If the host libc is glibc, return `true` if it is less than version 2.25. -/// -/// To restate and clarify, this function returning true does not mean the libc -/// is glibc just that if it is glibc, it is less than version 2.25. -/// -/// For now, this function is only available on Linux, but if it ends up being -/// used beyond that, this could be changed to e.g. `#[cfg(unix)]`. -#[cfg(all(unix, target_env = "gnu"))] -pub(crate) fn if_glibc_is_less_than_2_25() -> bool { - // This is also defined inside `weak_or_syscall!` in - // backend/libc/rand/syscalls.rs, but it's not convenient to re-export the weak - // symbol from that macro, so we duplicate it at a small cost here. - weak! { fn getrandom(*mut c::c_void, c::size_t, c::c_uint) -> c::ssize_t } - - // glibc 2.25 has `getrandom`, which is how we satisfy the API contract of - // this function. But, there are likely other libc versions which have it. - getrandom.get().is_none() -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/net/addr.rs b/vendor/rustix-0.37.6/src/backend/libc/net/addr.rs deleted file mode 100644 index d00a48626..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/net/addr.rs +++ /dev/null @@ -1,226 +0,0 @@ -//! IPv4, IPv6, and Socket addresses. - -use super::super::c; -#[cfg(unix)] -use crate::ffi::CStr; -#[cfg(unix)] -use crate::io; -#[cfg(unix)] -use crate::path; -#[cfg(not(windows))] -use core::convert::TryInto; -#[cfg(unix)] -use core::fmt; -#[cfg(unix)] -use core::slice; - -/// `struct sockaddr_un` -#[cfg(unix)] -#[derive(Clone)] -#[doc(alias = "sockaddr_un")] -pub struct SocketAddrUnix { - pub(crate) unix: c::sockaddr_un, - #[cfg(not(any(bsd, target_os = "haiku")))] - len: c::socklen_t, -} - -#[cfg(unix)] -impl SocketAddrUnix { - /// Construct a new Unix-domain address from a filesystem path. - #[inline] - pub fn new<P: path::Arg>(path: P) -> io::Result<Self> { - path.into_with_c_str(Self::_new) - } - - #[inline] - fn _new(path: &CStr) -> io::Result<Self> { - let mut unix = Self::init(); - let bytes = path.to_bytes_with_nul(); - if bytes.len() > unix.sun_path.len() { - return Err(io::Errno::NAMETOOLONG); - } - for (i, b) in bytes.iter().enumerate() { - unix.sun_path[i] = *b as c::c_char; - } - - #[cfg(any(bsd, target_os = "haiku"))] - { - unix.sun_len = (offsetof_sun_path() + bytes.len()).try_into().unwrap(); - } - - Ok(Self { - unix, - #[cfg(not(any(bsd, target_os = "haiku")))] - len: (offsetof_sun_path() + bytes.len()).try_into().unwrap(), - }) - } - - /// Construct a new abstract Unix-domain address from a byte slice. - #[cfg(any(target_os = "android", target_os = "linux"))] - #[inline] - pub fn new_abstract_name(name: &[u8]) -> io::Result<Self> { - let mut unix = Self::init(); - if 1 + name.len() > unix.sun_path.len() { - return Err(io::Errno::NAMETOOLONG); - } - unix.sun_path[0] = b'\0' as c::c_char; - for (i, b) in name.iter().enumerate() { - unix.sun_path[1 + i] = *b as c::c_char; - } - let len = offsetof_sun_path() + 1 + name.len(); - let len = len.try_into().unwrap(); - Ok(Self { - unix, - #[cfg(not(any(bsd, target_os = "haiku")))] - len, - }) - } - - fn init() -> c::sockaddr_un { - c::sockaddr_un { - #[cfg(any(bsd, target_os = "haiku"))] - sun_len: 0, - sun_family: c::AF_UNIX as _, - #[cfg(bsd)] - sun_path: [0; 104], - #[cfg(not(any(bsd, target_os = "haiku")))] - sun_path: [0; 108], - #[cfg(target_os = "haiku")] - sun_path: [0; 126], - } - } - - /// For a filesystem path address, return the path. - #[inline] - pub fn path(&self) -> Option<&CStr> { - let len = self.len(); - if len != 0 && self.unix.sun_path[0] != b'\0' as c::c_char { - let end = len as usize - offsetof_sun_path(); - let bytes = &self.unix.sun_path[..end]; - // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`. And - // `from_bytes_with_nul_unchecked` since the string is NUL-terminated. - unsafe { - Some(CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts( - bytes.as_ptr().cast(), - bytes.len(), - ))) - } - } else { - None - } - } - - /// For an abstract address, return the identifier. - #[cfg(any(target_os = "android", target_os = "linux"))] - #[inline] - pub fn abstract_name(&self) -> Option<&[u8]> { - let len = self.len(); - if len != 0 && self.unix.sun_path[0] == b'\0' as c::c_char { - let end = len as usize - offsetof_sun_path(); - let bytes = &self.unix.sun_path[1..end]; - // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`. - unsafe { Some(slice::from_raw_parts(bytes.as_ptr().cast(), bytes.len())) } - } else { - None - } - } - - #[inline] - pub(crate) fn addr_len(&self) -> c::socklen_t { - #[cfg(not(any(bsd, target_os = "haiku")))] - { - self.len - } - #[cfg(any(bsd, target_os = "haiku"))] - { - c::socklen_t::from(self.unix.sun_len) - } - } - - #[inline] - pub(crate) fn len(&self) -> usize { - self.addr_len() as usize - } -} - -#[cfg(unix)] -impl PartialEq for SocketAddrUnix { - #[inline] - fn eq(&self, other: &Self) -> bool { - let self_len = self.len() - offsetof_sun_path(); - let other_len = other.len() - offsetof_sun_path(); - self.unix.sun_path[..self_len].eq(&other.unix.sun_path[..other_len]) - } -} - -#[cfg(unix)] -impl Eq for SocketAddrUnix {} - -#[cfg(unix)] -impl PartialOrd for SocketAddrUnix { - #[inline] - fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> { - let self_len = self.len() - offsetof_sun_path(); - let other_len = other.len() - offsetof_sun_path(); - self.unix.sun_path[..self_len].partial_cmp(&other.unix.sun_path[..other_len]) - } -} - -#[cfg(unix)] -impl Ord for SocketAddrUnix { - #[inline] - fn cmp(&self, other: &Self) -> core::cmp::Ordering { - let self_len = self.len() - offsetof_sun_path(); - let other_len = other.len() - offsetof_sun_path(); - self.unix.sun_path[..self_len].cmp(&other.unix.sun_path[..other_len]) - } -} - -#[cfg(unix)] -impl core::hash::Hash for SocketAddrUnix { - #[inline] - fn hash<H: core::hash::Hasher>(&self, state: &mut H) { - let self_len = self.len() - offsetof_sun_path(); - self.unix.sun_path[..self_len].hash(state) - } -} - -#[cfg(unix)] -impl fmt::Debug for SocketAddrUnix { - fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - if let Some(path) = self.path() { - path.fmt(fmt) - } else { - #[cfg(any(target_os = "android", target_os = "linux"))] - if let Some(name) = self.abstract_name() { - return name.fmt(fmt); - } - - "(unnamed)".fmt(fmt) - } - } -} - -/// `struct sockaddr_storage` as a raw struct. -pub type SocketAddrStorage = c::sockaddr_storage; - -/// Return the offset of the `sun_path` field of `sockaddr_un`. -#[cfg(not(windows))] -#[inline] -pub(crate) fn offsetof_sun_path() -> usize { - let z = c::sockaddr_un { - #[cfg(any(bsd, target_os = "haiku"))] - sun_len: 0_u8, - #[cfg(any(bsd, target_os = "haiku"))] - sun_family: 0_u8, - #[cfg(not(any(bsd, target_os = "haiku")))] - sun_family: 0_u16, - #[cfg(bsd)] - sun_path: [0; 104], - #[cfg(not(any(bsd, target_os = "haiku")))] - sun_path: [0; 108], - #[cfg(target_os = "haiku")] - sun_path: [0; 126], - }; - (crate::utils::as_ptr(&z.sun_path) as usize) - (crate::utils::as_ptr(&z) as usize) -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/net/ext.rs b/vendor/rustix-0.37.6/src/backend/libc/net/ext.rs deleted file mode 100644 index f4ad316dd..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/net/ext.rs +++ /dev/null @@ -1,193 +0,0 @@ -use super::super::c; - -/// The windows `sockaddr_in6` type is a union with accessor functions which -/// are not `const fn`. Define our own layout-compatible version so that we -/// can transmute in and out of it. -#[cfg(windows)] -#[repr(C)] -struct sockaddr_in6 { - sin6_family: u16, - sin6_port: u16, - sin6_flowinfo: u32, - sin6_addr: c::in6_addr, - sin6_scope_id: u32, -} - -#[cfg(not(windows))] -#[inline] -pub(crate) const fn in_addr_s_addr(addr: c::in_addr) -> u32 { - addr.s_addr -} - -#[cfg(not(feature = "std"))] -#[cfg(windows)] -#[inline] -pub(crate) const fn in_addr_s_addr(addr: c::in_addr) -> u32 { - // This should be `*addr.S_un.S_addr()`, except that isn't a `const fn`. - unsafe { core::mem::transmute(addr) } -} - -// TODO: With Rust 1.55, we can use the above `in_addr_s_addr` definition that -// uses a const-fn transmute. -#[cfg(feature = "std")] -#[cfg(windows)] -#[inline] -pub(crate) fn in_addr_s_addr(addr: c::in_addr) -> u32 { - // This should be `*addr.S_un.S_addr()`, except that isn't a `const fn`. - unsafe { core::mem::transmute(addr) } -} - -#[cfg(not(windows))] -#[inline] -pub(crate) const fn in_addr_new(s_addr: u32) -> c::in_addr { - c::in_addr { s_addr } -} - -#[cfg(not(feature = "std"))] -#[cfg(windows)] -#[inline] -pub(crate) const fn in_addr_new(s_addr: u32) -> c::in_addr { - unsafe { core::mem::transmute(s_addr) } -} - -// TODO: With Rust 1.55, we can use the above `in_addr_new` definition that -// uses a const-fn transmute. -#[cfg(feature = "std")] -#[cfg(windows)] -#[inline] -pub(crate) fn in_addr_new(s_addr: u32) -> c::in_addr { - unsafe { core::mem::transmute(s_addr) } -} - -#[cfg(not(windows))] -#[inline] -pub(crate) const fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] { - addr.s6_addr -} - -#[cfg(not(feature = "std"))] -#[cfg(windows)] -#[inline] -pub(crate) const fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] { - unsafe { core::mem::transmute(addr) } -} - -// TODO: With Rust 1.55, we can use the above `in6_addr_s6_addr` definition -// that uses a const-fn transmute. -#[cfg(feature = "std")] -#[cfg(windows)] -#[inline] -pub(crate) fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] { - unsafe { core::mem::transmute(addr) } -} - -#[cfg(not(windows))] -#[inline] -pub(crate) const fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr { - c::in6_addr { s6_addr } -} - -#[cfg(not(feature = "std"))] -#[cfg(windows)] -#[inline] -pub(crate) const fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr { - unsafe { core::mem::transmute(s6_addr) } -} - -// TODO: With Rust 1.55, we can use the above `in6_addr_new` definition that -// uses a const-fn transmute. -#[cfg(feature = "std")] -#[cfg(windows)] -#[inline] -pub(crate) fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr { - unsafe { core::mem::transmute(s6_addr) } -} - -#[cfg(not(windows))] -#[inline] -pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 { - addr.sin6_scope_id -} - -#[cfg(not(feature = "std"))] -#[cfg(windows)] -#[inline] -pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 { - let addr: sockaddr_in6 = unsafe { core::mem::transmute(addr) }; - addr.sin6_scope_id -} - -// TODO: With Rust 1.55, we can use the above `sockaddr_in6_sin6_scope_id` -// definition that uses a const-fn transmute. -#[cfg(feature = "std")] -#[cfg(windows)] -#[inline] -pub(crate) fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 { - let addr: sockaddr_in6 = unsafe { core::mem::transmute(addr) }; - addr.sin6_scope_id -} - -#[cfg(not(windows))] -#[inline] -pub(crate) const fn sockaddr_in6_new( - #[cfg(any(bsd, target_os = "haiku"))] sin6_len: u8, - sin6_family: c::sa_family_t, - sin6_port: u16, - sin6_flowinfo: u32, - sin6_addr: c::in6_addr, - sin6_scope_id: u32, -) -> c::sockaddr_in6 { - c::sockaddr_in6 { - #[cfg(any(bsd, target_os = "haiku"))] - sin6_len, - sin6_family, - sin6_port, - sin6_flowinfo, - sin6_addr, - sin6_scope_id, - #[cfg(solarish)] - __sin6_src_id: 0, - } -} - -#[cfg(not(feature = "std"))] -#[cfg(windows)] -#[inline] -pub(crate) const fn sockaddr_in6_new( - sin6_family: u16, - sin6_port: u16, - sin6_flowinfo: u32, - sin6_addr: c::in6_addr, - sin6_scope_id: u32, -) -> c::sockaddr_in6 { - let addr = sockaddr_in6 { - sin6_family, - sin6_port, - sin6_flowinfo, - sin6_addr, - sin6_scope_id, - }; - unsafe { core::mem::transmute(addr) } -} - -// TODO: With Rust 1.55, we can use the above `sockaddr_in6_new` definition -// that uses a const-fn transmute. -#[cfg(feature = "std")] -#[cfg(windows)] -#[inline] -pub(crate) fn sockaddr_in6_new( - sin6_family: u16, - sin6_port: u16, - sin6_flowinfo: u32, - sin6_addr: c::in6_addr, - sin6_scope_id: u32, -) -> c::sockaddr_in6 { - let addr = sockaddr_in6 { - sin6_family, - sin6_port, - sin6_flowinfo, - sin6_addr, - sin6_scope_id, - }; - unsafe { core::mem::transmute(addr) } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/net/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/net/mod.rs deleted file mode 100644 index f7196ae4f..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/net/mod.rs +++ /dev/null @@ -1,7 +0,0 @@ -pub(crate) mod addr; -pub(crate) mod ext; -pub(crate) mod read_sockaddr; -pub(crate) mod send_recv; -pub(crate) mod syscalls; -pub(crate) mod types; -pub(crate) mod write_sockaddr; diff --git a/vendor/rustix-0.37.6/src/backend/libc/net/read_sockaddr.rs b/vendor/rustix-0.37.6/src/backend/libc/net/read_sockaddr.rs deleted file mode 100644 index 575102c27..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/net/read_sockaddr.rs +++ /dev/null @@ -1,210 +0,0 @@ -use super::super::c; -#[cfg(unix)] -use super::addr::SocketAddrUnix; -use super::ext::{in6_addr_s6_addr, in_addr_s_addr, sockaddr_in6_sin6_scope_id}; -#[cfg(not(windows))] -use crate::ffi::CStr; -use crate::io; -use crate::net::{Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrV4, SocketAddrV6}; -#[cfg(not(windows))] -use alloc::vec::Vec; -use core::mem::size_of; - -// This must match the header of `sockaddr`. -#[repr(C)] -struct sockaddr_header { - #[cfg(any(bsd, target_os = "haiku"))] - sa_len: u8, - #[cfg(any(bsd, target_os = "haiku"))] - ss_family: u8, - #[cfg(not(any(bsd, target_os = "haiku")))] - ss_family: u16, -} - -#[inline] -unsafe fn read_ss_family(storage: *const c::sockaddr_storage) -> u16 { - // Assert that we know the layout of `sockaddr`. - let _ = c::sockaddr { - #[cfg(any(bsd, target_os = "haiku"))] - sa_len: 0_u8, - #[cfg(any(bsd, target_os = "haiku"))] - sa_family: 0_u8, - #[cfg(not(any(bsd, target_os = "haiku")))] - sa_family: 0_u16, - #[cfg(not(target_os = "haiku"))] - sa_data: [0; 14], - #[cfg(target_os = "haiku")] - sa_data: [0; 30], - }; - - (*storage.cast::<sockaddr_header>()).ss_family.into() -} - -/// Set the `ss_family` field of a socket address to `AF_UNSPEC`, so that we -/// can test for `AF_UNSPEC` to test whether it was stored to. -pub(crate) unsafe fn initialize_family_to_unspec(storage: *mut c::sockaddr_storage) { - (*storage.cast::<sockaddr_header>()).ss_family = c::AF_UNSPEC as _; -} - -pub(crate) unsafe fn read_sockaddr( - storage: *const c::sockaddr_storage, - len: usize, -) -> io::Result<SocketAddrAny> { - #[cfg(unix)] - let offsetof_sun_path = super::addr::offsetof_sun_path(); - - if len < size_of::<c::sa_family_t>() { - return Err(io::Errno::INVAL); - } - match read_ss_family(storage).into() { - c::AF_INET => { - if len < size_of::<c::sockaddr_in>() { - return Err(io::Errno::INVAL); - } - let decode = *storage.cast::<c::sockaddr_in>(); - Ok(SocketAddrAny::V4(SocketAddrV4::new( - Ipv4Addr::from(u32::from_be(in_addr_s_addr(decode.sin_addr))), - u16::from_be(decode.sin_port), - ))) - } - c::AF_INET6 => { - if len < size_of::<c::sockaddr_in6>() { - return Err(io::Errno::INVAL); - } - let decode = *storage.cast::<c::sockaddr_in6>(); - #[cfg(not(windows))] - let s6_addr = decode.sin6_addr.s6_addr; - #[cfg(windows)] - let s6_addr = decode.sin6_addr.u.Byte; - #[cfg(not(windows))] - let sin6_scope_id = decode.sin6_scope_id; - #[cfg(windows)] - let sin6_scope_id = decode.Anonymous.sin6_scope_id; - Ok(SocketAddrAny::V6(SocketAddrV6::new( - Ipv6Addr::from(s6_addr), - u16::from_be(decode.sin6_port), - u32::from_be(decode.sin6_flowinfo), - sin6_scope_id, - ))) - } - #[cfg(unix)] - c::AF_UNIX => { - if len < offsetof_sun_path { - return Err(io::Errno::INVAL); - } - if len == offsetof_sun_path { - Ok(SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap())) - } else { - let decode = *storage.cast::<c::sockaddr_un>(); - - // Trim off unused bytes from the end of `path_bytes`. - let path_bytes = if cfg!(target_os = "freebsd") { - // FreeBSD sometimes sets the length to longer than the length - // of the NUL-terminated string. Find the NUL and truncate the - // string accordingly. - &decode.sun_path[..decode.sun_path.iter().position(|b| *b == 0).unwrap()] - } else { - // Otherwise, use the provided length. - let provided_len = len - 1 - offsetof_sun_path; - if decode.sun_path[provided_len] != b'\0' as c::c_char { - return Err(io::Errno::INVAL); - } - debug_assert_eq!( - CStr::from_ptr(decode.sun_path.as_ptr()).to_bytes().len(), - provided_len - ); - &decode.sun_path[..provided_len] - }; - - Ok(SocketAddrAny::Unix( - SocketAddrUnix::new(path_bytes.iter().map(|c| *c as u8).collect::<Vec<u8>>()) - .unwrap(), - )) - } - } - _ => Err(io::Errno::INVAL), - } -} - -pub(crate) unsafe fn maybe_read_sockaddr_os( - storage: *const c::sockaddr_storage, - len: usize, -) -> Option<SocketAddrAny> { - if len == 0 { - return None; - } - - assert!(len >= size_of::<c::sa_family_t>()); - let family = read_ss_family(storage).into(); - if family == c::AF_UNSPEC { - None - } else { - Some(inner_read_sockaddr_os(family, storage, len)) - } -} - -pub(crate) unsafe fn read_sockaddr_os( - storage: *const c::sockaddr_storage, - len: usize, -) -> SocketAddrAny { - assert!(len >= size_of::<c::sa_family_t>()); - let family = read_ss_family(storage).into(); - inner_read_sockaddr_os(family, storage, len) -} - -unsafe fn inner_read_sockaddr_os( - family: c::c_int, - storage: *const c::sockaddr_storage, - len: usize, -) -> SocketAddrAny { - #[cfg(unix)] - let offsetof_sun_path = super::addr::offsetof_sun_path(); - - assert!(len >= size_of::<c::sa_family_t>()); - match family { - c::AF_INET => { - assert!(len >= size_of::<c::sockaddr_in>()); - let decode = *storage.cast::<c::sockaddr_in>(); - SocketAddrAny::V4(SocketAddrV4::new( - Ipv4Addr::from(u32::from_be(in_addr_s_addr(decode.sin_addr))), - u16::from_be(decode.sin_port), - )) - } - c::AF_INET6 => { - assert!(len >= size_of::<c::sockaddr_in6>()); - let decode = *storage.cast::<c::sockaddr_in6>(); - SocketAddrAny::V6(SocketAddrV6::new( - Ipv6Addr::from(in6_addr_s6_addr(decode.sin6_addr)), - u16::from_be(decode.sin6_port), - u32::from_be(decode.sin6_flowinfo), - sockaddr_in6_sin6_scope_id(decode), - )) - } - #[cfg(unix)] - c::AF_UNIX => { - assert!(len >= offsetof_sun_path); - if len == offsetof_sun_path { - SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap()) - } else { - let decode = *storage.cast::<c::sockaddr_un>(); - assert_eq!( - decode.sun_path[len - 1 - offsetof_sun_path], - b'\0' as c::c_char - ); - let path_bytes = &decode.sun_path[..len - 1 - offsetof_sun_path]; - - // FreeBSD sometimes sets the length to longer than the length - // of the NUL-terminated string. Find the NUL and truncate the - // string accordingly. - #[cfg(target_os = "freebsd")] - let path_bytes = &path_bytes[..path_bytes.iter().position(|b| *b == 0).unwrap()]; - - SocketAddrAny::Unix( - SocketAddrUnix::new(path_bytes.iter().map(|c| *c as u8).collect::<Vec<u8>>()) - .unwrap(), - ) - } - } - other => unimplemented!("{:?}", other), - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/net/send_recv.rs b/vendor/rustix-0.37.6/src/backend/libc/net/send_recv.rs deleted file mode 100644 index 114807808..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/net/send_recv.rs +++ /dev/null @@ -1,65 +0,0 @@ -use super::super::c; -use bitflags::bitflags; - -bitflags! { - /// `MSG_*` - pub struct SendFlags: i32 { - /// `MSG_CONFIRM` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - const CONFIRM = c::MSG_CONFIRM; - /// `MSG_DONTROUTE` - const DONTROUTE = c::MSG_DONTROUTE; - /// `MSG_DONTWAIT` - #[cfg(not(windows))] - const DONTWAIT = c::MSG_DONTWAIT; - /// `MSG_EOR` - #[cfg(not(windows))] - const EOT = c::MSG_EOR; - /// `MSG_MORE` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - const MORE = c::MSG_MORE; - #[cfg(not(any(apple, windows)))] - /// `MSG_NOSIGNAL` - const NOSIGNAL = c::MSG_NOSIGNAL; - /// `MSG_OOB` - const OOB = c::MSG_OOB; - } -} - -bitflags! { - /// `MSG_*` - pub struct RecvFlags: i32 { - #[cfg(not(any(apple, solarish, windows, target_os = "haiku")))] - /// `MSG_CMSG_CLOEXEC` - const CMSG_CLOEXEC = c::MSG_CMSG_CLOEXEC; - /// `MSG_DONTWAIT` - #[cfg(not(windows))] - const DONTWAIT = c::MSG_DONTWAIT; - /// `MSG_ERRQUEUE` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - const ERRQUEUE = c::MSG_ERRQUEUE; - /// `MSG_OOB` - const OOB = c::MSG_OOB; - /// `MSG_PEEK` - const PEEK = c::MSG_PEEK; - /// `MSG_TRUNC` - const TRUNC = c::MSG_TRUNC as c::c_int; - /// `MSG_WAITALL` - const WAITALL = c::MSG_WAITALL; - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/net/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/net/syscalls.rs deleted file mode 100644 index ed4494394..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/net/syscalls.rs +++ /dev/null @@ -1,863 +0,0 @@ -//! libc syscalls supporting `rustix::net`. - -use super::super::c; -use super::super::conv::{borrowed_fd, ret, ret_owned_fd, ret_send_recv, send_recv_len}; -#[cfg(unix)] -use super::addr::SocketAddrUnix; -use super::ext::{in6_addr_new, in_addr_new}; -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -use super::read_sockaddr::initialize_family_to_unspec; -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -use super::read_sockaddr::{maybe_read_sockaddr_os, read_sockaddr_os}; -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -use super::send_recv::{RecvFlags, SendFlags}; -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -use super::types::{AcceptFlags, AddressFamily, Protocol, Shutdown, SocketFlags, SocketType}; -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -use super::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6}; -use crate::fd::{BorrowedFd, OwnedFd}; -use crate::io; -use crate::net::{SocketAddrAny, SocketAddrV4, SocketAddrV6}; -use crate::utils::as_ptr; -use core::convert::TryInto; -use core::mem::{size_of, MaybeUninit}; -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -use core::ptr::null_mut; - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn recv(fd: BorrowedFd<'_>, buf: &mut [u8], flags: RecvFlags) -> io::Result<usize> { - let nrecv = unsafe { - ret_send_recv(c::recv( - borrowed_fd(fd), - buf.as_mut_ptr().cast(), - send_recv_len(buf.len()), - flags.bits(), - ))? - }; - Ok(nrecv as usize) -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn send(fd: BorrowedFd<'_>, buf: &[u8], flags: SendFlags) -> io::Result<usize> { - let nwritten = unsafe { - ret_send_recv(c::send( - borrowed_fd(fd), - buf.as_ptr().cast(), - send_recv_len(buf.len()), - flags.bits(), - ))? - }; - Ok(nwritten as usize) -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn recvfrom( - fd: BorrowedFd<'_>, - buf: &mut [u8], - flags: RecvFlags, -) -> io::Result<(usize, Option<SocketAddrAny>)> { - unsafe { - let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit(); - let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t; - - // `recvfrom` does not write to the storage if the socket is - // connection-oriented sockets, so we initialize the family field to - // `AF_UNSPEC` so that we can detect this case. - initialize_family_to_unspec(storage.as_mut_ptr()); - - let nread = ret_send_recv(c::recvfrom( - borrowed_fd(fd), - buf.as_mut_ptr().cast(), - send_recv_len(buf.len()), - flags.bits(), - storage.as_mut_ptr().cast(), - &mut len, - ))?; - Ok(( - nread as usize, - maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()), - )) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn sendto_v4( - fd: BorrowedFd<'_>, - buf: &[u8], - flags: SendFlags, - addr: &SocketAddrV4, -) -> io::Result<usize> { - let nwritten = unsafe { - ret_send_recv(c::sendto( - borrowed_fd(fd), - buf.as_ptr().cast(), - send_recv_len(buf.len()), - flags.bits(), - as_ptr(&encode_sockaddr_v4(addr)).cast::<c::sockaddr>(), - size_of::<SocketAddrV4>() as _, - ))? - }; - Ok(nwritten as usize) -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn sendto_v6( - fd: BorrowedFd<'_>, - buf: &[u8], - flags: SendFlags, - addr: &SocketAddrV6, -) -> io::Result<usize> { - let nwritten = unsafe { - ret_send_recv(c::sendto( - borrowed_fd(fd), - buf.as_ptr().cast(), - send_recv_len(buf.len()), - flags.bits(), - as_ptr(&encode_sockaddr_v6(addr)).cast::<c::sockaddr>(), - size_of::<SocketAddrV6>() as _, - ))? - }; - Ok(nwritten as usize) -} - -#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))] -pub(crate) fn sendto_unix( - fd: BorrowedFd<'_>, - buf: &[u8], - flags: SendFlags, - addr: &SocketAddrUnix, -) -> io::Result<usize> { - let nwritten = unsafe { - ret_send_recv(c::sendto( - borrowed_fd(fd), - buf.as_ptr().cast(), - send_recv_len(buf.len()), - flags.bits(), - as_ptr(&addr.unix).cast(), - addr.addr_len(), - ))? - }; - Ok(nwritten as usize) -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn socket( - domain: AddressFamily, - type_: SocketType, - protocol: Protocol, -) -> io::Result<OwnedFd> { - unsafe { - ret_owned_fd(c::socket( - domain.0 as c::c_int, - type_.0 as c::c_int, - protocol.0, - )) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn socket_with( - domain: AddressFamily, - type_: SocketType, - flags: SocketFlags, - protocol: Protocol, -) -> io::Result<OwnedFd> { - unsafe { - ret_owned_fd(c::socket( - domain.0 as c::c_int, - type_.0 as c::c_int | flags.bits(), - protocol.0, - )) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn bind_v4(sockfd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> { - unsafe { - ret(c::bind( - borrowed_fd(sockfd), - as_ptr(&encode_sockaddr_v4(addr)).cast(), - size_of::<c::sockaddr_in>() as c::socklen_t, - )) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn bind_v6(sockfd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> { - unsafe { - ret(c::bind( - borrowed_fd(sockfd), - as_ptr(&encode_sockaddr_v6(addr)).cast(), - size_of::<c::sockaddr_in6>() as c::socklen_t, - )) - } -} - -#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))] -pub(crate) fn bind_unix(sockfd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> { - unsafe { - ret(c::bind( - borrowed_fd(sockfd), - as_ptr(&addr.unix).cast(), - addr.addr_len(), - )) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn connect_v4(sockfd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> { - unsafe { - ret(c::connect( - borrowed_fd(sockfd), - as_ptr(&encode_sockaddr_v4(addr)).cast(), - size_of::<c::sockaddr_in>() as c::socklen_t, - )) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn connect_v6(sockfd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> { - unsafe { - ret(c::connect( - borrowed_fd(sockfd), - as_ptr(&encode_sockaddr_v6(addr)).cast(), - size_of::<c::sockaddr_in6>() as c::socklen_t, - )) - } -} - -#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))] -pub(crate) fn connect_unix(sockfd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> { - unsafe { - ret(c::connect( - borrowed_fd(sockfd), - as_ptr(&addr.unix).cast(), - addr.addr_len(), - )) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn listen(sockfd: BorrowedFd<'_>, backlog: c::c_int) -> io::Result<()> { - unsafe { ret(c::listen(borrowed_fd(sockfd), backlog)) } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn accept(sockfd: BorrowedFd<'_>) -> io::Result<OwnedFd> { - unsafe { - let owned_fd = ret_owned_fd(c::accept(borrowed_fd(sockfd), null_mut(), null_mut()))?; - Ok(owned_fd) - } -} - -#[cfg(not(any( - apple, - windows, - target_os = "haiku", - target_os = "redox", - target_os = "wasi", -)))] -pub(crate) fn accept_with(sockfd: BorrowedFd<'_>, flags: AcceptFlags) -> io::Result<OwnedFd> { - unsafe { - let owned_fd = ret_owned_fd(c::accept4( - borrowed_fd(sockfd), - null_mut(), - null_mut(), - flags.bits(), - ))?; - Ok(owned_fd) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn acceptfrom(sockfd: BorrowedFd<'_>) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> { - unsafe { - let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit(); - let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t; - let owned_fd = ret_owned_fd(c::accept( - borrowed_fd(sockfd), - storage.as_mut_ptr().cast(), - &mut len, - ))?; - Ok(( - owned_fd, - maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()), - )) - } -} - -#[cfg(not(any( - apple, - windows, - target_os = "haiku", - target_os = "redox", - target_os = "wasi", -)))] -pub(crate) fn acceptfrom_with( - sockfd: BorrowedFd<'_>, - flags: AcceptFlags, -) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> { - unsafe { - let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit(); - let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t; - let owned_fd = ret_owned_fd(c::accept4( - borrowed_fd(sockfd), - storage.as_mut_ptr().cast(), - &mut len, - flags.bits(), - ))?; - Ok(( - owned_fd, - maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()), - )) - } -} - -/// Darwin lacks `accept4`, but does have `accept`. We define -/// `AcceptFlags` to have no flags, so we can discard it here. -#[cfg(any(apple, windows, target_os = "haiku"))] -pub(crate) fn accept_with(sockfd: BorrowedFd<'_>, _flags: AcceptFlags) -> io::Result<OwnedFd> { - accept(sockfd) -} - -/// Darwin lacks `accept4`, but does have `accept`. We define -/// `AcceptFlags` to have no flags, so we can discard it here. -#[cfg(any(apple, windows, target_os = "haiku"))] -pub(crate) fn acceptfrom_with( - sockfd: BorrowedFd<'_>, - _flags: AcceptFlags, -) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> { - acceptfrom(sockfd) -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn shutdown(sockfd: BorrowedFd<'_>, how: Shutdown) -> io::Result<()> { - unsafe { ret(c::shutdown(borrowed_fd(sockfd), how as c::c_int)) } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn getsockname(sockfd: BorrowedFd<'_>) -> io::Result<SocketAddrAny> { - unsafe { - let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit(); - let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t; - ret(c::getsockname( - borrowed_fd(sockfd), - storage.as_mut_ptr().cast(), - &mut len, - ))?; - Ok(read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap())) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) fn getpeername(sockfd: BorrowedFd<'_>) -> io::Result<Option<SocketAddrAny>> { - unsafe { - let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit(); - let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t; - ret(c::getpeername( - borrowed_fd(sockfd), - storage.as_mut_ptr().cast(), - &mut len, - ))?; - Ok(maybe_read_sockaddr_os( - storage.as_ptr(), - len.try_into().unwrap(), - )) - } -} - -#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))] -pub(crate) fn socketpair( - domain: AddressFamily, - type_: SocketType, - flags: SocketFlags, - protocol: Protocol, -) -> io::Result<(OwnedFd, OwnedFd)> { - unsafe { - let mut fds = MaybeUninit::<[OwnedFd; 2]>::uninit(); - ret(c::socketpair( - c::c_int::from(domain.0), - type_.0 as c::c_int | flags.bits(), - protocol.0, - fds.as_mut_ptr().cast::<c::c_int>(), - ))?; - - let [fd0, fd1] = fds.assume_init(); - Ok((fd0, fd1)) - } -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -pub(crate) mod sockopt { - use super::{c, in6_addr_new, in_addr_new, BorrowedFd}; - use crate::io; - use crate::net::sockopt::Timeout; - use crate::net::{Ipv4Addr, Ipv6Addr, SocketType}; - use crate::utils::as_mut_ptr; - use core::convert::TryInto; - use core::time::Duration; - #[cfg(windows)] - use windows_sys::Win32::Foundation::BOOL; - - // TODO: With Rust 1.53 we can use `Duration::ZERO` instead. - const DURATION_ZERO: Duration = Duration::from_secs(0); - - #[inline] - fn getsockopt<T: Copy>(fd: BorrowedFd<'_>, level: i32, optname: i32) -> io::Result<T> { - use super::*; - - let mut optlen = core::mem::size_of::<T>().try_into().unwrap(); - debug_assert!( - optlen as usize >= core::mem::size_of::<c::c_int>(), - "Socket APIs don't ever use `bool` directly" - ); - - unsafe { - let mut value = core::mem::zeroed::<T>(); - ret(c::getsockopt( - borrowed_fd(fd), - level, - optname, - as_mut_ptr(&mut value).cast(), - &mut optlen, - ))?; - // On Windows at least, `getsockopt` has been observed writing 1 - // byte on at least (`IPPROTO_TCP`, `TCP_NODELAY`), even though - // Windows' documentation says that should write a 4-byte `BOOL`. - // So, we initialize the memory to zeros above, and just assert - // that `getsockopt` doesn't write too many bytes here. - assert!( - optlen as usize <= size_of::<T>(), - "unexpected getsockopt size" - ); - Ok(value) - } - } - - #[inline] - fn setsockopt<T: Copy>( - fd: BorrowedFd<'_>, - level: i32, - optname: i32, - value: T, - ) -> io::Result<()> { - use super::*; - - let optlen = core::mem::size_of::<T>().try_into().unwrap(); - debug_assert!( - optlen as usize >= core::mem::size_of::<c::c_int>(), - "Socket APIs don't ever use `bool` directly" - ); - - unsafe { - ret(c::setsockopt( - borrowed_fd(fd), - level, - optname, - as_ptr(&value).cast(), - optlen, - )) - } - } - - #[inline] - pub(crate) fn get_socket_type(fd: BorrowedFd<'_>) -> io::Result<SocketType> { - getsockopt(fd, c::SOL_SOCKET as _, c::SO_TYPE) - } - - #[inline] - pub(crate) fn set_socket_reuseaddr(fd: BorrowedFd<'_>, reuseaddr: bool) -> io::Result<()> { - setsockopt( - fd, - c::SOL_SOCKET as _, - c::SO_REUSEADDR, - from_bool(reuseaddr), - ) - } - - #[inline] - pub(crate) fn set_socket_broadcast(fd: BorrowedFd<'_>, broadcast: bool) -> io::Result<()> { - setsockopt( - fd, - c::SOL_SOCKET as _, - c::SO_BROADCAST, - from_bool(broadcast), - ) - } - - #[inline] - pub(crate) fn get_socket_broadcast(fd: BorrowedFd<'_>) -> io::Result<bool> { - getsockopt(fd, c::SOL_SOCKET as _, c::SO_BROADCAST).map(to_bool) - } - - #[inline] - pub(crate) fn set_socket_linger( - fd: BorrowedFd<'_>, - linger: Option<Duration>, - ) -> io::Result<()> { - // Convert `linger` to seconds, rounding up. - let l_linger = if let Some(linger) = linger { - let mut l_linger = linger.as_secs(); - if linger.subsec_nanos() != 0 { - l_linger = l_linger.checked_add(1).ok_or(io::Errno::INVAL)?; - } - l_linger.try_into().map_err(|_e| io::Errno::INVAL)? - } else { - 0 - }; - let linger = c::linger { - l_onoff: linger.is_some() as _, - l_linger, - }; - setsockopt(fd, c::SOL_SOCKET as _, c::SO_LINGER, linger) - } - - #[inline] - pub(crate) fn get_socket_linger(fd: BorrowedFd<'_>) -> io::Result<Option<Duration>> { - let linger: c::linger = getsockopt(fd, c::SOL_SOCKET as _, c::SO_LINGER)?; - // TODO: With Rust 1.50, this could use `.then`. - Ok(if linger.l_onoff != 0 { - Some(Duration::from_secs(linger.l_linger as u64)) - } else { - None - }) - } - - #[cfg(any(target_os = "android", target_os = "linux"))] - #[inline] - pub(crate) fn set_socket_passcred(fd: BorrowedFd<'_>, passcred: bool) -> io::Result<()> { - setsockopt(fd, c::SOL_SOCKET as _, c::SO_PASSCRED, from_bool(passcred)) - } - - #[cfg(any(target_os = "android", target_os = "linux"))] - #[inline] - pub(crate) fn get_socket_passcred(fd: BorrowedFd<'_>) -> io::Result<bool> { - getsockopt(fd, c::SOL_SOCKET as _, c::SO_PASSCRED).map(to_bool) - } - - #[inline] - pub(crate) fn set_socket_timeout( - fd: BorrowedFd<'_>, - id: Timeout, - timeout: Option<Duration>, - ) -> io::Result<()> { - let optname = match id { - Timeout::Recv => c::SO_RCVTIMEO, - Timeout::Send => c::SO_SNDTIMEO, - }; - - #[cfg(not(windows))] - let timeout = match timeout { - Some(timeout) => { - if timeout == DURATION_ZERO { - return Err(io::Errno::INVAL); - } - - // Rust's musl libc bindings deprecated `time_t` while they - // transition to 64-bit `time_t`. What we want here is just - // "whatever type `timeval`'s `tv_sec` is", so we're ok using - // the deprecated type. - #[allow(deprecated)] - let tv_sec = timeout.as_secs().try_into().unwrap_or(c::time_t::MAX); - - // `subsec_micros` rounds down, so we use `subsec_nanos` and - // manually round up. - let mut timeout = c::timeval { - tv_sec, - tv_usec: ((timeout.subsec_nanos() + 999) / 1000) as _, - }; - if timeout.tv_sec == 0 && timeout.tv_usec == 0 { - timeout.tv_usec = 1; - } - timeout - } - None => c::timeval { - tv_sec: 0, - tv_usec: 0, - }, - }; - - #[cfg(windows)] - let timeout: u32 = match timeout { - Some(timeout) => { - if timeout == DURATION_ZERO { - return Err(io::Errno::INVAL); - } - - // `as_millis` rounds down, so we use `as_nanos` and - // manually round up. - let mut timeout: u32 = ((timeout.as_nanos() + 999_999) / 1_000_000) - .try_into() - .map_err(|_convert_err| io::Errno::INVAL)?; - if timeout == 0 { - timeout = 1; - } - timeout - } - None => 0, - }; - - setsockopt(fd, c::SOL_SOCKET, optname, timeout) - } - - #[inline] - pub(crate) fn get_socket_timeout( - fd: BorrowedFd<'_>, - id: Timeout, - ) -> io::Result<Option<Duration>> { - let optname = match id { - Timeout::Recv => c::SO_RCVTIMEO, - Timeout::Send => c::SO_SNDTIMEO, - }; - - #[cfg(not(windows))] - { - let timeout: c::timeval = getsockopt(fd, c::SOL_SOCKET, optname)?; - if timeout.tv_sec == 0 && timeout.tv_usec == 0 { - Ok(None) - } else { - Ok(Some( - Duration::from_secs(timeout.tv_sec as u64) - + Duration::from_micros(timeout.tv_usec as u64), - )) - } - } - - #[cfg(windows)] - { - let timeout: u32 = getsockopt(fd, c::SOL_SOCKET, optname)?; - if timeout == 0 { - Ok(None) - } else { - Ok(Some(Duration::from_millis(timeout as u64))) - } - } - } - - #[cfg(any(apple, target_os = "freebsd"))] - #[inline] - pub(crate) fn getsockopt_nosigpipe(fd: BorrowedFd<'_>) -> io::Result<bool> { - getsockopt(fd, c::SOL_SOCKET, c::SO_NOSIGPIPE).map(to_bool) - } - - #[cfg(any(apple, target_os = "freebsd"))] - #[inline] - pub(crate) fn setsockopt_nosigpipe(fd: BorrowedFd<'_>, val: bool) -> io::Result<()> { - setsockopt(fd, c::SOL_SOCKET, c::SO_NOSIGPIPE, from_bool(val)) - } - - #[inline] - pub(crate) fn get_socket_error(fd: BorrowedFd<'_>) -> io::Result<Result<(), crate::io::Errno>> { - let err: c::c_int = getsockopt(fd, c::SOL_SOCKET as _, c::SO_ERROR)?; - Ok(if err == 0 { - Ok(()) - } else { - Err(crate::io::Errno::from_raw_os_error(err)) - }) - } - - #[inline] - pub(crate) fn set_ip_ttl(fd: BorrowedFd<'_>, ttl: u32) -> io::Result<()> { - setsockopt(fd, c::IPPROTO_IP as _, c::IP_TTL, ttl) - } - - #[inline] - pub(crate) fn get_ip_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> { - getsockopt(fd, c::IPPROTO_IP as _, c::IP_TTL) - } - - #[inline] - pub(crate) fn set_ipv6_v6only(fd: BorrowedFd<'_>, only_v6: bool) -> io::Result<()> { - setsockopt(fd, c::IPPROTO_IPV6 as _, c::IPV6_V6ONLY, from_bool(only_v6)) - } - - #[inline] - pub(crate) fn get_ipv6_v6only(fd: BorrowedFd<'_>) -> io::Result<bool> { - getsockopt(fd, c::IPPROTO_IPV6 as _, c::IPV6_V6ONLY).map(to_bool) - } - - #[inline] - pub(crate) fn set_ip_multicast_loop( - fd: BorrowedFd<'_>, - multicast_loop: bool, - ) -> io::Result<()> { - setsockopt( - fd, - c::IPPROTO_IP as _, - c::IP_MULTICAST_LOOP, - from_bool(multicast_loop), - ) - } - - #[inline] - pub(crate) fn get_ip_multicast_loop(fd: BorrowedFd<'_>) -> io::Result<bool> { - getsockopt(fd, c::IPPROTO_IP as _, c::IP_MULTICAST_LOOP).map(to_bool) - } - - #[inline] - pub(crate) fn set_ip_multicast_ttl(fd: BorrowedFd<'_>, multicast_ttl: u32) -> io::Result<()> { - setsockopt(fd, c::IPPROTO_IP as _, c::IP_MULTICAST_TTL, multicast_ttl) - } - - #[inline] - pub(crate) fn get_ip_multicast_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> { - getsockopt(fd, c::IPPROTO_IP as _, c::IP_MULTICAST_TTL) - } - - #[inline] - pub(crate) fn set_ipv6_multicast_loop( - fd: BorrowedFd<'_>, - multicast_loop: bool, - ) -> io::Result<()> { - setsockopt( - fd, - c::IPPROTO_IPV6 as _, - c::IPV6_MULTICAST_LOOP, - from_bool(multicast_loop), - ) - } - - #[inline] - pub(crate) fn get_ipv6_multicast_loop(fd: BorrowedFd<'_>) -> io::Result<bool> { - getsockopt(fd, c::IPPROTO_IPV6 as _, c::IPV6_MULTICAST_LOOP).map(to_bool) - } - - #[inline] - pub(crate) fn set_ipv6_multicast_hops( - fd: BorrowedFd<'_>, - multicast_hops: u32, - ) -> io::Result<()> { - setsockopt( - fd, - c::IPPROTO_IP as _, - c::IPV6_MULTICAST_LOOP, - multicast_hops, - ) - } - - #[inline] - pub(crate) fn get_ipv6_multicast_hops(fd: BorrowedFd<'_>) -> io::Result<u32> { - getsockopt(fd, c::IPPROTO_IP as _, c::IPV6_MULTICAST_LOOP) - } - - #[inline] - pub(crate) fn set_ip_add_membership( - fd: BorrowedFd<'_>, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr, - ) -> io::Result<()> { - let mreq = to_imr(multiaddr, interface); - setsockopt(fd, c::IPPROTO_IP as _, c::IP_ADD_MEMBERSHIP, mreq) - } - - #[inline] - pub(crate) fn set_ipv6_add_membership( - fd: BorrowedFd<'_>, - multiaddr: &Ipv6Addr, - interface: u32, - ) -> io::Result<()> { - #[cfg(not(any(bsd, solarish, target_os = "haiku", target_os = "l4re")))] - use c::IPV6_ADD_MEMBERSHIP; - #[cfg(any(bsd, solarish, target_os = "haiku", target_os = "l4re"))] - use c::IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP; - - let mreq = to_ipv6mr(multiaddr, interface); - setsockopt(fd, c::IPPROTO_IPV6 as _, IPV6_ADD_MEMBERSHIP, mreq) - } - - #[inline] - pub(crate) fn set_ip_drop_membership( - fd: BorrowedFd<'_>, - multiaddr: &Ipv4Addr, - interface: &Ipv4Addr, - ) -> io::Result<()> { - let mreq = to_imr(multiaddr, interface); - setsockopt(fd, c::IPPROTO_IP as _, c::IP_DROP_MEMBERSHIP, mreq) - } - - #[inline] - pub(crate) fn set_ipv6_drop_membership( - fd: BorrowedFd<'_>, - multiaddr: &Ipv6Addr, - interface: u32, - ) -> io::Result<()> { - #[cfg(not(any(bsd, solarish, target_os = "haiku", target_os = "l4re")))] - use c::IPV6_DROP_MEMBERSHIP; - #[cfg(any(bsd, solarish, target_os = "haiku", target_os = "l4re"))] - use c::IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP; - - let mreq = to_ipv6mr(multiaddr, interface); - setsockopt(fd, c::IPPROTO_IPV6 as _, IPV6_DROP_MEMBERSHIP, mreq) - } - - #[inline] - pub(crate) fn set_tcp_nodelay(fd: BorrowedFd<'_>, nodelay: bool) -> io::Result<()> { - setsockopt(fd, c::IPPROTO_TCP as _, c::TCP_NODELAY, from_bool(nodelay)) - } - - #[inline] - pub(crate) fn get_tcp_nodelay(fd: BorrowedFd<'_>) -> io::Result<bool> { - getsockopt(fd, c::IPPROTO_TCP as _, c::TCP_NODELAY).map(to_bool) - } - - #[inline] - fn to_imr(multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> c::ip_mreq { - c::ip_mreq { - imr_multiaddr: to_imr_addr(multiaddr), - imr_interface: to_imr_addr(interface), - } - } - - #[inline] - fn to_imr_addr(addr: &Ipv4Addr) -> c::in_addr { - in_addr_new(u32::from_ne_bytes(addr.octets())) - } - - #[inline] - fn to_ipv6mr(multiaddr: &Ipv6Addr, interface: u32) -> c::ipv6_mreq { - c::ipv6_mreq { - ipv6mr_multiaddr: to_ipv6mr_multiaddr(multiaddr), - ipv6mr_interface: to_ipv6mr_interface(interface), - } - } - - #[inline] - fn to_ipv6mr_multiaddr(multiaddr: &Ipv6Addr) -> c::in6_addr { - in6_addr_new(multiaddr.octets()) - } - - #[cfg(target_os = "android")] - #[inline] - fn to_ipv6mr_interface(interface: u32) -> c::c_int { - interface as c::c_int - } - - #[cfg(not(target_os = "android"))] - #[inline] - fn to_ipv6mr_interface(interface: u32) -> c::c_uint { - interface as c::c_uint - } - - // `getsockopt` and `setsockopt` represent boolean values as integers. - #[cfg(not(windows))] - type RawSocketBool = c::c_int; - #[cfg(windows)] - type RawSocketBool = BOOL; - - // Wrap `RawSocketBool` in a newtype to discourage misuse. - #[repr(transparent)] - #[derive(Copy, Clone)] - struct SocketBool(RawSocketBool); - - // Convert from a `bool` to a `SocketBool`. - #[inline] - fn from_bool(value: bool) -> SocketBool { - SocketBool(value as _) - } - - // Convert from a `SocketBool` to a `bool`. - #[inline] - fn to_bool(value: SocketBool) -> bool { - value.0 != 0 - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/net/types.rs b/vendor/rustix-0.37.6/src/backend/libc/net/types.rs deleted file mode 100644 index 54f60ca50..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/net/types.rs +++ /dev/null @@ -1,510 +0,0 @@ -use super::super::c; -use bitflags::bitflags; - -/// A type for holding raw integer socket types. -#[doc(hidden)] -pub type RawSocketType = u32; - -/// `SOCK_*` constants for use with [`socket`]. -/// -/// [`socket`]: crate::net::socket -#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] -#[repr(transparent)] -pub struct SocketType(pub(crate) RawSocketType); - -#[rustfmt::skip] -impl SocketType { - /// `SOCK_STREAM` - pub const STREAM: Self = Self(c::SOCK_STREAM as u32); - - /// `SOCK_DGRAM` - pub const DGRAM: Self = Self(c::SOCK_DGRAM as u32); - - /// `SOCK_SEQPACKET` - pub const SEQPACKET: Self = Self(c::SOCK_SEQPACKET as u32); - - /// `SOCK_RAW` - pub const RAW: Self = Self(c::SOCK_RAW as u32); - - /// `SOCK_RDM` - #[cfg(not(target_os = "haiku"))] - pub const RDM: Self = Self(c::SOCK_RDM as u32); - - /// Constructs a `SocketType` from a raw integer. - #[inline] - pub const fn from_raw(raw: RawSocketType) -> Self { - Self(raw) - } - - /// Returns the raw integer for this `SocketType`. - #[inline] - pub const fn as_raw(self) -> RawSocketType { - self.0 - } -} - -/// A type for holding raw integer address families. -#[doc(hidden)] -pub type RawAddressFamily = c::sa_family_t; - -/// `AF_*` constants. -#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] -#[repr(transparent)] -pub struct AddressFamily(pub(crate) RawAddressFamily); - -#[rustfmt::skip] -impl AddressFamily { - /// `AF_UNSPEC` - pub const UNSPEC: Self = Self(c::AF_UNSPEC as _); - /// `AF_INET` - pub const INET: Self = Self(c::AF_INET as _); - /// `AF_INET6` - pub const INET6: Self = Self(c::AF_INET6 as _); - /// `AF_NETLINK` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const NETLINK: Self = Self(c::AF_NETLINK as _); - /// `AF_UNIX`, aka `AF_LOCAL` - #[doc(alias = "LOCAL")] - pub const UNIX: Self = Self(c::AF_UNIX as _); - /// `AF_AX25` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const AX25: Self = Self(c::AF_AX25 as _); - /// `AF_IPX` - pub const IPX: Self = Self(c::AF_IPX as _); - /// `AF_APPLETALK` - pub const APPLETALK: Self = Self(c::AF_APPLETALK as _); - /// `AF_NETROM` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const NETROM: Self = Self(c::AF_NETROM as _); - /// `AF_BRIDGE` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const BRIDGE: Self = Self(c::AF_BRIDGE as _); - /// `AF_ATMPVC` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const ATMPVC: Self = Self(c::AF_ATMPVC as _); - /// `AF_X25` - #[cfg(not(any( - bsd, - windows, - target_os = "haiku", - )))] - pub const X25: Self = Self(c::AF_X25 as _); - /// `AF_ROSE` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const ROSE: Self = Self(c::AF_ROSE as _); - /// `AF_DECnet` - #[allow(non_upper_case_globals)] - #[cfg(not(target_os = "haiku"))] - pub const DECnet: Self = Self(c::AF_DECnet as _); - /// `AF_NETBEUI` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const NETBEUI: Self = Self(c::AF_NETBEUI as _); - /// `AF_SECURITY` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const SECURITY: Self = Self(c::AF_SECURITY as _); - /// `AF_KEY` - #[cfg(not(any( - bsd, - windows, - target_os = "haiku", - )))] - pub const KEY: Self = Self(c::AF_KEY as _); - /// `AF_PACKET` - #[cfg(not(any( - bsd, - windows, - target_os = "haiku", - )))] - pub const PACKET: Self = Self(c::AF_PACKET as _); - /// `AF_ASH` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const ASH: Self = Self(c::AF_ASH as _); - /// `AF_ECONET` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const ECONET: Self = Self(c::AF_ECONET as _); - /// `AF_ATMSVC` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const ATMSVC: Self = Self(c::AF_ATMSVC as _); - /// `AF_RDS` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const RDS: Self = Self(c::AF_RDS as _); - /// `AF_SNA` - #[cfg(not(target_os = "haiku"))] - pub const SNA: Self = Self(c::AF_SNA as _); - /// `AF_IRDA` - #[cfg(not(any( - bsd, - solarish, - target_os = "haiku", - )))] - pub const IRDA: Self = Self(c::AF_IRDA as _); - /// `AF_PPPOX` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const PPPOX: Self = Self(c::AF_PPPOX as _); - /// `AF_WANPIPE` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const WANPIPE: Self = Self(c::AF_WANPIPE as _); - /// `AF_LLC` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const LLC: Self = Self(c::AF_LLC as _); - /// `AF_CAN` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const CAN: Self = Self(c::AF_CAN as _); - /// `AF_TIPC` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const TIPC: Self = Self(c::AF_TIPC as _); - /// `AF_BLUETOOTH` - #[cfg(not(any(apple, solarish, windows)))] - pub const BLUETOOTH: Self = Self(c::AF_BLUETOOTH as _); - /// `AF_IUCV` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const IUCV: Self = Self(c::AF_IUCV as _); - /// `AF_RXRPC` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const RXRPC: Self = Self(c::AF_RXRPC as _); - /// `AF_ISDN` - #[cfg(not(any(solarish, windows, target_os = "haiku")))] - pub const ISDN: Self = Self(c::AF_ISDN as _); - /// `AF_PHONET` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const PHONET: Self = Self(c::AF_PHONET as _); - /// `AF_IEEE802154` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const IEEE802154: Self = Self(c::AF_IEEE802154 as _); - - /// Constructs a `AddressFamily` from a raw integer. - #[inline] - pub const fn from_raw(raw: RawAddressFamily) -> Self { - Self(raw) - } - - /// Returns the raw integer for this `AddressFamily`. - #[inline] - pub const fn as_raw(self) -> RawAddressFamily { - self.0 - } -} - -/// A type for holding raw integer protocols. -#[doc(hidden)] -pub type RawProtocol = i32; - -/// `IPPROTO_*` -#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] -#[repr(transparent)] -pub struct Protocol(pub(crate) RawProtocol); - -#[rustfmt::skip] -impl Protocol { - /// `IPPROTO_IP` - pub const IP: Self = Self(c::IPPROTO_IP as _); - /// `IPPROTO_ICMP` - pub const ICMP: Self = Self(c::IPPROTO_ICMP as _); - /// `IPPROTO_IGMP` - #[cfg(not(any(solarish, target_os = "haiku")))] - pub const IGMP: Self = Self(c::IPPROTO_IGMP as _); - /// `IPPROTO_IPIP` - #[cfg(not(any(solarish, windows, target_os = "haiku")))] - pub const IPIP: Self = Self(c::IPPROTO_IPIP as _); - /// `IPPROTO_TCP` - pub const TCP: Self = Self(c::IPPROTO_TCP as _); - /// `IPPROTO_EGP` - #[cfg(not(any(solarish, target_os = "haiku")))] - pub const EGP: Self = Self(c::IPPROTO_EGP as _); - /// `IPPROTO_PUP` - #[cfg(not(any(solarish, target_os = "haiku")))] - pub const PUP: Self = Self(c::IPPROTO_PUP as _); - /// `IPPROTO_UDP` - pub const UDP: Self = Self(c::IPPROTO_UDP as _); - /// `IPPROTO_IDP` - #[cfg(not(any(solarish, target_os = "haiku")))] - pub const IDP: Self = Self(c::IPPROTO_IDP as _); - /// `IPPROTO_TP` - #[cfg(not(any(solarish, windows, target_os = "haiku")))] - pub const TP: Self = Self(c::IPPROTO_TP as _); - /// `IPPROTO_DCCP` - #[cfg(not(any( - apple, - solarish, - windows, - target_os = "dragonfly", - target_os = "haiku", - target_os = "openbsd", - )))] - pub const DCCP: Self = Self(c::IPPROTO_DCCP as _); - /// `IPPROTO_IPV6` - pub const IPV6: Self = Self(c::IPPROTO_IPV6 as _); - /// `IPPROTO_RSVP` - #[cfg(not(any(solarish, windows, target_os = "haiku")))] - pub const RSVP: Self = Self(c::IPPROTO_RSVP as _); - /// `IPPROTO_GRE` - #[cfg(not(any(solarish, windows, target_os = "haiku")))] - pub const GRE: Self = Self(c::IPPROTO_GRE as _); - /// `IPPROTO_ESP` - #[cfg(not(any(solarish, target_os = "haiku")))] - pub const ESP: Self = Self(c::IPPROTO_ESP as _); - /// `IPPROTO_AH` - #[cfg(not(any(solarish, target_os = "haiku")))] - pub const AH: Self = Self(c::IPPROTO_AH as _); - /// `IPPROTO_MTP` - #[cfg(not(any( - solarish, - netbsdlike, - windows, - target_os = "haiku", - )))] - pub const MTP: Self = Self(c::IPPROTO_MTP as _); - /// `IPPROTO_BEETPH` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const BEETPH: Self = Self(c::IPPROTO_BEETPH as _); - /// `IPPROTO_ENCAP` - #[cfg(not(any(solarish, windows, target_os = "haiku")))] - pub const ENCAP: Self = Self(c::IPPROTO_ENCAP as _); - /// `IPPROTO_PIM` - #[cfg(not(any(solarish, target_os = "haiku")))] - pub const PIM: Self = Self(c::IPPROTO_PIM as _); - /// `IPPROTO_COMP` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "haiku", - )))] - pub const COMP: Self = Self(c::IPPROTO_COMP as _); - /// `IPPROTO_SCTP` - #[cfg(not(any(solarish, target_os = "dragonfly", target_os = "haiku", target_os = "openbsd")))] - pub const SCTP: Self = Self(c::IPPROTO_SCTP as _); - /// `IPPROTO_UDPLITE` - #[cfg(not(any( - apple, - netbsdlike, - solarish, - windows, - target_os = "dragonfly", - target_os = "haiku", - )))] - pub const UDPLITE: Self = Self(c::IPPROTO_UDPLITE as _); - /// `IPPROTO_MPLS` - #[cfg(not(any( - apple, - solarish, - windows, - target_os = "dragonfly", - target_os = "haiku", - target_os = "netbsd", - )))] - pub const MPLS: Self = Self(c::IPPROTO_MPLS as _); - /// `IPPROTO_RAW` - pub const RAW: Self = Self(c::IPPROTO_RAW as _); - /// `IPPROTO_MPTCP` - #[cfg(not(any( - bsd, - solarish, - windows, - target_os = "android", - target_os = "emscripten", - target_os = "fuchsia", - target_os = "haiku", - )))] - pub const MPTCP: Self = Self(c::IPPROTO_MPTCP as _); - /// `IPPROTO_FRAGMENT` - #[cfg(not(any(solarish, target_os = "haiku")))] - pub const FRAGMENT: Self = Self(c::IPPROTO_FRAGMENT as _); - /// `IPPROTO_ICMPV6` - pub const ICMPV6: Self = Self(c::IPPROTO_ICMPV6 as _); - /// `IPPROTO_MH` - #[cfg(not(any( - apple, - netbsdlike, - solarish, - windows, - target_os = "dragonfly", - target_os = "haiku", - )))] - pub const MH: Self = Self(c::IPPROTO_MH as _); - /// `IPPROTO_ROUTING` - #[cfg(not(any(solarish, target_os = "haiku")))] - pub const ROUTING: Self = Self(c::IPPROTO_ROUTING as _); - - /// Constructs a `Protocol` from a raw integer. - #[inline] - pub const fn from_raw(raw: RawProtocol) -> Self { - Self(raw) - } - - /// Returns the raw integer for this `Protocol`. - #[inline] - pub const fn as_raw(self) -> RawProtocol { - self.0 - } -} - -/// `SHUT_*` constants for use with [`shutdown`]. -/// -/// [`shutdown`]: crate::net::shutdown -#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] -#[repr(i32)] -pub enum Shutdown { - /// `SHUT_RD`—Disable further read operations. - Read = c::SHUT_RD, - /// `SHUT_WR`—Disable further write operations. - Write = c::SHUT_WR, - /// `SHUT_RDWR`—Disable further read and write operations. - ReadWrite = c::SHUT_RDWR, -} - -bitflags! { - /// `SOCK_*` constants for use with [`accept_with`] and [`acceptfrom_with`]. - /// - /// [`accept_with`]: crate::net::accept_with - /// [`acceptfrom_with`]: crate::net::acceptfrom_with - pub struct AcceptFlags: c::c_int { - /// `SOCK_NONBLOCK` - #[cfg(not(any(apple, windows, target_os = "haiku")))] - const NONBLOCK = c::SOCK_NONBLOCK; - - /// `SOCK_CLOEXEC` - #[cfg(not(any(apple, windows, target_os = "haiku")))] - const CLOEXEC = c::SOCK_CLOEXEC; - } -} - -bitflags! { - /// `SOCK_*` constants for use with [`socket`]. - /// - /// [`socket`]: crate::net::socket - pub struct SocketFlags: c::c_int { - /// `SOCK_NONBLOCK` - #[cfg(not(any(apple, windows, target_os = "haiku")))] - const NONBLOCK = c::SOCK_NONBLOCK; - - /// `SOCK_CLOEXEC` - #[cfg(not(any(apple, windows, target_os = "haiku")))] - const CLOEXEC = c::SOCK_CLOEXEC; - } -} - -/// Timeout identifier for use with [`set_socket_timeout`] and -/// [`get_socket_timeout`]. -/// -/// [`set_socket_timeout`]: crate::net::sockopt::set_socket_timeout. -/// [`get_socket_timeout`]: crate::net::sockopt::get_socket_timeout. -#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] -#[repr(i32)] -pub enum Timeout { - /// `SO_RCVTIMEO`—Timeout for receiving. - Recv = c::SO_RCVTIMEO, - - /// `SO_SNDTIMEO`—Timeout for sending. - Send = c::SO_SNDTIMEO, -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/net/write_sockaddr.rs b/vendor/rustix-0.37.6/src/backend/libc/net/write_sockaddr.rs deleted file mode 100644 index f8ab62966..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/net/write_sockaddr.rs +++ /dev/null @@ -1,78 +0,0 @@ -//! The BSD sockets API requires us to read the `ss_family` field before -//! we can interpret the rest of a `sockaddr` produced by the kernel. - -use super::super::c; -use super::addr::SocketAddrStorage; -#[cfg(unix)] -use super::addr::SocketAddrUnix; -use super::ext::{in6_addr_new, in_addr_new, sockaddr_in6_new}; -use crate::net::{SocketAddrAny, SocketAddrV4, SocketAddrV6}; -use core::mem::size_of; - -pub(crate) unsafe fn write_sockaddr( - addr: &SocketAddrAny, - storage: *mut SocketAddrStorage, -) -> usize { - match addr { - SocketAddrAny::V4(v4) => write_sockaddr_v4(v4, storage), - SocketAddrAny::V6(v6) => write_sockaddr_v6(v6, storage), - #[cfg(unix)] - SocketAddrAny::Unix(unix) => write_sockaddr_unix(unix, storage), - } -} - -pub(crate) unsafe fn encode_sockaddr_v4(v4: &SocketAddrV4) -> c::sockaddr_in { - c::sockaddr_in { - #[cfg(any(bsd, target_os = "haiku"))] - sin_len: size_of::<c::sockaddr_in>() as _, - sin_family: c::AF_INET as _, - sin_port: u16::to_be(v4.port()), - sin_addr: in_addr_new(u32::from_ne_bytes(v4.ip().octets())), - #[cfg(not(target_os = "haiku"))] - sin_zero: [0; 8_usize], - #[cfg(target_os = "haiku")] - sin_zero: [0; 24_usize], - } -} - -unsafe fn write_sockaddr_v4(v4: &SocketAddrV4, storage: *mut SocketAddrStorage) -> usize { - let encoded = encode_sockaddr_v4(v4); - core::ptr::write(storage.cast(), encoded); - size_of::<c::sockaddr_in>() -} - -pub(crate) unsafe fn encode_sockaddr_v6(v6: &SocketAddrV6) -> c::sockaddr_in6 { - #[cfg(any(bsd, target_os = "haiku"))] - { - sockaddr_in6_new( - size_of::<c::sockaddr_in6>() as _, - c::AF_INET6 as _, - u16::to_be(v6.port()), - u32::to_be(v6.flowinfo()), - in6_addr_new(v6.ip().octets()), - v6.scope_id(), - ) - } - #[cfg(not(any(bsd, target_os = "haiku")))] - { - sockaddr_in6_new( - c::AF_INET6 as _, - u16::to_be(v6.port()), - u32::to_be(v6.flowinfo()), - in6_addr_new(v6.ip().octets()), - v6.scope_id(), - ) - } -} - -unsafe fn write_sockaddr_v6(v6: &SocketAddrV6, storage: *mut SocketAddrStorage) -> usize { - let encoded = encode_sockaddr_v6(v6); - core::ptr::write(storage.cast(), encoded); - size_of::<c::sockaddr_in6>() -} - -#[cfg(unix)] -unsafe fn write_sockaddr_unix(unix: &SocketAddrUnix, storage: *mut SocketAddrStorage) -> usize { - core::ptr::write(storage.cast(), unix.unix); - unix.len() -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/offset.rs b/vendor/rustix-0.37.6/src/backend/libc/offset.rs deleted file mode 100644 index 9747eb954..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/offset.rs +++ /dev/null @@ -1,412 +0,0 @@ -//! Automatically enable “large file” support features. - -#[cfg(not(windows))] -use super::c; - -#[cfg(not(any(linux_like, windows)))] -#[cfg(feature = "fs")] -pub(super) use c::{ - fstat as libc_fstat, fstatat as libc_fstatat, ftruncate as libc_ftruncate, lseek as libc_lseek, - off_t as libc_off_t, -}; - -#[cfg(linux_like)] -#[cfg(feature = "fs")] -pub(super) use c::{ - fstat64 as libc_fstat, fstatat64 as libc_fstatat, ftruncate64 as libc_ftruncate, - lseek64 as libc_lseek, off64_t as libc_off_t, -}; - -#[cfg(linux_like)] -pub(super) use c::rlimit64 as libc_rlimit; - -#[cfg(not(any(linux_like, windows, target_os = "wasi")))] -#[cfg(feature = "mm")] -pub(super) use c::mmap as libc_mmap; - -#[cfg(not(any( - linux_like, - windows, - target_os = "fuchsia", - target_os = "redox", - target_os = "wasi", -)))] -pub(super) use c::{rlimit as libc_rlimit, RLIM_INFINITY as LIBC_RLIM_INFINITY}; - -#[cfg(not(any(linux_like, windows, target_os = "fuchsia", target_os = "wasi")))] -pub(super) use c::{getrlimit as libc_getrlimit, setrlimit as libc_setrlimit}; - -// TODO: Add `RLIM64_INFINITY` to upstream libc. -#[cfg(linux_like)] -pub(super) const LIBC_RLIM_INFINITY: u64 = !0_u64; - -#[cfg(linux_like)] -pub(super) use c::{getrlimit64 as libc_getrlimit, setrlimit64 as libc_setrlimit}; - -#[cfg(linux_like)] -#[cfg(feature = "mm")] -pub(super) use c::mmap64 as libc_mmap; - -// `prlimit64` wasn't supported in glibc until 2.13. -#[cfg(all(target_os = "linux", target_env = "gnu"))] -weak_or_syscall! { - fn prlimit64( - pid: c::pid_t, - resource: c::__rlimit_resource_t, - new_limit: *const c::rlimit64, - old_limit: *mut c::rlimit64 - ) via SYS_prlimit64 -> c::c_int -} -#[cfg(all(target_os = "linux", target_env = "musl"))] -weak_or_syscall! { - fn prlimit64( - pid: c::pid_t, - resource: c::c_int, - new_limit: *const c::rlimit64, - old_limit: *mut c::rlimit64 - ) via SYS_prlimit64 -> c::c_int -} -#[cfg(target_os = "android")] -weak_or_syscall! { - fn prlimit64( - pid: c::pid_t, - resource: c::c_int, - new_limit: *const c::rlimit64, - old_limit: *mut c::rlimit64 - ) via SYS_prlimit64 -> c::c_int -} -#[cfg(all(target_os = "linux", target_env = "gnu"))] -pub(super) unsafe fn libc_prlimit( - pid: c::pid_t, - resource: c::__rlimit_resource_t, - new_limit: *const c::rlimit64, - old_limit: *mut c::rlimit64, -) -> c::c_int { - prlimit64(pid, resource, new_limit, old_limit) -} -#[cfg(all(target_os = "linux", target_env = "musl"))] -pub(super) unsafe fn libc_prlimit( - pid: c::pid_t, - resource: c::c_int, - new_limit: *const c::rlimit64, - old_limit: *mut c::rlimit64, -) -> c::c_int { - prlimit64(pid, resource, new_limit, old_limit) -} -#[cfg(target_os = "android")] -pub(super) unsafe fn libc_prlimit( - pid: c::pid_t, - resource: c::c_int, - new_limit: *const c::rlimit64, - old_limit: *mut c::rlimit64, -) -> c::c_int { - prlimit64(pid, resource, new_limit, old_limit) -} - -#[cfg(not(any(linux_like, windows, target_os = "redox")))] -#[cfg(feature = "fs")] -pub(super) use c::openat as libc_openat; -#[cfg(linux_like)] -#[cfg(feature = "fs")] -pub(super) use c::openat64 as libc_openat; - -#[cfg(target_os = "fuchsia")] -#[cfg(feature = "fs")] -pub(super) use c::fallocate as libc_fallocate; -#[cfg(any(target_os = "android", target_os = "linux"))] -#[cfg(feature = "fs")] -pub(super) use c::fallocate64 as libc_fallocate; -#[cfg(not(any( - apple, - linux_like, - netbsdlike, - solarish, - windows, - target_os = "dragonfly", - target_os = "haiku", - target_os = "redox", -)))] -#[cfg(feature = "fs")] -pub(super) use c::posix_fadvise as libc_posix_fadvise; -#[cfg(linux_like)] -#[cfg(feature = "fs")] -pub(super) use c::posix_fadvise64 as libc_posix_fadvise; - -#[cfg(all(not(any( - windows, - target_os = "android", - target_os = "linux", - target_os = "emscripten", -))))] -pub(super) use c::{pread as libc_pread, pwrite as libc_pwrite}; -#[cfg(any(target_os = "android", target_os = "linux", target_os = "emscripten"))] -pub(super) use c::{pread64 as libc_pread, pwrite64 as libc_pwrite}; -#[cfg(not(any( - apple, - windows, - target_os = "android", - target_os = "emscripten", - target_os = "haiku", - target_os = "linux", - target_os = "redox", - target_os = "solaris", -)))] -pub(super) use c::{preadv as libc_preadv, pwritev as libc_pwritev}; -#[cfg(any(target_os = "linux", target_os = "emscripten"))] -pub(super) use c::{preadv64 as libc_preadv, pwritev64 as libc_pwritev}; - -#[cfg(target_os = "android")] -mod readwrite_pv64 { - use super::c; - - // 64-bit offsets on 32-bit platforms are passed in endianness-specific - // lo/hi pairs. See src/backend/linux_raw/conv.rs for details. - #[cfg(all(target_endian = "little", target_pointer_width = "32"))] - fn lo(x: u64) -> usize { - (x >> 32) as usize - } - #[cfg(all(target_endian = "little", target_pointer_width = "32"))] - fn hi(x: u64) -> usize { - (x & 0xffff_ffff) as usize - } - #[cfg(all(target_endian = "big", target_pointer_width = "32"))] - fn lo(x: u64) -> usize { - (x & 0xffff_ffff) as usize - } - #[cfg(all(target_endian = "big", target_pointer_width = "32"))] - fn hi(x: u64) -> usize { - (x >> 32) as usize - } - - pub(in super::super) unsafe fn preadv64( - fd: c::c_int, - iov: *const c::iovec, - iovcnt: c::c_int, - offset: c::off64_t, - ) -> c::ssize_t { - // Older Android libc lacks `preadv64`, so use the `weak!` mechanism to - // test for it, and call back to `c::syscall`. We don't use - // `weak_or_syscall` here because we need to pass the 64-bit offset - // specially. - weak! { - fn preadv64(c::c_int, *const c::iovec, c::c_int, c::off64_t) -> c::ssize_t - } - if let Some(fun) = preadv64.get() { - fun(fd, iov, iovcnt, offset) - } else { - #[cfg(target_pointer_width = "32")] - { - c::syscall( - c::SYS_preadv, - fd, - iov, - iovcnt, - hi(offset as u64), - lo(offset as u64), - ) as c::ssize_t - } - #[cfg(target_pointer_width = "64")] - { - c::syscall(c::SYS_preadv, fd, iov, iovcnt, offset) as c::ssize_t - } - } - } - pub(in super::super) unsafe fn pwritev64( - fd: c::c_int, - iov: *const c::iovec, - iovcnt: c::c_int, - offset: c::off64_t, - ) -> c::ssize_t { - // See the comments in `preadv64`. - weak! { - fn pwritev64(c::c_int, *const c::iovec, c::c_int, c::off64_t) -> c::ssize_t - } - if let Some(fun) = pwritev64.get() { - fun(fd, iov, iovcnt, offset) - } else { - #[cfg(target_pointer_width = "32")] - { - c::syscall( - c::SYS_pwritev, - fd, - iov, - iovcnt, - hi(offset as u64), - lo(offset as u64), - ) as c::ssize_t - } - #[cfg(target_pointer_width = "64")] - { - c::syscall(c::SYS_pwritev, fd, iov, iovcnt, offset) as c::ssize_t - } - } - } -} -#[cfg(target_os = "android")] -pub(super) use readwrite_pv64::{preadv64 as libc_preadv, pwritev64 as libc_pwritev}; - -// macOS added preadv and pwritev in version 11.0 -#[cfg(apple)] -mod readwrite_pv { - use super::c; - - weakcall! { - pub(in super::super) fn preadv( - fd: c::c_int, - iov: *const c::iovec, - iovcnt: c::c_int, - offset: c::off_t - ) -> c::ssize_t - } - weakcall! { - pub(in super::super) fn pwritev( - fd: c::c_int, - iov: *const c::iovec, - iovcnt: c::c_int, offset: c::off_t - ) -> c::ssize_t - } -} -#[cfg(apple)] -pub(super) use readwrite_pv::{preadv as libc_preadv, pwritev as libc_pwritev}; - -// GLIBC added `preadv64v2` and `pwritev64v2` in version 2.26. -#[cfg(all(target_os = "linux", target_env = "gnu"))] -mod readwrite_pv64v2 { - use super::c; - - // 64-bit offsets on 32-bit platforms are passed in endianness-specific - // lo/hi pairs. See src/backend/linux_raw/conv.rs for details. - #[cfg(all(target_endian = "little", target_pointer_width = "32"))] - fn lo(x: u64) -> usize { - (x >> 32) as usize - } - #[cfg(all(target_endian = "little", target_pointer_width = "32"))] - fn hi(x: u64) -> usize { - (x & 0xffff_ffff) as usize - } - #[cfg(all(target_endian = "big", target_pointer_width = "32"))] - fn lo(x: u64) -> usize { - (x & 0xffff_ffff) as usize - } - #[cfg(all(target_endian = "big", target_pointer_width = "32"))] - fn hi(x: u64) -> usize { - (x >> 32) as usize - } - - pub(in super::super) unsafe fn preadv64v2( - fd: c::c_int, - iov: *const c::iovec, - iovcnt: c::c_int, - offset: c::off64_t, - flags: c::c_int, - ) -> c::ssize_t { - // Older GLIBC lacks `preadv64v2`, so use the `weak!` mechanism to - // test for it, and call back to `c::syscall`. We don't use - // `weak_or_syscall` here because we need to pass the 64-bit offset - // specially. - weak! { - fn preadv64v2(c::c_int, *const c::iovec, c::c_int, c::off64_t, c::c_int) -> c::ssize_t - } - if let Some(fun) = preadv64v2.get() { - fun(fd, iov, iovcnt, offset, flags) - } else { - #[cfg(target_pointer_width = "32")] - { - c::syscall( - c::SYS_preadv, - fd, - iov, - iovcnt, - hi(offset as u64), - lo(offset as u64), - flags, - ) as c::ssize_t - } - #[cfg(target_pointer_width = "64")] - { - c::syscall(c::SYS_preadv2, fd, iov, iovcnt, offset, flags) as c::ssize_t - } - } - } - pub(in super::super) unsafe fn pwritev64v2( - fd: c::c_int, - iov: *const c::iovec, - iovcnt: c::c_int, - offset: c::off64_t, - flags: c::c_int, - ) -> c::ssize_t { - // See the comments in `preadv64v2`. - weak! { - fn pwritev64v2(c::c_int, *const c::iovec, c::c_int, c::off64_t, c::c_int) -> c::ssize_t - } - if let Some(fun) = pwritev64v2.get() { - fun(fd, iov, iovcnt, offset, flags) - } else { - #[cfg(target_pointer_width = "32")] - { - c::syscall( - c::SYS_pwritev, - fd, - iov, - iovcnt, - hi(offset as u64), - lo(offset as u64), - flags, - ) as c::ssize_t - } - #[cfg(target_pointer_width = "64")] - { - c::syscall(c::SYS_pwritev2, fd, iov, iovcnt, offset, flags) as c::ssize_t - } - } - } -} -#[cfg(all(target_os = "linux", target_env = "gnu"))] -pub(super) use readwrite_pv64v2::{preadv64v2 as libc_preadv2, pwritev64v2 as libc_pwritev2}; - -#[cfg(not(any( - apple, - netbsdlike, - solarish, - windows, - target_os = "aix", - target_os = "android", - target_os = "dragonfly", - target_os = "fuchsia", - target_os = "linux", - target_os = "l4re", - target_os = "redox", -)))] -#[cfg(feature = "fs")] -pub(super) use c::posix_fallocate as libc_posix_fallocate; -#[cfg(target_os = "l4re")] -#[cfg(feature = "fs")] -pub(super) use c::posix_fallocate64 as libc_posix_fallocate; -#[cfg(not(any( - linux_like, - solarish, - windows, - target_os = "haiku", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", -)))] -#[cfg(feature = "fs")] -pub(super) use {c::fstatfs as libc_fstatfs, c::statfs as libc_statfs}; -#[cfg(not(any( - linux_like, - solarish, - windows, - target_os = "haiku", - target_os = "redox", - target_os = "wasi", -)))] -#[cfg(feature = "fs")] -pub(super) use {c::fstatvfs as libc_fstatvfs, c::statvfs as libc_statvfs}; - -#[cfg(linux_like)] -#[cfg(feature = "fs")] -pub(super) use { - c::fstatfs64 as libc_fstatfs, c::fstatvfs64 as libc_fstatvfs, c::statfs64 as libc_statfs, - c::statvfs64 as libc_statvfs, -}; diff --git a/vendor/rustix-0.37.6/src/backend/libc/param/auxv.rs b/vendor/rustix-0.37.6/src/backend/libc/param/auxv.rs deleted file mode 100644 index a770c60d8..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/param/auxv.rs +++ /dev/null @@ -1,54 +0,0 @@ -use super::super::c; -#[cfg(any( - all(target_os = "android", target_pointer_width = "64"), - target_os = "linux", -))] -use crate::ffi::CStr; - -// `getauxval` wasn't supported in glibc until 2.16. -#[cfg(any( - all(target_os = "android", target_pointer_width = "64"), - target_os = "linux", -))] -weak!(fn getauxval(c::c_ulong) -> *mut c::c_void); - -#[inline] -pub(crate) fn page_size() -> usize { - unsafe { c::sysconf(c::_SC_PAGESIZE) as usize } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn clock_ticks_per_second() -> u64 { - unsafe { c::sysconf(c::_SC_CLK_TCK) as u64 } -} - -#[cfg(any( - all(target_os = "android", target_pointer_width = "64"), - target_os = "linux", -))] -#[inline] -pub(crate) fn linux_hwcap() -> (usize, usize) { - if let Some(libc_getauxval) = getauxval.get() { - unsafe { - let hwcap = libc_getauxval(c::AT_HWCAP) as usize; - let hwcap2 = libc_getauxval(c::AT_HWCAP2) as usize; - (hwcap, hwcap2) - } - } else { - (0, 0) - } -} - -#[cfg(any( - all(target_os = "android", target_pointer_width = "64"), - target_os = "linux", -))] -#[inline] -pub(crate) fn linux_execfn() -> &'static CStr { - if let Some(libc_getauxval) = getauxval.get() { - unsafe { CStr::from_ptr(libc_getauxval(c::AT_EXECFN).cast()) } - } else { - cstr!("") - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/param/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/param/mod.rs deleted file mode 100644 index 2cb2fe78a..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/param/mod.rs +++ /dev/null @@ -1 +0,0 @@ -pub(crate) mod auxv; diff --git a/vendor/rustix-0.37.6/src/backend/libc/process/cpu_set.rs b/vendor/rustix-0.37.6/src/backend/libc/process/cpu_set.rs deleted file mode 100644 index a9d6d89c2..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/process/cpu_set.rs +++ /dev/null @@ -1,51 +0,0 @@ -//! Rust implementation of the `CPU_*` macro API. - -#![allow(non_snake_case)] - -use super::super::c; -use super::types::{RawCpuSet, CPU_SETSIZE}; - -#[inline] -pub(crate) fn CPU_SET(cpu: usize, cpuset: &mut RawCpuSet) { - assert!( - cpu < CPU_SETSIZE, - "cpu out of bounds: the cpu max is {} but the cpu is {}", - CPU_SETSIZE, - cpu - ); - unsafe { c::CPU_SET(cpu, cpuset) } -} - -#[inline] -pub(crate) fn CPU_ZERO(cpuset: &mut RawCpuSet) { - unsafe { c::CPU_ZERO(cpuset) } -} - -#[inline] -pub(crate) fn CPU_CLR(cpu: usize, cpuset: &mut RawCpuSet) { - assert!( - cpu < CPU_SETSIZE, - "cpu out of bounds: the cpu max is {} but the cpu is {}", - CPU_SETSIZE, - cpu - ); - unsafe { c::CPU_CLR(cpu, cpuset) } -} - -#[inline] -pub(crate) fn CPU_ISSET(cpu: usize, cpuset: &RawCpuSet) -> bool { - assert!( - cpu < CPU_SETSIZE, - "cpu out of bounds: the cpu max is {} but the cpu is {}", - CPU_SETSIZE, - cpu - ); - unsafe { c::CPU_ISSET(cpu, cpuset) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn CPU_COUNT(cpuset: &RawCpuSet) -> u32 { - use core::convert::TryInto; - unsafe { c::CPU_COUNT(cpuset).try_into().unwrap() } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/process/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/process/mod.rs deleted file mode 100644 index 8675c1af9..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/process/mod.rs +++ /dev/null @@ -1,12 +0,0 @@ -#[cfg(any( - target_os = "android", - target_os = "dragonfly", - target_os = "fuchsia", - target_os = "linux", -))] -pub(crate) mod cpu_set; -#[cfg(not(windows))] -pub(crate) mod syscalls; -pub(crate) mod types; -#[cfg(not(target_os = "wasi"))] -pub(crate) mod wait; diff --git a/vendor/rustix-0.37.6/src/backend/libc/process/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/process/syscalls.rs deleted file mode 100644 index d208bda7a..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/process/syscalls.rs +++ /dev/null @@ -1,570 +0,0 @@ -//! libc syscalls supporting `rustix::process`. - -use super::super::c; -#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))] -use super::super::conv::borrowed_fd; -use super::super::conv::{c_str, ret, ret_c_int, ret_discarded_char_ptr}; -#[cfg(not(target_os = "wasi"))] -use super::super::conv::{ret_infallible, ret_pid_t}; -#[cfg(any(target_os = "android", target_os = "linux"))] -use super::super::conv::{syscall_ret, syscall_ret_u32}; -#[cfg(any( - target_os = "android", - target_os = "dragonfly", - target_os = "fuchsia", - target_os = "linux", -))] -use super::types::RawCpuSet; -#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))] -use crate::fd::BorrowedFd; -#[cfg(target_os = "linux")] -use crate::fd::{AsRawFd, OwnedFd}; -use crate::ffi::CStr; -#[cfg(feature = "fs")] -use crate::fs::Mode; -use crate::io; -#[cfg(not(any(target_os = "wasi", target_os = "redox", target_os = "openbsd")))] -use crate::process::{WaitId, WaitidOptions, WaitidStatus}; -use core::mem::MaybeUninit; -#[cfg(target_os = "linux")] -use {super::super::conv::syscall_ret_owned_fd, crate::process::PidfdFlags}; -#[cfg(any(target_os = "android", target_os = "linux"))] -use { - super::super::offset::libc_prlimit, - crate::process::{Cpuid, MembarrierCommand, MembarrierQuery}, -}; -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -use { - super::super::offset::{libc_getrlimit, libc_rlimit, libc_setrlimit, LIBC_RLIM_INFINITY}, - crate::process::{Resource, Rlimit}, - core::convert::TryInto, -}; -#[cfg(not(target_os = "wasi"))] -use { - super::types::RawUname, - crate::process::{Gid, Pid, RawNonZeroPid, RawPid, Signal, Uid, WaitOptions, WaitStatus}, -}; - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn chdir(path: &CStr) -> io::Result<()> { - unsafe { ret(c::chdir(c_str(path))) } -} - -#[cfg(not(any(target_os = "wasi", target_os = "fuchsia")))] -pub(crate) fn fchdir(dirfd: BorrowedFd<'_>) -> io::Result<()> { - unsafe { ret(c::fchdir(borrowed_fd(dirfd))) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn getcwd(buf: &mut [u8]) -> io::Result<()> { - unsafe { ret_discarded_char_ptr(c::getcwd(buf.as_mut_ptr().cast(), buf.len())) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn membarrier_query() -> MembarrierQuery { - // GLIBC does not have a wrapper for `membarrier`; [the documentation] - // says to use `syscall`. - // - // [the documentation]: https://man7.org/linux/man-pages/man2/membarrier.2.html#NOTES - const MEMBARRIER_CMD_QUERY: u32 = 0; - unsafe { - match syscall_ret_u32(c::syscall(c::SYS_membarrier, MEMBARRIER_CMD_QUERY, 0)) { - Ok(query) => MembarrierQuery::from_bits_unchecked(query), - Err(_) => MembarrierQuery::empty(), - } - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn membarrier(cmd: MembarrierCommand) -> io::Result<()> { - unsafe { syscall_ret(c::syscall(c::SYS_membarrier, cmd as u32, 0)) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn membarrier_cpu(cmd: MembarrierCommand, cpu: Cpuid) -> io::Result<()> { - const MEMBARRIER_CMD_FLAG_CPU: u32 = 1; - unsafe { - syscall_ret(c::syscall( - c::SYS_membarrier, - cmd as u32, - MEMBARRIER_CMD_FLAG_CPU, - cpu.as_raw(), - )) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn getuid() -> Uid { - unsafe { - let uid = c::getuid(); - Uid::from_raw(uid) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn geteuid() -> Uid { - unsafe { - let uid = c::geteuid(); - Uid::from_raw(uid) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn getgid() -> Gid { - unsafe { - let gid = c::getgid(); - Gid::from_raw(gid) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn getegid() -> Gid { - unsafe { - let gid = c::getegid(); - Gid::from_raw(gid) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn getpid() -> Pid { - unsafe { - let pid = c::getpid(); - debug_assert_ne!(pid, 0); - Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid)) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn getppid() -> Option<Pid> { - unsafe { - let pid: i32 = c::getppid(); - Pid::from_raw(pid) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn getpgid(pid: Option<Pid>) -> io::Result<Pid> { - unsafe { - let pgid = ret_pid_t(c::getpgid(Pid::as_raw(pid) as _))?; - debug_assert_ne!(pgid, 0); - Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pgid))) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn getpgrp() -> Pid { - unsafe { - let pgid = c::getpgrp(); - debug_assert_ne!(pgid, 0); - Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pgid)) - } -} - -#[cfg(any( - target_os = "android", - target_os = "dragonfly", - target_os = "fuchsia", - target_os = "linux", -))] -#[inline] -pub(crate) fn sched_getaffinity(pid: Option<Pid>, cpuset: &mut RawCpuSet) -> io::Result<()> { - unsafe { - ret(c::sched_getaffinity( - Pid::as_raw(pid) as _, - core::mem::size_of::<RawCpuSet>(), - cpuset, - )) - } -} - -#[cfg(any( - target_os = "android", - target_os = "dragonfly", - target_os = "fuchsia", - target_os = "linux", -))] -#[inline] -pub(crate) fn sched_setaffinity(pid: Option<Pid>, cpuset: &RawCpuSet) -> io::Result<()> { - unsafe { - ret(c::sched_setaffinity( - Pid::as_raw(pid) as _, - core::mem::size_of::<RawCpuSet>(), - cpuset, - )) - } -} - -#[inline] -pub(crate) fn sched_yield() { - unsafe { - let _ = c::sched_yield(); - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn uname() -> RawUname { - let mut uname = MaybeUninit::<RawUname>::uninit(); - unsafe { - ret_infallible(c::uname(uname.as_mut_ptr())); - uname.assume_init() - } -} - -#[cfg(not(target_os = "wasi"))] -#[cfg(feature = "fs")] -#[inline] -pub(crate) fn umask(mask: Mode) -> Mode { - // TODO: Use `from_bits_retain` when we switch to bitflags 2.0. - unsafe { Mode::from_bits_truncate(c::umask(mask.bits() as _) as _) } -} - -#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))] -#[inline] -pub(crate) fn nice(inc: i32) -> io::Result<i32> { - libc_errno::set_errno(libc_errno::Errno(0)); - let r = unsafe { c::nice(inc) }; - if libc_errno::errno().0 != 0 { - ret_c_int(r) - } else { - Ok(r) - } -} - -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -#[inline] -pub(crate) fn getpriority_user(uid: Uid) -> io::Result<i32> { - libc_errno::set_errno(libc_errno::Errno(0)); - let r = unsafe { c::getpriority(c::PRIO_USER, uid.as_raw() as _) }; - if libc_errno::errno().0 != 0 { - ret_c_int(r) - } else { - Ok(r) - } -} - -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -#[inline] -pub(crate) fn getpriority_pgrp(pgid: Option<Pid>) -> io::Result<i32> { - libc_errno::set_errno(libc_errno::Errno(0)); - let r = unsafe { c::getpriority(c::PRIO_PGRP, Pid::as_raw(pgid) as _) }; - if libc_errno::errno().0 != 0 { - ret_c_int(r) - } else { - Ok(r) - } -} - -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -#[inline] -pub(crate) fn getpriority_process(pid: Option<Pid>) -> io::Result<i32> { - libc_errno::set_errno(libc_errno::Errno(0)); - let r = unsafe { c::getpriority(c::PRIO_PROCESS, Pid::as_raw(pid) as _) }; - if libc_errno::errno().0 != 0 { - ret_c_int(r) - } else { - Ok(r) - } -} - -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -#[inline] -pub(crate) fn setpriority_user(uid: Uid, priority: i32) -> io::Result<()> { - unsafe { ret(c::setpriority(c::PRIO_USER, uid.as_raw() as _, priority)) } -} - -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -#[inline] -pub(crate) fn setpriority_pgrp(pgid: Option<Pid>, priority: i32) -> io::Result<()> { - unsafe { - ret(c::setpriority( - c::PRIO_PGRP, - Pid::as_raw(pgid) as _, - priority, - )) - } -} - -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -#[inline] -pub(crate) fn setpriority_process(pid: Option<Pid>, priority: i32) -> io::Result<()> { - unsafe { - ret(c::setpriority( - c::PRIO_PROCESS, - Pid::as_raw(pid) as _, - priority, - )) - } -} - -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -#[inline] -pub(crate) fn getrlimit(limit: Resource) -> Rlimit { - let mut result = MaybeUninit::<libc_rlimit>::uninit(); - unsafe { - ret_infallible(libc_getrlimit(limit as _, result.as_mut_ptr())); - rlimit_from_libc(result.assume_init()) - } -} - -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -#[inline] -pub(crate) fn setrlimit(limit: Resource, new: Rlimit) -> io::Result<()> { - let lim = rlimit_to_libc(new)?; - unsafe { ret(libc_setrlimit(limit as _, &lim)) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn prlimit(pid: Option<Pid>, limit: Resource, new: Rlimit) -> io::Result<Rlimit> { - let lim = rlimit_to_libc(new)?; - let mut result = MaybeUninit::<libc_rlimit>::uninit(); - unsafe { - ret(libc_prlimit( - Pid::as_raw(pid), - limit as _, - &lim, - result.as_mut_ptr(), - ))?; - Ok(rlimit_from_libc(result.assume_init())) - } -} - -/// Convert a Rust [`Rlimit`] to a C `libc_rlimit`. -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -fn rlimit_from_libc(lim: libc_rlimit) -> Rlimit { - let current = if lim.rlim_cur == LIBC_RLIM_INFINITY { - None - } else { - Some(lim.rlim_cur.try_into().unwrap()) - }; - let maximum = if lim.rlim_max == LIBC_RLIM_INFINITY { - None - } else { - Some(lim.rlim_max.try_into().unwrap()) - }; - Rlimit { current, maximum } -} - -/// Convert a C `libc_rlimit` to a Rust `Rlimit`. -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -fn rlimit_to_libc(lim: Rlimit) -> io::Result<libc_rlimit> { - let Rlimit { current, maximum } = lim; - let rlim_cur = match current { - Some(r) => r.try_into().map_err(|_e| io::Errno::INVAL)?, - None => LIBC_RLIM_INFINITY as _, - }; - let rlim_max = match maximum { - Some(r) => r.try_into().map_err(|_e| io::Errno::INVAL)?, - None => LIBC_RLIM_INFINITY as _, - }; - Ok(libc_rlimit { rlim_cur, rlim_max }) -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn wait(waitopts: WaitOptions) -> io::Result<Option<(Pid, WaitStatus)>> { - _waitpid(!0, waitopts) -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn waitpid( - pid: Option<Pid>, - waitopts: WaitOptions, -) -> io::Result<Option<(Pid, WaitStatus)>> { - _waitpid(Pid::as_raw(pid), waitopts) -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn _waitpid( - pid: RawPid, - waitopts: WaitOptions, -) -> io::Result<Option<(Pid, WaitStatus)>> { - unsafe { - let mut status: c::c_int = 0; - let pid = ret_c_int(c::waitpid(pid as _, &mut status, waitopts.bits() as _))?; - Ok(RawNonZeroPid::new(pid).map(|non_zero| { - ( - Pid::from_raw_nonzero(non_zero), - WaitStatus::new(status as _), - ) - })) - } -} - -#[cfg(not(any(target_os = "wasi", target_os = "redox", target_os = "openbsd")))] -#[inline] -pub(crate) fn waitid(id: WaitId<'_>, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> { - // Get the id to wait on. - match id { - WaitId::All => _waitid_all(options), - WaitId::Pid(pid) => _waitid_pid(pid, options), - #[cfg(target_os = "linux")] - WaitId::PidFd(fd) => _waitid_pidfd(fd, options), - #[cfg(not(target_os = "linux"))] - WaitId::__EatLifetime(_) => unreachable!(), - } -} - -#[cfg(not(any(target_os = "wasi", target_os = "redox", target_os = "openbsd")))] -#[inline] -fn _waitid_all(options: WaitidOptions) -> io::Result<Option<WaitidStatus>> { - let mut status = MaybeUninit::<c::siginfo_t>::uninit(); - unsafe { - ret(c::waitid( - c::P_ALL, - 0, - status.as_mut_ptr(), - options.bits() as _, - ))? - }; - - Ok(unsafe { cvt_waitid_status(status) }) -} - -#[cfg(not(any(target_os = "wasi", target_os = "redox", target_os = "openbsd")))] -#[inline] -fn _waitid_pid(pid: Pid, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> { - let mut status = MaybeUninit::<c::siginfo_t>::uninit(); - unsafe { - ret(c::waitid( - c::P_PID, - Pid::as_raw(Some(pid)) as _, - status.as_mut_ptr(), - options.bits() as _, - ))? - }; - - Ok(unsafe { cvt_waitid_status(status) }) -} - -#[cfg(target_os = "linux")] -#[inline] -fn _waitid_pidfd(fd: BorrowedFd<'_>, options: WaitidOptions) -> io::Result<Option<WaitidStatus>> { - let mut status = MaybeUninit::<c::siginfo_t>::uninit(); - unsafe { - ret(c::waitid( - c::P_PIDFD, - fd.as_raw_fd() as _, - status.as_mut_ptr(), - options.bits() as _, - ))? - }; - - Ok(unsafe { cvt_waitid_status(status) }) -} - -/// Convert a `siginfo_t` to a `WaitidStatus`. -/// -/// # Safety -/// -/// The caller must ensure that `status` is initialized and that `waitid` -/// returned successfully. -#[cfg(not(any(target_os = "wasi", target_os = "redox", target_os = "openbsd")))] -#[inline] -unsafe fn cvt_waitid_status(status: MaybeUninit<c::siginfo_t>) -> Option<WaitidStatus> { - let status = status.assume_init(); - if status.si_signo == 0 { - None - } else { - Some(WaitidStatus(status)) - } -} - -#[inline] -pub(crate) fn exit_group(code: c::c_int) -> ! { - // `_exit` and `_Exit` are the same; it's just a matter of which ones - // the libc bindings expose. - #[cfg(any(target_os = "wasi", target_os = "solid"))] - unsafe { - c::_Exit(code) - } - #[cfg(unix)] - unsafe { - c::_exit(code) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn setsid() -> io::Result<Pid> { - unsafe { - let pid = ret_c_int(c::setsid())?; - debug_assert_ne!(pid, 0); - Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid))) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn kill_process(pid: Pid, sig: Signal) -> io::Result<()> { - unsafe { ret(c::kill(pid.as_raw_nonzero().get(), sig as i32)) } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn kill_process_group(pid: Pid, sig: Signal) -> io::Result<()> { - unsafe { - ret(c::kill( - pid.as_raw_nonzero().get().wrapping_neg(), - sig as i32, - )) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn kill_current_process_group(sig: Signal) -> io::Result<()> { - unsafe { ret(c::kill(0, sig as i32)) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) unsafe fn prctl( - option: c::c_int, - arg2: *mut c::c_void, - arg3: *mut c::c_void, - arg4: *mut c::c_void, - arg5: *mut c::c_void, -) -> io::Result<c::c_int> { - ret_c_int(c::prctl(option, arg2, arg3, arg4, arg5)) -} - -#[cfg(freebsdlike)] -#[inline] -pub(crate) unsafe fn procctl( - idtype: c::idtype_t, - id: c::id_t, - option: c::c_int, - data: *mut c::c_void, -) -> io::Result<()> { - ret(c::procctl(idtype, id, option, data)) -} - -#[cfg(target_os = "linux")] -pub(crate) fn pidfd_open(pid: Pid, flags: PidfdFlags) -> io::Result<OwnedFd> { - unsafe { - syscall_ret_owned_fd(libc::syscall( - c::SYS_pidfd_open, - pid.as_raw_nonzero().get(), - flags.bits(), - )) - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/process/types.rs b/vendor/rustix-0.37.6/src/backend/libc/process/types.rs deleted file mode 100644 index 203186b20..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/process/types.rs +++ /dev/null @@ -1,335 +0,0 @@ -use super::super::c; - -/// A command for use with [`membarrier`] and [`membarrier_cpu`]. -/// -/// For `MEMBARRIER_CMD_QUERY`, see [`membarrier_query`]. -/// -/// [`membarrier`]: crate::process::membarrier -/// [`membarrier_cpu`]: crate::process::membarrier_cpu -/// [`membarrier_query`]: crate::process::membarrier_query -// TODO: These are not yet exposed through libc, so we define the -// constants ourselves. -#[cfg(any(target_os = "android", target_os = "linux"))] -#[derive(Copy, Clone, Eq, PartialEq, Debug)] -#[repr(u32)] -pub enum MembarrierCommand { - /// `MEMBARRIER_CMD_GLOBAL` - #[doc(alias = "Shared")] - #[doc(alias = "MEMBARRIER_CMD_SHARED")] - Global = 1, - /// `MEMBARRIER_CMD_GLOBAL_EXPEDITED` - GlobalExpedited = 2, - /// `MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED` - RegisterGlobalExpedited = 4, - /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED` - PrivateExpedited = 8, - /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED` - RegisterPrivateExpedited = 16, - /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE` - PrivateExpeditedSyncCore = 32, - /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE` - RegisterPrivateExpeditedSyncCore = 64, - /// `MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10) - PrivateExpeditedRseq = 128, - /// `MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ` (since Linux 5.10) - RegisterPrivateExpeditedRseq = 256, -} - -/// A resource value for use with [`getrlimit`], [`setrlimit`], and -/// [`prlimit`]. -/// -/// [`getrlimit`]: crate::process::getrlimit -/// [`setrlimit`]: crate::process::setrlimit -/// [`prlimit`]: crate::process::prlimit -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(i32)] -pub enum Resource { - /// `RLIMIT_CPU` - Cpu = c::RLIMIT_CPU as c::c_int, - /// `RLIMIT_FSIZE` - Fsize = c::RLIMIT_FSIZE as c::c_int, - /// `RLIMIT_DATA` - Data = c::RLIMIT_DATA as c::c_int, - /// `RLIMIT_STACK` - Stack = c::RLIMIT_STACK as c::c_int, - /// `RLIMIT_CORE` - #[cfg(not(target_os = "haiku"))] - Core = c::RLIMIT_CORE as c::c_int, - /// `RLIMIT_RSS` - #[cfg(not(any(apple, solarish, target_os = "haiku")))] - Rss = c::RLIMIT_RSS as c::c_int, - /// `RLIMIT_NPROC` - #[cfg(not(any(solarish, target_os = "haiku")))] - Nproc = c::RLIMIT_NPROC as c::c_int, - /// `RLIMIT_NOFILE` - Nofile = c::RLIMIT_NOFILE as c::c_int, - /// `RLIMIT_MEMLOCK` - #[cfg(not(any(solarish, target_os = "aix", target_os = "haiku")))] - Memlock = c::RLIMIT_MEMLOCK as c::c_int, - /// `RLIMIT_AS` - #[cfg(not(target_os = "openbsd"))] - As = c::RLIMIT_AS as c::c_int, - /// `RLIMIT_LOCKS` - #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))] - Locks = c::RLIMIT_LOCKS as c::c_int, - /// `RLIMIT_SIGPENDING` - #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))] - Sigpending = c::RLIMIT_SIGPENDING as c::c_int, - /// `RLIMIT_MSGQUEUE` - #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))] - Msgqueue = c::RLIMIT_MSGQUEUE as c::c_int, - /// `RLIMIT_NICE` - #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))] - Nice = c::RLIMIT_NICE as c::c_int, - /// `RLIMIT_RTPRIO` - #[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))] - Rtprio = c::RLIMIT_RTPRIO as c::c_int, - /// `RLIMIT_RTTIME` - #[cfg(not(any( - bsd, - solarish, - target_os = "aix", - target_os = "android", - target_os = "emscripten", - target_os = "haiku", - )))] - Rttime = c::RLIMIT_RTTIME as c::c_int, -} - -#[cfg(apple)] -impl Resource { - /// `RLIMIT_RSS` - #[allow(non_upper_case_globals)] - pub const Rss: Self = Self::As; -} - -/// A signal number for use with [`kill_process`], [`kill_process_group`], -/// and [`kill_current_process_group`]. -/// -/// [`kill_process`]: crate::process::kill_process -/// [`kill_process_group`]: crate::process::kill_process_group -/// [`kill_current_process_group`]: crate::process::kill_current_process_group -#[cfg(not(target_os = "wasi"))] -#[derive(Copy, Clone, Debug, Eq, PartialEq)] -#[repr(i32)] -pub enum Signal { - /// `SIGHUP` - Hup = c::SIGHUP, - /// `SIGINT` - Int = c::SIGINT, - /// `SIGQUIT` - Quit = c::SIGQUIT, - /// `SIGILL` - Ill = c::SIGILL, - /// `SIGTRAP` - Trap = c::SIGTRAP, - /// `SIGABRT`, aka `SIGIOT` - #[doc(alias = "Iot")] - #[doc(alias = "Abrt")] - Abort = c::SIGABRT, - /// `SIGBUS` - Bus = c::SIGBUS, - /// `SIGFPE` - Fpe = c::SIGFPE, - /// `SIGKILL` - Kill = c::SIGKILL, - /// `SIGUSR1` - Usr1 = c::SIGUSR1, - /// `SIGSEGV` - Segv = c::SIGSEGV, - /// `SIGUSR2` - Usr2 = c::SIGUSR2, - /// `SIGPIPE` - Pipe = c::SIGPIPE, - /// `SIGALRM` - #[doc(alias = "Alrm")] - Alarm = c::SIGALRM, - /// `SIGTERM` - Term = c::SIGTERM, - /// `SIGSTKFLT` - #[cfg(not(any( - bsd, - solarish, - target_os = "aix", - target_os = "haiku", - all( - any(target_os = "android", target_os = "linux"), - any( - target_arch = "mips", - target_arch = "mips64", - target_arch = "sparc", - target_arch = "sparc64" - ), - ) - )))] - Stkflt = c::SIGSTKFLT, - /// `SIGCHLD` - #[doc(alias = "Chld")] - Child = c::SIGCHLD, - /// `SIGCONT` - Cont = c::SIGCONT, - /// `SIGSTOP` - Stop = c::SIGSTOP, - /// `SIGTSTP` - Tstp = c::SIGTSTP, - /// `SIGTTIN` - Ttin = c::SIGTTIN, - /// `SIGTTOU` - Ttou = c::SIGTTOU, - /// `SIGURG` - Urg = c::SIGURG, - /// `SIGXCPU` - Xcpu = c::SIGXCPU, - /// `SIGXFSZ` - Xfsz = c::SIGXFSZ, - /// `SIGVTALRM` - #[doc(alias = "Vtalrm")] - Vtalarm = c::SIGVTALRM, - /// `SIGPROF` - Prof = c::SIGPROF, - /// `SIGWINCH` - Winch = c::SIGWINCH, - /// `SIGIO`, aka `SIGPOLL` - #[doc(alias = "Poll")] - #[cfg(not(target_os = "haiku"))] - Io = c::SIGIO, - /// `SIGPWR` - #[cfg(not(any(bsd, target_os = "haiku")))] - #[doc(alias = "Pwr")] - Power = c::SIGPWR, - /// `SIGSYS`, aka `SIGUNUSED` - #[doc(alias = "Unused")] - Sys = c::SIGSYS, - /// `SIGEMT` - #[cfg(bsd)] - Emt = c::SIGEMT, - /// `SIGINFO` - #[cfg(bsd)] - Info = c::SIGINFO, - /// `SIGTHR` - #[cfg(target_os = "freebsd")] - #[doc(alias = "Lwp")] - Thr = c::SIGTHR, - /// `SIGLIBRT` - #[cfg(target_os = "freebsd")] - Librt = c::SIGLIBRT, -} - -#[cfg(not(target_os = "wasi"))] -impl Signal { - /// Convert a raw signal number into a `Signal`, if possible. - pub fn from_raw(sig: i32) -> Option<Self> { - match sig as _ { - c::SIGHUP => Some(Self::Hup), - c::SIGINT => Some(Self::Int), - c::SIGQUIT => Some(Self::Quit), - c::SIGILL => Some(Self::Ill), - c::SIGTRAP => Some(Self::Trap), - c::SIGABRT => Some(Self::Abort), - c::SIGBUS => Some(Self::Bus), - c::SIGFPE => Some(Self::Fpe), - c::SIGKILL => Some(Self::Kill), - c::SIGUSR1 => Some(Self::Usr1), - c::SIGSEGV => Some(Self::Segv), - c::SIGUSR2 => Some(Self::Usr2), - c::SIGPIPE => Some(Self::Pipe), - c::SIGALRM => Some(Self::Alarm), - c::SIGTERM => Some(Self::Term), - #[cfg(not(any( - bsd, - solarish, - target_os = "aix", - target_os = "haiku", - all( - any(target_os = "android", target_os = "linux"), - any( - target_arch = "mips", - target_arch = "mips64", - target_arch = "sparc", - target_arch = "sparc64" - ), - ) - )))] - c::SIGSTKFLT => Some(Self::Stkflt), - c::SIGCHLD => Some(Self::Child), - c::SIGCONT => Some(Self::Cont), - c::SIGSTOP => Some(Self::Stop), - c::SIGTSTP => Some(Self::Tstp), - c::SIGTTIN => Some(Self::Ttin), - c::SIGTTOU => Some(Self::Ttou), - c::SIGURG => Some(Self::Urg), - c::SIGXCPU => Some(Self::Xcpu), - c::SIGXFSZ => Some(Self::Xfsz), - c::SIGVTALRM => Some(Self::Vtalarm), - c::SIGPROF => Some(Self::Prof), - c::SIGWINCH => Some(Self::Winch), - #[cfg(not(target_os = "haiku"))] - c::SIGIO => Some(Self::Io), - #[cfg(not(any(bsd, target_os = "haiku")))] - c::SIGPWR => Some(Self::Power), - c::SIGSYS => Some(Self::Sys), - #[cfg(bsd)] - c::SIGEMT => Some(Self::Emt), - #[cfg(bsd)] - c::SIGINFO => Some(Self::Info), - #[cfg(target_os = "freebsd")] - c::SIGTHR => Some(Self::Thr), - #[cfg(target_os = "freebsd")] - c::SIGLIBRT => Some(Self::Librt), - _ => None, - } - } -} - -pub const EXIT_SUCCESS: c::c_int = c::EXIT_SUCCESS; -pub const EXIT_FAILURE: c::c_int = c::EXIT_FAILURE; -#[cfg(not(target_os = "wasi"))] -pub const EXIT_SIGNALED_SIGABRT: c::c_int = 128 + c::SIGABRT; - -/// A process identifier as a raw integer. -#[cfg(not(target_os = "wasi"))] -pub type RawPid = c::pid_t; -/// A non-zero process identifier as a raw non-zero integer. -#[cfg(not(target_os = "wasi"))] -pub type RawNonZeroPid = core::num::NonZeroI32; -/// A group identifier as a raw integer. -#[cfg(not(target_os = "wasi"))] -pub type RawGid = c::gid_t; -/// A user identifier as a raw integer. -#[cfg(not(target_os = "wasi"))] -pub type RawUid = c::uid_t; -/// A CPU identifier as a raw integer. -#[cfg(any(target_os = "android", target_os = "linux"))] -pub type RawCpuid = u32; -#[cfg(target_os = "freebsd")] -pub type RawId = c::id_t; - -#[cfg(not(target_os = "wasi"))] -pub(crate) type RawUname = c::utsname; - -#[cfg(any( - target_os = "android", - target_os = "dragonfly", - target_os = "fuchsia", - target_os = "linux", -))] -pub(crate) type RawCpuSet = c::cpu_set_t; - -#[cfg(any( - target_os = "android", - target_os = "dragonfly", - target_os = "fuchsia", - target_os = "linux", -))] -#[inline] -pub(crate) fn raw_cpu_set_new() -> RawCpuSet { - let mut set = unsafe { core::mem::zeroed() }; - super::cpu_set::CPU_ZERO(&mut set); - set -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -pub(crate) const CPU_SETSIZE: usize = c::CPU_SETSIZE as usize; -#[cfg(target_os = "dragonfly")] -pub(crate) const CPU_SETSIZE: usize = 256; diff --git a/vendor/rustix-0.37.6/src/backend/libc/process/wait.rs b/vendor/rustix-0.37.6/src/backend/libc/process/wait.rs deleted file mode 100644 index c09ee1002..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/process/wait.rs +++ /dev/null @@ -1,9 +0,0 @@ -use super::super::c; - -pub(crate) use c::{ - WCONTINUED, WEXITSTATUS, WIFCONTINUED, WIFEXITED, WIFSIGNALED, WIFSTOPPED, WNOHANG, WSTOPSIG, - WTERMSIG, WUNTRACED, -}; - -#[cfg(not(any(target_os = "openbsd", target_os = "redox", target_os = "wasi")))] -pub(crate) use c::{WEXITED, WNOWAIT, WSTOPPED}; diff --git a/vendor/rustix-0.37.6/src/backend/libc/rand/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/rand/mod.rs deleted file mode 100644 index 1e0181a99..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/rand/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub(crate) mod syscalls; -pub(crate) mod types; diff --git a/vendor/rustix-0.37.6/src/backend/libc/rand/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/rand/syscalls.rs deleted file mode 100644 index ce1746055..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/rand/syscalls.rs +++ /dev/null @@ -1,16 +0,0 @@ -//! libc syscalls supporting `rustix::rand`. - -#[cfg(any(target_os = "android", target_os = "linux"))] -use {super::super::c, super::super::conv::ret_ssize_t, crate::io, crate::rand::GetRandomFlags}; - -#[cfg(any(target_os = "android", target_os = "linux"))] -pub(crate) fn getrandom(buf: &mut [u8], flags: GetRandomFlags) -> io::Result<usize> { - // `getrandom` wasn't supported in glibc until 2.25. - weak_or_syscall! { - fn getrandom(buf: *mut c::c_void, buflen: c::size_t, flags: c::c_uint) via SYS_getrandom -> c::ssize_t - } - - let nread = - unsafe { ret_ssize_t(getrandom(buf.as_mut_ptr().cast(), buf.len(), flags.bits()))? }; - Ok(nread as usize) -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/rand/types.rs b/vendor/rustix-0.37.6/src/backend/libc/rand/types.rs deleted file mode 100644 index e12bd9cbd..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/rand/types.rs +++ /dev/null @@ -1,19 +0,0 @@ -#[cfg(any(target_os = "android", target_os = "linux"))] -use super::super::c; -#[cfg(any(target_os = "android", target_os = "linux"))] -use bitflags::bitflags; - -#[cfg(any(target_os = "android", target_os = "linux"))] -bitflags! { - /// `GRND_*` flags for use with [`getrandom`]. - /// - /// [`getrandom`]: crate::rand::getrandom - pub struct GetRandomFlags: u32 { - /// `GRND_RANDOM` - const RANDOM = c::GRND_RANDOM; - /// `GRND_NONBLOCK` - const NONBLOCK = c::GRND_NONBLOCK; - /// `GRND_INSECURE` - const INSECURE = c::GRND_INSECURE; - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/termios/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/termios/mod.rs deleted file mode 100644 index c82c95958..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/termios/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -pub(crate) mod syscalls; -#[cfg(not(target_os = "wasi"))] -pub(crate) mod types; diff --git a/vendor/rustix-0.37.6/src/backend/libc/termios/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/termios/syscalls.rs deleted file mode 100644 index 097d368ed..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/termios/syscalls.rs +++ /dev/null @@ -1,211 +0,0 @@ -//! libc syscalls supporting `rustix::termios`. -//! -//! # Safety -//! -//! See the `rustix::backend::syscalls` module documentation for details. - -use super::super::c; -use super::super::conv::{borrowed_fd, ret, ret_pid_t}; -use crate::fd::BorrowedFd; -#[cfg(feature = "procfs")] -#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))] -use crate::ffi::CStr; -#[cfg(not(target_os = "wasi"))] -use crate::io; -#[cfg(not(target_os = "wasi"))] -use crate::process::{Pid, RawNonZeroPid}; -#[cfg(not(target_os = "wasi"))] -use crate::termios::{Action, OptionalActions, QueueSelector, Speed, Termios, Winsize}; -use core::mem::MaybeUninit; - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcgetattr(fd: BorrowedFd<'_>) -> io::Result<Termios> { - let mut result = MaybeUninit::<Termios>::uninit(); - unsafe { - ret(c::tcgetattr(borrowed_fd(fd), result.as_mut_ptr()))?; - Ok(result.assume_init()) - } -} - -#[cfg(all( - any(target_os = "android", target_os = "linux"), - any( - target_arch = "x86", - target_arch = "x86_64", - target_arch = "x32", - target_arch = "riscv64", - target_arch = "aarch64", - target_arch = "arm", - target_arch = "mips", - target_arch = "mips64", - ) -))] -pub(crate) fn tcgetattr2(fd: BorrowedFd<'_>) -> io::Result<crate::termios::Termios2> { - let mut result = MaybeUninit::<crate::termios::Termios2>::uninit(); - unsafe { - ret(c::ioctl(borrowed_fd(fd), c::TCGETS2, result.as_mut_ptr()))?; - Ok(result.assume_init()) - } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcgetpgrp(fd: BorrowedFd<'_>) -> io::Result<Pid> { - unsafe { - let pid = ret_pid_t(c::tcgetpgrp(borrowed_fd(fd)))?; - debug_assert_ne!(pid, 0); - Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid))) - } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcsetpgrp(fd: BorrowedFd<'_>, pid: Pid) -> io::Result<()> { - unsafe { ret(c::tcsetpgrp(borrowed_fd(fd), pid.as_raw_nonzero().get())) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcsetattr( - fd: BorrowedFd, - optional_actions: OptionalActions, - termios: &Termios, -) -> io::Result<()> { - unsafe { - ret(c::tcsetattr( - borrowed_fd(fd), - optional_actions as _, - termios, - )) - } -} - -#[cfg(all( - any(target_os = "android", target_os = "linux"), - any( - target_arch = "x86", - target_arch = "x86_64", - target_arch = "x32", - target_arch = "riscv64", - target_arch = "aarch64", - target_arch = "arm", - target_arch = "mips", - target_arch = "mips64", - ) -))] -pub(crate) fn tcsetattr2( - fd: BorrowedFd, - optional_actions: OptionalActions, - termios: &crate::termios::Termios2, -) -> io::Result<()> { - unsafe { - ret(c::ioctl( - borrowed_fd(fd), - (c::TCSETS2 as u32 + optional_actions as u32) as _, - termios, - )) - } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcsendbreak(fd: BorrowedFd) -> io::Result<()> { - unsafe { ret(c::tcsendbreak(borrowed_fd(fd), 0)) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcdrain(fd: BorrowedFd) -> io::Result<()> { - unsafe { ret(c::tcdrain(borrowed_fd(fd))) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcflush(fd: BorrowedFd, queue_selector: QueueSelector) -> io::Result<()> { - unsafe { ret(c::tcflush(borrowed_fd(fd), queue_selector as _)) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcflow(fd: BorrowedFd, action: Action) -> io::Result<()> { - unsafe { ret(c::tcflow(borrowed_fd(fd), action as _)) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcgetsid(fd: BorrowedFd) -> io::Result<Pid> { - unsafe { - let pid = ret_pid_t(c::tcgetsid(borrowed_fd(fd)))?; - debug_assert_ne!(pid, 0); - Ok(Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(pid))) - } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcsetwinsize(fd: BorrowedFd, winsize: Winsize) -> io::Result<()> { - unsafe { ret(c::ioctl(borrowed_fd(fd), c::TIOCSWINSZ, &winsize)) } -} - -#[cfg(not(target_os = "wasi"))] -pub(crate) fn tcgetwinsize(fd: BorrowedFd) -> io::Result<Winsize> { - unsafe { - let mut buf = MaybeUninit::<Winsize>::uninit(); - ret(c::ioctl( - borrowed_fd(fd), - c::TIOCGWINSZ.into(), - buf.as_mut_ptr(), - ))?; - Ok(buf.assume_init()) - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn cfgetospeed(termios: &Termios) -> Speed { - unsafe { c::cfgetospeed(termios) } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn cfgetispeed(termios: &Termios) -> Speed { - unsafe { c::cfgetispeed(termios) } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn cfmakeraw(termios: &mut Termios) { - unsafe { c::cfmakeraw(termios) } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn cfsetospeed(termios: &mut Termios, speed: Speed) -> io::Result<()> { - unsafe { ret(c::cfsetospeed(termios, speed)) } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn cfsetispeed(termios: &mut Termios, speed: Speed) -> io::Result<()> { - unsafe { ret(c::cfsetispeed(termios, speed)) } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn cfsetspeed(termios: &mut Termios, speed: Speed) -> io::Result<()> { - unsafe { ret(c::cfsetspeed(termios, speed)) } -} - -pub(crate) fn isatty(fd: BorrowedFd<'_>) -> bool { - // Use the return value of `isatty` alone. We don't check `errno` because - // we return `bool` rather than `io::Result<bool>`, because we assume - // `BorrrowedFd` protects us from `EBADF`, and any other reasonably - // anticipated errno value would end up interpreted as "assume it's not a - // terminal" anyway. - unsafe { c::isatty(borrowed_fd(fd)) != 0 } -} - -#[cfg(feature = "procfs")] -#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))] -pub(crate) fn ttyname(dirfd: BorrowedFd<'_>, buf: &mut [u8]) -> io::Result<usize> { - unsafe { - // `ttyname_r` returns its error status rather than using `errno`. - match c::ttyname_r(borrowed_fd(dirfd), buf.as_mut_ptr().cast(), buf.len()) { - 0 => Ok(CStr::from_ptr(buf.as_ptr().cast()).to_bytes().len()), - err => Err(io::Errno::from_raw_os_error(err)), - } - } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/termios/types.rs b/vendor/rustix-0.37.6/src/backend/libc/termios/types.rs deleted file mode 100644 index bbacdbea0..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/termios/types.rs +++ /dev/null @@ -1,780 +0,0 @@ -use super::super::c; - -/// `TCSA*` values for use with [`tcsetattr`]. -/// -/// [`tcsetattr`]: crate::termios::tcsetattr -#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] -#[repr(i32)] -pub enum OptionalActions { - /// `TCSANOW`—Make the change immediately. - #[doc(alias = "TCSANOW")] - Now = c::TCSANOW, - - /// `TCSADRAIN`—Make the change after all output has been transmitted. - #[doc(alias = "TCSADRAIN")] - Drain = c::TCSADRAIN, - - /// `TCSAFLUSH`—Discard any pending input and then make the change - /// after all output has been transmitted. - #[doc(alias = "TCSAFLUSH")] - Flush = c::TCSAFLUSH, -} - -/// `TC*` values for use with [`tcflush`]. -/// -/// [`tcflush`]: crate::termios::tcflush -#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] -#[repr(i32)] -pub enum QueueSelector { - /// `TCIFLUSH`—Flush data received but not read. - #[doc(alias = "TCIFLUSH")] - IFlush = c::TCIFLUSH, - - /// `TCOFLUSH`—Flush data written but not transmitted. - #[doc(alias = "TCOFLUSH")] - OFlush = c::TCOFLUSH, - - /// `TCIOFLUSH`—`IFlush` and `OFlush` combined. - #[doc(alias = "TCIOFLUSH")] - IOFlush = c::TCIOFLUSH, -} - -/// `TC*` values for use with [`tcflow`]. -/// -/// [`tcflow`]: crate::termios::tcflow -#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)] -#[repr(i32)] -pub enum Action { - /// `TCOOFF`—Suspend output. - #[doc(alias = "TCOOFF")] - OOff = c::TCOOFF, - - /// `TCOON`—Restart suspended output. - #[doc(alias = "TCOON")] - OOn = c::TCOON, - - /// `TCIOFF`—Transmits a STOP byte. - #[doc(alias = "TCIOFF")] - IOff = c::TCIOFF, - - /// `TCION`—Transmits a START byte. - #[doc(alias = "TCION")] - IOn = c::TCION, -} - -/// `struct termios` for use with [`tcgetattr`] and [`tcsetattr`]. -/// -/// [`tcgetattr`]: crate::termios::tcgetattr -/// [`tcsetattr`]: crate::termios::tcsetattr -#[doc(alias = "termios")] -pub type Termios = c::termios; - -/// `struct termios2` for use with [`tcgetattr2`] and [`tcsetattr2`]. -/// -/// [`tcgetattr2`]: crate::termios::tcgetattr2 -/// [`tcsetattr2`]: crate::termios::tcsetattr2 -#[cfg(all( - any(target_os = "android", target_os = "linux"), - any( - target_arch = "x86", - target_arch = "x86_64", - target_arch = "x32", - target_arch = "riscv64", - target_arch = "aarch64", - target_arch = "arm", - target_arch = "mips", - target_arch = "mips64", - ) -))] -#[doc(alias = "termios2")] -pub type Termios2 = c::termios2; - -/// `struct winsize` for use with [`tcgetwinsize`]. -/// -/// [`tcgetwinsize`]: crate::termios::tcgetwinsize -#[doc(alias = "winsize")] -pub type Winsize = c::winsize; - -/// `tcflag_t`—A type for the flags fields of [`Termios`]. -#[doc(alias = "tcflag_t")] -pub type Tcflag = c::tcflag_t; - -/// `speed_t`—A return type for [`cfsetspeed`] and similar. -/// -/// [`cfsetspeed`]: crate::termios::cfsetspeed -#[doc(alias = "speed_t")] -pub type Speed = c::speed_t; - -/// `VINTR` -pub const VINTR: usize = c::VINTR as usize; - -/// `VQUIT` -pub const VQUIT: usize = c::VQUIT as usize; - -/// `VERASE` -pub const VERASE: usize = c::VERASE as usize; - -/// `VKILL` -pub const VKILL: usize = c::VKILL as usize; - -/// `VEOF` -pub const VEOF: usize = c::VEOF as usize; - -/// `VTIME` -pub const VTIME: usize = c::VTIME as usize; - -/// `VMIN` -pub const VMIN: usize = c::VMIN as usize; - -/// `VSWTC` -#[cfg(not(any( - apple, - solarish, - target_os = "aix", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "haiku", - target_os = "netbsd", - target_os = "openbsd", -)))] -pub const VSWTC: usize = c::VSWTC as usize; - -/// `VSTART` -pub const VSTART: usize = c::VSTART as usize; - -/// `VSTOP` -pub const VSTOP: usize = c::VSTOP as usize; - -/// `VSUSP` -pub const VSUSP: usize = c::VSUSP as usize; - -/// `VEOL` -pub const VEOL: usize = c::VEOL as usize; - -/// `VREPRINT` -#[cfg(not(target_os = "haiku"))] -pub const VREPRINT: usize = c::VREPRINT as usize; - -/// `VDISCARD` -#[cfg(not(any(target_os = "aix", target_os = "haiku")))] -pub const VDISCARD: usize = c::VDISCARD as usize; - -/// `VWERASE` -#[cfg(not(any(target_os = "aix", target_os = "haiku")))] -pub const VWERASE: usize = c::VWERASE as usize; - -/// `VLNEXT` -#[cfg(not(target_os = "haiku"))] -pub const VLNEXT: usize = c::VLNEXT as usize; - -/// `VEOL2` -pub const VEOL2: usize = c::VEOL2 as usize; - -/// `IGNBRK` -#[cfg(not(apple))] -pub const IGNBRK: c::c_uint = c::IGNBRK; - -/// `BRKINT` -#[cfg(not(apple))] -pub const BRKINT: c::c_uint = c::BRKINT; - -/// `IGNPAR` -#[cfg(not(apple))] -pub const IGNPAR: c::c_uint = c::IGNPAR; - -/// `PARMRK` -#[cfg(not(apple))] -pub const PARMRK: c::c_uint = c::PARMRK; - -/// `INPCK` -#[cfg(not(apple))] -pub const INPCK: c::c_uint = c::INPCK; - -/// `ISTRIP` -#[cfg(not(apple))] -pub const ISTRIP: c::c_uint = c::ISTRIP; - -/// `INLCR` -#[cfg(not(apple))] -pub const INLCR: c::c_uint = c::INLCR; - -/// `IGNCR` -#[cfg(not(apple))] -pub const IGNCR: c::c_uint = c::IGNCR; - -/// `ICRNL` -#[cfg(not(apple))] -pub const ICRNL: c::c_uint = c::ICRNL; - -/// `IUCLC` -#[cfg(any(solarish, target_os = "haiku"))] -pub const IUCLC: c::c_uint = c::IUCLC; - -/// `IXON` -#[cfg(not(apple))] -pub const IXON: c::c_uint = c::IXON; - -/// `IXANY` -#[cfg(not(any(apple, target_os = "redox")))] -pub const IXANY: c::c_uint = c::IXANY; - -/// `IXOFF` -#[cfg(not(apple))] -pub const IXOFF: c::c_uint = c::IXOFF; - -/// `IMAXBEL` -#[cfg(not(any(apple, target_os = "haiku", target_os = "redox")))] -pub const IMAXBEL: c::c_uint = c::IMAXBEL; - -/// `IUTF8` -#[cfg(not(any( - apple, - solarish, - target_os = "aix", - target_os = "dragonfly", - target_os = "emscripten", - target_os = "freebsd", - target_os = "haiku", - target_os = "netbsd", - target_os = "openbsd", - target_os = "redox", -)))] -pub const IUTF8: c::c_uint = c::IUTF8; - -/// `OPOST` -#[cfg(not(apple))] -pub const OPOST: c::c_uint = c::OPOST; - -/// `OLCUC` -#[cfg(not(any( - apple, - target_os = "aix", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "netbsd", - target_os = "redox", -)))] -pub const OLCUC: c::c_uint = c::OLCUC; - -/// `ONLCR` -#[cfg(not(apple))] -pub const ONLCR: c::c_uint = c::ONLCR; - -/// `OCRNL` -#[cfg(not(apple))] -pub const OCRNL: c::c_uint = c::OCRNL; - -/// `ONOCR` -#[cfg(not(apple))] -pub const ONOCR: c::c_uint = c::ONOCR; - -/// `ONLRET` -#[cfg(not(apple))] -pub const ONLRET: c::c_uint = c::ONLRET; - -/// `OFILL` -#[cfg(not(bsd))] -pub const OFILL: c::c_uint = c::OFILL; - -/// `OFDEL` -#[cfg(not(bsd))] -pub const OFDEL: c::c_uint = c::OFDEL; - -/// `NLDLY` -#[cfg(not(any(bsd, solarish, target_os = "redox")))] -pub const NLDLY: c::c_uint = c::NLDLY; - -/// `NL0` -#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))] -pub const NL0: c::c_uint = c::NL0; - -/// `NL1` -#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))] -pub const NL1: c::c_uint = c::NL1; - -/// `CRDLY` -#[cfg(not(any(bsd, solarish, target_os = "redox")))] -pub const CRDLY: c::c_uint = c::CRDLY; - -/// `CR0` -#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))] -pub const CR0: c::c_uint = c::CR0; - -/// `CR1` -#[cfg(not(any( - target_env = "musl", - bsd, - solarish, - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const CR1: c::c_uint = c::CR1; - -/// `CR2` -#[cfg(not(any( - target_env = "musl", - bsd, - solarish, - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const CR2: c::c_uint = c::CR2; - -/// `CR3` -#[cfg(not(any( - target_env = "musl", - bsd, - solarish, - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const CR3: c::c_uint = c::CR3; - -/// `TABDLY` -#[cfg(not(any( - apple, - netbsdlike, - solarish, - target_os = "dragonfly", - target_os = "redox", -)))] -pub const TABDLY: c::c_uint = c::TABDLY; - -/// `TAB0` -#[cfg(not(any( - apple, - netbsdlike, - solarish, - target_os = "dragonfly", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const TAB0: c::c_uint = c::TAB0; - -/// `TAB1` -#[cfg(not(any( - target_env = "musl", - bsd, - solarish, - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const TAB1: c::c_uint = c::TAB1; - -/// `TAB2` -#[cfg(not(any( - target_env = "musl", - bsd, - solarish, - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const TAB2: c::c_uint = c::TAB2; - -/// `TAB3` -#[cfg(not(any( - target_env = "musl", - bsd, - solarish, - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const TAB3: c::c_uint = c::TAB3; - -/// `BSDLY` -#[cfg(not(any(bsd, solarish, target_os = "redox")))] -pub const BSDLY: c::c_uint = c::BSDLY; - -/// `BS0` -#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))] -pub const BS0: c::c_uint = c::BS0; - -/// `BS1` -#[cfg(not(any( - target_env = "musl", - bsd, - solarish, - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const BS1: c::c_uint = c::BS1; - -/// `FFDLY` -#[cfg(not(any(target_env = "musl", bsd, solarish, target_os = "redox")))] -pub const FFDLY: c::c_uint = c::FFDLY; - -/// `FF0` -#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))] -pub const FF0: c::c_uint = c::FF0; - -/// `FF1` -#[cfg(not(any( - target_env = "musl", - bsd, - solarish, - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const FF1: c::c_uint = c::FF1; - -/// `VTDLY` -#[cfg(not(any(target_env = "musl", bsd, solarish, target_os = "redox")))] -pub const VTDLY: c::c_uint = c::VTDLY; - -/// `VT0` -#[cfg(not(any(bsd, solarish, target_os = "fuchsia", target_os = "redox")))] -pub const VT0: c::c_uint = c::VT0; - -/// `VT1` -#[cfg(not(any( - target_env = "musl", - bsd, - solarish, - target_os = "emscripten", - target_os = "fuchsia", - target_os = "redox", -)))] -pub const VT1: c::c_uint = c::VT1; - -/// `B0` -pub const B0: Speed = c::B0; - -/// `B50` -pub const B50: Speed = c::B50; - -/// `B75` -pub const B75: Speed = c::B75; - -/// `B110` -pub const B110: Speed = c::B110; - -/// `B134` -pub const B134: Speed = c::B134; - -/// `B150` -pub const B150: Speed = c::B150; - -/// `B200` -pub const B200: Speed = c::B200; - -/// `B300` -pub const B300: Speed = c::B300; - -/// `B600` -pub const B600: Speed = c::B600; - -/// `B1200` -pub const B1200: Speed = c::B1200; - -/// `B1800` -pub const B1800: Speed = c::B1800; - -/// `B2400` -pub const B2400: Speed = c::B2400; - -/// `B4800` -pub const B4800: Speed = c::B4800; - -/// `B9600` -pub const B9600: Speed = c::B9600; - -/// `B19200` -pub const B19200: Speed = c::B19200; - -/// `B38400` -pub const B38400: Speed = c::B38400; - -/// `B57600` -#[cfg(not(target_os = "aix"))] -pub const B57600: Speed = c::B57600; - -/// `B115200` -#[cfg(not(target_os = "aix"))] -pub const B115200: Speed = c::B115200; - -/// `B230400` -#[cfg(not(target_os = "aix"))] -pub const B230400: Speed = c::B230400; - -/// `B460800` -#[cfg(not(any( - apple, - target_os = "aix", - target_os = "dragonfly", - target_os = "haiku", - target_os = "openbsd" -)))] -pub const B460800: Speed = c::B460800; - -/// `B500000` -#[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))] -pub const B500000: Speed = c::B500000; - -/// `B576000` -#[cfg(not(any(bsd, solarish, target_os = "aix", target_os = "haiku")))] -pub const B576000: Speed = c::B576000; - -/// `B921600` -#[cfg(not(any( - apple, - target_os = "aix", - target_os = "dragonfly", - target_os = "haiku", - target_os = "openbsd" -)))] -pub const B921600: Speed = c::B921600; - -/// `B1000000` -#[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "solaris")))] -pub const B1000000: Speed = c::B1000000; - -/// `B1152000` -#[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "solaris")))] -pub const B1152000: Speed = c::B1152000; - -/// `B1500000` -#[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "solaris")))] -pub const B1500000: Speed = c::B1500000; - -/// `B2000000` -#[cfg(not(any(bsd, target_os = "aix", target_os = "haiku", target_os = "solaris")))] -pub const B2000000: Speed = c::B2000000; - -/// `B2500000` -#[cfg(not(any( - target_arch = "sparc", - target_arch = "sparc64", - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "solaris", -)))] -pub const B2500000: Speed = c::B2500000; - -/// `B3000000` -#[cfg(not(any( - target_arch = "sparc", - target_arch = "sparc64", - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "solaris", -)))] -pub const B3000000: Speed = c::B3000000; - -/// `B3500000` -#[cfg(not(any( - target_arch = "sparc", - target_arch = "sparc64", - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "solaris", -)))] -pub const B3500000: Speed = c::B3500000; - -/// `B4000000` -#[cfg(not(any( - target_arch = "sparc", - target_arch = "sparc64", - bsd, - target_os = "aix", - target_os = "haiku", - target_os = "solaris", -)))] -pub const B4000000: Speed = c::B4000000; - -/// `BOTHER` -#[cfg(any(target_os = "android", target_os = "linux"))] -pub const BOTHER: c::c_uint = c::BOTHER; - -/// `CSIZE` -#[cfg(not(apple))] -pub const CSIZE: c::c_uint = c::CSIZE; - -/// `CS5` -#[cfg(not(apple))] -pub const CS5: c::c_uint = c::CS5; - -/// `CS6` -#[cfg(not(apple))] -pub const CS6: c::c_uint = c::CS6; - -/// `CS7` -#[cfg(not(apple))] -pub const CS7: c::c_uint = c::CS7; - -/// `CS8` -#[cfg(not(apple))] -pub const CS8: c::c_uint = c::CS8; - -/// `CSTOPB` -#[cfg(not(apple))] -pub const CSTOPB: c::c_uint = c::CSTOPB; - -/// `CREAD` -#[cfg(not(apple))] -pub const CREAD: c::c_uint = c::CREAD; - -/// `PARENB` -#[cfg(not(apple))] -pub const PARENB: c::c_uint = c::PARENB; - -/// `PARODD` -#[cfg(not(apple))] -pub const PARODD: c::c_uint = c::PARODD; - -/// `HUPCL` -#[cfg(not(apple))] -pub const HUPCL: c::c_uint = c::HUPCL; - -/// `CLOCAL` -#[cfg(not(apple))] -pub const CLOCAL: c::c_uint = c::CLOCAL; - -/// `ISIG` -#[cfg(not(apple))] -pub const ISIG: c::c_uint = c::ISIG; - -/// `ICANON`—A flag for the `c_lflag` field of [`Termios`] indicating -/// canonical mode. -pub const ICANON: Tcflag = c::ICANON; - -/// `ECHO` -#[cfg(not(apple))] -pub const ECHO: c::c_uint = c::ECHO; - -/// `ECHOE` -#[cfg(not(apple))] -pub const ECHOE: c::c_uint = c::ECHOE; - -/// `ECHOK` -#[cfg(not(apple))] -pub const ECHOK: c::c_uint = c::ECHOK; - -/// `ECHONL` -#[cfg(not(apple))] -pub const ECHONL: c::c_uint = c::ECHONL; - -/// `NOFLSH` -#[cfg(not(apple))] -pub const NOFLSH: c::c_uint = c::NOFLSH; - -/// `TOSTOP` -#[cfg(not(apple))] -pub const TOSTOP: c::c_uint = c::TOSTOP; - -/// `IEXTEN` -#[cfg(not(apple))] -pub const IEXTEN: c::c_uint = c::IEXTEN; - -/// `EXTA` -#[cfg(not(any( - apple, - solarish, - target_os = "emscripten", - target_os = "haiku", - target_os = "redox", -)))] -pub const EXTA: c::c_uint = c::EXTA; - -/// `EXTB` -#[cfg(not(any( - apple, - solarish, - target_os = "emscripten", - target_os = "haiku", - target_os = "redox", -)))] -pub const EXTB: c::c_uint = c::EXTB; - -/// `CBAUD` -#[cfg(not(any(bsd, target_os = "haiku", target_os = "redox")))] -pub const CBAUD: c::c_uint = c::CBAUD; - -/// `CBAUDEX` -#[cfg(not(any( - bsd, - solarish, - target_os = "aix", - target_os = "haiku", - target_os = "redox", -)))] -pub const CBAUDEX: c::c_uint = c::CBAUDEX; - -/// `CIBAUD` -#[cfg(not(any( - target_arch = "powerpc", - target_arch = "powerpc64", - bsd, - target_os = "emscripten", - target_os = "haiku", - target_os = "redox", -)))] -pub const CIBAUD: c::tcflag_t = c::CIBAUD; - -/// `CIBAUD` -// TODO: Upstream this. -#[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))] -pub const CIBAUD: c::tcflag_t = 0o77600000; - -/// `CMSPAR` -#[cfg(not(any( - bsd, - solarish, - target_os = "aix", - target_os = "emscripten", - target_os = "haiku", - target_os = "redox", -)))] -pub const CMSPAR: c::c_uint = c::CMSPAR; - -/// `CRTSCTS` -#[cfg(not(any(apple, target_os = "aix", target_os = "redox")))] -pub const CRTSCTS: c::c_uint = c::CRTSCTS; - -/// `XCASE` -#[cfg(any(target_arch = "s390x", target_os = "haiku"))] -pub const XCASE: c::c_uint = c::XCASE; - -/// `ECHOCTL` -#[cfg(not(any(apple, target_os = "redox")))] -pub const ECHOCTL: c::c_uint = c::ECHOCTL; - -/// `ECHOPRT` -#[cfg(not(any(apple, target_os = "redox")))] -pub const ECHOPRT: c::c_uint = c::ECHOPRT; - -/// `ECHOKE` -#[cfg(not(any(apple, target_os = "redox")))] -pub const ECHOKE: c::c_uint = c::ECHOKE; - -/// `FLUSHO` -#[cfg(not(any(apple, target_os = "redox")))] -pub const FLUSHO: c::c_uint = c::FLUSHO; - -/// `PENDIN` -#[cfg(not(any(apple, target_os = "redox")))] -pub const PENDIN: c::c_uint = c::PENDIN; - -/// `EXTPROC` -#[cfg(not(any(apple, target_os = "aix", target_os = "haiku", target_os = "redox")))] -pub const EXTPROC: c::c_uint = c::EXTPROC; - -/// `XTABS` -#[cfg(not(any( - bsd, - solarish, - target_os = "aix", - target_os = "haiku", - target_os = "redox", -)))] -pub const XTABS: c::c_uint = c::XTABS; diff --git a/vendor/rustix-0.37.6/src/backend/libc/thread/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/thread/mod.rs deleted file mode 100644 index 40e0d1135..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/thread/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -#[cfg(not(windows))] -pub(crate) mod syscalls; diff --git a/vendor/rustix-0.37.6/src/backend/libc/thread/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/thread/syscalls.rs deleted file mode 100644 index adf4bb700..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/thread/syscalls.rs +++ /dev/null @@ -1,363 +0,0 @@ -//! libc syscalls supporting `rustix::thread`. - -use super::super::c; -use super::super::conv::ret; -#[cfg(any(target_os = "android", target_os = "linux"))] -use super::super::conv::{borrowed_fd, ret_c_int, syscall_ret}; -use super::super::time::types::LibcTimespec; -#[cfg(any(target_os = "android", target_os = "linux"))] -use crate::fd::BorrowedFd; -use crate::io; -#[cfg(any(target_os = "android", target_os = "linux"))] -use crate::process::{Pid, RawNonZeroPid}; -#[cfg(not(target_os = "redox"))] -use crate::thread::{NanosleepRelativeResult, Timespec}; -use core::mem::MaybeUninit; -#[cfg(not(any( - apple, - freebsdlike, - target_os = "emscripten", - target_os = "haiku", - target_os = "openbsd", - target_os = "redox", - target_os = "wasi", -)))] -use {crate::thread::ClockId, core::ptr::null_mut}; - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -weak!(fn __clock_nanosleep_time64(c::clockid_t, c::c_int, *const LibcTimespec, *mut LibcTimespec) -> c::c_int); -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -weak!(fn __nanosleep64(*const LibcTimespec, *mut LibcTimespec) -> c::c_int); - -#[cfg(not(any( - apple, - target_os = "dragonfly", - target_os = "emscripten", - target_os = "freebsd", // FreeBSD 12 has clock_nanosleep, but libc targets FreeBSD 11. - target_os = "haiku", - target_os = "openbsd", - target_os = "redox", - target_os = "wasi", -)))] -#[inline] -pub(crate) fn clock_nanosleep_relative(id: ClockId, request: &Timespec) -> NanosleepRelativeResult { - let mut remain = MaybeUninit::<LibcTimespec>::uninit(); - let flags = 0; - - // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe by - // default. - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - unsafe { - if let Some(libc_clock_nanosleep) = __clock_nanosleep_time64.get() { - match libc_clock_nanosleep( - id as c::clockid_t, - flags, - &request.clone().into(), - remain.as_mut_ptr(), - ) { - 0 => NanosleepRelativeResult::Ok, - err if err == io::Errno::INTR.0 => { - NanosleepRelativeResult::Interrupted(remain.assume_init().into()) - } - err => NanosleepRelativeResult::Err(io::Errno(err)), - } - } else { - clock_nanosleep_relative_old(id, request) - } - } - - // Main version: libc is y2038 safe and has `clock_nanosleep`. - #[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - )))] - unsafe { - match c::clock_nanosleep(id as c::clockid_t, flags, request, remain.as_mut_ptr()) { - 0 => NanosleepRelativeResult::Ok, - err if err == io::Errno::INTR.0 => { - NanosleepRelativeResult::Interrupted(remain.assume_init()) - } - err => NanosleepRelativeResult::Err(io::Errno(err)), - } - } -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -unsafe fn clock_nanosleep_relative_old(id: ClockId, request: &Timespec) -> NanosleepRelativeResult { - use core::convert::TryInto; - let tv_sec = match request.tv_sec.try_into() { - Ok(tv_sec) => tv_sec, - Err(_) => return NanosleepRelativeResult::Err(io::Errno::OVERFLOW), - }; - let tv_nsec = match request.tv_nsec.try_into() { - Ok(tv_nsec) => tv_nsec, - Err(_) => return NanosleepRelativeResult::Err(io::Errno::INVAL), - }; - let old_request = c::timespec { tv_sec, tv_nsec }; - let mut old_remain = MaybeUninit::<c::timespec>::uninit(); - let flags = 0; - - match c::clock_nanosleep( - id as c::clockid_t, - flags, - &old_request, - old_remain.as_mut_ptr(), - ) { - 0 => NanosleepRelativeResult::Ok, - err if err == io::Errno::INTR.0 => { - let old_remain = old_remain.assume_init(); - let remain = Timespec { - tv_sec: old_remain.tv_sec.into(), - tv_nsec: old_remain.tv_nsec.into(), - }; - NanosleepRelativeResult::Interrupted(remain) - } - err => NanosleepRelativeResult::Err(io::Errno(err)), - } -} - -#[cfg(not(any( - apple, - target_os = "dragonfly", - target_os = "emscripten", - target_os = "freebsd", // FreeBSD 12 has clock_nanosleep, but libc targets FreeBSD 11. - target_os = "haiku", - target_os = "openbsd", - target_os = "redox", - target_os = "wasi", -)))] -#[inline] -pub(crate) fn clock_nanosleep_absolute(id: ClockId, request: &Timespec) -> io::Result<()> { - let flags = c::TIMER_ABSTIME; - - // 32-bit gnu version: libc has `clock_nanosleep` but it is not y2038 safe by - // default. - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - { - if let Some(libc_clock_nanosleep) = __clock_nanosleep_time64.get() { - match unsafe { - libc_clock_nanosleep( - id as c::clockid_t, - flags, - &request.clone().into(), - null_mut(), - ) - } { - 0 => Ok(()), - err => Err(io::Errno(err)), - } - } else { - clock_nanosleep_absolute_old(id, request) - } - } - - // Main version: libc is y2038 safe and has `clock_nanosleep`. - #[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - )))] - match unsafe { c::clock_nanosleep(id as c::clockid_t, flags, request, null_mut()) } { - 0 => Ok(()), - err => Err(io::Errno(err)), - } -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -fn clock_nanosleep_absolute_old(id: ClockId, request: &Timespec) -> io::Result<()> { - use core::convert::TryInto; - - let flags = c::TIMER_ABSTIME; - - let old_request = c::timespec { - tv_sec: request.tv_sec.try_into().map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: request.tv_nsec.try_into().map_err(|_| io::Errno::INVAL)?, - }; - match unsafe { c::clock_nanosleep(id as c::clockid_t, flags, &old_request, null_mut()) } { - 0 => Ok(()), - err => Err(io::Errno(err)), - } -} - -#[cfg(not(target_os = "redox"))] -#[inline] -pub(crate) fn nanosleep(request: &Timespec) -> NanosleepRelativeResult { - let mut remain = MaybeUninit::<LibcTimespec>::uninit(); - - // 32-bit gnu version: libc has `nanosleep` but it is not y2038 safe by - // default. - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - unsafe { - if let Some(libc_nanosleep) = __nanosleep64.get() { - match ret(libc_nanosleep(&request.clone().into(), remain.as_mut_ptr())) { - Ok(()) => NanosleepRelativeResult::Ok, - Err(io::Errno::INTR) => { - NanosleepRelativeResult::Interrupted(remain.assume_init().into()) - } - Err(err) => NanosleepRelativeResult::Err(err), - } - } else { - nanosleep_old(request) - } - } - - // Main version: libc is y2038 safe and has `nanosleep`. - #[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - )))] - unsafe { - match ret(c::nanosleep(request, remain.as_mut_ptr())) { - Ok(()) => NanosleepRelativeResult::Ok, - Err(io::Errno::INTR) => NanosleepRelativeResult::Interrupted(remain.assume_init()), - Err(err) => NanosleepRelativeResult::Err(err), - } - } -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -unsafe fn nanosleep_old(request: &Timespec) -> NanosleepRelativeResult { - use core::convert::TryInto; - let tv_sec = match request.tv_sec.try_into() { - Ok(tv_sec) => tv_sec, - Err(_) => return NanosleepRelativeResult::Err(io::Errno::OVERFLOW), - }; - let tv_nsec = match request.tv_nsec.try_into() { - Ok(tv_nsec) => tv_nsec, - Err(_) => return NanosleepRelativeResult::Err(io::Errno::INVAL), - }; - let old_request = c::timespec { tv_sec, tv_nsec }; - let mut old_remain = MaybeUninit::<c::timespec>::uninit(); - - match ret(c::nanosleep(&old_request, old_remain.as_mut_ptr())) { - Ok(()) => NanosleepRelativeResult::Ok, - Err(io::Errno::INTR) => { - let old_remain = old_remain.assume_init(); - let remain = Timespec { - tv_sec: old_remain.tv_sec.into(), - tv_nsec: old_remain.tv_nsec.into(), - }; - NanosleepRelativeResult::Interrupted(remain) - } - Err(err) => NanosleepRelativeResult::Err(err), - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -#[must_use] -pub(crate) fn gettid() -> Pid { - // `gettid` wasn't supported in glibc until 2.30, and musl until 1.2.2, - // so use `syscall`. - // <https://sourceware.org/bugzilla/show_bug.cgi?id=6399#c62> - weak_or_syscall! { - fn gettid() via SYS_gettid -> c::pid_t - } - - unsafe { - let tid = gettid(); - debug_assert_ne!(tid, 0); - Pid::from_raw_nonzero(RawNonZeroPid::new_unchecked(tid)) - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn setns(fd: BorrowedFd, nstype: c::c_int) -> io::Result<c::c_int> { - // `setns` wasn't supported in glibc until 2.14, and musl until 0.9.5, - // so use `syscall`. - weak_or_syscall! { - fn setns(fd: c::c_int, nstype: c::c_int) via SYS_setns -> c::c_int - } - - unsafe { ret_c_int(setns(borrowed_fd(fd), nstype)) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn unshare(flags: crate::thread::UnshareFlags) -> io::Result<()> { - unsafe { ret(c::unshare(flags.bits() as i32)) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn capget( - header: &mut linux_raw_sys::general::__user_cap_header_struct, - data: &mut [MaybeUninit<linux_raw_sys::general::__user_cap_data_struct>], -) -> io::Result<()> { - let header: *mut _ = header; - unsafe { syscall_ret(c::syscall(c::SYS_capget, header, data.as_mut_ptr())) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn capset( - header: &mut linux_raw_sys::general::__user_cap_header_struct, - data: &[linux_raw_sys::general::__user_cap_data_struct], -) -> io::Result<()> { - let header: *mut _ = header; - unsafe { syscall_ret(c::syscall(c::SYS_capset, header, data.as_ptr())) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn setuid_thread(uid: crate::process::Uid) -> io::Result<()> { - unsafe { syscall_ret(c::syscall(c::SYS_setuid, uid.as_raw())) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn setresuid_thread( - ruid: crate::process::Uid, - euid: crate::process::Uid, - suid: crate::process::Uid, -) -> io::Result<()> { - #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))] - const SYS: c::c_long = c::SYS_setresuid32 as c::c_long; - #[cfg(not(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc")))] - const SYS: c::c_long = c::SYS_setresuid as c::c_long; - unsafe { syscall_ret(c::syscall(SYS, ruid.as_raw(), euid.as_raw(), suid.as_raw())) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn setgid_thread(gid: crate::process::Gid) -> io::Result<()> { - unsafe { syscall_ret(c::syscall(c::SYS_setgid, gid.as_raw())) } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[inline] -pub(crate) fn setresgid_thread( - rgid: crate::process::Gid, - egid: crate::process::Gid, - sgid: crate::process::Gid, -) -> io::Result<()> { - #[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc"))] - const SYS: c::c_long = c::SYS_setresgid32 as c::c_long; - #[cfg(not(any(target_arch = "x86", target_arch = "arm", target_arch = "sparc")))] - const SYS: c::c_long = c::SYS_setresgid as c::c_long; - unsafe { syscall_ret(c::syscall(SYS, rgid.as_raw(), egid.as_raw(), sgid.as_raw())) } -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/time/mod.rs b/vendor/rustix-0.37.6/src/backend/libc/time/mod.rs deleted file mode 100644 index bff7fd564..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/time/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -#[cfg(not(windows))] -pub(crate) mod syscalls; -pub(crate) mod types; diff --git a/vendor/rustix-0.37.6/src/backend/libc/time/syscalls.rs b/vendor/rustix-0.37.6/src/backend/libc/time/syscalls.rs deleted file mode 100644 index 9d341d886..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/time/syscalls.rs +++ /dev/null @@ -1,472 +0,0 @@ -//! libc syscalls supporting `rustix::time`. - -use super::super::c; -use super::super::conv::ret; -#[cfg(feature = "time")] -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -use super::super::time::types::LibcItimerspec; -use super::super::time::types::LibcTimespec; -use super::types::Timespec; -#[cfg(not(target_os = "wasi"))] -use super::types::{ClockId, DynamicClockId}; -use crate::io; -use core::mem::MaybeUninit; -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(feature = "time")] -use { - super::super::conv::{borrowed_fd, ret_owned_fd}, - crate::fd::{BorrowedFd, OwnedFd}, - crate::time::{Itimerspec, TimerfdClockId, TimerfdFlags, TimerfdTimerFlags}, -}; - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -weak!(fn __clock_gettime64(c::clockid_t, *mut LibcTimespec) -> c::c_int); -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -weak!(fn __clock_settime64(c::clockid_t, *const LibcTimespec) -> c::c_int); -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -weak!(fn __clock_getres64(c::clockid_t, *mut LibcTimespec) -> c::c_int); -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[cfg(feature = "time")] -weak!(fn __timerfd_gettime64(c::c_int, *mut LibcItimerspec) -> c::c_int); -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[cfg(feature = "time")] -weak!(fn __timerfd_settime64(c::c_int, c::c_int, *const LibcItimerspec, *mut LibcItimerspec) -> c::c_int); - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[inline] -#[must_use] -pub(crate) fn clock_getres(id: ClockId) -> Timespec { - let mut timespec = MaybeUninit::<LibcTimespec>::uninit(); - - // 32-bit gnu version: libc has `clock_getres` but it is not y2038 safe by - // default. - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - unsafe { - if let Some(libc_clock_getres) = __clock_getres64.get() { - ret(libc_clock_getres(id as c::clockid_t, timespec.as_mut_ptr())).unwrap(); - timespec.assume_init().into() - } else { - clock_getres_old(id) - } - } - - // Main version: libc is y2038 safe and has `clock_getres`. - #[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - )))] - unsafe { - let _ = c::clock_getres(id as c::clockid_t, timespec.as_mut_ptr()); - timespec.assume_init() - } -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[must_use] -unsafe fn clock_getres_old(id: ClockId) -> Timespec { - let mut old_timespec = MaybeUninit::<c::timespec>::uninit(); - ret(c::clock_getres( - id as c::clockid_t, - old_timespec.as_mut_ptr(), - )) - .unwrap(); - let old_timespec = old_timespec.assume_init(); - Timespec { - tv_sec: old_timespec.tv_sec.into(), - tv_nsec: old_timespec.tv_nsec.into(), - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn clock_gettime(id: ClockId) -> Timespec { - let mut timespec = MaybeUninit::<LibcTimespec>::uninit(); - - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - unsafe { - if let Some(libc_clock_gettime) = __clock_gettime64.get() { - ret(libc_clock_gettime( - id as c::clockid_t, - timespec.as_mut_ptr(), - )) - .unwrap(); - timespec.assume_init().into() - } else { - clock_gettime_old(id) - } - } - - // Use `unwrap()` here because `clock_getres` can fail if the clock itself - // overflows a number of seconds, but if that happens, the monotonic clocks - // can't maintain their invariants, or the realtime clocks aren't properly - // configured. - #[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - )))] - unsafe { - ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr())).unwrap(); - timespec.assume_init() - } -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[must_use] -unsafe fn clock_gettime_old(id: ClockId) -> Timespec { - let mut old_timespec = MaybeUninit::<c::timespec>::uninit(); - ret(c::clock_gettime( - id as c::clockid_t, - old_timespec.as_mut_ptr(), - )) - .unwrap(); - let old_timespec = old_timespec.assume_init(); - Timespec { - tv_sec: old_timespec.tv_sec.into(), - tv_nsec: old_timespec.tv_nsec.into(), - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn clock_gettime_dynamic(id: DynamicClockId<'_>) -> io::Result<Timespec> { - let mut timespec = MaybeUninit::<LibcTimespec>::uninit(); - unsafe { - let id: c::clockid_t = match id { - DynamicClockId::Known(id) => id as c::clockid_t, - - #[cfg(any(target_os = "android", target_os = "linux"))] - DynamicClockId::Dynamic(fd) => { - use crate::fd::AsRawFd; - const CLOCKFD: i32 = 3; - (!fd.as_raw_fd() << 3) | CLOCKFD - } - - #[cfg(not(any(target_os = "android", target_os = "linux")))] - DynamicClockId::Dynamic(_fd) => { - // Dynamic clocks are not supported on this platform. - return Err(io::Errno::INVAL); - } - - #[cfg(any(target_os = "android", target_os = "linux"))] - DynamicClockId::RealtimeAlarm => c::CLOCK_REALTIME_ALARM, - - #[cfg(any(target_os = "android", target_os = "linux"))] - DynamicClockId::Tai => c::CLOCK_TAI, - - #[cfg(any(target_os = "android", target_os = "linux"))] - DynamicClockId::Boottime => c::CLOCK_BOOTTIME, - - #[cfg(any(target_os = "android", target_os = "linux"))] - DynamicClockId::BoottimeAlarm => c::CLOCK_BOOTTIME_ALARM, - }; - - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - { - if let Some(libc_clock_gettime) = __clock_gettime64.get() { - ret(libc_clock_gettime( - id as c::clockid_t, - timespec.as_mut_ptr(), - ))?; - - Ok(timespec.assume_init().into()) - } else { - clock_gettime_dynamic_old(id) - } - } - - #[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - )))] - { - ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr()))?; - - Ok(timespec.assume_init()) - } - } -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[inline] -unsafe fn clock_gettime_dynamic_old(id: c::clockid_t) -> io::Result<Timespec> { - let mut old_timespec = MaybeUninit::<c::timespec>::uninit(); - - ret(c::clock_gettime( - id as c::clockid_t, - old_timespec.as_mut_ptr(), - ))?; - - let old_timespec = old_timespec.assume_init(); - Ok(Timespec { - tv_sec: old_timespec.tv_sec.into(), - tv_nsec: old_timespec.tv_nsec.into(), - }) -} - -#[cfg(not(any( - target_os = "redox", - target_os = "wasi", - all(apple, not(target_os = "macos")) -)))] -#[inline] -pub(crate) fn clock_settime(id: ClockId, timespec: Timespec) -> io::Result<()> { - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - unsafe { - if let Some(libc_clock_settime) = __clock_settime64.get() { - let mut new_timespec = core::mem::zeroed::<LibcTimespec>(); - new_timespec.tv_sec = timespec.tv_sec; - new_timespec.tv_nsec = timespec.tv_nsec as _; - ret(libc_clock_settime(id as c::clockid_t, &new_timespec)) - } else { - clock_settime_old(id, timespec) - } - } - - #[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - )))] - unsafe { - ret(c::clock_settime(id as c::clockid_t, ×pec)) - } -} - -#[cfg(not(any( - target_os = "redox", - target_os = "wasi", - all(apple, not(target_os = "macos")) -)))] -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[must_use] -unsafe fn clock_settime_old(id: ClockId, timespec: Timespec) -> io::Result<()> { - use core::convert::TryInto; - let old_timespec = c::timespec { - tv_sec: timespec - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: timespec.tv_nsec as _, - }; - ret(c::clock_settime(id as c::clockid_t, &old_timespec)) -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(feature = "time")] -pub(crate) fn timerfd_create(id: TimerfdClockId, flags: TimerfdFlags) -> io::Result<OwnedFd> { - unsafe { ret_owned_fd(c::timerfd_create(id as c::clockid_t, flags.bits())) } -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(feature = "time")] -pub(crate) fn timerfd_settime( - fd: BorrowedFd<'_>, - flags: TimerfdTimerFlags, - new_value: &Itimerspec, -) -> io::Result<Itimerspec> { - let mut result = MaybeUninit::<LibcItimerspec>::uninit(); - - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - unsafe { - if let Some(libc_timerfd_settime) = __timerfd_settime64.get() { - ret(libc_timerfd_settime( - borrowed_fd(fd), - flags.bits(), - &new_value.clone().into(), - result.as_mut_ptr(), - ))?; - Ok(result.assume_init().into()) - } else { - timerfd_settime_old(fd, flags, new_value) - } - } - - #[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - )))] - unsafe { - ret(c::timerfd_settime( - borrowed_fd(fd), - flags.bits(), - new_value, - result.as_mut_ptr(), - ))?; - Ok(result.assume_init()) - } -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[cfg(feature = "time")] -unsafe fn timerfd_settime_old( - fd: BorrowedFd<'_>, - flags: TimerfdTimerFlags, - new_value: &Itimerspec, -) -> io::Result<Itimerspec> { - use core::convert::TryInto; - - let mut old_result = MaybeUninit::<c::itimerspec>::uninit(); - - // Convert `new_value` to the old `itimerspec` format. - let old_new_value = c::itimerspec { - it_interval: c::timespec { - tv_sec: new_value - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: new_value - .it_interval - .tv_nsec - .try_into() - .map_err(|_| io::Errno::INVAL)?, - }, - it_value: c::timespec { - tv_sec: new_value - .it_value - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: new_value - .it_value - .tv_nsec - .try_into() - .map_err(|_| io::Errno::INVAL)?, - }, - }; - - ret(c::timerfd_settime( - borrowed_fd(fd), - flags.bits(), - &old_new_value, - old_result.as_mut_ptr(), - ))?; - - let old_result = old_result.assume_init(); - Ok(Itimerspec { - it_interval: Timespec { - tv_sec: old_result - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: old_result.it_interval.tv_nsec as _, - }, - it_value: Timespec { - tv_sec: old_result - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: old_result.it_interval.tv_nsec as _, - }, - }) -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(feature = "time")] -pub(crate) fn timerfd_gettime(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> { - let mut result = MaybeUninit::<LibcItimerspec>::uninit(); - - #[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - ))] - unsafe { - if let Some(libc_timerfd_gettime) = __timerfd_gettime64.get() { - ret(libc_timerfd_gettime(borrowed_fd(fd), result.as_mut_ptr()))?; - Ok(result.assume_init().into()) - } else { - timerfd_gettime_old(fd) - } - } - - #[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", - )))] - unsafe { - ret(c::timerfd_gettime(borrowed_fd(fd), result.as_mut_ptr()))?; - Ok(result.assume_init()) - } -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[cfg(feature = "time")] -unsafe fn timerfd_gettime_old(fd: BorrowedFd<'_>) -> io::Result<Itimerspec> { - use core::convert::TryInto; - - let mut old_result = MaybeUninit::<c::itimerspec>::uninit(); - - ret(c::timerfd_gettime(borrowed_fd(fd), old_result.as_mut_ptr()))?; - - let old_result = old_result.assume_init(); - Ok(Itimerspec { - it_interval: Timespec { - tv_sec: old_result - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: old_result.it_interval.tv_nsec as _, - }, - it_value: Timespec { - tv_sec: old_result - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: old_result.it_interval.tv_nsec as _, - }, - }) -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/time/types.rs b/vendor/rustix-0.37.6/src/backend/libc/time/types.rs deleted file mode 100644 index 47cd85701..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/time/types.rs +++ /dev/null @@ -1,356 +0,0 @@ -use super::super::c; -#[cfg(not(target_os = "wasi"))] -use crate::fd::BorrowedFd; -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -use bitflags::bitflags; - -/// `struct timespec` -#[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -)))] -pub type Timespec = c::timespec; - -/// `struct timespec` -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[derive(Debug, Clone, Copy)] -#[repr(C)] -pub struct Timespec { - /// Seconds. - pub tv_sec: Secs, - - /// Nanoseconds. Must be less than 1_000_000_000. - pub tv_nsec: Nsecs, -} - -/// A type for the `tv_sec` field of [`Timespec`]. -#[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -)))] -#[allow(deprecated)] -pub type Secs = c::time_t; - -/// A type for the `tv_sec` field of [`Timespec`]. -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -pub type Secs = i64; - -/// A type for the `tv_nsec` field of [`Timespec`]. -#[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] -pub type Nsecs = i64; - -/// A type for the `tv_nsec` field of [`Timespec`]. -#[cfg(not(all(target_arch = "x86_64", target_pointer_width = "32")))] -pub type Nsecs = c::c_long; - -/// On most platforms, `LibcTimespec` is just `Timespec`. -#[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -)))] -pub(crate) type LibcTimespec = Timespec; - -/// On 32-bit glibc platforms, `timespec` has anonymous padding fields, which -/// Rust doesn't support yet (see `unnamed_fields`), so we define our own -/// struct with explicit padding, with bidirectional `From` impls. -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[repr(C)] -#[derive(Debug, Clone)] -pub(crate) struct LibcTimespec { - pub(crate) tv_sec: Secs, - - #[cfg(target_endian = "big")] - padding: core::mem::MaybeUninit<u32>, - - pub(crate) tv_nsec: Nsecs, - - #[cfg(target_endian = "little")] - padding: core::mem::MaybeUninit<u32>, -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -impl From<LibcTimespec> for Timespec { - #[inline] - fn from(t: LibcTimespec) -> Self { - Self { - tv_sec: t.tv_sec, - tv_nsec: t.tv_nsec, - } - } -} - -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -impl From<Timespec> for LibcTimespec { - #[inline] - fn from(t: Timespec) -> Self { - Self { - tv_sec: t.tv_sec, - tv_nsec: t.tv_nsec, - padding: core::mem::MaybeUninit::uninit(), - } - } -} - -/// `CLOCK_*` constants for use with [`clock_gettime`]. -/// -/// These constants are always supported at runtime so `clock_gettime` never -/// has to fail with `INVAL` due to an unsupported clock. See -/// [`DynamicClockId`] for a greater set of clocks, with the caveat that not -/// all of them are always supported. -/// -/// [`clock_gettime`]: crate::time::clock_gettime -#[cfg(not(any(apple, target_os = "wasi")))] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -#[cfg_attr(not(target_os = "dragonfly"), repr(i32))] -#[cfg_attr(target_os = "dragonfly", repr(u64))] -#[non_exhaustive] -pub enum ClockId { - /// `CLOCK_REALTIME` - Realtime = c::CLOCK_REALTIME, - - /// `CLOCK_MONOTONIC` - Monotonic = c::CLOCK_MONOTONIC, - - /// `CLOCK_UPTIME` - #[cfg(any(freebsdlike))] - Uptime = c::CLOCK_UPTIME, - - /// `CLOCK_PROCESS_CPUTIME_ID` - #[cfg(not(any(netbsdlike, solarish, target_os = "redox")))] - ProcessCPUTime = c::CLOCK_PROCESS_CPUTIME_ID, - - /// `CLOCK_THREAD_CPUTIME_ID` - #[cfg(not(any(netbsdlike, solarish, target_os = "redox")))] - ThreadCPUTime = c::CLOCK_THREAD_CPUTIME_ID, - - /// `CLOCK_REALTIME_COARSE` - #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))] - RealtimeCoarse = c::CLOCK_REALTIME_COARSE, - - /// `CLOCK_MONOTONIC_COARSE` - #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))] - MonotonicCoarse = c::CLOCK_MONOTONIC_COARSE, - - /// `CLOCK_MONOTONIC_RAW` - #[cfg(any(target_os = "android", target_os = "linux"))] - MonotonicRaw = c::CLOCK_MONOTONIC_RAW, -} - -/// `CLOCK_*` constants for use with [`clock_gettime`]. -/// -/// These constants are always supported at runtime so `clock_gettime` never -/// has to fail with `INVAL` due to an unsupported clock. See -/// [`DynamicClockId`] for a greater set of clocks, with the caveat that not -/// all of them are always supported. -#[cfg(apple)] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -#[repr(u32)] -#[non_exhaustive] -pub enum ClockId { - /// `CLOCK_REALTIME` - Realtime = c::CLOCK_REALTIME, - - /// `CLOCK_MONOTONIC` - Monotonic = c::CLOCK_MONOTONIC, - - /// `CLOCK_PROCESS_CPUTIME_ID` - ProcessCPUTime = c::CLOCK_PROCESS_CPUTIME_ID, - - /// `CLOCK_THREAD_CPUTIME_ID` - ThreadCPUTime = c::CLOCK_THREAD_CPUTIME_ID, -} - -/// `CLOCK_*` constants for use with [`clock_gettime_dynamic`]. -/// -/// These constants may be unsupported at runtime, depending on the OS version, -/// and `clock_gettime_dynamic` may fail with `INVAL`. See [`ClockId`] for -/// clocks which are always supported at runtime. -/// -/// [`clock_gettime_dynamic`]: crate::time::clock_gettime_dynamic -#[cfg(not(target_os = "wasi"))] -#[derive(Debug, Copy, Clone)] -#[non_exhaustive] -pub enum DynamicClockId<'a> { - /// `ClockId` values that are always supported at runtime. - Known(ClockId), - - /// Linux dynamic clocks. - Dynamic(BorrowedFd<'a>), - - /// `CLOCK_REALTIME_ALARM`, available on Linux >= 3.0 - #[cfg(any(target_os = "android", target_os = "linux"))] - RealtimeAlarm, - - /// `CLOCK_TAI`, available on Linux >= 3.10 - #[cfg(any(target_os = "android", target_os = "linux"))] - Tai, - - /// `CLOCK_BOOTTIME`, available on Linux >= 2.6.39 - #[cfg(any(target_os = "android", target_os = "linux"))] - Boottime, - - /// `CLOCK_BOOTTIME_ALARM`, available on Linux >= 2.6.39 - #[cfg(any(target_os = "android", target_os = "linux"))] - BoottimeAlarm, -} - -/// `struct itimerspec` -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -)))] -pub type Itimerspec = c::itimerspec; - -/// `struct itimerspec` -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[allow(missing_docs)] -#[repr(C)] -#[derive(Debug, Clone)] -pub struct Itimerspec { - pub it_interval: Timespec, - pub it_value: Timespec, -} - -/// On most platforms, `LibcItimerspec` is just `Itimerspec`. -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(not(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -)))] -pub(crate) type LibcItimerspec = Itimerspec; - -/// On 32-bit glibc platforms, `LibcTimespec` differs from `Timespec`, so we -/// define our own struct, with bidirectional `From` impls. -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -#[repr(C)] -#[derive(Debug, Clone)] -pub(crate) struct LibcItimerspec { - pub it_interval: LibcTimespec, - pub it_value: LibcTimespec, -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -impl From<LibcItimerspec> for Itimerspec { - #[inline] - fn from(t: LibcItimerspec) -> Self { - Self { - it_interval: t.it_interval.into(), - it_value: t.it_value.into(), - } - } -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[cfg(all( - any(target_arch = "arm", target_arch = "mips", target_arch = "x86"), - target_env = "gnu", -))] -impl From<Itimerspec> for LibcItimerspec { - #[inline] - fn from(t: Itimerspec) -> Self { - Self { - it_interval: t.it_interval.into(), - it_value: t.it_value.into(), - } - } -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -bitflags! { - /// `TFD_*` flags for use with [`timerfd_create`]. - pub struct TimerfdFlags: c::c_int { - /// `TFD_NONBLOCK` - const NONBLOCK = c::TFD_NONBLOCK; - - /// `TFD_CLOEXEC` - const CLOEXEC = c::TFD_CLOEXEC; - } -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -bitflags! { - /// `TFD_TIMER_*` flags for use with [`timerfd_settime`]. - pub struct TimerfdTimerFlags: c::c_int { - /// `TFD_TIMER_ABSTIME` - const ABSTIME = c::TFD_TIMER_ABSTIME; - - /// `TFD_TIMER_CANCEL_ON_SET` - #[cfg(any(target_os = "android", target_os = "linux"))] - const CANCEL_ON_SET = c::TFD_TIMER_CANCEL_ON_SET; - } -} - -/// `CLOCK_*` constants for use with [`timerfd_create`]. -/// -/// [`timerfd_create`]: crate::time::timerfd_create -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -#[repr(i32)] -#[non_exhaustive] -pub enum TimerfdClockId { - /// `CLOCK_REALTIME`—A clock that tells the "real" time. - /// - /// This is a clock that tells the amount of time elapsed since the - /// Unix epoch, 1970-01-01T00:00:00Z. The clock is externally settable, so - /// it is not monotonic. Successive reads may see decreasing times, so it - /// isn't reliable for measuring durations. - Realtime = c::CLOCK_REALTIME, - - /// `CLOCK_MONOTONIC`—A clock that tells an abstract time. - /// - /// Unlike `Realtime`, this clock is not based on a fixed known epoch, so - /// individual times aren't meaningful. However, since it isn't settable, - /// it is reliable for measuring durations. - /// - /// This clock does not advance while the system is suspended; see - /// `Boottime` for a clock that does. - Monotonic = c::CLOCK_MONOTONIC, - - /// `CLOCK_BOOTTIME`—Like `Monotonic`, but advances while suspended. - /// - /// This clock is similar to `Monotonic`, but does advance while the system - /// is suspended. - Boottime = c::CLOCK_BOOTTIME, - - /// `CLOCK_REALTIME_ALARM`—Like `Realtime`, but wakes a suspended system. - /// - /// This clock is like `Realtime`, but can wake up a suspended system. - /// - /// Use of this clock requires the `CAP_WAKE_ALARM` Linux capability. - RealtimeAlarm = c::CLOCK_REALTIME_ALARM, - - /// `CLOCK_BOOTTIME_ALARM`—Like `Boottime`, but wakes a suspended system. - /// - /// This clock is like `Boottime`, but can wake up a suspended system. - /// - /// Use of this clock requires the `CAP_WAKE_ALARM` Linux capability. - BoottimeAlarm = c::CLOCK_BOOTTIME_ALARM, -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/weak.rs b/vendor/rustix-0.37.6/src/backend/libc/weak.rs deleted file mode 100644 index b7f185da3..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/weak.rs +++ /dev/null @@ -1,226 +0,0 @@ -// Implementation derived from `weak` in Rust's -// library/std/src/sys/unix/weak.rs at revision -// fd0cb0cdc21dd9c06025277d772108f8d42cb25f. - -//! Support for "weak linkage" to symbols on Unix -//! -//! Some I/O operations we do in libstd require newer versions of OSes but we -//! need to maintain binary compatibility with older releases for now. In order -//! to use the new functionality when available we use this module for -//! detection. -//! -//! One option to use here is weak linkage, but that is unfortunately only -//! really workable on Linux. Hence, use dlsym to get the symbol value at -//! runtime. This is also done for compatibility with older versions of glibc, -//! and to avoid creating dependencies on `GLIBC_PRIVATE` symbols. It assumes -//! that we've been dynamically linked to the library the symbol comes from, -//! but that is currently always the case for things like libpthread/libc. -//! -//! A long time ago this used weak linkage for the `__pthread_get_minstack` -//! symbol, but that caused Debian to detect an unnecessarily strict versioned -//! dependency on libc6 (#23628). - -// There are a variety of `#[cfg]`s controlling which targets are involved in -// each instance of `weak!` and `syscall!`. Rather than trying to unify all of -// that, we'll just allow that some unix targets don't use this module at all. -#![allow(dead_code, unused_macros)] -#![allow(clippy::doc_markdown)] - -use crate::ffi::CStr; -use core::ffi::c_void; -use core::ptr::null_mut; -use core::sync::atomic::{self, AtomicPtr, Ordering}; -use core::{marker, mem}; - -const NULL: *mut c_void = null_mut(); -const INVALID: *mut c_void = 1 as *mut c_void; - -macro_rules! weak { - ($vis:vis fn $name:ident($($t:ty),*) -> $ret:ty) => ( - #[allow(non_upper_case_globals)] - $vis static $name: $crate::backend::weak::Weak<unsafe extern fn($($t),*) -> $ret> = - $crate::backend::weak::Weak::new(concat!(stringify!($name), '\0')); - ) -} - -pub(crate) struct Weak<F> { - name: &'static str, - addr: AtomicPtr<c_void>, - _marker: marker::PhantomData<F>, -} - -impl<F> Weak<F> { - pub(crate) const fn new(name: &'static str) -> Self { - Self { - name, - addr: AtomicPtr::new(INVALID), - _marker: marker::PhantomData, - } - } - - pub(crate) fn get(&self) -> Option<F> { - assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>()); - unsafe { - // Relaxed is fine here because we fence before reading through the - // pointer (see the comment below). - match self.addr.load(Ordering::Relaxed) { - INVALID => self.initialize(), - NULL => None, - addr => { - let func = mem::transmute_copy::<*mut c_void, F>(&addr); - // The caller is presumably going to read through this value - // (by calling the function we've dlsymed). This means we'd - // need to have loaded it with at least C11's consume - // ordering in order to be guaranteed that the data we read - // from the pointer isn't from before the pointer was - // stored. Rust has no equivalent to memory_order_consume, - // so we use an acquire fence (sorry, ARM). - // - // Now, in practice this likely isn't needed even on CPUs - // where relaxed and consume mean different things. The - // symbols we're loading are probably present (or not) at - // init, and even if they aren't the runtime dynamic loader - // is extremely likely have sufficient barriers internally - // (possibly implicitly, for example the ones provided by - // invoking `mprotect`). - // - // That said, none of that's *guaranteed*, and so we fence. - atomic::fence(Ordering::Acquire); - Some(func) - } - } - } - } - - // Cold because it should only happen during first-time initialization. - #[cold] - unsafe fn initialize(&self) -> Option<F> { - let val = fetch(self.name); - // This synchronizes with the acquire fence in `get`. - self.addr.store(val, Ordering::Release); - - match val { - NULL => None, - addr => Some(mem::transmute_copy::<*mut c_void, F>(&addr)), - } - } -} - -unsafe fn fetch(name: &str) -> *mut c_void { - let name = match CStr::from_bytes_with_nul(name.as_bytes()) { - Ok(c_str) => c_str, - Err(..) => return null_mut(), - }; - libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr()) -} - -#[cfg(not(any(target_os = "android", target_os = "linux")))] -macro_rules! syscall { - (fn $name:ident($($arg_name:ident: $t:ty),*) via $_sys_name:ident -> $ret:ty) => ( - unsafe fn $name($($arg_name: $t),*) -> $ret { - weak! { fn $name($($t),*) -> $ret } - - if let Some(fun) = $name.get() { - fun($($arg_name),*) - } else { - libc_errno::set_errno(libc_errno::Errno(libc::ENOSYS)); - -1 - } - } - ) -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -macro_rules! syscall { - (fn $name:ident($($arg_name:ident: $t:ty),*) via $sys_name:ident -> $ret:ty) => ( - unsafe fn $name($($arg_name:$t),*) -> $ret { - // This looks like a hack, but concat_idents only accepts idents - // (not paths). - use libc::*; - - trait AsSyscallArg { - type SyscallArgType; - fn into_syscall_arg(self) -> Self::SyscallArgType; - } - - // Pass pointer types as pointers, to preserve provenance. - impl<T> AsSyscallArg for *mut T { - type SyscallArgType = *mut T; - fn into_syscall_arg(self) -> Self::SyscallArgType { self } - } - impl<T> AsSyscallArg for *const T { - type SyscallArgType = *const T; - fn into_syscall_arg(self) -> Self::SyscallArgType { self } - } - - // Pass `BorrowedFd` values as the integer value. - impl AsSyscallArg for $crate::fd::BorrowedFd<'_> { - type SyscallArgType = c::c_long; - fn into_syscall_arg(self) -> Self::SyscallArgType { - $crate::fd::AsRawFd::as_raw_fd(&self) as _ - } - } - - // Coerce integer values into `c_long`. - impl AsSyscallArg for i32 { - type SyscallArgType = c::c_long; - fn into_syscall_arg(self) -> Self::SyscallArgType { self as _ } - } - impl AsSyscallArg for u32 { - type SyscallArgType = c::c_long; - fn into_syscall_arg(self) -> Self::SyscallArgType { self as _ } - } - impl AsSyscallArg for usize { - type SyscallArgType = c::c_long; - fn into_syscall_arg(self) -> Self::SyscallArgType { self as _ } - } - - // `concat_idents is unstable, so we take an extra `sys_name` - // parameter and have our users do the concat for us for now. - /* - syscall( - concat_idents!(SYS_, $name), - $($arg_name.into_syscall_arg()),* - ) as $ret - */ - - syscall($sys_name, $($arg_name.into_syscall_arg()),*) as $ret - } - ) -} - -macro_rules! weakcall { - ($vis:vis fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( - $vis unsafe fn $name($($arg_name: $t),*) -> $ret { - weak! { fn $name($($t),*) -> $ret } - - // Use a weak symbol from libc when possible, allowing `LD_PRELOAD` - // interposition, but if it's not found just fail. - if let Some(fun) = $name.get() { - fun($($arg_name),*) - } else { - libc_errno::set_errno(libc_errno::Errno(libc::ENOSYS)); - -1 - } - } - ) -} - -/// A combination of `weakcall` and `syscall`. Use the libc function if it's -/// available, and fall back to `libc::syscall` otherwise. -macro_rules! weak_or_syscall { - ($vis:vis fn $name:ident($($arg_name:ident: $t:ty),*) via $sys_name:ident -> $ret:ty) => ( - $vis unsafe fn $name($($arg_name: $t),*) -> $ret { - weak! { fn $name($($t),*) -> $ret } - - // Use a weak symbol from libc when possible, allowing `LD_PRELOAD` - // interposition, but if it's not found just fail. - if let Some(fun) = $name.get() { - fun($($arg_name),*) - } else { - syscall! { fn $name($($arg_name: $t),*) via $sys_name -> $ret } - $name($($arg_name),*) - } - } - ) -} diff --git a/vendor/rustix-0.37.6/src/backend/libc/winsock_c.rs b/vendor/rustix-0.37.6/src/backend/libc/winsock_c.rs deleted file mode 100644 index 521a7bbb1..000000000 --- a/vendor/rustix-0.37.6/src/backend/libc/winsock_c.rs +++ /dev/null @@ -1,83 +0,0 @@ -//! Adapt the Winsock2 API to resemble a POSIX-style libc API. - -#![allow(unused_imports)] -#![allow(non_camel_case_types)] - -use windows_sys::Win32::Networking::WinSock; - -pub(crate) use libc::{ - c_char, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong, c_ulonglong, - c_ushort, c_void, ssize_t, -}; -pub(crate) type socklen_t = i32; - -// windows-sys declares these constants as unsigned. For better compatibility -// with Unix-family APIs, redeclare them as signed. Filed upstream: -// <https://github.com/microsoft/windows-rs/issues/1718> -pub(crate) const AF_INET: i32 = WinSock::AF_INET as _; -pub(crate) const AF_INET6: i32 = WinSock::AF_INET6 as _; -pub(crate) const AF_UNSPEC: i32 = WinSock::AF_UNSPEC as _; -pub(crate) const SO_TYPE: i32 = WinSock::SO_TYPE as _; -pub(crate) const SO_REUSEADDR: i32 = WinSock::SO_REUSEADDR as _; -pub(crate) const SO_BROADCAST: i32 = WinSock::SO_BROADCAST as _; -pub(crate) const SO_LINGER: i32 = WinSock::SO_LINGER as _; -pub(crate) const SOL_SOCKET: i32 = WinSock::SOL_SOCKET as _; -pub(crate) const SO_RCVTIMEO: i32 = WinSock::SO_RCVTIMEO as _; -pub(crate) const SO_SNDTIMEO: i32 = WinSock::SO_SNDTIMEO as _; -pub(crate) const SO_ERROR: i32 = WinSock::SO_ERROR as _; -pub(crate) const IP_TTL: i32 = WinSock::IP_TTL as _; -pub(crate) const TCP_NODELAY: i32 = WinSock::TCP_NODELAY as _; -pub(crate) const IP_ADD_MEMBERSHIP: i32 = WinSock::IP_ADD_MEMBERSHIP as _; -pub(crate) const IP_DROP_MEMBERSHIP: i32 = WinSock::IP_DROP_MEMBERSHIP as _; -pub(crate) const IP_MULTICAST_TTL: i32 = WinSock::IP_MULTICAST_TTL as _; -pub(crate) const IP_MULTICAST_LOOP: i32 = WinSock::IP_MULTICAST_LOOP as _; -pub(crate) const IPV6_ADD_MEMBERSHIP: i32 = WinSock::IPV6_ADD_MEMBERSHIP as _; -pub(crate) const IPV6_DROP_MEMBERSHIP: i32 = WinSock::IPV6_DROP_MEMBERSHIP as _; -pub(crate) const IPV6_MULTICAST_LOOP: i32 = WinSock::IPV6_MULTICAST_LOOP as _; -pub(crate) const IPV6_V6ONLY: i32 = WinSock::IPV6_V6ONLY as _; -pub(crate) const POLLERR: i16 = WinSock::POLLERR as _; -pub(crate) const POLLIN: i16 = WinSock::POLLIN as _; -pub(crate) const POLLNVAL: i16 = WinSock::POLLNVAL as _; -pub(crate) const POLLHUP: i16 = WinSock::POLLHUP as _; -pub(crate) const POLLPRI: i16 = WinSock::POLLPRI as _; -pub(crate) const POLLOUT: i16 = WinSock::POLLOUT as _; -pub(crate) const POLLRDNORM: i16 = WinSock::POLLRDNORM as _; -pub(crate) const POLLWRNORM: i16 = WinSock::POLLWRNORM as _; -pub(crate) const POLLRDBAND: i16 = WinSock::POLLRDBAND as _; -pub(crate) const POLLWRBAND: i16 = WinSock::POLLWRBAND as _; - -// As above, cast the types for better compatibility, and also rename these to -// their Unix names. -pub(crate) const SHUT_RDWR: i32 = WinSock::SD_BOTH as _; -pub(crate) const SHUT_RD: i32 = WinSock::SD_RECEIVE as _; -pub(crate) const SHUT_WR: i32 = WinSock::SD_SEND as _; - -// Include the contents of `WinSock`, renaming as needed to match POSIX. -// -// Use `WSA_E_CANCELLED` for `ECANCELED` instead of `WSAECANCELLED`, because -// `WSAECANCELLED` will be removed in the future. -// <https://docs.microsoft.com/en-us/windows/win32/api/ws2spi/nc-ws2spi-lpnsplookupserviceend#remarks> -pub(crate) use WinSock::{ - closesocket as close, ioctlsocket as ioctl, WSAPoll as poll, ADDRESS_FAMILY as sa_family_t, - ADDRINFOA as addrinfo, IN6_ADDR as in6_addr, IN_ADDR as in_addr, IPV6_MREQ as ipv6_mreq, - IP_MREQ as ip_mreq, LINGER as linger, SOCKADDR as sockaddr, SOCKADDR_IN as sockaddr_in, - SOCKADDR_IN6 as sockaddr_in6, SOCKADDR_STORAGE as sockaddr_storage, WSAEACCES as EACCES, - WSAEADDRINUSE as EADDRINUSE, WSAEADDRNOTAVAIL as EADDRNOTAVAIL, - WSAEAFNOSUPPORT as EAFNOSUPPORT, WSAEALREADY as EALREADY, WSAEBADF as EBADF, - WSAECONNABORTED as ECONNABORTED, WSAECONNREFUSED as ECONNREFUSED, WSAECONNRESET as ECONNRESET, - WSAEDESTADDRREQ as EDESTADDRREQ, WSAEDISCON as EDISCON, WSAEDQUOT as EDQUOT, - WSAEFAULT as EFAULT, WSAEHOSTDOWN as EHOSTDOWN, WSAEHOSTUNREACH as EHOSTUNREACH, - WSAEINPROGRESS as EINPROGRESS, WSAEINTR as EINTR, WSAEINVAL as EINVAL, - WSAEINVALIDPROCTABLE as EINVALIDPROCTABLE, WSAEINVALIDPROVIDER as EINVALIDPROVIDER, - WSAEISCONN as EISCONN, WSAELOOP as ELOOP, WSAEMFILE as EMFILE, WSAEMSGSIZE as EMSGSIZE, - WSAENAMETOOLONG as ENAMETOOLONG, WSAENETDOWN as ENETDOWN, WSAENETRESET as ENETRESET, - WSAENETUNREACH as ENETUNREACH, WSAENOBUFS as ENOBUFS, WSAENOMORE as ENOMORE, - WSAENOPROTOOPT as ENOPROTOOPT, WSAENOTCONN as ENOTCONN, WSAENOTEMPTY as ENOTEMPTY, - WSAENOTSOCK as ENOTSOCK, WSAEOPNOTSUPP as EOPNOTSUPP, WSAEPFNOSUPPORT as EPFNOSUPPORT, - WSAEPROCLIM as EPROCLIM, WSAEPROTONOSUPPORT as EPROTONOSUPPORT, WSAEPROTOTYPE as EPROTOTYPE, - WSAEPROVIDERFAILEDINIT as EPROVIDERFAILEDINIT, WSAEREFUSED as EREFUSED, WSAEREMOTE as EREMOTE, - WSAESHUTDOWN as ESHUTDOWN, WSAESOCKTNOSUPPORT as ESOCKTNOSUPPORT, WSAESTALE as ESTALE, - WSAETIMEDOUT as ETIMEDOUT, WSAETOOMANYREFS as ETOOMANYREFS, WSAEUSERS as EUSERS, - WSAEWOULDBLOCK as EWOULDBLOCK, WSAEWOULDBLOCK as EAGAIN, WSAPOLLFD as pollfd, - WSA_E_CANCELLED as ECANCELED, *, -}; |