std: sys: pal: uefi: Overhaul Time

Use UEFI time format for SystemTime.

All calculations and comparisons are being done using UnixTime since
UEFI Time format does not seem good fit for those calculations.

Signed-off-by: Ayush Singh <[email protected]>

Author: Ayush1325

library/std/src/sys/pal/uefi/tests.rs

@@ -1,6 +1,4 @@
 use super::alloc::*;
-use super::time::*;
-use crate::time::Duration;
 
 #[test]
 fn align() {
@@ -21,21 +19,3 @@ fn align() {
         }
     }
 }
-
-#[test]
-fn epoch() {
-    let t = r_efi::system::Time {
-        year: 1970,
-        month: 1,
-        day: 1,
-        hour: 0,
-        minute: 0,
-        second: 0,
-        nanosecond: 0,
-        timezone: r_efi::efi::UNSPECIFIED_TIMEZONE,
-        daylight: 0,
-        pad1: 0,
-        pad2: 0,
-    };
-    assert_eq!(system_time_internal::uefi_time_to_duration(t), Duration::new(0, 0));
-}

library/std/src/sys/pal/uefi/time.rs

@@ -1,16 +1,55 @@
+use crate::cmp::Ordering;
 use crate::time::Duration;
 
-const SECS_IN_MINUTE: u64 = 60;
-const SECS_IN_HOUR: u64 = SECS_IN_MINUTE * 60;
-const SECS_IN_DAY: u64 = SECS_IN_HOUR * 24;
-
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 pub struct Instant(Duration);
 
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-pub struct SystemTime(Duration);
+#[derive(Copy, Clone, Debug)]
+pub struct SystemTime(r_efi::efi::Time);
+
+/// Deriving does not work because we need to account for timezone
+impl Ord for SystemTime {
+    fn cmp(&self, other: &Self) -> Ordering {
+        system_time_internal::UnixTime::from_uefi(&self.0)
+            .cmp(&system_time_internal::UnixTime::from_uefi(&other.0))
+    }
+}
+
+impl PartialOrd for SystemTime {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+/// Deriving does not work because we need to account for timezone
+impl PartialEq for SystemTime {
+    fn eq(&self, other: &Self) -> bool {
+        system_time_internal::UnixTime::from_uefi(&self.0)
+            == system_time_internal::UnixTime::from_uefi(&other.0)
+    }
+}
+
+impl Eq for SystemTime {}
 
-pub const UNIX_EPOCH: SystemTime = SystemTime(Duration::from_secs(0));
+impl crate::hash::Hash for SystemTime {
+    fn hash<H: crate::hash::Hasher>(&self, state: &mut H) {
+        system_time_internal::UnixTime::from_uefi(&self.0).hash(state);
+    }
+}
+
+pub const UNIX_EPOCH: SystemTime = SystemTime(r_efi::efi::Time {
+    year: 1970,
+    month: 1,
+    day: 1,
+    hour: 0,
+    minute: 0,
+    second: 0,
+    nanosecond: 0,
+    timezone: 0,
+    daylight: 0,
+    pad1: 0,
+    pad2: 0,
+});
 
 impl Instant {
     pub fn now() -> Instant {
@@ -40,21 +79,39 @@ impl Instant {
 }
 
 impl SystemTime {
+    pub(crate) const fn from_uefi(t: r_efi::efi::Time) -> Self {
+        Self(t)
+    }
+
+    #[expect(dead_code)]
+    pub(crate) const fn to_uefi(self) -> r_efi::efi::Time {
+        self.0
+    }
+
     pub fn now() -> SystemTime {
         system_time_internal::now()
             .unwrap_or_else(|| panic!("time not implemented on this platform"))
     }
 
     pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
-        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
+        system_time_internal::UnixTime::from_uefi(&self.0)
+            .sub_time(system_time_internal::UnixTime::from_uefi(&other.0))
     }
 
     pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime(self.0.checked_add(*other)?))
+        Some(
+            system_time_internal::UnixTime::from_uefi(&self.0)
+                .checked_add(*other)
+                .to_systemtime(self.0.timezone, self.0.daylight),
+        )
     }
 
     pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime(self.0.checked_sub(*other)?))
+        Some(
+            system_time_internal::UnixTime::from_uefi(&self.0)
+                .checked_sub(*other)
+                .to_systemtime(self.0.timezone, self.0.daylight),
+        )
     }
 }
 
