wip

Author: nicholasbishop

uefi/src/boot.rs

@@ -12,7 +12,8 @@ use crate::table::boot::{
     AllocateType, BootServices, EventNotifyFn, EventType, LoadImageSource, MemoryMap, MemoryType,
     OpenProtocolAttributes, OpenProtocolParams, SearchType, TimerTrigger, Tpl, IMAGE_HANDLE,
 };
-use crate::{system, Char16, Error, Event, Guid, Handle, Result, Status, StatusExt};
+use crate::table::{Boot, SystemTable};
+use crate::{table, Char16, Error, Event, Guid, Handle, Result, Status, StatusExt};
 use core::ffi::c_void;
 use core::mem::MaybeUninit;
 use core::ops::{Deref, DerefMut};
@@ -21,14 +22,21 @@ use core::slice;
 use core::sync::atomic::Ordering;
 
 // TODO
+fn boot_services() -> NonNull<BootServices> {
+    let st = table::system_table_boot().expect("boot services are not active");
+    let ptr: *const _ = st.boot_services();
+    NonNull::new(ptr.cast_mut()).unwrap()
+}
+
 fn boot_services_raw() -> NonNull<uefi_raw::table::boot::BootServices> {
-    let st = unsafe { system::system_table().as_mut() };
-    NonNull::new(st.boot_services).expect("boot services are not active")
+    // OK to cast: `BootServices` is a `repr(transparent)` wrapper around
+    // the raw type.
+    boot_services().cast()
 }
 
