| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License.. |
| |
| use sgx_trts::libc; |
| use core::cmp::Ordering; |
| use core::hash::{Hash, Hasher}; |
| use core::convert::TryInto; |
| use crate::time::Duration; |
| pub use self::inner::{Instant, SystemTime, UNIX_EPOCH}; |
| |
| const NSEC_PER_SEC: u64 = 1_000_000_000; |
| |
| #[derive(Copy, Clone)] |
| struct Timespec { |
| t: libc::timespec, |
| } |
| |
| impl Timespec { |
| const fn zero() -> Timespec { |
| Timespec { t: libc::timespec { tv_sec: 0, tv_nsec: 0 } } |
| } |
| |
| fn sub_timespec(&self, other: &Timespec) -> Result<Duration, Duration> { |
| if self >= other { |
| Ok(if self.t.tv_nsec >= other.t.tv_nsec { |
| Duration::new( |
| (self.t.tv_sec - other.t.tv_sec) as u64, |
| (self.t.tv_nsec - other.t.tv_nsec) as u32, |
| ) |
| } else { |
| Duration::new( |
| (self.t.tv_sec - 1 - other.t.tv_sec) as u64, |
| self.t.tv_nsec as u32 + (NSEC_PER_SEC as u32) - other.t.tv_nsec as u32, |
| ) |
| }) |
| } else { |
| match other.sub_timespec(self) { |
| Ok(d) => Err(d), |
| Err(d) => Ok(d), |
| } |
| } |
| } |
| |
| fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> { |
| let mut secs = other |
| .as_secs() |
| .try_into() // <- target type would be `libc::time_t` |
| .ok() |
| .and_then(|secs| self.t.tv_sec.checked_add(secs))?; |
| |
| // Nano calculations can't overflow because nanos are <1B which fit |
| // in a u32. |
| let mut nsec = other.subsec_nanos() + self.t.tv_nsec as u32; |
| if nsec >= NSEC_PER_SEC as u32 { |
| nsec -= NSEC_PER_SEC as u32; |
| secs = secs.checked_add(1)?; |
| } |
| Some(Timespec { t: libc::timespec { tv_sec: secs, tv_nsec: nsec as _ } }) |
| } |
| |
| fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> { |
| let mut secs = other |
| .as_secs() |
| .try_into() // <- target type would be `libc::time_t` |
| .ok() |
| .and_then(|secs| self.t.tv_sec.checked_sub(secs))?; |
| |
| // Similar to above, nanos can't overflow. |
| let mut nsec = self.t.tv_nsec as i32 - other.subsec_nanos() as i32; |
| if nsec < 0 { |
| nsec += NSEC_PER_SEC as i32; |
| secs = secs.checked_sub(1)?; |
| } |
| Some(Timespec { t: libc::timespec { tv_sec: secs, tv_nsec: nsec as _ } }) |
| } |
| } |
| |
| impl PartialEq for Timespec { |
| fn eq(&self, other: &Timespec) -> bool { |
| self.t.tv_sec == other.t.tv_sec && self.t.tv_nsec == other.t.tv_nsec |
| } |
| } |
| |
| impl Eq for Timespec {} |
| |
| impl PartialOrd for Timespec { |
| fn partial_cmp(&self, other: &Timespec) -> Option<Ordering> { |
| Some(self.cmp(other)) |
| } |
| } |
| |
| impl Ord for Timespec { |
| fn cmp(&self, other: &Timespec) -> Ordering { |
| let me = (self.t.tv_sec, self.t.tv_nsec); |
| let other = (other.t.tv_sec, other.t.tv_nsec); |
| me.cmp(&other) |
| } |
| } |
| |
| impl Hash for Timespec { |
| fn hash<H: Hasher>(&self, state: &mut H) { |
| self.t.tv_sec.hash(state); |
| self.t.tv_nsec.hash(state); |
| } |
| } |
| |
| mod inner { |
| use core::fmt; |
| use crate::sys::cvt; |
| use crate::time::Duration; |
| |
| use super::Timespec; |
| |
| #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] |
| pub struct Instant { |
| t: Timespec, |
| } |
| |
| #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] |
| pub struct SystemTime { |
| t: Timespec, |
| } |
| |
| pub const UNIX_EPOCH: SystemTime = SystemTime { |
| t: Timespec::zero(), |
| }; |
| |
| impl Instant { |
| pub fn now() -> Instant { |
| Instant { t: now(libc::CLOCK_MONOTONIC) } |
| } |
| |
| pub const fn zero() -> Instant { |
| Instant { |
| t: Timespec::zero(), |
| } |
| } |
| |
| pub fn actually_monotonic() -> bool { |
| (cfg!(target_os = "linux") && cfg!(target_arch = "x86_64")) || |
| (cfg!(target_os = "linux") && cfg!(target_arch = "x86")) || |
| false // last clause, used so `||` is always trailing above |
| } |
| |
| pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> { |
| self.t.sub_timespec(&other.t).ok() |
| } |
| |
| pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> { |
| Some(Instant { t: self.t.checked_add_duration(other)? }) |
| } |
| |
| pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> { |
| Some(Instant { t: self.t.checked_sub_duration(other)? }) |
| } |
| |
| pub fn get_tup(&self) -> (i64, i64) { |
| (self.t.t.tv_sec, self.t.t.tv_nsec) |
| } |
| } |
| |
| impl fmt::Debug for Instant { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_struct("Instant") |
| .field("tv_sec", &self.t.t.tv_sec) |
| .field("tv_nsec", &self.t.t.tv_nsec) |
| .finish() |
| } |
| } |
| |
| impl SystemTime { |
| pub fn now() -> SystemTime { |
| SystemTime { t: now(libc::CLOCK_REALTIME) } |
| } |
| |
| pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> { |
| self.t.sub_timespec(&other.t) |
| } |
| |
| pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> { |
| Some(SystemTime { t: self.t.checked_add_duration(other)? }) |
| } |
| |
| pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> { |
| Some(SystemTime { t: self.t.checked_sub_duration(other)? }) |
| } |
| |
| pub fn get_tup(&self) -> (i64, i64) { |
| (self.t.t.tv_sec, self.t.t.tv_nsec) |
| } |
| } |
| |
| impl From<libc::timespec> for SystemTime { |
| fn from(t: libc::timespec) -> SystemTime { |
| SystemTime { t: Timespec { t } } |
| } |
| } |
| |
| impl fmt::Debug for SystemTime { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_struct("SystemTime") |
| .field("tv_sec", &self.t.t.tv_sec) |
| .field("tv_nsec", &self.t.t.tv_nsec) |
| .finish() |
| } |
| } |
| |
| fn now(clock: libc::clockid_t) -> Timespec { |
| let mut t = Timespec { t: libc::timespec { tv_sec: 0, tv_nsec: 0 } }; |
| cvt(unsafe { libc::clock_gettime(clock, &mut t.t) }).unwrap(); |
| t |
| } |
| |
| mod libc { |
| pub use sgx_trts::libc::*; |
| pub use sgx_trts::libc::ocall::clock_gettime; |
| } |
| } |