uefi::helper: clean up, multiple sub modules

phip1611 · phip1611 · commit c6d7bd785569 · 2024-04-13T11:41:26.000+02:00
I didn't change anything about the implementations, just moved the existing code into the
corresponding modules.
diff --git a/uefi/src/allocator.rs b/uefi/src/allocator.rs
@@ -130,5 +130,3 @@ unsafe impl GlobalAlloc for Allocator {
         (*boot_services()).free_pool(ptr).unwrap();
     }
 }
-
-
diff --git a/uefi/src/helpers/global_allocator.rs b/uefi/src/helpers/global_allocator.rs
@@ -0,0 +1,4 @@
+use crate::allocator::Allocator;
+
+#[global_allocator]
+static ALLOCATOR: Allocator = Allocator;
diff --git a/uefi/src/helpers/logger.rs b/uefi/src/helpers/logger.rs
@@ -14,10 +14,36 @@
 
 use crate::proto::console::text::Output;
 
+use crate::helpers::logger;
+use crate::prelude::{Boot, SystemTable};
 use core::fmt::{self, Write};
 use core::ptr;
 use core::sync::atomic::{AtomicPtr, Ordering};
 
+/// Global logger object
+#[cfg(feature = "logger")]
+static LOGGER: logger::Logger = logger::Logger::new();
+
+/// Set up logging
+///
+/// This is unsafe because you must arrange for the logger to be reset with
+/// disable() on exit from UEFI boot services.
+#[cfg(feature = "logger")]
+pub unsafe fn init(st: &mut SystemTable<Boot>) {
+    // Connect the logger to stdout.
+    LOGGER.set_output(st.stdout());
+
+    // Set the logger.
+    log::set_logger(&LOGGER).unwrap(); // Can only fail if already initialized.
+
+    // Set logger max level to level specified by log features
+    log::set_max_level(log::STATIC_MAX_LEVEL);
+}
+
+pub fn disable() {
+    LOGGER.disable();
+}
+
 /// Logging implementation which writes to a UEFI output stream.
 ///
 /// If this logger is used as a global logger, you must disable it using the
diff --git a/uefi/src/helpers/mod.rs b/uefi/src/helpers/mod.rs
@@ -12,34 +12,33 @@
 //! **PLEASE NOTE** that these helpers are meant for the pre exit boot service
 //! epoch.
 
-#[cfg(feature = "logger")]
-pub mod logger;
-
-#[cfg(feature = "panic_handler")]
-use cfg_if::cfg_if;
+use crate::prelude::{Boot, SystemTable};
+use crate::Event;
+use crate::Result;
+use crate::StatusExt;
 use core::ffi::c_void;
-use core::fmt::Write;
-use core::ptr::{self, NonNull};
+use core::ptr;
+use core::ptr::NonNull;
 use core::sync::atomic::{AtomicPtr, Ordering};
-use log::Log;
-use uefi::allocator::Allocator;
-use uefi::table::boot::{EventType, Tpl};
-use uefi::table::{Boot, SystemTable};
-use uefi::{Event, Result, Status, StatusExt};
+#[doc(hidden)]
+pub use println::_print;
+use uefi_raw::table::boot::{EventType, Tpl};
+use uefi_raw::Status;
 
-#[cfg_attr(feature = "global_allocator", global_allocator)]
-static ALLOCATOR: Allocator = Allocator;
+#[cfg(feature = "global_allocator")]
+mod global_allocator;
+#[cfg(feature = "logger")]
+mod logger;
+#[cfg(feature = "panic_handler")]
+mod panic_handler;
+mod println;
 
 /// Reference to the system table.
 ///
 /// 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 SYSTEM_TABLE: AtomicPtr<c_void> = AtomicPtr::new(ptr::null_mut());
