Merge pull request #977 from nicholasbishop/bishop-atomic-system-table

uefi-services: Change SYSTEM_TABLE to an atomic pointer

Author: phip1611

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Added
 - Implemented `Index`, `IndexMut`, `get`, and `get_mut` on `MemoryMap`.
+- Added `SystemTable::as_ptr`.
 
 ### Changed
 - We fixed a memory leak in `GraphicsOutput::query_mode`. As a consequence, we

uefi-services/src/lib.rs

@@ -36,7 +36,8 @@ extern crate uefi;
 
 use core::ffi::c_void;
 use core::fmt::Write;
-use core::ptr::NonNull;
+use core::ptr::{self, NonNull};
+use core::sync::atomic::{AtomicPtr, Ordering};
 
 use cfg_if::cfg_if;
 
@@ -50,12 +51,24 @@ use uefi::{Event, Result};
 /// This table is only fully safe to use until UEFI boot services have been exited.
 /// After that, some fields and methods are unsafe to use, see the documentation of
 /// UEFI's ExitBootServices entry point for more details.
-static mut SYSTEM_TABLE: Option<SystemTable<Boot>> = None;
+static SYSTEM_TABLE: AtomicPtr<c_void> = AtomicPtr::new(ptr::null_mut());
 
 /// Global logger object
 #[cfg(feature = "logger")]
 static mut LOGGER: Option<uefi::logger::Logger> = None;
 
+#[must_use]
+fn system_table_opt() -> Option<SystemTable<Boot>> {
+    let ptr = SYSTEM_TABLE.load(Ordering::Acquire);
+    // Safety: the `SYSTEM_TABLE` pointer either be null or a valid system
+    // table.
+    //
+    // Null is the initial value, as well as the value set when exiting boot
+    // services. Otherwise, the value is set by the call to `init`, which
+    // requires a valid system table reference as input.
+    unsafe { SystemTable::from_ptr(ptr) }
+}
+
 /// Obtains a pointer to the system table.
 ///
 /// This is meant to be used by higher-level libraries,
@@ -66,28 +79,23 @@ static mut LOGGER: Option<uefi::logger::Logger> = None;
 /// The returned pointer is only valid until boot services are exited.
 #[must_use]
 pub fn system_table() -> SystemTable<Boot> {
-    unsafe {
-        let table_ref = SYSTEM_TABLE
-            .as_ref()
-            .expect("The system table handle is not available");
-        table_ref.unsafe_clone()
-    }
+    system_table_opt().expect("The system table handle is not available")
 }
 
 /// Initialize the UEFI utility library.
 ///
 /// This must be called as early as possible,
 /// before trying to use logging or memory allocation capabilities.
 pub fn init(st: &mut SystemTable<Boot>) -> Result<Option<Event>> {
-    unsafe {
+    if system_table_opt().is_some() {
         // Avoid double initialization.
-        if SYSTEM_TABLE.is_some() {
-            return Status::SUCCESS.to_result_with_val(|| None);
-        }
+        return Status::SUCCESS.to_result_with_val(|| None);
+    }
 
-        // Setup the system table singleton
-        SYSTEM_TABLE = Some(st.unsafe_clone());
+    // Setup the system table singleton
+    SYSTEM_TABLE.store(st.as_ptr().cast_mut(), Ordering::Release);
 
+    unsafe {
         // Setup logging and memory allocation
 
         #[cfg(feature = "logger")]
@@ -111,15 +119,10 @@ pub fn init(st: &mut SystemTable<Boot>) -> Result<Option<Event>> {
 // Internal function for print macros.
 #[doc(hidden)]
 pub fn _print(args: core::fmt::Arguments) {
-    unsafe {
-        let st = SYSTEM_TABLE
-            .as_mut()
-            .expect("The system table handle is not available");
-
-        st.stdout()
-            .write_fmt(args)
-            .expect("Failed to write to stdout");
-    }
+    system_table()
+        .stdout()
+        .write_fmt(args)
+        .expect("Failed to write to stdout");
 }
 
 /// Prints to the standard output.
@@ -185,7 +188,7 @@ unsafe extern "efiapi" fn exit_boot_services(_e: Event, _ctx: Option<NonNull<c_v
     //        check that the callback does get called.
     //
     // info!("Shutting down the UEFI utility library");
-    SYSTEM_TABLE = None;
+    SYSTEM_TABLE.store(ptr::null_mut(), Ordering::Release);
 
     #[cfg(feature = "logger")]
     if let Some(ref mut logger) = LOGGER {
@@ -201,7 +204,7 @@ fn panic_handler(info: &core::panic::PanicInfo) -> ! {
     println!("[PANIC]: {}", info);
 
     // Give the user some time to read the message
-    if let Some(st) = unsafe { SYSTEM_TABLE.as_ref() } {
+    if let Some(st) = system_table_opt() {
         st.boot_services().stall(10_000_000);
     } else {
         let mut dummy = 0u64;
@@ -222,7 +225,7 @@ fn panic_handler(info: &core::panic::PanicInfo) -> ! {
             qemu_exit_handle.exit_failure();
         } else {
             // If the system table is available, use UEFI's standard shutdown mechanism
-            if let Some(st) = unsafe { SYSTEM_TABLE.as_ref() } {
+            if let Some(st) = system_table_opt() {
                 use uefi::table::runtime::ResetType;
                 st.runtime_services()
                     .reset(ResetType::SHUTDOWN, uefi::Status::ABORTED, None);

uefi/src/table/system.rs

@@ -113,6 +113,12 @@ impl<View: SystemTableView> SystemTable<View> {
             _marker: PhantomData,
         })
     }
+
+    /// Get the underlying raw pointer.
+    #[must_use]
+    pub fn as_ptr(&self) -> *const c_void {
+        self.table.cast()
+    }
 }
 
 // These parts of the UEFI System Table interface may only be used until boot