wip: Add global system table pointer

Author: nicholasbishop

uefi-macros/src/lib.rs

@@ -254,6 +254,64 @@ pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
     result.into()
 }
 
+/// TODO
+#[proc_macro_attribute]
+pub fn main(args: TokenStream, input: TokenStream) -> TokenStream {
+    let mut errors = TokenStream2::new();
+
+    if !args.is_empty() {
+        errors.append_all(err!(
+            TokenStream2::from(args),
+            "Entry attribute accepts no arguments"
+        ));
+    }
+
+    let f = parse_macro_input!(input as ItemFn);
+
+    if let Some(ref abi) = f.sig.abi {
+        errors.append_all(err!(abi, "Entry method must have no ABI modifier"));
+    }
+    if let Some(asyncness) = f.sig.asyncness {
+        errors.append_all(err!(asyncness, "Entry method should not be async"));
+    }
+    if let Some(constness) = f.sig.constness {
+        errors.append_all(err!(constness, "Entry method should not be const"));
+    }
+    if !f.sig.generics.params.is_empty() {
+        errors.append_all(err!(
+            f.sig.generics.params,
+            "Entry method should not be generic"
+        ));
+    }
+
+    // TODO: validate no fn args, validate return type
+
+    // show most errors at once instead of one by one
+    if !errors.is_empty() {
+        return errors.into();
+    }
+
+    let fn_ident = &f.sig.ident;
+    let result = quote! {
+        #f
+
+        // TODO: non-conflicting name?
+        #[export_name = "efi_main"]
+        fn efi_main(image: ::uefi::Handle, system_table: *mut ::core::ffi::c_void) -> ::uefi::Status {
+            unsafe {
+                ::uefi::boot::set_image_handle(image);
+                ::uefi::system::set_system_table(system_table.cast());
+                match #fn_ident() {
+                    Ok(()) => Status::SUCCESS,
+                    Err(err) => err.status(),
+                }
+            }
+        }
+
+    };
+    result.into()
+}
+
 /// Builds a `CStr8` literal at compile time from a string literal.
 ///
 /// This will throw a compile error if an invalid character is in the passed string.

uefi-services/src/lib.rs

@@ -43,7 +43,7 @@ use cfg_if::cfg_if;
 use uefi::prelude::*;
 use uefi::table::boot::{EventType, Tpl};
 use uefi::table::{Boot, SystemTable};
-use uefi::{Event, Result};
+use uefi::{system, Event, Result};
 
 /// Reference to the system table.
 ///
@@ -74,6 +74,12 @@ pub fn system_table() -> NonNull<SystemTable<Boot>> {
     }
 }
 
+/// TODO
+pub fn init_v2() -> Result {
+    let mut st = system::system_table_boot();
+    init(&mut st)
+}
+
 /// Initialize the UEFI utility library.
 ///
 /// This must be called as early as possible,

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

@@ -18,17 +18,14 @@ use uefi::proto::device_path::build::{self, DevicePathBuilder};
 use uefi::proto::device_path::{DevicePath, DeviceSubType, DeviceType, LoadedImageDevicePath};
 use uefi::proto::loaded_image::LoadedImage;
 use uefi::table::boot::LoadImageSource;
-use uefi::Status;
+use uefi::{boot, Result, Status};
 
 /// 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() {
@@ -45,29 +42,26 @@ fn get_shell_app_device_path<'a>(
     builder.finalize().unwrap()
 }
 
-#[entry]
-fn efi_main(image: Handle, mut st: SystemTable<Boot>) -> Status {
-    uefi_services::init(&mut st).unwrap();
-    let boot_services = st.boot_services();
+#[uefi::main]
+fn main() -> Result {
+    uefi_services::init_v2().unwrap();
 
     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");
     unsafe {
@@ -78,9 +72,7 @@ fn efi_main(image: Handle, mut 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
+    Ok(())
 }

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

@@ -1,26 +1,24 @@
-use uefi::table::boot::{AllocateType, BootServices, MemoryType};
+use uefi::boot;
+use uefi::table::boot::{AllocateType, 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();
-    memmove(bt);
 
-    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");
 
@@ -32,7 +30,7 @@ fn allocate_pages(bt: &BootServices) {
     buf[4095] = 0x23;
 
     // Clean up to avoid memory leaks.
-    bt.free_pages(pgs, 1).unwrap();
+    boot::free_pages(pgs, 1).unwrap();
 }
 
 // Simple test to ensure our custom allocator works with the `alloc` crate.
@@ -57,43 +55,19 @@ fn alloc_alignment() {
     assert_eq!(value.as_ptr() as usize % 0x100, 0, "Wrong alignment");
 }
 
-// Test that the `memmove` / `set_mem` functions work.
-fn memmove(bt: &BootServices) {
-    info!("Testing the `memmove` / `set_mem` functions");
-
-    let src = [1, 2, 3, 4];
-    let mut dest = [0u8; 4];
-
-    // Fill the buffer with a value
-    unsafe {
-        bt.set_mem(dest.as_mut_ptr(), dest.len(), 1);
-    }
-
-    assert_eq!(dest, [1; 4], "Failed to set memory");
-
-    // Copy other values on it
-    unsafe {
-        bt.memmove(dest.as_mut_ptr(), src.as_ptr(), dest.len());
-    }
-
-    assert_eq!(dest, src, "Failed to copy memory");
-}
-
-fn memory_map(bt: &BootServices) {
+fn memory_map() {
     info!("Testing memory map functions");
 
     // Get the memory descriptor size and an estimate of the memory map size
-    let sizes = bt.memory_map_size();
+    let sizes = boot::memory_map_size();
 
     // 2 extra descriptors should be enough.
     let buf_sz = sizes.map_size + 2 * sizes.entry_size;
 
     // We will use vectors for convenience.
     let mut buffer = vec![0_u8; buf_sz];
 
-    let mut memory_map = bt
-        .memory_map(&mut buffer)
-        .expect("Failed to retrieve UEFI memory map");
+    let mut memory_map = boot::memory_map(&mut buffer).expect("Failed to retrieve UEFI memory map");
 
     memory_map.sort();