WIP: UEFI shell protocol testing

Author: nicholasbishop

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

@@ -0,0 +1,168 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+
+use alloc::string::ToString;
+use alloc::vec::Vec;
+use uefi::prelude::*;
+use uefi::proto::device_path::build::{self, DevicePathBuilder};
+use uefi::proto::device_path::{DeviceSubType, DeviceType, LoadedImageDevicePath};
+use uefi::proto::loaded_image::LoadedImage;
+use uefi::table::boot::LoadImageSource;
+use uefi::table::runtime::{ResetType, VariableVendor};
+use uefi::{CStr16, Result, Status};
+
+use uefi::proto::device_path::DevicePath;
+fn print_dp(boot_services: &BootServices, path: &DevicePath) {
+    use uefi::proto::device_path::text::{AllowShortcuts, DevicePathToText, DisplayOnly};
+
+    let handle = boot_services
+        .get_handle_for_protocol::<DevicePathToText>()
+        .unwrap();
+
+    let to_text = boot_services
+        .open_protocol_exclusive::<DevicePathToText>(handle)
+        .unwrap();
+
+    log::info!(
+        "path: {}",
+        &*to_text
+            .convert_device_path_to_text(
+                boot_services,
+                path,
+                DisplayOnly(true),
+                AllowShortcuts(false),
+            )
+            .unwrap()
+    );
+}
+
+fn boot_internal_shell(runtime_services: &RuntimeServices) -> Result {
+    for var in runtime_services.variable_keys().unwrap() {
+        if var.vendor != VariableVendor::GLOBAL_VARIABLE {
+            continue;
+        }
+        let name = var.name().unwrap();
+        let name_string = name.to_string();
+        if !name_string.starts_with("Boot") {
+            continue;
+        }
+        if name_string.len() != 8 {
+            continue;
+        }
+        let number = &name_string[4..];
+        let number = if let Ok(number) = u16::from_str_radix(number, 16) {
+            number
+        } else {
+            continue;
+        };
+
+        log::info!("var: {}", name);
+        let (data, attr) = runtime_services
+            .get_variable_boxed(name, &var.vendor)
+            .unwrap();
+        let description = unsafe { CStr16::from_ptr(data[6..].as_ptr().cast()) };
+        log::info!("description: {}", description);
+
+        if description == cstr16!("EFI Internal Shell") {
+            let file_path_list_length = u16::from_le_bytes(data[4..6].try_into().unwrap());
+            log::info!("file_path_list_length: {file_path_list_length}");
+
+            // Convert to a vec, and chop off any existing `OptionalData[]` bytes.
+            let mut data =
+                data[..4 + 2 + description.num_bytes() + file_path_list_length as usize].to_vec();
+            data.extend(cstr16!("shell.efi test_runner.efi").as_bytes());
+
+            log::info!("Setting up next boot for internal shell");
+
+            runtime_services
+                .set_variable(name, &VariableVendor::GLOBAL_VARIABLE, attr, &data)
+                .unwrap();
+
+            runtime_services
+                .set_variable(
+                    cstr16!("BootNext"),
+                    &VariableVendor::GLOBAL_VARIABLE,
+                    attr,
+                    &number.to_le_bytes(),
+                )
+                .unwrap();
+
+            return Ok(());
+        }
+    }
+
+    Status::ABORTED.to_result()
+}
+
+// This launcher attempts to launch the shell app and run the main
+// uefi-test-running app inside that shell. This allows testing of protocols
+// that require the shell.
+//
+// Launching the shell programmatically allows us to avoid the built-in five
+// second delay when starting the shell.
+//
+// If the shell app is not present, the UEFI test runner is launched directly.
+#[entry]
+fn efi_main(image: Handle, mut st: SystemTable<Boot>) -> Status {
+    uefi_services::init(&mut st).unwrap();
+
+    let boot_services = st.boot_services();
+
+    let loaded_image_device_path = boot_services
+        .open_protocol_exclusive::<LoadedImageDevicePath>(image)
+        .unwrap();
+
+    print_dp(boot_services, &loaded_image_device_path);
+
+    let mut storage = Vec::new();
+    let mut builder = DevicePathBuilder::with_vec(&mut storage);
+    for node in loaded_image_device_path.node_iter() {
+        if node.full_type() == (DeviceType::MEDIA, DeviceSubType::MEDIA_FILE_PATH) {
+            break;
+        }
+        builder = builder.push(&node).unwrap();
+    }
+    builder = builder
+        .push(&build::media::FilePath {
+            path_name: cstr16!(r"efi\boot\shell.efi"),
+        })
+        .unwrap();
+    let new_image_path = builder.finalize().unwrap();
+
+    // TODO
+    let new_image = if let Ok(new_image) = boot_services.load_image(
+        image,
+        LoadImageSource::FromFilePath {
+            file_path: new_image_path,
+            from_boot_manager: false,
+        },
+    ) {
+        new_image
+    } else {
+        log::info!("EFI shell app not found");
+
+        let runtime_services = st.runtime_services();
+
+        boot_internal_shell(runtime_services).unwrap();
+
+        log::info!("Rebooting");
+        runtime_services.reset(ResetType::Warm, Status::SUCCESS, None);
+    };
+
+    let mut new_loaded_image = boot_services
+        .open_protocol_exclusive::<LoadedImage>(new_image)
+        .unwrap();
+    let load_options = cstr16!(r"shell.efi test_runner.efi");
+    unsafe {
+        new_loaded_image.set_load_options(
+            load_options.as_ptr().cast(),
+            load_options.num_bytes() as u32,
+        );
+    }
+
+    boot_services.start_image(new_image).unwrap();
+
+    Status::SUCCESS
+}

