|
| 1 | +use core::num::niche_types::Nanoseconds; |
| 2 | + |
| 3 | +use crate::io; |
| 4 | +use crate::time::Duration; |
| 5 | + |
| 6 | +const NSEC_PER_SEC: u64 = 1_000_000_000; |
| 7 | + |
| 8 | +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] |
| 9 | +pub(crate) struct Timespec { |
| 10 | + pub(crate) tv_sec: i64, |
| 11 | + pub(crate) tv_nsec: Nanoseconds, |
| 12 | +} |
| 13 | + |
| 14 | +impl Timespec { |
| 15 | + const unsafe fn new_unchecked(tv_sec: i64, tv_nsec: i64) -> Timespec { |
| 16 | + Timespec { tv_sec, tv_nsec: unsafe { Nanoseconds::new_unchecked(tv_nsec as u32) } } |
| 17 | + } |
| 18 | + |
| 19 | + pub const fn zero() -> Timespec { |
| 20 | + unsafe { Self::new_unchecked(0, 0) } |
| 21 | + } |
| 22 | + |
| 23 | + pub(crate) const fn new(tv_sec: i64, tv_nsec: i64) -> Result<Timespec, io::Error> { |
| 24 | + // On Apple OS, dates before epoch are represented differently than on other |
| 25 | + // Unix platforms: e.g. 1/10th of a second before epoch is represented as `seconds=-1` |
| 26 | + // and `nanoseconds=100_000_000` on other platforms, but is `seconds=0` and |
| 27 | + // `nanoseconds=-900_000_000` on Apple OS. |
| 28 | + // |
| 29 | + // To compensate, we first detect this special case by checking if both |
| 30 | + // seconds and nanoseconds are in range, and then correct the value for seconds |
| 31 | + // and nanoseconds to match the common unix representation. |
| 32 | + // |
| 33 | + // Please note that Apple OS nonetheless accepts the standard unix format when |
| 34 | + // setting file times, which makes this compensation round-trippable and generally |
| 35 | + // transparent. |
| 36 | + #[cfg(target_vendor = "apple")] |
| 37 | + let (tv_sec, tv_nsec) = |
| 38 | + if (tv_sec <= 0 && tv_sec > i64::MIN) && (tv_nsec < 0 && tv_nsec > -1_000_000_000) { |
| 39 | + (tv_sec - 1, tv_nsec + 1_000_000_000) |
| 40 | + } else { |
| 41 | + (tv_sec, tv_nsec) |
| 42 | + }; |
| 43 | + if tv_nsec >= 0 && tv_nsec < NSEC_PER_SEC as i64 { |
| 44 | + Ok(unsafe { Self::new_unchecked(tv_sec, tv_nsec) }) |
| 45 | + } else { |
| 46 | + Err(io::const_error!(io::ErrorKind::InvalidData, "invalid timestamp")) |
| 47 | + } |
| 48 | + } |
| 49 | + |
| 50 | + #[cfg(unix)] |
| 51 | + pub fn now(clock: libc::clockid_t) -> Timespec { |
| 52 | + use crate::mem::MaybeUninit; |
| 53 | + use crate::sys::cvt; |
| 54 | + |
| 55 | + // Try to use 64-bit time in preparation for Y2038. |
| 56 | + #[cfg(all( |
| 57 | + target_os = "linux", |
| 58 | + target_env = "gnu", |
| 59 | + target_pointer_width = "32", |
| 60 | + not(target_arch = "riscv32") |
| 61 | + ))] |
| 62 | + { |
| 63 | + use crate::sys::weak::weak; |
| 64 | + |
| 65 | + // __clock_gettime64 was added to 32-bit arches in glibc 2.34, |
| 66 | + // and it handles both vDSO calls and ENOSYS fallbacks itself. |
| 67 | + weak!( |
| 68 | + fn __clock_gettime64( |
| 69 | + clockid: libc::clockid_t, |
| 70 | + tp: *mut __timespec64, |
| 71 | + ) -> libc::c_int; |
| 72 | + ); |
| 73 | + |
| 74 | + if let Some(clock_gettime64) = __clock_gettime64.get() { |
| 75 | + let mut t = MaybeUninit::uninit(); |
| 76 | + cvt(unsafe { clock_gettime64(clock, t.as_mut_ptr()) }).unwrap(); |
| 77 | + let t = unsafe { t.assume_init() }; |
| 78 | + return Timespec::new(t.tv_sec as i64, t.tv_nsec as i64).unwrap(); |
| 79 | + } |
| 80 | + } |
| 81 | + |
| 82 | + let mut t = MaybeUninit::uninit(); |
| 83 | + cvt(unsafe { libc::clock_gettime(clock, t.as_mut_ptr()) }).unwrap(); |
| 84 | + let t = unsafe { t.assume_init() }; |
| 85 | + Timespec::new(t.tv_sec as i64, t.tv_nsec as i64).unwrap() |
| 86 | + } |
| 87 | + |
| 88 | + pub fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> { |
| 89 | + // When a >= b, the difference fits in u64. |
| 90 | + fn sub_ge_to_unsigned(a: i64, b: i64) -> u64 { |
| 91 | + debug_assert!(a >= b); |
| 92 | + a.wrapping_sub(b).cast_unsigned() |
| 93 | + } |
| 94 | + |
| 95 | + if self >= other { |
| 96 | + let (secs, nsec) = if self.tv_nsec.as_inner() >= other.tv_nsec.as_inner() { |
| 97 | + ( |
| 98 | + sub_ge_to_unsigned(self.tv_sec, other.tv_sec), |
| 99 | + self.tv_nsec.as_inner() - other.tv_nsec.as_inner(), |
| 100 | + ) |
| 101 | + } else { |
| 102 | + // Following sequence of assertions explain why `self.tv_sec - 1` does not underflow. |
| 103 | + debug_assert!(self.tv_nsec < other.tv_nsec); |
| 104 | + debug_assert!(self.tv_sec > other.tv_sec); |
| 105 | + debug_assert!(self.tv_sec > i64::MIN); |
| 106 | + ( |
| 107 | + sub_ge_to_unsigned(self.tv_sec - 1, other.tv_sec), |
| 108 | + self.tv_nsec.as_inner() + (NSEC_PER_SEC as u32) - other.tv_nsec.as_inner(), |
| 109 | + ) |
| 110 | + }; |
| 111 | + |
| 112 | + Ok(Duration::new(secs, nsec)) |
| 113 | + } else { |
| 114 | + match other.sub_timespec(self) { |
| 115 | + Ok(d) => Err(d), |
| 116 | + Err(d) => Ok(d), |
| 117 | + } |
| 118 | + } |
| 119 | + } |
| 120 | + |
| 121 | + pub fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> { |
| 122 | + let mut secs = self.tv_sec.checked_add_unsigned(other.as_secs())?; |
| 123 | + |
| 124 | + // Nano calculations can't overflow because nanos are <1B which fit |
| 125 | + // in a u32. |
| 126 | + let mut nsec = other.subsec_nanos() + self.tv_nsec.as_inner(); |
| 127 | + if nsec >= NSEC_PER_SEC as u32 { |
| 128 | + nsec -= NSEC_PER_SEC as u32; |
| 129 | + secs = secs.checked_add(1)?; |
| 130 | + } |
| 131 | + Some(unsafe { Timespec::new_unchecked(secs, nsec.into()) }) |
| 132 | + } |
| 133 | + |
| 134 | + pub fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> { |
| 135 | + let mut secs = self.tv_sec.checked_sub_unsigned(other.as_secs())?; |
| 136 | + |
| 137 | + // Similar to above, nanos can't overflow. |
| 138 | + let mut nsec = self.tv_nsec.as_inner() as i32 - other.subsec_nanos() as i32; |
| 139 | + if nsec < 0 { |
| 140 | + nsec += NSEC_PER_SEC as i32; |
| 141 | + secs = secs.checked_sub(1)?; |
| 142 | + } |
| 143 | + Some(unsafe { Timespec::new_unchecked(secs, nsec.into()) }) |
| 144 | + } |
| 145 | + |
| 146 | + #[allow(dead_code)] |
| 147 | + pub fn to_timespec(&self) -> Option<libc::timespec> { |
| 148 | + Some(libc::timespec { |
| 149 | + tv_sec: self.tv_sec.try_into().ok()?, |
| 150 | + tv_nsec: self.tv_nsec.as_inner().try_into().ok()?, |
| 151 | + }) |
| 152 | + } |
| 153 | + |
| 154 | + // On QNX Neutrino, the maximum timespec for e.g. pthread_cond_timedwait |
| 155 | + // is 2^64 nanoseconds |
| 156 | + #[cfg(target_os = "nto")] |
| 157 | + pub(in crate::sys) fn to_timespec_capped(&self) -> Option<libc::timespec> { |
| 158 | + // Check if timeout in nanoseconds would fit into an u64 |
| 159 | + if (self.tv_nsec.as_inner() as u64) |
| 160 | + .checked_add((self.tv_sec as u64).checked_mul(NSEC_PER_SEC)?) |
| 161 | + .is_none() |
| 162 | + { |
| 163 | + return None; |
| 164 | + } |
| 165 | + self.to_timespec() |
| 166 | + } |
| 167 | + |
| 168 | + #[cfg(all( |
| 169 | + target_os = "linux", |
| 170 | + target_env = "gnu", |
| 171 | + target_pointer_width = "32", |
| 172 | + not(target_arch = "riscv32") |
| 173 | + ))] |
| 174 | + pub fn to_timespec64(&self) -> __timespec64 { |
| 175 | + __timespec64::new(self.tv_sec, self.tv_nsec.as_inner() as _) |
| 176 | + } |
| 177 | +} |
0 commit comments