-
-/// Global logger object
-#[cfg(feature = "logger")]
-static LOGGER: logger::Logger = logger::Logger::new();
+static SYSTEM_TABLE: AtomicPtr<c_void> = AtomicPtr::new(core::ptr::null_mut());
 
 #[must_use]
 fn system_table_opt() -> Option<SystemTable<Boot>> {
@@ -62,7 +61,7 @@ fn system_table_opt() -> Option<SystemTable<Boot>> {
 ///
 /// The returned pointer is only valid until boot services are exited.
 #[must_use]
-pub fn system_table() -> SystemTable<Boot> {
+fn system_table() -> SystemTable<Boot> {
     system_table_opt().expect("The system table handle is not available")
 }
 
@@ -87,7 +86,7 @@ pub fn init(st: &mut SystemTable<Boot>) -> Result<Option<Event>> {
         // Setup logging and memory allocation
 
         #[cfg(feature = "logger")]
-        init_logger(st);
+        logger::init(st);
 
         uefi::allocator::init(st);
 
@@ -104,64 +103,6 @@ pub fn init(st: &mut SystemTable<Boot>) -> Result<Option<Event>> {
     }
 }
 
-/// INTERNAL API! Helper for print macros.
-#[doc(hidden)]
-pub fn _print(args: core::fmt::Arguments) {
-    system_table()
-        .stdout()
-        .write_fmt(args)
-        .expect("Failed to write to stdout");
-}
-
-/// Prints to the standard output.
-///
-/// # Panics
-/// Will panic if `SYSTEM_TABLE` is `None` (Before [init()] and after [uefi::prelude::SystemTable::exit_boot_services()]).
-///
-/// # Examples
-/// ```
-/// print!("");
-/// print!("Hello World\n");
-/// print!("Hello {}", "World");
-/// ```
-#[macro_export]
-macro_rules! print {
-    ($($arg:tt)*) => ($crate::helpers::_print(core::format_args!($($arg)*)));
-}
-
-/// Prints to the standard output, with a newline.
-///
-/// # Panics
-/// Will panic if `SYSTEM_TABLE` is `None` (Before [init()] and after [uefi::prelude::SystemTable::exit_boot_services()]).
-///
-/// # Examples
-/// ```
-/// println!();
-/// println!("Hello World");
-/// println!("Hello {}", "World");
-/// ```
-#[macro_export]
-macro_rules! println {
-    () => ($crate::print!("\n"));
-    ($($arg:tt)*) => ($crate::helpers::_print(core::format_args!("{}{}", core::format_args!($($arg)*), "\n")));
-}
-
-/// Set up logging
-///
-/// This is unsafe because you must arrange for the logger to be reset with
-/// disable() on exit from UEFI boot services.
-#[cfg(feature = "logger")]
-unsafe fn init_logger(st: &mut SystemTable<Boot>) {
-    // Connect the logger to stdout.
-    LOGGER.set_output(st.stdout());
-
-    // Set the logger.
-    log::set_logger(&LOGGER).unwrap(); // Can only fail if already initialized.
-
-    // Set logger max level to level specified by log features
-    log::set_max_level(log::STATIC_MAX_LEVEL);
-}
-
 /// Notify the utility library that boot services are not safe to call anymore
 /// As this is a callback, it must be `extern "efiapi"`.
 unsafe extern "efiapi" fn exit_boot_services(_e: Event, _ctx: Option<NonNull<c_void>>) {
@@ -174,68 +115,8 @@ unsafe extern "efiapi" fn exit_boot_services(_e: Event, _ctx: Option<NonNull<c_v
     SYSTEM_TABLE.store(ptr::null_mut(), Ordering::Release);
 
     #[cfg(feature = "logger")]
-    LOGGER.disable();
+    logger::disable();
 
+    #[cfg(feature = "global_allocator")]
     uefi::allocator::exit_boot_services();
 }
-
-#[cfg(feature = "panic_handler")]
-#[panic_handler]
-fn panic_handler(info: &core::panic::PanicInfo) -> ! {
-    println!("[PANIC]: {}", info);
-
-    // Give the user some time to read the message
-    if let Some(st) = system_table_opt() {
-        st.boot_services().stall(10_000_000);
-    } else {
-        let mut dummy = 0u64;
-        // FIXME: May need different counter values in debug & release builds
-        for i in 0..300_000_000 {
-            unsafe {
-                core::ptr::write_volatile(&mut dummy, i);
-            }
-        }
-    }
-
-    cfg_if! {
-        if #[cfg(all(target_arch = "x86_64", feature = "qemu"))] {
-            // If running in QEMU, use the f4 exit port to signal the error and exit
-            use qemu_exit::QEMUExit;
-            let custom_exit_success = 3;
-            let qemu_exit_handle = qemu_exit::X86::new(0xF4, custom_exit_success);
-            qemu_exit_handle.exit_failure();
-        } else {
-            // If the system table is available, use UEFI's standard shutdown mechanism
-            if let Some(st) = system_table_opt() {
-                use uefi::table::runtime::ResetType;
-                st.runtime_services()
-                    .reset(ResetType::SHUTDOWN, uefi::Status::ABORTED, None);
-            }
-
-            // If we don't have any shutdown mechanism handy, the best we can do is loop
-            log::error!("Could not shut down, please power off the system manually...");
-
-            cfg_if! {
-                if #[cfg(target_arch = "x86_64")] {
-                    loop {
-                        unsafe {
-                            // Try to at least keep CPU from running at 100%
-                            core::arch::asm!("hlt", options(nomem, nostack));
-                        }
-                    }
-                } else if #[cfg(target_arch = "aarch64")] {
-                    loop {
-                        unsafe {
-                            // Try to at least keep CPU from running at 100%
-                            core::arch::asm!("hlt 420", options(nomem, nostack));
-                        }
-                    }
-                } else {
-                    loop {
-                        // just run forever dammit how do you return never anyway
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/uefi/src/helpers/panic_handler.rs b/uefi/src/helpers/panic_handler.rs
@@ -0,0 +1,63 @@
+use crate::helpers::system_table_opt;
+use crate::println;
+use cfg_if::cfg_if;
+
+#[panic_handler]
+fn panic_handler(info: &core::panic::PanicInfo) -> ! {
+    println!("[PANIC]: {}", info);
+
+    // Give the user some time to read the message
+    if let Some(st) = system_table_opt() {
+        st.boot_services().stall(10_000_000);
+    } else {
+        let mut dummy = 0u64;
+        // FIXME: May need different counter values in debug & release builds
+        for i in 0..300_000_000 {
+            unsafe {
+                core::ptr::write_volatile(&mut dummy, i);
+            }
+        }
+    }
+
+    cfg_if! {
+        if #[cfg(all(target_arch = "x86_64", feature = "qemu"))] {
+            // If running in QEMU, use the f4 exit port to signal the error and exit
+            use qemu_exit::QEMUExit;
+            let custom_exit_success = 3;
+            let qemu_exit_handle = qemu_exit::X86::new(0xF4, custom_exit_success);
+            qemu_exit_handle.exit_failure();
+        } else {
+            // If the system table is available, use UEFI's standard shutdown mechanism
+            if let Some(st) = system_table_opt() {
+                use uefi::table::runtime::ResetType;
+                st.runtime_services()
+                    .reset(ResetType::SHUTDOWN, uefi::Status::ABORTED, None);
+            }
+
+            // If we don't have any shutdown mechanism handy, the best we can do is loop
+            log::error!("Could not shut down, please power off the system manually...");
+
+            cfg_if! {
+                if #[cfg(target_arch = "x86_64")] {
+                    loop {
+                        unsafe {
+                            // Try to at least keep CPU from running at 100%
+                            core::arch::asm!("hlt", options(nomem, nostack));
+                        }
+                    }
+                } else if #[cfg(target_arch = "aarch64")] {
+                    loop {
+                        unsafe {
+                            // Try to at least keep CPU from running at 100%
+                            core::arch::asm!("hlt 420", options(nomem, nostack));
+                        }
+                    }
+                } else {
+                    loop {
+                        // just run forever dammit how do you return never anyway
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/uefi/src/helpers/println.rs b/uefi/src/helpers/println.rs
@@ -0,0 +1,44 @@
+use crate::helpers::system_table;
+use core::fmt::Write;
+
+/// INTERNAL API! Helper for print macros.
+#[doc(hidden)]
+pub fn _print(args: core::fmt::Arguments) {
+    system_table()
+        .stdout()
+        .write_fmt(args)
+        .expect("Failed to write to stdout");
+}
+
+/// Prints to the standard output.
+///
+/// # Panics
+/// Will panic if `SYSTEM_TABLE` is `None` (Before [init()] and after [uefi::prelude::SystemTable::exit_boot_services()]).
+///
+/// # Examples
+/// ```
+/// print!("");
+/// print!("Hello World\n");
+/// print!("Hello {}", "World");
+/// ```
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ($crate::helpers::_print(core::format_args!($($arg)*)));
+}
+
+/// Prints to the standard output, with a newline.
+///
+/// # Panics
+/// Will panic if `SYSTEM_TABLE` is `None` (Before [init()] and after [uefi::prelude::SystemTable::exit_boot_services()]).
+///
+/// # Examples
+/// ```
+/// println!();
+/// println!("Hello World");
+/// println!("Hello {}", "World");
+/// ```
+#[macro_export]
+macro_rules! println {
+    () => ($crate::print!("\n"));
+    ($($arg:tt)*) => ($crate::helpers::_print(core::format_args!("{}{}", core::format_args!($($arg)*), "\n")));
+}
diff --git a/uefi/src/lib.rs b/uefi/src/lib.rs
@@ -127,7 +127,6 @@ pub mod helpers;
 
 mod util;
 
-
 #[cfg(test)]
 // Crates that create procedural macros can't unit test the macros they export.
 // Therefore, we do some tests here.

Original file line number	Diff line number	Diff line change
`@@ -130,5 +130,3 @@ unsafe impl GlobalAlloc for Allocator {`
`130`	`130`	`(*boot_services()).free_pool(ptr).unwrap();`
`131`	`131`	`}`
`132`	`132`	`}`
`133`		`-`
`134`		`-`