@@ -63,9 +120,179 @@ pub(crate) mod system_time_internal {
 
     use super::super::helpers;
     use super::*;
+    use crate::cmp::Ordering;
     use crate::mem::MaybeUninit;
     use crate::ptr::NonNull;
 
+    const SECS_IN_MINUTE: i64 = 60;
+    const SECS_IN_HOUR: i64 = SECS_IN_MINUTE * 60;
+    const SECS_IN_DAY: i64 = SECS_IN_HOUR * 24;
+    const NS_PER_SEC: u32 = 1_000_000_000;
+
+    #[derive(Eq, PartialEq, Hash)]
+    pub(crate) struct UnixTime {
+        secs: i64,
+        nanos: u32,
+    }
+
+    impl UnixTime {
+        // This algorithm is based on the one described in the post
+        // https://blog.reverberate.org/2020/05/12/optimizing-date-algorithms.html
+        pub(crate) const fn from_uefi(t: &Time) -> Self {
+            assert!(t.month <= 12);
+            assert!(t.month != 0);
+
+            const YEAR_BASE: u32 = 4800; /* Before min year, multiple of 400. */
+
+            // Calculate the number of days since 1/1/1970
+            // Use 1 March as the start
+            let (m_adj, overflow): (u32, bool) = (t.month as u32).overflowing_sub(3);
+            let (carry, adjust): (u32, u32) = if overflow { (1, 12) } else { (0, 0) };
+            let y_adj: u32 = (t.year as u32) + YEAR_BASE - carry;
+            let month_days: u32 = (m_adj.wrapping_add(adjust) * 62719 + 769) / 2048;
+            let leap_days: u32 = y_adj / 4 - y_adj / 100 + y_adj / 400;
+
+            // Allow days to be negative to denote days before EPOCH
+            let days: i64 =
+                (y_adj * 365 + leap_days + month_days + (t.day as u32 - 1)) as i64 - 2472632;
+
+            let localtime_epoch: i64 = days * SECS_IN_DAY
+                + (t.second as i64)
+                + (t.minute as i64) * SECS_IN_MINUTE
+                + (t.hour as i64) * SECS_IN_HOUR;
+
+            let utc_epoch: i64 = if t.timezone == r_efi::efi::UNSPECIFIED_TIMEZONE {
+                localtime_epoch
+            } else {
+                localtime_epoch + (t.timezone as i64) * SECS_IN_MINUTE
+            };
+
+            Self { secs: utc_epoch, nanos: t.nanosecond }
+        }
+
+        /// This algorithm is taken from: http://howardhinnant.github.io/date_algorithms.html
+        pub(crate) const fn to_systemtime(&self, timezone: i16, daylight: u8) -> super::SystemTime {
+            let secs: i64 = if timezone == r_efi::efi::UNSPECIFIED_TIMEZONE {
+                self.secs
+            } else {
+                self.secs - (timezone as i64) * SECS_IN_MINUTE
+            };
+
+            let (days, remaining_secs): (i64, u64) = {
+                let days = secs / SECS_IN_DAY;
+                let remaining_secs = secs % SECS_IN_DAY;
+
+                if remaining_secs < 0 {
+                    (days - 1, (SECS_IN_DAY + remaining_secs) as u64)
+                } else {
+                    (days, remaining_secs as u64)
+                }
+            };
+
+            let z = days + 719468;
+            let era = z / 146097;
+            let doe = z - (era * 146097);
+            let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+            let mut y = yoe + era * 400;
+            let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+            let mp = (5 * doy + 2) / 153;
+            let d = doy - (153 * mp + 2) / 5 + 1;
+            let m = if mp < 10 { mp + 3 } else { mp - 9 };
+
+            if m <= 2 {
+                y += 1;
+            }
+
+            let hour = (remaining_secs / SECS_IN_HOUR as u64) as u8;
+            let minute = ((remaining_secs % SECS_IN_HOUR as u64) / SECS_IN_MINUTE as u64) as u8;
+            let second = (remaining_secs % SECS_IN_MINUTE as u64) as u8;
+
+            super::SystemTime::from_uefi(Time {
+                year: y as u16,
+                month: m as u8,
+                day: d as u8,
+                hour,
+                minute,
+                second,
+                nanosecond: self.nanos,
+                timezone,
+                daylight,
+                pad1: 0,
+                pad2: 0,
+            })
+        }
+
+        pub(crate) const fn checked_add(&self, dur: Duration) -> Self {
+            let temp: u32 = self.nanos + dur.subsec_nanos();
+            let nanos: u32 = temp % NS_PER_SEC;
+            let secs: i64 = self.secs + dur.as_secs() as i64 + (temp / NS_PER_SEC) as i64;
+
+            Self { secs, nanos }
+        }
+
+        pub(crate) const fn checked_sub(&self, dur: Duration) -> Self {
+            let (secs, nanos) = if self.nanos < dur.subsec_nanos() {
+                let temp = NS_PER_SEC + self.nanos - dur.subsec_nanos();
+                (self.secs - dur.as_secs() as i64 - 1, temp)
+            } else {
+                (self.secs - dur.as_secs() as i64, self.nanos - dur.subsec_nanos())
+            };
+
+            Self { secs, nanos }
+        }
+
+        pub(crate) fn sub_time(self, other: Self) -> Result<Duration, Duration> {
+            if self >= other {
+                let temp = self - other;
+                assert!(temp.secs > 0);
+
+                Ok(Duration::new(temp.secs as u64, temp.nanos))
+            } else {
+                let temp = other - self;
+                assert!(temp.secs > 0);
+
+                Err(Duration::new(temp.secs as u64, temp.nanos))
+            }
+        }
+    }
+
+    impl Ord for UnixTime {
+        fn cmp(&self, other: &Self) -> Ordering {
+            if self.secs > other.secs {
+                Ordering::Greater
+            } else if self.secs < other.secs {
+                Ordering::Less
+            } else if self.nanos > other.nanos {
+                Ordering::Greater
+            } else if self.nanos < other.nanos {
+                Ordering::Less
+            } else {
+                Ordering::Equal
+            }
+        }
+    }
+
+    impl PartialOrd for UnixTime {
+        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+            Some(self.cmp(other))
+        }
+    }
+
+    impl crate::ops::Sub for UnixTime {
+        type Output = Self;
+
+        fn sub(self, other: Self) -> Self {
+            let (secs, nanos) = if self.nanos < other.nanos {
+                let temp = NS_PER_SEC + self.nanos - other.nanos;
+                (self.secs - other.secs - 1, temp)
+            } else {
+                (self.secs - other.secs, self.nanos - other.nanos)
+            };
+
+            Self { secs, nanos }
+        }
+    }
+
     pub fn now() -> Option<SystemTime> {
         let runtime_services: NonNull<RuntimeServices> = helpers::runtime_services()?;
         let mut t: MaybeUninit<Time> = MaybeUninit::uninit();
@@ -79,38 +306,7 @@ pub(crate) mod system_time_internal {
 
         let t = unsafe { t.assume_init() };
 
-        Some(SystemTime(uefi_time_to_duration(t)))
-    }
-
-    // This algorithm is based on the one described in the post
-    // https://blog.reverberate.org/2020/05/12/optimizing-date-algorithms.html
-    pub(crate) const fn uefi_time_to_duration(t: r_efi::system::Time) -> Duration {
-        assert!(t.month <= 12);
-        assert!(t.month != 0);
-
-        const YEAR_BASE: u32 = 4800; /* Before min year, multiple of 400. */
-
-        // Calculate the number of days since 1/1/1970
-        // Use 1 March as the start
-        let (m_adj, overflow): (u32, bool) = (t.month as u32).overflowing_sub(3);
-        let (carry, adjust): (u32, u32) = if overflow { (1, 12) } else { (0, 0) };
-        let y_adj: u32 = (t.year as u32) + YEAR_BASE - carry;
-        let month_days: u32 = (m_adj.wrapping_add(adjust) * 62719 + 769) / 2048;
-        let leap_days: u32 = y_adj / 4 - y_adj / 100 + y_adj / 400;
-        let days: u32 = y_adj * 365 + leap_days + month_days + (t.day as u32 - 1) - 2472632;
-
-        let localtime_epoch: u64 = (days as u64) * SECS_IN_DAY
-            + (t.second as u64)
-            + (t.minute as u64) * SECS_IN_MINUTE
-            + (t.hour as u64) * SECS_IN_HOUR;
-
-        let utc_epoch: u64 = if t.timezone == r_efi::efi::UNSPECIFIED_TIMEZONE {
-            localtime_epoch
-        } else {
-            (localtime_epoch as i64 + (t.timezone as i64) * SECS_IN_MINUTE as i64) as u64
-        };
-
-        Duration::new(utc_epoch, t.nanosecond)
+        Some(SystemTime::from_uefi(t))
     }
 }