WIP: UEFI shell protocol testing

Author: nicholasbishop

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

@@ -0,0 +1,72 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use log::info;
+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::Status;
+
+// 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.
+#[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();
+
+    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 = boot_services
+        .load_image(
+            image,
+            LoadImageSource::FromFilePath {
+                file_path: new_image_path,
+                from_boot_manager: false,
+            },
+        )
+        .expect("failed to load shell app");
+
+    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,
+        );
+    }
+
+    info!("launching the UEFI shell");
+    boot_services.start_image(new_image).unwrap();
+
+    Status::SUCCESS
+}

xtask/src/qemu.rs

@@ -135,13 +135,22 @@ fn update_prebuilt() -> Result<PathBuf> {
 enum OvmfFileType {
     Code,
     Vars,
+    Shell,
 }
 
 impl OvmfFileType {
     fn as_str(&self) -> &'static str {
         match self {
             Self::Code => "code",
             Self::Vars => "vars",
+            Self::Shell => "shell",
+        }
+    }
+
+    fn extension(&self) -> &'static str {
+        match self {
+            Self::Code | Self::Vars => "fd",
+            Self::Shell => "efi",
         }
     }
 
@@ -161,6 +170,10 @@ impl OvmfFileType {
                 opt_path = &opt.ovmf_vars;
                 var_name = "OVMF_VARS";
             }
+            Self::Shell => {
+                opt_path = &None;
+                var_name = "OVMF_SHELL";
+            }
         }
         if let Some(path) = opt_path {
             Some(path.clone())
@@ -173,6 +186,7 @@ impl OvmfFileType {
 struct OvmfPaths {
     code: PathBuf,
     vars: PathBuf,
+    shell: PathBuf,
 }
 
 impl OvmfPaths {
@@ -199,7 +213,11 @@ impl OvmfPaths {
         } else {
             let prebuilt_dir = update_prebuilt()?;
 
-            Ok(prebuilt_dir.join(format!("{arch}/{}.fd", file_type.as_str())))
+            Ok(prebuilt_dir.join(format!(
+                "{arch}/{}.{}",
+                file_type.as_str(),
+                file_type.extension()
+            )))
         }
     }
 
@@ -208,8 +226,9 @@ impl OvmfPaths {
     fn find(opt: &QemuOpt, arch: UefiArch) -> Result<Self> {
         let code = Self::find_ovmf_file(OvmfFileType::Code, opt, arch)?;
         let vars = Self::find_ovmf_file(OvmfFileType::Vars, opt, arch)?;
+        let shell = Self::find_ovmf_file(OvmfFileType::Shell, opt, arch)?;
 
-        Ok(Self { code, vars })
+        Ok(Self { code, vars, shell })
     }
 }
 
@@ -352,7 +371,7 @@ fn process_qemu_io(mut monitor_io: Io, mut serial_io: Io, tmp_dir: &Path) -> Res
 }
 
 /// Create an EFI boot directory to pass into QEMU.
-fn build_esp_dir(opt: &QemuOpt) -> Result<PathBuf> {
+fn build_esp_dir(opt: &QemuOpt, ovmf_paths: &OvmfPaths) -> Result<PathBuf> {
     let build_mode = if opt.build_mode.release {
         "release"
     } else {
@@ -362,21 +381,31 @@ fn build_esp_dir(opt: &QemuOpt) -> Result<PathBuf> {
         .join(opt.target.as_triple())
         .join(build_mode);
     let esp_dir = build_dir.join("esp");
+
+    // Create boot dir.
     let boot_dir = esp_dir.join("EFI").join("Boot");
-    let built_file = if let Some(example) = &opt.example {
-        build_dir.join("examples").join(format!("{example}.efi"))
-    } else {
-        build_dir.join("uefi-test-runner.efi")
-    };
-    let output_file = match *opt.target {
+    if !boot_dir.exists() {
+        fs_err::create_dir_all(&boot_dir)?;
+    }
+
+    let boot_file_name = match *opt.target {
         UefiArch::AArch64 => "BootAA64.efi",
         UefiArch::IA32 => "BootIA32.efi",
         UefiArch::X86_64 => "BootX64.efi",
     };
-    if !boot_dir.exists() {
-        fs_err::create_dir_all(&boot_dir)?;
-    }
-    fs_err::copy(built_file, boot_dir.join(output_file))?;
+
+    if let Some(example) = &opt.example {
+        let src_path = build_dir.join("examples").join(format!("{example}.efi"));
+        fs_err::copy(src_path, boot_dir.join(boot_file_name))?;
+    } else {
+        let shell_launcher = build_dir.join("shell_launcher.efi");
+        fs_err::copy(shell_launcher, boot_dir.join(boot_file_name))?;
+
+        let test_runner = build_dir.join("uefi-test-runner.efi");
+        fs_err::copy(test_runner, boot_dir.join("test_runner.efi"))?;
+
+        fs_err::copy(&ovmf_paths.shell, boot_dir.join("shell.efi"))?;
+    };
 
     Ok(esp_dir)
 }
@@ -403,8 +432,6 @@ impl Drop for ChildWrapper {
 }
 
 pub fn run_qemu(arch: UefiArch, opt: &QemuOpt) -> Result<()> {
-    let esp_dir = build_esp_dir(opt)?;
-
     let qemu_exe = match arch {
         UefiArch::AArch64 => "qemu-system-aarch64",
         UefiArch::IA32 | UefiArch::X86_64 => "qemu-system-x86_64",
@@ -506,6 +533,7 @@ pub fn run_qemu(arch: UefiArch, opt: &QemuOpt) -> Result<()> {
     // Mount a local directory as a FAT partition.
     cmd.arg("-drive");
     let mut drive_arg = OsString::from("format=raw,file=fat:rw:");
+    let esp_dir = build_esp_dir(opt, &ovmf_paths)?;
     drive_arg.push(esp_dir);
     cmd.arg(drive_arg);