WIP: Use global system table pointer

uefi-test-runner/src/bin/shell_launcher.rs

@@ -13,6 +13,7 @@ extern crate alloc;
 
 use alloc::vec::Vec;
 use log::info;
+use uefi::boot;
 use uefi::prelude::*;
 use uefi::proto::device_path::build::{self, DevicePathBuilder};
 use uefi::proto::device_path::{DevicePath, DeviceSubType, DeviceType, LoadedImageDevicePath};
@@ -21,13 +22,10 @@ use uefi::table::boot::LoadImageSource;
 
 /// Get the device path of the shell app. This is the same as the
 /// currently-loaded image's device path, but with the file path part changed.
-fn get_shell_app_device_path<'a>(
-    boot_services: &BootServices,
-    storage: &'a mut Vec<u8>,
-) -> &'a DevicePath {
-    let loaded_image_device_path = boot_services
-        .open_protocol_exclusive::<LoadedImageDevicePath>(boot_services.image_handle())
-        .expect("failed to open LoadedImageDevicePath protocol");
+fn get_shell_app_device_path(storage: &mut Vec<u8>) -> &DevicePath {
+    let loaded_image_device_path =
+        boot::open_protocol_exclusive::<LoadedImageDevicePath>(boot::image_handle())
+            .expect("failed to open LoadedImageDevicePath protocol");
 
     let mut builder = DevicePathBuilder::with_vec(storage);
     for node in loaded_image_device_path.node_iter() {
@@ -47,26 +45,23 @@ fn get_shell_app_device_path<'a>(
 #[entry]
 fn efi_main(image: Handle, st: SystemTable<Boot>) -> Status {
     uefi::helpers::init().unwrap();
-    let boot_services = st.boot_services();
 
     let mut storage = Vec::new();
-    let shell_image_path = get_shell_app_device_path(boot_services, &mut storage);
+    let shell_image_path = get_shell_app_device_path(&mut storage);
 
     // Load the shell app.
-    let shell_image_handle = boot_services
-        .load_image(
-            image,
-            LoadImageSource::FromDevicePath {
-                device_path: shell_image_path,
-                from_boot_manager: false,
-            },
-        )
-        .expect("failed to load shell app");
+    let shell_image_handle = boot::load_image(
+        boot::image_handle(),
+        LoadImageSource::FromDevicePath {
+            device_path: shell_image_path,
+            from_boot_manager: false,
+        },
+    )
+    .expect("failed to load shell app");
 
     // Set the command line passed to the shell app so that it will run the
     // test-runner app. This automatically turns off the five-second delay.
-    let mut shell_loaded_image = boot_services
-        .open_protocol_exclusive::<LoadedImage>(shell_image_handle)
+    let mut shell_loaded_image = boot::open_protocol_exclusive::<LoadedImage>(shell_image_handle)
         .expect("failed to open LoadedImage protocol");
     let load_options = cstr16!(r"shell.efi test_runner.efi arg1 arg2");
     unsafe {
@@ -77,9 +72,7 @@ fn efi_main(image: Handle, st: SystemTable<Boot>) -> Status {
     }
 
     info!("launching the shell app");
-    boot_services
-        .start_image(shell_image_handle)
-        .expect("failed to launch the shell app");
+    boot::start_image(shell_image_handle).expect("failed to launch the shell app");
 
     Status::SUCCESS
 }

uefi-test-runner/src/boot/memory.rs

@@ -1,25 +1,24 @@
-use uefi::table::boot::{AllocateType, BootServices, MemoryMap, MemoryMapMut, MemoryType};
+use uefi::boot;
+use uefi::table::boot::{AllocateType, MemoryMap, MemoryMapMut, MemoryType};
 
 use alloc::vec::Vec;
 
-pub fn test(bt: &BootServices) {
+pub fn test() {
     info!("Testing memory functions");
 
-    allocate_pages(bt);
+    allocate_pages();
     vec_alloc();
     alloc_alignment();
 
-    memory_map(bt);
+    memory_map();
 }
 
-fn allocate_pages(bt: &BootServices) {
+fn allocate_pages() {
     info!("Allocating some pages of memory");
 
     let ty = AllocateType::AnyPages;
     let mem_ty = MemoryType::LOADER_DATA;
-    let pgs = bt
-        .allocate_pages(ty, mem_ty, 1)
-        .expect("Failed to allocate a page of memory");
+    let pgs = boot::allocate_pages(ty, mem_ty, 1).expect("Failed to allocate a page of memory");
 
     assert_eq!(pgs % 4096, 0, "Page pointer is not page-aligned");
 
@@ -31,7 +30,7 @@ fn allocate_pages(bt: &BootServices) {
     buf[4095] = 0x23;
 
     // Clean up to avoid memory leaks.
-    unsafe { bt.free_pages(pgs, 1) }.unwrap();
+    unsafe { boot::free_pages(pgs, 1) }.unwrap();
 }
 
 // Simple test to ensure our custom allocator works with the `alloc` crate.
@@ -60,15 +59,14 @@ fn alloc_alignment() {
     assert_eq!(value.as_ptr() as usize % 0x100, 0, "Wrong alignment");
 }
 
-fn memory_map(bt: &BootServices) {
+fn memory_map() {
     info!("Testing memory map functions");
 
     // Ensure that the memory map is freed after each iteration (on drop).
     // Otherwise, we will have an OOM.
     for _ in 0..200000 {
-        let mut memory_map = bt
-            .memory_map(MemoryType::LOADER_DATA)
-            .expect("Failed to retrieve UEFI memory map");
+        let mut memory_map =
+            boot::memory_map(MemoryType::LOADER_DATA).expect("Failed to retrieve UEFI memory map");
 
         memory_map.sort();
 

uefi-test-runner/src/boot/misc.rs

@@ -4,51 +4,49 @@ use core::ptr::{self, NonNull};
 use core::mem;
 use uefi::proto::unsafe_protocol;
 use uefi::table::boot::{
-    BootServices, EventType, MemoryType, OpenProtocolAttributes, OpenProtocolParams, SearchType,
-    TimerTrigger, Tpl,
+    EventType, MemoryType, OpenProtocolAttributes, OpenProtocolParams, SearchType, TimerTrigger,
+    Tpl,
 };
-use uefi::table::{Boot, SystemTable};
+use uefi::{boot, system};
 use uefi::{guid, Event, Guid, Identify};
 
-pub fn test(st: &SystemTable<Boot>) {
-    let bt = st.boot_services();
+pub fn test() {
     info!("Testing timer...");
-    test_timer(bt);
+    test_timer();
     info!("Testing events...");
-    test_event_callback(bt);
-    test_callback_with_ctx(bt);
+    test_event_callback();
+    test_callback_with_ctx();
     info!("Testing watchdog...");
-    test_watchdog(bt);
+    test_watchdog();
     info!("Testing protocol handler services...");
-    test_register_protocol_notify(bt);
-    test_install_protocol_interface(bt);
-    test_reinstall_protocol_interface(bt);
-    test_uninstall_protocol_interface(bt);
-    test_install_configuration_table(st);
+    test_register_protocol_notify();
+    test_install_protocol_interface();
+    test_reinstall_protocol_interface();
+    test_uninstall_protocol_interface();
+    test_install_configuration_table();
 }
 
-fn test_timer(bt: &BootServices) {
-    let timer_event = unsafe { bt.create_event(EventType::TIMER, Tpl::APPLICATION, None, None) }
+fn test_timer() {
+    let timer_event = unsafe { boot::create_event(EventType::TIMER, Tpl::APPLICATION, None, None) }
         .expect("Failed to create TIMER event");
     let mut events = unsafe { [timer_event.unsafe_clone()] };
-    bt.set_timer(&timer_event, TimerTrigger::Relative(5_0 /*00 ns */))
+    boot::set_timer(&timer_event, TimerTrigger::Relative(5_0 /*00 ns */))
         .expect("Failed to set timer");
-    bt.wait_for_event(&mut events)
-        .expect("Wait for event failed");
+    boot::wait_for_event(&mut events).expect("Wait for event failed");
 }
 
-fn test_event_callback(bt: &BootServices) {
+fn test_event_callback() {
     extern "efiapi" fn callback(_event: Event, _ctx: Option<NonNull<c_void>>) {
         info!("Inside the event callback");
     }
 
     let event =
-        unsafe { bt.create_event(EventType::NOTIFY_WAIT, Tpl::CALLBACK, Some(callback), None) }
+        unsafe { boot::create_event(EventType::NOTIFY_WAIT, Tpl::CALLBACK, Some(callback), None) }
             .expect("Failed to create custom event");
-    bt.check_event(event).expect("Failed to check event");
+    boot::check_event(event).expect("Failed to check event");
 }
 
-fn test_callback_with_ctx(bt: &BootServices) {
+fn test_callback_with_ctx() {
     let mut data = 123u32;
 
     extern "efiapi" fn callback(_event: Event, ctx: Option<NonNull<c_void>>) {
@@ -65,7 +63,7 @@ fn test_callback_with_ctx(bt: &BootServices) {
     let ctx = NonNull::new(ctx.cast::<c_void>()).unwrap();
 
     let event = unsafe {
-        bt.create_event(
+        boot::create_event(
             EventType::NOTIFY_WAIT,
             Tpl::CALLBACK,
             Some(callback),
@@ -74,16 +72,15 @@ fn test_callback_with_ctx(bt: &BootServices) {
         .expect("Failed to create event with context")
     };
 
-    bt.check_event(event).expect("Failed to check event");
+    boot::check_event(event).expect("Failed to check event");
 
     // Check that `data` was updated inside the event callback.
     assert_eq!(data, 456);
 }
 
-fn test_watchdog(bt: &BootServices) {
+fn test_watchdog() {
     // Disable the UEFI watchdog timer
-    bt.set_watchdog_timer(0, 0x10000, None)
-        .expect("Could not set watchdog timer");
+    boot::set_watchdog_timer(0, 0x10000, None).expect("Could not set watchdog timer");
 }
 
 /// Dummy protocol for tests
@@ -96,10 +93,10 @@ unsafe extern "efiapi" fn _test_notify(_event: Event, _context: Option<NonNull<c
     info!("Protocol was (re)installed and this function notified.")
 }
 
-fn test_register_protocol_notify(bt: &BootServices) {
+fn test_register_protocol_notify() {
     let protocol = &TestProtocol::GUID;
     let event = unsafe {
-        bt.create_event(
+        boot::create_event(
             EventType::NOTIFY_SIGNAL,
             Tpl::NOTIFY,
             Some(_test_notify),
@@ -108,41 +105,37 @@ fn test_register_protocol_notify(bt: &BootServices) {
         .expect("Failed to create an event")
     };
 
-    bt.register_protocol_notify(protocol, event)
-        .expect("Failed to register protocol notify fn");
+    boot::register_protocol_notify(protocol, event).expect("Failed to register protocol notify fn");
 }
 
-fn test_install_protocol_interface(bt: &BootServices) {
+fn test_install_protocol_interface() {
     info!("Installing TestProtocol");
 
-    let alloc: *mut TestProtocol = bt
-        .allocate_pool(
-            MemoryType::BOOT_SERVICES_DATA,
-            mem::size_of::<TestProtocol>(),
-        )
-        .unwrap()
-        .cast()
-        .as_ptr();
+    let alloc: *mut TestProtocol = boot::allocate_pool(
+        MemoryType::BOOT_SERVICES_DATA,
+        mem::size_of::<TestProtocol>(),
+    )
+    .unwrap()
+    .as_ptr()
+    .cast();
     unsafe { alloc.write(TestProtocol { data: 123 }) };
 
     let _ = unsafe {
-        bt.install_protocol_interface(None, &TestProtocol::GUID, alloc.cast())
+        boot::install_protocol_interface(None, &TestProtocol::GUID, alloc.cast())
             .expect("Failed to install protocol interface")
     };
 
-    let _ = bt
-        .locate_handle_buffer(SearchType::from_proto::<TestProtocol>())
+    let _ = boot::locate_handle_buffer(SearchType::from_proto::<TestProtocol>())
         .expect("Failed to find protocol after it was installed");
 }
 
-fn test_reinstall_protocol_interface(bt: &BootServices) {
+fn test_reinstall_protocol_interface() {
     info!("Reinstalling TestProtocol");
-    let handle = bt
-        .locate_handle_buffer(SearchType::from_proto::<TestProtocol>())
+    let handle = boot::locate_handle_buffer(SearchType::from_proto::<TestProtocol>())
         .expect("Failed to find protocol to uninstall")[0];
 
     unsafe {
-        let _ = bt.reinstall_protocol_interface(
+        let _ = boot::reinstall_protocol_interface(
             handle,
             &TestProtocol::GUID,
             ptr::null_mut(),
@@ -151,61 +144,57 @@ fn test_reinstall_protocol_interface(bt: &BootServices) {
     }
 }
 
-fn test_uninstall_protocol_interface(bt: &BootServices) {
+fn test_uninstall_protocol_interface() {
     info!("Uninstalling TestProtocol");
 
-    let handle = bt
-        .locate_handle_buffer(SearchType::from_proto::<TestProtocol>())
+    let handle = boot::locate_handle_buffer(SearchType::from_proto::<TestProtocol>())
         .expect("Failed to find protocol to uninstall")[0];
 
     unsafe {
         // Uninstalling a protocol interface requires knowing the interface
         // pointer. Open the protocol to get that pointer, making sure to drop
         // the `ScopedProtocol` _before_ uninstalling the protocol interface.
         let interface_ptr: *mut TestProtocol = {
-            let mut sp = bt
-                .open_protocol::<TestProtocol>(
-                    OpenProtocolParams {
-                        handle,
-                        agent: bt.image_handle(),
-                        controller: None,
-                    },
-                    OpenProtocolAttributes::GetProtocol,
-                )
-                .unwrap();
+            let mut sp = boot::open_protocol::<TestProtocol>(
+                OpenProtocolParams {
+                    handle,
+                    agent: boot::image_handle(),
+                    controller: None,
+                },
+                OpenProtocolAttributes::GetProtocol,
+            )
+            .unwrap();
             assert_eq!(sp.data, 123);
             &mut *sp
         };
 
-        bt.uninstall_protocol_interface(handle, &TestProtocol::GUID, interface_ptr.cast())
+        boot::uninstall_protocol_interface(handle, &TestProtocol::GUID, interface_ptr.cast())
             .expect("Failed to uninstall protocol interface");
 
-        bt.free_pool(interface_ptr.cast()).unwrap();
+        boot::free_pool(interface_ptr.cast()).unwrap();
     }
 }
 
-fn test_install_configuration_table(st: &SystemTable<Boot>) {
-    let config = st
-        .boot_services()
-        .allocate_pool(MemoryType::ACPI_RECLAIM, 1)
+fn test_install_configuration_table() {
+    let config = boot::allocate_pool(MemoryType::ACPI_RECLAIM, 1)
         .expect("Failed to allocate config table")
         .as_ptr();
     unsafe { config.write(42) };
 
-    let count = st.config_table().len();
+    let count = system::with_config_table(|t| t.len());
     const ID: Guid = guid!("3bdb3089-5662-42df-840e-3922ed6467c9");
 
     unsafe {
-        st.boot_services()
-            .install_configuration_table(&ID, config.cast())
+        boot::install_configuration_table(&ID, config.cast())
             .expect("Failed to install configuration table");
     }
 
-    assert_eq!(count + 1, st.config_table().len());
-    let config_entry = st
-        .config_table()
-        .iter()
-        .find(|ct| ct.guid == ID)
-        .expect("Failed to find test config table");
-    assert_eq!(unsafe { *(config_entry.address as *const u8) }, 42);
+    assert_eq!(count + 1, system::with_config_table(|t| t.len()));
+    let entry_addr = system::with_config_table(|t| {
+        t.iter()
+            .find(|ct| ct.guid == ID)
+            .expect("Failed to find test config table")
+            .address
+    });
+    assert_eq!(unsafe { *(entry_addr as *const u8) }, 42);
 }