Initial implementation of Instant using TSC

Signed-off-by: Ayush <ayushsingh1325@gmail.com>

Author: Ayush1325

Cargo.lock

@@ -2946,7 +2946,7 @@ dependencies = [
 [[package]]
 name = "r-efi"
 version = "4.0.0"
-source = "git+https://github.com/r-efi/r-efi#30e0e8b8552179e1cc7f054a8b64f243db7c9bee"
+source = "git+https://github.com/r-efi/r-efi#2c5125e697c68010813c1dfbc68de4ba573f277d"
 dependencies = [
  "compiler_builtins",
  "rustc-std-workspace-core",

library/std/src/os/uefi/env.rs

@@ -50,8 +50,7 @@ pub fn get_runtime_services() -> Option<NonNull<RuntimeServices>> {
 
 /// Open Protocol on a handle
 /// Implemented using `EFI_BOOT_SERVICES.OpenProtocol()`
-#[unstable(feature = "uefi_std", issue = "100499")]
-pub fn open_protocol<T>(
+pub(crate) fn open_protocol<T>(
     handle: NonNull<c_void>,
     mut protocol_guid: Guid,
 ) -> io::Result<NonNull<T>> {
@@ -82,8 +81,7 @@ pub fn open_protocol<T>(
 
 // Locate handles with a particular protocol GUID
 /// Implemented using `EFI_BOOT_SERVICES.LocateHandles()`
-#[unstable(feature = "uefi_std", issue = "100499")]
-pub fn locate_handles(mut guid: Guid) -> io::Result<Vec<NonNull<c_void>>> {
+pub(crate) fn locate_handles(mut guid: Guid) -> io::Result<Vec<NonNull<c_void>>> {
     fn inner(
         guid: &mut Guid,
         boot_services: NonNull<BootServices>,

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

@@ -1,33 +1,66 @@
-//! Time is implemeted using `EFI_RUNTIME_SERVICES.GetTime()`
-//! While this is  not technically monotonic, the single-threaded nature of UEFI might make it fine
-//! to use for Instant. Still, maybe revisit this in future.
-
+use crate::mem::MaybeUninit;
 use crate::os::uefi;
+use crate::ptr::NonNull;
+use crate::sys_common::mul_div_u64;
 use crate::time::Duration;
 
+use r_efi::protocols::timestamp;
+
 #[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);
 
 pub const UNIX_EPOCH: SystemTime = SystemTime(Duration::ZERO);
+const NS_PER_SEC: u64 = 1_000_000_000;
 
 impl Instant {
     pub fn now() -> Instant {
+        if let Ok(handles) = crate::os::uefi::env::locate_handles(timestamp::PROTOCOL_GUID) {
+            // First try using `EFI_TIMESTAMP_PROTOCOL` if present
+            for handle in handles {
+                let protocol: NonNull<timestamp::Protocol> =
+                    match uefi::env::open_protocol(handle, timestamp::PROTOCOL_GUID) {
+                        Ok(x) => x,
+                        Err(_) => continue,
+                    };
+                let mut properties: MaybeUninit<timestamp::Properties> = MaybeUninit::uninit();
+                let r = unsafe { ((*protocol.as_ptr()).get_properties)(properties.as_mut_ptr()) };
+                if r.is_error() {
+                    continue;
+                } else {
+                    let properties = unsafe { properties.assume_init() };
+                    let ts = unsafe { ((*protocol.as_ptr()).get_timestamp)() };
+                    let frequency = properties.frequency;
+                    let ns = mul_div_u64(ts, NS_PER_SEC, frequency);
+                    return Instant(Duration::from_nanos(ns));
+                }
+            }
+        }
+
+        // Try using raw CPU Registers
+        // Currently only implemeted for x86_64 using CPUID (0x15) and TSC register
+        #[cfg(target_arch = "x86_64")]
+        if let Some(ns) = get_timestamp() {
+            return Instant(Duration::from_nanos(ns));
+        }
+
         if let Some(runtime_services) = uefi::env::get_runtime_services() {
+            // Finally just use `EFI_RUNTIME_SERVICES.GetTime()`
             let mut t = r_efi::efi::Time::default();
             let r =
                 unsafe { ((*runtime_services.as_ptr()).get_time)(&mut t, crate::ptr::null_mut()) };
 
             if r.is_error() {
                 panic!("time not implemented on this platform")
             } else {
-                Instant(uefi_time_to_duration(t))
+                return Instant(uefi_time_to_duration(t));
             }
-        } else {
-            panic!("Runtime Services are needed for Time to work")
         }
+
+        // Panic if nothing works
+        panic!("Failed to create Instant")
     }
 
     pub fn checked_sub_instant(&self, other: &Instant) -> Option<Duration> {
@@ -100,3 +133,43 @@ fn uefi_time_to_duration(t: r_efi::system::Time) -> Duration {
 
     Duration::new(utc_epoch, t.nanosecond)
 }
+
+// Returns the Frequency in Mhz
+// Mostly based on [`edk2/UefiCpuPkg/Library/CpuTimerLib/CpuTimerLib.c`](https://github.com/tianocore/edk2/blob/master/UefiCpuPkg/Library/CpuTimerLib/CpuTimerLib.c)
+// Currently implemented only for x86_64 but can be extended for other arch if they ever support
+// std.
+#[cfg(target_arch = "x86_64")]
+fn frequency() -> Option<u64> {
+    use crate::sync::atomic::{AtomicU64, Ordering};
+
+    static FREQUENCY: AtomicU64 = AtomicU64::new(0);
+
+    let cached = FREQUENCY.load(Ordering::Relaxed);
+    if cached != 0 {
+        return Some(cached);
+    }
+
+    if crate::arch::x86_64::has_cpuid() {
+        let cpuid = unsafe { crate::arch::x86_64::__cpuid(0x15) };
+
+        if cpuid.eax == 0 || cpuid.ebx == 0 || cpuid.ecx == 0 {
+            return None;
+        }
+
+        let freq = mul_div_u64(cpuid.ecx as u64, cpuid.ebx as u64, cpuid.eax as u64);
+        FREQUENCY.store(freq, Ordering::Relaxed);
+        return Some(freq);
+    }
+
+    None
+}
+
+// Currently implemented only for x86_64 but can be extended for other arch if they ever support
+// std.
+#[cfg(target_arch = "x86_64")]
+fn get_timestamp() -> Option<u64> {
+    let freq = frequency()?;
+    let ts = unsafe { crate::arch::x86_64::_rdtsc() };
+    let ns = mul_div_u64(ts, 1000, freq);
+    Some(ns)
+}