Add Minimal Std implementation for UEFI

Implemented modules:
1. alloc
2. os_str
3. env
4. math

Tracking Issue: rust-lang#100499
API Change Proposal: rust-lang/libs-team#87

This was originally part of rust-lang#100316. Since
that PR was becoming too unwieldy and cluttered, and with suggestion
from @dvdhrm, I have extracted a minimal std implementation to this PR.

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

Author: Ayush1325

panic_abort/src/lib.rs

@@ -45,6 +45,7 @@ pub unsafe fn __rust_start_panic(_payload: &mut dyn PanicPayload) -> u32 {
         } else if #[cfg(any(target_os = "hermit",
                             all(target_vendor = "fortanix", target_env = "sgx"),
                             target_os = "xous"
+                            target_os = "uefi",
         ))] {
             unsafe fn abort() -> ! {
                 // call std::sys::abort_internal

std/Cargo.toml

@@ -48,6 +48,10 @@ hermit-abi = { version = "0.3.2", features = ['rustc-dep-of-std'], public = true
 [target.'cfg(target_os = "wasi")'.dependencies]
 wasi = { version = "0.11.0", features = ['rustc-dep-of-std'], default-features = false }
 
+[target.'cfg(target_os = "uefi")'.dependencies]
+r-efi = { version = "4.1.0", features = ['rustc-dep-of-std', 'efiapi']}
+r-efi-alloc = { version = "1.0.0", features = ['rustc-dep-of-std']}
+
 [features]
 backtrace = [
   "gimli-symbolize",

std/build.rs

@@ -39,6 +39,7 @@ fn main() {
         || target.contains("nto")
         || target.contains("xous")
         || target.contains("hurd")
+        || target.contains("uefi")
         // See src/bootstrap/synthetic_targets.rs
         || env::var("RUSTC_BOOTSTRAP_SYNTHETIC_TARGET").is_ok()
     {
@@ -51,7 +52,7 @@ fn main() {
         // - mipsel-sony-psp
         // - nvptx64-nvidia-cuda
         // - arch=avr
-        // - uefi (x86_64-unknown-uefi, i686-unknown-uefi)
+        // - tvos (aarch64-apple-tvos, x86_64-apple-tvos)
         // - JSON targets
         // - Any new targets that have not been explicitly added above.
         println!("cargo:rustc-cfg=feature=\"restricted-std\"");

std/src/lib.rs

@@ -263,7 +263,6 @@
 #![cfg_attr(target_os = "xous", feature(slice_ptr_len))]
 //
 // Language features:
-// tidy-alphabetical-start
 #![feature(alloc_error_handler)]
 #![feature(allocator_internals)]
 #![feature(allow_internal_unsafe)]

std/src/os/mod.rs

@@ -142,6 +142,8 @@ pub mod solid;
 #[cfg(target_os = "tvos")]
 #[path = "ios/mod.rs"]
 pub(crate) mod tvos;
+#[cfg(target_os = "uefi")]
+pub mod uefi;
 #[cfg(target_os = "vita")]
 pub mod vita;
 #[cfg(target_os = "vxworks")]

std/src/os/uefi/env.rs

@@ -0,0 +1,54 @@
+//! UEFI-specific extensions to the primitives in `std::env` module
+
+use crate::ffi::c_void;
+use crate::ptr::NonNull;
+use crate::sync::atomic::{AtomicPtr, Ordering};
+use crate::sync::OnceLock;
+
+// Position 0 = SystemTable
+// Position 1 = ImageHandle
+static GLOBALS: OnceLock<(AtomicPtr<c_void>, AtomicPtr<c_void>)> = OnceLock::new();
+
+/// Initializes the global System Table and Image Handle pointers.
+///
+/// The standard library requires access to the UEFI System Table and the Application Image Handle
+/// to operate. Those are provided to UEFI Applications via their application entry point. By
+/// calling `init_globals()`, those pointers are retained by the standard library for future use.
+/// The pointers are never exposed to any entity outside of this application and it is guaranteed
+/// that, once the application exited, these pointers are never dereferenced again.
+///
+/// Callers are required to ensure the pointers are valid for the entire lifetime of this
+/// application. In particular, UEFI Boot Services must not be exited while an application with the
+/// standard library is loaded.
+///
+/// This function must not be called more than once.
+#[unstable(feature = "uefi_std", issue = "100499")]
+pub unsafe fn init_globals(handle: NonNull<c_void>, system_table: NonNull<c_void>) {
+    GLOBALS.set((AtomicPtr::new(system_table.as_ptr()), AtomicPtr::new(handle.as_ptr()))).unwrap()
+}
+
+/// Get the SystemTable Pointer.
+/// Note: This function panics if the System Table and Image Handle is Not initialized
+#[unstable(feature = "uefi_std", issue = "100499")]
+pub fn system_table() -> NonNull<c_void> {
+    try_system_table().unwrap()
+}
+
+/// Get the SystemHandle Pointer.
+/// Note: This function panics if the System Table and Image Handle is Not initialized
+#[unstable(feature = "uefi_std", issue = "100499")]
+pub fn image_handle() -> NonNull<c_void> {
+    try_image_handle().unwrap()
+}
+
+/// Get the SystemTable Pointer.
+/// This function is mostly intended for places where panic is not an option
+pub(crate) fn try_system_table() -> Option<NonNull<crate::ffi::c_void>> {
+    NonNull::new(GLOBALS.get()?.0.load(Ordering::Acquire))
+}
+
+/// Get the SystemHandle Pointer.
+/// This function is mostly intended for places where panic is not an option
+pub(crate) fn try_image_handle() -> Option<NonNull<crate::ffi::c_void>> {
+    NonNull::new(GLOBALS.get()?.1.load(Ordering::Acquire))
+}

std/src/os/uefi/mod.rs

@@ -0,0 +1,7 @@
+//! Platform-specific extensions to `std` for UEFI.
+
+#![unstable(feature = "uefi_std", issue = "100499")]
+
+pub mod env;
+#[path = "../windows/ffi.rs"]
+pub mod ffi;

std/src/sys/common/thread_local/mod.rs

@@ -6,7 +6,7 @@
 // "static" is for single-threaded platforms where a global static is sufficient.
 
 cfg_if::cfg_if! {
-    if #[cfg(all(target_family = "wasm", not(target_feature = "atomics")))] {
+    if #[cfg(any(all(target_family = "wasm", not(target_feature = "atomics")), target_os = "uefi"))] {
         #[doc(hidden)]
         mod static_local;
         #[doc(hidden)]

std/src/sys/mod.rs

@@ -47,6 +47,9 @@ cfg_if::cfg_if! {
     } else if #[cfg(target_os = "xous")] {
         mod xous;
         pub use self::xous::*;
+    } else if #[cfg(target_os = "uefi")] {
+        mod uefi;
+        pub use self::uefi::*;
     } else if #[cfg(all(target_vendor = "fortanix", target_env = "sgx"))] {
         mod sgx;
         pub use self::sgx::*;

std/src/sys/uefi/alloc.rs

@@ -0,0 +1,32 @@
+//! Global Allocator for UEFI.
+//! Uses [r-efi-alloc](https://crates.io/crates/r-efi-alloc)
+
+use crate::alloc::{handle_alloc_error, GlobalAlloc, Layout, System};
+
+const MEMORY_TYPE: u32 = r_efi::efi::LOADER_DATA;
+
+#[stable(feature = "alloc_system_type", since = "1.28.0")]
+unsafe impl GlobalAlloc for System {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let system_table = match crate::os::uefi::env::try_system_table() {
+            None => return crate::ptr::null_mut(),
+            Some(x) => x.as_ptr() as *mut _,
+        };
+
+        if layout.size() > 0 {
+            unsafe { r_efi_alloc::raw::alloc(system_table, layout, MEMORY_TYPE) }
+        } else {
+            layout.dangling().as_ptr()
+        }
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let system_table = match crate::os::uefi::env::try_system_table() {
+            None => handle_alloc_error(layout),
+            Some(x) => x.as_ptr() as *mut _,
+        };
+        if layout.size() > 0 {
+            unsafe { r_efi_alloc::raw::dealloc(system_table, ptr, layout) }
+        }
+    }
+}