From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001 From: Valentin Popov Date: Fri, 19 Jul 2024 16:37:58 +0400 Subject: Deleted vendor folder --- vendor/rustix/src/backend/libc/time/mod.rs | 3 - vendor/rustix/src/backend/libc/time/syscalls.rs | 452 ------------------------ vendor/rustix/src/backend/libc/time/types.rs | 177 ---------- 3 files changed, 632 deletions(-) delete mode 100644 vendor/rustix/src/backend/libc/time/mod.rs delete mode 100644 vendor/rustix/src/backend/libc/time/syscalls.rs delete mode 100644 vendor/rustix/src/backend/libc/time/types.rs (limited to 'vendor/rustix/src/backend/libc/time') diff --git a/vendor/rustix/src/backend/libc/time/mod.rs b/vendor/rustix/src/backend/libc/time/mod.rs deleted file mode 100644 index bff7fd5..0000000 --- a/vendor/rustix/src/backend/libc/time/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -#[cfg(not(windows))] -pub(crate) mod syscalls; -pub(crate) mod types; diff --git a/vendor/rustix/src/backend/libc/time/syscalls.rs b/vendor/rustix/src/backend/libc/time/syscalls.rs deleted file mode 100644 index 6b1c9fd..0000000 --- a/vendor/rustix/src/backend/libc/time/syscalls.rs +++ /dev/null @@ -1,452 +0,0 @@ -//! libc syscalls supporting `rustix::time`. - -use crate::backend::c; -use crate::backend::conv::ret; -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(feature = "time")] -#[cfg(any(all(target_env = "gnu", fix_y2038), not(fix_y2038)))] -use crate::backend::time::types::LibcItimerspec; -#[cfg(not(target_os = "wasi"))] -use crate::clockid::{ClockId, DynamicClockId}; -use crate::io; -#[cfg(all(target_env = "gnu", fix_y2038))] -use crate::timespec::LibcTimespec; -use crate::timespec::Timespec; -use core::mem::MaybeUninit; -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(feature = "time")] -use { - crate::backend::conv::{borrowed_fd, ret_owned_fd}, - crate::fd::{BorrowedFd, OwnedFd}, - crate::time::{Itimerspec, TimerfdClockId, TimerfdFlags, TimerfdTimerFlags}, -}; - -#[cfg(all(target_env = "gnu", fix_y2038))] -weak!(fn __clock_gettime64(c::clockid_t, *mut LibcTimespec) -> c::c_int); -#[cfg(all(target_env = "gnu", fix_y2038))] -weak!(fn __clock_settime64(c::clockid_t, *const LibcTimespec) -> c::c_int); -#[cfg(all(target_env = "gnu", fix_y2038))] -weak!(fn __clock_getres64(c::clockid_t, *mut LibcTimespec) -> c::c_int); -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(all(target_env = "gnu", fix_y2038))] -#[cfg(feature = "time")] -weak!(fn __timerfd_gettime64(c::c_int, *mut LibcItimerspec) -> c::c_int); -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(all(target_env = "gnu", fix_y2038))] -#[cfg(feature = "time")] -weak!(fn __timerfd_settime64(c::c_int, c::c_int, *const LibcItimerspec, *mut LibcItimerspec) -> c::c_int); - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[inline] -#[must_use] -pub(crate) fn clock_getres(id: ClockId) -> Timespec { - // Old 32-bit version: libc has `clock_getres` but it is not y2038 safe by - // default. But there may be a `__clock_getres64` we can use. - #[cfg(fix_y2038)] - { - #[cfg(target_env = "gnu")] - if let Some(libc_clock_getres) = __clock_getres64.get() { - let mut timespec = MaybeUninit::::uninit(); - unsafe { - ret(libc_clock_getres(id as c::clockid_t, timespec.as_mut_ptr())).unwrap(); - return timespec.assume_init().into(); - } - } - - clock_getres_old(id) - } - - // Main version: libc is y2038 safe and has `clock_getres`. - #[cfg(not(fix_y2038))] - unsafe { - let mut timespec = MaybeUninit::::uninit(); - let _ = c::clock_getres(id as c::clockid_t, timespec.as_mut_ptr()); - timespec.assume_init() - } -} - -#[cfg(fix_y2038)] -#[must_use] -fn clock_getres_old(id: ClockId) -> Timespec { - let mut old_timespec = MaybeUninit::::uninit(); - - let old_timespec = unsafe { - ret(c::clock_getres( - id as c::clockid_t, - old_timespec.as_mut_ptr(), - )) - .unwrap(); - old_timespec.assume_init() - }; - - Timespec { - tv_sec: old_timespec.tv_sec.into(), - tv_nsec: old_timespec.tv_nsec.into(), - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -#[must_use] -pub(crate) fn clock_gettime(id: ClockId) -> Timespec { - // Old 32-bit version: libc has `clock_gettime` but it is not y2038 safe by - // default. But there may be a `__clock_gettime64` we can use. - #[cfg(fix_y2038)] - { - #[cfg(target_env = "gnu")] - if let Some(libc_clock_gettime) = __clock_gettime64.get() { - let mut timespec = MaybeUninit::::uninit(); - unsafe { - ret(libc_clock_gettime( - id as c::clockid_t, - timespec.as_mut_ptr(), - )) - .unwrap(); - return timespec.assume_init().into(); - } - } - - clock_gettime_old(id) - } - - // Use `.unwrap()` here because `clock_getres` can fail if the clock itself - // overflows a number of seconds, but if that happens, the monotonic clocks - // can't maintain their invariants, or the realtime clocks aren't properly - // configured. - #[cfg(not(fix_y2038))] - unsafe { - let mut timespec = MaybeUninit::::uninit(); - ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr())).unwrap(); - timespec.assume_init() - } -} - -#[cfg(fix_y2038)] -#[must_use] -fn clock_gettime_old(id: ClockId) -> Timespec { - let mut old_timespec = MaybeUninit::::uninit(); - - let old_timespec = unsafe { - ret(c::clock_gettime( - id as c::clockid_t, - old_timespec.as_mut_ptr(), - )) - .unwrap(); - old_timespec.assume_init() - }; - - Timespec { - tv_sec: old_timespec.tv_sec.into(), - tv_nsec: old_timespec.tv_nsec.into(), - } -} - -#[cfg(not(target_os = "wasi"))] -#[inline] -pub(crate) fn clock_gettime_dynamic(id: DynamicClockId<'_>) -> io::Result { - let id: c::clockid_t = match id { - DynamicClockId::Known(id) => id as c::clockid_t, - - #[cfg(linux_kernel)] - DynamicClockId::Dynamic(fd) => { - use crate::fd::AsRawFd; - const CLOCKFD: i32 = 3; - (!fd.as_raw_fd() << 3) | CLOCKFD - } - - #[cfg(not(linux_kernel))] - DynamicClockId::Dynamic(_fd) => { - // Dynamic clocks are not supported on this platform. - return Err(io::Errno::INVAL); - } - - #[cfg(linux_kernel)] - DynamicClockId::RealtimeAlarm => c::CLOCK_REALTIME_ALARM, - - #[cfg(linux_kernel)] - DynamicClockId::Tai => c::CLOCK_TAI, - - #[cfg(any( - freebsdlike, - linux_kernel, - target_os = "fuchsia", - target_os = "openbsd" - ))] - DynamicClockId::Boottime => c::CLOCK_BOOTTIME, - - #[cfg(any(linux_kernel, target_os = "fuchsia"))] - DynamicClockId::BoottimeAlarm => c::CLOCK_BOOTTIME_ALARM, - }; - - // Old 32-bit version: libc has `clock_gettime` but it is not y2038 - // safe by default. But there may be a `__clock_gettime64` we can use. - #[cfg(fix_y2038)] - { - #[cfg(target_env = "gnu")] - if let Some(libc_clock_gettime) = __clock_gettime64.get() { - let mut timespec = MaybeUninit::::uninit(); - unsafe { - ret(libc_clock_gettime( - id as c::clockid_t, - timespec.as_mut_ptr(), - ))?; - - return Ok(timespec.assume_init().into()); - } - } - - clock_gettime_dynamic_old(id) - } - - // Main version: libc is y2038 safe and has `clock_gettime`. - #[cfg(not(fix_y2038))] - unsafe { - let mut timespec = MaybeUninit::::uninit(); - - ret(c::clock_gettime(id as c::clockid_t, timespec.as_mut_ptr()))?; - - Ok(timespec.assume_init()) - } -} - -#[cfg(fix_y2038)] -#[inline] -fn clock_gettime_dynamic_old(id: c::clockid_t) -> io::Result { - let mut old_timespec = MaybeUninit::::uninit(); - - let old_timespec = unsafe { - ret(c::clock_gettime( - id as c::clockid_t, - old_timespec.as_mut_ptr(), - ))?; - - old_timespec.assume_init() - }; - - Ok(Timespec { - tv_sec: old_timespec.tv_sec.into(), - tv_nsec: old_timespec.tv_nsec.into(), - }) -} - -#[cfg(not(any( - target_os = "redox", - target_os = "wasi", - all(apple, not(target_os = "macos")) -)))] -#[inline] -pub(crate) fn clock_settime(id: ClockId, timespec: Timespec) -> io::Result<()> { - // Old 32-bit version: libc has `clock_gettime` but it is not y2038 safe by - // default. But there may be a `__clock_settime64` we can use. - #[cfg(fix_y2038)] - { - #[cfg(target_env = "gnu")] - if let Some(libc_clock_settime) = __clock_settime64.get() { - unsafe { - let mut new_timespec = core::mem::zeroed::(); - new_timespec.tv_sec = timespec.tv_sec; - new_timespec.tv_nsec = timespec.tv_nsec as _; - return ret(libc_clock_settime(id as c::clockid_t, &new_timespec)); - } - } - - clock_settime_old(id, timespec) - } - - // Main version: libc is y2038 safe and has `clock_settime`. - #[cfg(not(fix_y2038))] - unsafe { - ret(c::clock_settime(id as c::clockid_t, ×pec)) - } -} - -#[cfg(not(any( - target_os = "redox", - target_os = "wasi", - all(apple, not(target_os = "macos")) -)))] -#[cfg(fix_y2038)] -fn clock_settime_old(id: ClockId, timespec: Timespec) -> io::Result<()> { - let old_timespec = c::timespec { - tv_sec: timespec - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: timespec.tv_nsec as _, - }; - - unsafe { ret(c::clock_settime(id as c::clockid_t, &old_timespec)) } -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(feature = "time")] -pub(crate) fn timerfd_create(id: TimerfdClockId, flags: TimerfdFlags) -> io::Result { - unsafe { ret_owned_fd(c::timerfd_create(id as c::clockid_t, bitflags_bits!(flags))) } -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(feature = "time")] -pub(crate) fn timerfd_settime( - fd: BorrowedFd<'_>, - flags: TimerfdTimerFlags, - new_value: &Itimerspec, -) -> io::Result { - // Old 32-bit version: libc has `timerfd_settime` but it is not y2038 safe - // by default. But there may be a `__timerfd_settime64` we can use. - #[cfg(fix_y2038)] - { - #[cfg(target_env = "gnu")] - if let Some(libc_timerfd_settime) = __timerfd_settime64.get() { - let mut result = MaybeUninit::::uninit(); - unsafe { - ret(libc_timerfd_settime( - borrowed_fd(fd), - bitflags_bits!(flags), - &new_value.clone().into(), - result.as_mut_ptr(), - ))?; - return Ok(result.assume_init().into()); - } - } - - timerfd_settime_old(fd, flags, new_value) - } - - #[cfg(not(fix_y2038))] - unsafe { - let mut result = MaybeUninit::::uninit(); - ret(c::timerfd_settime( - borrowed_fd(fd), - bitflags_bits!(flags), - new_value, - result.as_mut_ptr(), - ))?; - Ok(result.assume_init()) - } -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(fix_y2038)] -#[cfg(feature = "time")] -fn timerfd_settime_old( - fd: BorrowedFd<'_>, - flags: TimerfdTimerFlags, - new_value: &Itimerspec, -) -> io::Result { - let mut old_result = MaybeUninit::::uninit(); - - // Convert `new_value` to the old `itimerspec` format. - let old_new_value = c::itimerspec { - it_interval: c::timespec { - tv_sec: new_value - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: new_value - .it_interval - .tv_nsec - .try_into() - .map_err(|_| io::Errno::INVAL)?, - }, - it_value: c::timespec { - tv_sec: new_value - .it_value - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: new_value - .it_value - .tv_nsec - .try_into() - .map_err(|_| io::Errno::INVAL)?, - }, - }; - - let old_result = unsafe { - ret(c::timerfd_settime( - borrowed_fd(fd), - bitflags_bits!(flags), - &old_new_value, - old_result.as_mut_ptr(), - ))?; - old_result.assume_init() - }; - - Ok(Itimerspec { - it_interval: Timespec { - tv_sec: old_result - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: old_result.it_interval.tv_nsec as _, - }, - it_value: Timespec { - tv_sec: old_result - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: old_result.it_interval.tv_nsec as _, - }, - }) -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(feature = "time")] -pub(crate) fn timerfd_gettime(fd: BorrowedFd<'_>) -> io::Result { - // Old 32-bit version: libc has `timerfd_gettime` but it is not y2038 safe - // by default. But there may be a `__timerfd_gettime64` we can use. - #[cfg(fix_y2038)] - { - #[cfg(target_env = "gnu")] - if let Some(libc_timerfd_gettime) = __timerfd_gettime64.get() { - let mut result = MaybeUninit::::uninit(); - unsafe { - ret(libc_timerfd_gettime(borrowed_fd(fd), result.as_mut_ptr()))?; - return Ok(result.assume_init().into()); - } - } - - timerfd_gettime_old(fd) - } - - #[cfg(not(fix_y2038))] - unsafe { - let mut result = MaybeUninit::::uninit(); - ret(c::timerfd_gettime(borrowed_fd(fd), result.as_mut_ptr()))?; - Ok(result.assume_init()) - } -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(fix_y2038)] -#[cfg(feature = "time")] -fn timerfd_gettime_old(fd: BorrowedFd<'_>) -> io::Result { - let mut old_result = MaybeUninit::::uninit(); - - let old_result = unsafe { - ret(c::timerfd_gettime(borrowed_fd(fd), old_result.as_mut_ptr()))?; - old_result.assume_init() - }; - - Ok(Itimerspec { - it_interval: Timespec { - tv_sec: old_result - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: old_result.it_interval.tv_nsec as _, - }, - it_value: Timespec { - tv_sec: old_result - .it_interval - .tv_sec - .try_into() - .map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: old_result.it_interval.tv_nsec as _, - }, - }) -} diff --git a/vendor/rustix/src/backend/libc/time/types.rs b/vendor/rustix/src/backend/libc/time/types.rs deleted file mode 100644 index 5254c6b..0000000 --- a/vendor/rustix/src/backend/libc/time/types.rs +++ /dev/null @@ -1,177 +0,0 @@ -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -use crate::backend::c; -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(fix_y2038)] -use crate::timespec::LibcTimespec; -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(fix_y2038)] -use crate::timespec::Timespec; -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -use bitflags::bitflags; - -/// `struct itimerspec` for use with [`timerfd_gettime`] and -/// [`timerfd_settime`]. -/// -/// [`timerfd_gettime`]: crate::time::timerfd_gettime -/// [`timerfd_settime`]: crate::time::timerfd_settime -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(not(fix_y2038))] -pub type Itimerspec = c::itimerspec; - -/// `struct itimerspec` for use with [`timerfd_gettime`] and -/// [`timerfd_settime`]. -/// -/// [`timerfd_gettime`]: crate::time::timerfd_gettime -/// [`timerfd_settime`]: crate::time::timerfd_settime -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(fix_y2038)] -#[repr(C)] -#[derive(Debug, Clone)] -pub struct Itimerspec { - /// The interval of an interval timer. - pub it_interval: Timespec, - /// Time remaining in the current interval. - pub it_value: Timespec, -} - -/// On most platforms, `LibcItimerspec` is just `Itimerspec`. -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(not(fix_y2038))] -pub(crate) type LibcItimerspec = Itimerspec; - -/// On 32-bit glibc platforms, `LibcTimespec` differs from `Timespec`, so we -/// define our own struct, with bidirectional `From` impls. -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(fix_y2038)] -#[repr(C)] -#[derive(Debug, Clone)] -pub(crate) struct LibcItimerspec { - pub it_interval: LibcTimespec, - pub it_value: LibcTimespec, -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(fix_y2038)] -impl From for Itimerspec { - #[inline] - fn from(t: LibcItimerspec) -> Self { - Self { - it_interval: t.it_interval.into(), - it_value: t.it_value.into(), - } - } -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[cfg(fix_y2038)] -impl From for LibcItimerspec { - #[inline] - fn from(t: Itimerspec) -> Self { - Self { - it_interval: t.it_interval.into(), - it_value: t.it_value.into(), - } - } -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -bitflags! { - /// `TFD_*` flags for use with [`timerfd_create`]. - /// - /// [`timerfd_create`]: crate::time::timerfd_create - #[repr(transparent)] - #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)] - pub struct TimerfdFlags: u32 { - /// `TFD_NONBLOCK` - #[doc(alias = "TFD_NONBLOCK")] - const NONBLOCK = bitcast!(c::TFD_NONBLOCK); - - /// `TFD_CLOEXEC` - #[doc(alias = "TFD_CLOEXEC")] - const CLOEXEC = bitcast!(c::TFD_CLOEXEC); - - /// - const _ = !0; - } -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -bitflags! { - /// `TFD_TIMER_*` flags for use with [`timerfd_settime`]. - /// - /// [`timerfd_settime`]: crate::time::timerfd_settime - #[repr(transparent)] - #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)] - pub struct TimerfdTimerFlags: u32 { - /// `TFD_TIMER_ABSTIME` - #[doc(alias = "TFD_TIMER_ABSTIME")] - const ABSTIME = bitcast!(c::TFD_TIMER_ABSTIME); - - /// `TFD_TIMER_CANCEL_ON_SET` - #[cfg(linux_kernel)] - #[doc(alias = "TFD_TIMER_CANCEL_ON_SET")] - const CANCEL_ON_SET = bitcast!(c::TFD_TIMER_CANCEL_ON_SET); - - /// - const _ = !0; - } -} - -/// `CLOCK_*` constants for use with [`timerfd_create`]. -/// -/// [`timerfd_create`]: crate::time::timerfd_create -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] -#[repr(u32)] -#[non_exhaustive] -pub enum TimerfdClockId { - /// `CLOCK_REALTIME`—A clock that tells the “real” time. - /// - /// This is a clock that tells the amount of time elapsed since the Unix - /// epoch, 1970-01-01T00:00:00Z. The clock is externally settable, so it is - /// not monotonic. Successive reads may see decreasing times, so it isn't - /// reliable for measuring durations. - #[doc(alias = "CLOCK_REALTIME")] - Realtime = bitcast!(c::CLOCK_REALTIME), - - /// `CLOCK_MONOTONIC`—A clock that tells an abstract time. - /// - /// Unlike `Realtime`, this clock is not based on a fixed known epoch, so - /// individual times aren't meaningful. However, since it isn't settable, - /// it is reliable for measuring durations. - /// - /// This clock does not advance while the system is suspended; see - /// `Boottime` for a clock that does. - #[doc(alias = "CLOCK_MONOTONIC")] - Monotonic = bitcast!(c::CLOCK_MONOTONIC), - - /// `CLOCK_BOOTTIME`—Like `Monotonic`, but advances while suspended. - /// - /// This clock is similar to `Monotonic`, but does advance while the system - /// is suspended. - #[doc(alias = "CLOCK_BOOTTIME")] - Boottime = bitcast!(c::CLOCK_BOOTTIME), - - /// `CLOCK_REALTIME_ALARM`—Like `Realtime`, but wakes a suspended system. - /// - /// This clock is like `Realtime`, but can wake up a suspended system. - /// - /// Use of this clock requires the `CAP_WAKE_ALARM` Linux capability. - #[doc(alias = "CLOCK_REALTIME_ALARM")] - RealtimeAlarm = bitcast!(c::CLOCK_REALTIME_ALARM), - - /// `CLOCK_BOOTTIME_ALARM`—Like `Boottime`, but wakes a suspended system. - /// - /// This clock is like `Boottime`, but can wake up a suspended system. - /// - /// Use of this clock requires the `CAP_WAKE_ALARM` Linux capability. - #[doc(alias = "CLOCK_BOOTTIME_ALARM")] - BoottimeAlarm = bitcast!(c::CLOCK_BOOTTIME_ALARM), -} - -#[cfg(any(linux_kernel, target_os = "fuchsia"))] -#[test] -fn test_types() { - assert_eq_size!(TimerfdFlags, c::c_int); - assert_eq_size!(TimerfdTimerFlags, c::c_int); -} -- cgit v1.2.3