uefi-test-runner/src/main.rs

@@ -51,6 +51,15 @@ fn efi_main(image: Handle, mut st: SystemTable<Boot>) -> Status {
 
     boot::test(bt);
 
+    {
+        let handles = bt
+            .locate_handle_buffer(uefi::table::boot::SearchType::ByProtocol(&uefi::guid!(
+                "752f3136-4e16-4fdc-a22a-e5f46812f4ca"
+            )))
+            .unwrap();
+        info!("BISH: {handles:?}");
+    }
+
     // Test all the supported protocols.
     proto::test(image, &mut st);
 

uefi/src/proto/device_path/mod.rs

@@ -85,6 +85,7 @@ use crate::proto::{unsafe_protocol, ProtocolPointer};
 use core::ffi::c_void;
 use core::fmt::{self, Debug, Formatter};
 use core::mem;
+use core::ops::Deref;
 use ptr_meta::Pointee;
 
 opaque_type! {
@@ -610,6 +611,35 @@ pub enum NodeConversionError {
     UnsupportedType,
 }
 
+/// Protocol for accessing the device path that was passed in to [`load_image`]
+/// when loading a PE/COFF image.
+///
+/// The layout of this type is the same as a [`DevicePath`].
+///
+/// [`load_image`]: crate::table::boot::BootServices::load_image
+#[repr(transparent)]
+#[unsafe_protocol("bc62157e-3e33-4fec-9920-2d3b36d750df")]
+#[derive(Pointee)]
+pub struct LoadedImageDevicePath(DevicePath);
+
+impl ProtocolPointer for LoadedImageDevicePath {
+    unsafe fn ptr_from_ffi(ptr: *const c_void) -> *const Self {
+        ptr_meta::from_raw_parts(ptr.cast(), DevicePath::size_in_bytes_from_ptr(ptr))
+    }
+
+    unsafe fn mut_ptr_from_ffi(ptr: *mut c_void) -> *mut Self {
+        ptr_meta::from_raw_parts_mut(ptr.cast(), DevicePath::size_in_bytes_from_ptr(ptr))
+    }
+}
+
+impl Deref for LoadedImageDevicePath {
+    type Target = DevicePath;
+
+    fn deref(&self) -> &DevicePath {
+        &self.0
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

uefi/src/table/boot.rs

@@ -986,10 +986,11 @@ impl BootServices {
     /// image.
     ///
     /// If the image is successfully loaded, a [`Handle`] supporting the
-    /// [`LoadedImage`] and `LoadedImageDevicePath` protocols is
+    /// [`LoadedImage`] and [`LoadedImageDevicePath`] protocols is
     /// returned. The image can be started with [`start_image`] or
     /// unloaded with [`unload_image`].
     ///
+    /// [`LoadedImageDevicePath`]: crate::proto::device_path::LoadedImageDevicePath
     /// [`start_image`]: BootServices::start_image
     /// [`unload_image`]: BootServices::unload_image
     ///