-fn boot_services() -> NonNull<BootServices> {
-    let st = unsafe { system::system_table().as_mut() };
-    NonNull::new(st.boot_services.cast()).expect("boot services are not active")
+#[track_caller]
+fn stboot() -> SystemTable<Boot> {
+    table::system_table_boot().expect("boot services are not available")
 }
 
 /// Get the [`Handle`] of the currently-executing image.
@@ -74,7 +82,7 @@ pub fn allocate_pages(
     mem_ty: MemoryType,
     count: usize,
 ) -> Result<PhysicalAddress> {
-    unsafe { boot_services().as_mut() }.allocate_pages(ty, mem_ty, count)
+    stboot().boot_services().allocate_pages(ty, mem_ty, count)
 }
 
 /// Frees memory pages allocated by UEFI.
@@ -86,7 +94,7 @@ pub fn allocate_pages(
 /// * [`uefi::Status::NOT_FOUND`]
 /// * [`uefi::Status::INVALID_PARAMETER`]
 pub unsafe fn free_pages(addr: PhysicalAddress, count: usize) -> Result {
-    unsafe { boot_services().as_mut() }.free_pages(addr, count)
+    stboot().boot_services().free_pages(addr, count)
 }
 
 /// Raises a task's priority level and returns its previous level.
@@ -130,7 +138,7 @@ pub unsafe fn raise_tpl(tpl: Tpl) -> TplGuard {
 /// * [`uefi::Status::BUFFER_TOO_SMALL`]
 /// * [`uefi::Status::INVALID_PARAMETER`]
 pub fn memory_map(mt: MemoryType) -> Result<MemoryMap> {
-    unsafe { boot_services().as_mut() }.memory_map(mt)
+    stboot().boot_services().memory_map(mt)
 }
 
 /// Allocates from a memory pool. The pointer will be 8-byte aligned.
@@ -142,7 +150,7 @@ pub fn memory_map(mt: MemoryType) -> Result<MemoryMap> {
 /// * [`uefi::Status::OUT_OF_RESOURCES`]
 /// * [`uefi::Status::INVALID_PARAMETER`]
 pub fn allocate_pool(mem_ty: MemoryType, size: usize) -> Result<NonNull<u8>> {
-    unsafe { boot_services().as_mut() }.allocate_pool(mem_ty, size)
+    stboot().boot_services().allocate_pool(mem_ty, size)
 }
 
 /// Frees memory allocated from a pool.
@@ -154,7 +162,7 @@ pub fn allocate_pool(mem_ty: MemoryType, size: usize) -> Result<NonNull<u8>> {
 /// * [`uefi::Status::INVALID_PARAMETER`]
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub unsafe fn free_pool(addr: *mut u8) -> Result {
-    unsafe { boot_services().as_mut() }.free_pool(addr)
+    stboot().boot_services().free_pool(addr)
 }
 
 /// Creates an event
@@ -185,7 +193,9 @@ pub unsafe fn create_event(
     notify_fn: Option<EventNotifyFn>,
     notify_ctx: Option<NonNull<c_void>>,
 ) -> Result<Event> {
-    unsafe { boot_services().as_mut() }.create_event(event_ty, notify_tpl, notify_fn, notify_ctx)
+    stboot()
+        .boot_services()
+        .create_event(event_ty, notify_tpl, notify_fn, notify_ctx)
 }
 
 /// Creates a new `Event` of type `event_type`. The event's notification function, context,
@@ -234,7 +244,7 @@ pub unsafe fn create_event_ex(
     notify_ctx: Option<NonNull<c_void>>,
     event_group: Option<NonNull<Guid>>,
 ) -> Result<Event> {
-    unsafe { boot_services().as_mut() }.create_event_ex(
+    stboot().boot_services().create_event_ex(
         event_type,
         notify_tpl,
         notify_fn,
@@ -251,7 +261,7 @@ pub unsafe fn create_event_ex(
 ///
 /// * [`uefi::Status::INVALID_PARAMETER`]
 pub fn set_timer(event: &Event, trigger_time: TimerTrigger) -> Result {
-    unsafe { boot_services().as_mut() }.set_timer(event, trigger_time)
+    stboot().boot_services().set_timer(event, trigger_time)
 }
 
 /// Stops execution until an event is signaled.
@@ -289,7 +299,7 @@ pub fn set_timer(event: &Event, trigger_time: TimerTrigger) -> Result {
 /// * [`uefi::Status::INVALID_PARAMETER`]
 /// * [`uefi::Status::UNSUPPORTED`]
 pub fn wait_for_event(events: &mut [Event]) -> Result<usize, Option<usize>> {
-    unsafe { boot_services().as_mut() }.wait_for_event(events)
+    stboot().boot_services().wait_for_event(events)
 }
 
 /// Place 'event' in the signaled stated. If 'event' is already in the signaled state,
@@ -311,7 +321,7 @@ pub fn wait_for_event(events: &mut [Event]) -> Result<usize, Option<usize>> {
 ///
 /// Currently, (as of UEFI Spec v2.9) this only returns `EFI_SUCCESS`.
 pub fn signal_event(event: &Event) -> Result {
-    unsafe { boot_services().as_mut() }.signal_event(event)
+    stboot().boot_services().signal_event(event)
 }
 
 /// Removes `event` from any event group to which it belongs and closes it. If `event` was
@@ -328,7 +338,7 @@ pub fn signal_event(event: &Event) -> Result {
 ///
 /// * [`uefi::Status::INVALID_PARAMETER`]
 pub fn close_event(event: Event) -> Result {
-    unsafe { boot_services().as_mut() }.close_event(event)
+    stboot().boot_services().close_event(event)
 }
 
 /// Checks to see if an event is signaled, without blocking execution to wait for it.
@@ -345,7 +355,7 @@ pub fn close_event(event: Event) -> Result {
 ///
 /// * [`uefi::Status::INVALID_PARAMETER`]
 pub fn check_event(event: Event) -> Result<bool> {
-    unsafe { boot_services().as_mut() }.check_event(event)
+    stboot().boot_services().check_event(event)
 }
 
 /// Installs a protocol interface on a device handle. If the inner `Option` in `handle` is `None`,
@@ -370,7 +380,9 @@ pub unsafe fn install_protocol_interface(
     protocol: &Guid,
     interface: *mut c_void,
 ) -> Result<Handle> {
-    unsafe { boot_services().as_mut() }.install_protocol_interface(handle, protocol, interface)
+    stboot()
+        .boot_services()
+        .install_protocol_interface(handle, protocol, interface)
 }
 
 /// Reinstalls a protocol interface on a device handle. `old_interface` is replaced with `new_interface`.
@@ -398,7 +410,7 @@ pub unsafe fn reinstall_protocol_interface(
     old_interface: *mut c_void,
     new_interface: *mut c_void,
 ) -> Result<()> {
-    unsafe { boot_services().as_mut() }.reinstall_protocol_interface(
+    stboot().boot_services().reinstall_protocol_interface(
         handle,
         protocol,
         old_interface,
@@ -430,7 +442,9 @@ pub unsafe fn uninstall_protocol_interface(
     protocol: &Guid,
     interface: *mut c_void,
 ) -> Result<()> {
-    unsafe { boot_services().as_mut() }.uninstall_protocol_interface(handle, protocol, interface)
+    stboot()
+        .boot_services()
+        .uninstall_protocol_interface(handle, protocol, interface)
 }
 
 /// Registers `event` to be signalled whenever a protocol interface is registered for
@@ -450,7 +464,9 @@ pub unsafe fn uninstall_protocol_interface(
 /// * [`uefi::Status::OUT_OF_RESOURCES`]
 /// * [`uefi::Status::INVALID_PARAMETER`]
 pub fn register_protocol_notify(protocol: &Guid, event: Event) -> Result<(Event, SearchType)> {
-    unsafe { boot_services().as_mut() }.register_protocol_notify(protocol, event)
+    stboot()
+        .boot_services()
+        .register_protocol_notify(protocol, event)
 }
 
 /// Enumerates all handles installed on the system which match a certain query.
@@ -471,7 +487,7 @@ pub fn locate_handle(
     search_ty: SearchType,
     output: Option<&mut [MaybeUninit<Handle>]>,
 ) -> Result<usize> {
-    unsafe { boot_services().as_mut() }.locate_handle(search_ty, output)
+    stboot().boot_services().locate_handle(search_ty, output)
 }
 
 /// Locates the handle to a device on the device path that supports the specified protocol.
@@ -494,7 +510,9 @@ pub fn locate_handle(
 pub fn locate_device_path<P: ProtocolPointer + ?Sized>(
     device_path: &mut &DevicePath,
 ) -> Result<Handle> {
-    unsafe { boot_services().as_mut() }.locate_device_path::<P>(device_path)
+    stboot()
+        .boot_services()
+        .locate_device_path::<P>(device_path)
 }
 
 /// Find an arbitrary handle that supports a particular
@@ -533,7 +551,7 @@ pub fn locate_device_path<P: ProtocolPointer + ?Sized>(
 ///
 /// Returns [`NOT_FOUND`] if no handles support the requested protocol.
 pub fn get_handle_for_protocol<P: ProtocolPointer + ?Sized>() -> Result<Handle> {
-    unsafe { boot_services().as_mut() }.get_handle_for_protocol::<P>()
+    stboot().boot_services().get_handle_for_protocol::<P>()
 }
 
 /// Load an EFI image into memory and return a [`Handle`] to the image.
@@ -569,7 +587,9 @@ pub fn get_handle_for_protocol<P: ProtocolPointer + ?Sized>() -> Result<Handle>
 /// * [`uefi::Status::ACCESS_DENIED`]
 /// * [`uefi::Status::SECURITY_VIOLATION`]
 pub fn load_image(parent_image_handle: Handle, source: LoadImageSource) -> uefi::Result<Handle> {
-    unsafe { boot_services().as_mut() }.load_image(parent_image_handle, source)
+    stboot()
+        .boot_services()
+        .load_image(parent_image_handle, source)
 }
 
 /// Unload an EFI image.
@@ -586,7 +606,7 @@ pub fn load_image(parent_image_handle: Handle, source: LoadImageSource) -> uefi:
 /// * [`uefi::Status::UNSUPPORTED`]
 /// * [`uefi::Status::INVALID_PARAMETER`]
 pub fn unload_image(image_handle: Handle) -> Result {
-    unsafe { boot_services().as_mut() }.unload_image(image_handle)
+    stboot().boot_services().unload_image(image_handle)
 }
 
 /// Transfer control to a loaded image's entry point.
@@ -602,7 +622,7 @@ pub fn unload_image(image_handle: Handle) -> Result {
 ///
 /// * [`uefi::Status::UNSUPPORTED`]
 pub fn start_image(image_handle: Handle) -> Result {
-    unsafe { boot_services().as_mut() }.start_image(image_handle)
+    stboot().boot_services().start_image(image_handle)
 }
 
 /// Exits the UEFI application and returns control to the UEFI component
@@ -620,12 +640,9 @@ pub unsafe fn exit(
     exit_data_size: usize,
     exit_data: *mut Char16,
 ) -> ! {
-    unsafe { boot_services().as_mut() }.exit(
-        image_handle,
-        exit_status,
-        exit_data_size,
-        exit_data.cast(),
-    )
+    stboot()
+        .boot_services()
+        .exit(image_handle, exit_status, exit_data_size, exit_data.cast())
 }
 
 /// Exit the UEFI boot services.
@@ -657,7 +674,8 @@ pub unsafe fn exit(
 /// caller, the system will be reset.
 #[must_use]
 pub unsafe fn exit_boot_services(memory_type: MemoryType) -> MemoryMap {
-    system::system_table_boot()
+    table::system_table_boot()
+        .expect("boot services are not active")
         .exit_boot_services(memory_type)
         .1
 }
@@ -666,7 +684,7 @@ pub unsafe fn exit_boot_services(memory_type: MemoryType) -> MemoryMap {
 ///
 /// The time is in microseconds.
 pub fn stall(time: usize) {
-    unsafe { boot_services().as_mut() }.stall(time)
+    stboot().boot_services().stall(time)
 }
 
 /// Adds, updates, or removes a configuration table entry
@@ -690,7 +708,9 @@ pub fn stall(time: usize) {
 /// * [`uefi::Status::NOT_FOUND`]
 /// * [`uefi::Status::OUT_OF_RESOURCES`]
 pub unsafe fn install_configuration_table(guid_entry: &Guid, table_ptr: *const c_void) -> Result {
-    unsafe { boot_services().as_mut() }.install_configuration_table(guid_entry, table_ptr)
+    stboot()
+        .boot_services()
+        .install_configuration_table(guid_entry, table_ptr)
 }
 
 /// Set the watchdog timer.
@@ -720,7 +740,9 @@ pub unsafe fn install_configuration_table(guid_entry: &Guid, table_ptr: *const c
 /// * [`uefi::Status::UNSUPPORTED`]
 /// * [`uefi::Status::DEVICE_ERROR`]
 pub fn set_watchdog_timer(timeout: usize, watchdog_code: u64, data: Option<&mut [u16]>) -> Result {
-    unsafe { boot_services().as_mut() }.set_watchdog_timer(timeout, watchdog_code, data)
+    stboot()
+        .boot_services()
+        .set_watchdog_timer(timeout, watchdog_code, data)
 }
 
 /// Connect one or more drivers to a controller.
@@ -742,7 +764,7 @@ pub fn connect_controller(
     remaining_device_path: Option<&DevicePath>,
     recursive: bool,
 ) -> Result {
-    unsafe { boot_services().as_mut() }.connect_controller(
+    stboot().boot_services().connect_controller(
         controller,
         driver_image,
         remaining_device_path,
@@ -766,7 +788,9 @@ pub fn disconnect_controller(
     driver_image: Option<Handle>,
     child: Option<Handle>,
 ) -> Result {
-    unsafe { boot_services().as_mut() }.disconnect_controller(controller, driver_image, child)
+    stboot()
+        .boot_services()
+        .disconnect_controller(controller, driver_image, child)
 }
 
 /// Open a protocol interface for a handle.
@@ -880,7 +904,7 @@ pub fn open_protocol_exclusive<P: ProtocolPointer + ?Sized>(
 /// * [`uefi::Status::ACCESS_DENIED`]
 /// * [`uefi::Status::ALREADY_STARTED`]
 pub fn test_protocol<P: ProtocolPointer + ?Sized>(params: OpenProtocolParams) -> Result<()> {
-    unsafe { boot_services().as_mut() }.test_protocol::<P>(params)
+    stboot().boot_services().test_protocol::<P>(params)
 }
 
 /// Get the list of protocol interface [`Guids`][Guid] that are installed

uefi/src/runtime.rs

@@ -8,15 +8,17 @@ use crate::table::runtime::{
     ResetType, RuntimeServices, Time, TimeCapabilities, VariableAttributes, VariableStorageInfo,
     VariableVendor,
 };
-use crate::{system, CStr16, Result, Status};
+use crate::{table, CStr16, Result, Status};
 use core::ptr::NonNull;
 
 #[cfg(feature = "alloc")]
 use {crate::table::runtime::VariableKey, alloc::boxed::Box, alloc::vec::Vec};
 
 fn runtime_services() -> NonNull<RuntimeServices> {
-    let st = unsafe { system::system_table().as_mut() };
-    NonNull::new(st.runtime_services.cast()).expect("runtime services are not active")
+    // TODO
+    let st = table::system_table_runtime().expect("runtime services are not available");
+    let ptr: *const _ = unsafe { st.runtime_services() };
+    NonNull::new(ptr.cast_mut()).unwrap()
 }
 
 /// Query the current time and date information