std: sys: pal: uefi: Overhaul Time

Use UEFI time format for SystemTime. Cannot use the UEFI struct directly
since it does not implement proper traits.

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, Hash, Eq)]
+pub struct SystemTime {
+    year: u16,
+    month: u8,
+    day: u8,
+    hour: u8,
+    minute: u8,
+    second: u8,
+    nanosecond: u32,
+    timezone: i16,
+    daylight: u8,
+}
+
+/// 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_systemtime(self)
+            .cmp(&system_time_internal::UnixTime::from_systemtime(other))
+    }
+}
+
+impl PartialOrd for SystemTime {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
 
-pub const UNIX_EPOCH: SystemTime = SystemTime(Duration::from_secs(0));
+/// 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_systemtime(self)
+            == system_time_internal::UnixTime::from_systemtime(other)
+    }
+}
+
+pub const UNIX_EPOCH: SystemTime = SystemTime {
+    year: 1970,
+    month: 1,
+    day: 1,
+    hour: 0,
+    minute: 0,
+    second: 0,
+    nanosecond: 0,
+    timezone: 0,
+    daylight: 0,
+};
 
 impl Instant {
     pub fn now() -> Instant {
@@ -40,21 +79,61 @@ impl Instant {
 }
 
 impl SystemTime {
+    pub(crate) const fn from_uefi(t: &r_efi::efi::Time) -> Self {
+        Self {
+            year: t.year,
+            month: t.month,
+            day: t.day,
+            hour: t.hour,
+            minute: t.minute,
+            second: t.second,
+            nanosecond: t.nanosecond,
+            timezone: t.timezone,
+            daylight: t.daylight,
+        }
+    }
+
+    #[expect(dead_code)]
+    pub(crate) const fn to_uefi(&self) -> r_efi::efi::Time {
+        r_efi::efi::Time {
+            year: self.year,
+            month: self.month,
+            day: self.day,
+            hour: self.hour,
+            minute: self.minute,
+            second: self.second,
+            nanosecond: self.nanosecond,
+            timezone: self.timezone,
+            daylight: self.daylight,
+            pad1: 0,
+            pad2: 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_systemtime(self)
+            .sub_time(system_time_internal::UnixTime::from_systemtime(other))
     }
 
     pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime(self.0.checked_add(*other)?))
+        Some(
+            system_time_internal::UnixTime::from_systemtime(self)
+                .checked_add(*other)
+                .to_systemtime(self.timezone, self.daylight),
+        )
     }
 
     pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
-        Some(SystemTime(self.0.checked_sub(*other)?))
+        Some(
+            system_time_internal::UnixTime::from_systemtime(self)
+                .checked_sub(*other)
+                .to_systemtime(self.timezone, self.daylight),
+        )
     }
 }
 
@@ -63,9 +142,177 @@ 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)]
+    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_systemtime(t: &super::SystemTime) -> 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 {
+                year: y as u16,
+                month: m as u8,
+                day: d as u8,
+                hour,
+                minute,
+                second,
+                nanosecond: self.nanos,
+                timezone,
+                daylight,
+            }
+        }
+
+        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 +326,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))
     }
 }