test: add load_image integration test

Author: phip1611

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

@@ -1,17 +1,20 @@
+use alloc::string::ToString;
 use uefi::proto::console::text::Output;
-use uefi::table::boot::{BootServices, SearchType};
-use uefi::Identify;
+use uefi::proto::device_path::{DevicePath, DeviceSubType, DeviceType, LoadedImageDevicePath};
+use uefi::table::boot::{BootServices, LoadImageSource, SearchType};
+use uefi::{CStr16, CString16, Identify};
+
+mod memory;
+mod misc;
 
 pub fn test(bt: &BootServices) {
     info!("Testing boot services");
     memory::test(bt);
     misc::test(bt);
     test_locate_handle_buffer(bt);
+    test_load_image(bt);
 }
 
-mod memory;
-mod misc;
-
 fn test_locate_handle_buffer(bt: &BootServices) {
     info!("Testing the `locate_handle_buffer` function");
 
@@ -34,3 +37,71 @@ fn test_locate_handle_buffer(bt: &BootServices) {
         );
     }
 }
+
+/// This test loads the "self image" again into memory using the `load_image`
+/// boot service function. The image is not started but just loaded into memory.
+///
+/// It transitively tests the protocols [`LoadedImageDevicePath`] which is
+/// required as helper.
+fn test_load_image(bt: &BootServices) {
+    info!("Testing the `load_image` function");
+
+    let image_device_path_protocol = bt
+        .open_protocol_exclusive::<LoadedImageDevicePath>(bt.image_handle())
+        .expect("should open LoadedImage protocol");
+
+    // Note: This is the full device path. The LoadedImage protocol would only
+    // provide us with the file-path portion of the device path.
+    let image_device_path: &DevicePath = &image_device_path_protocol;
+
+    // Get the file-path portion of the device path which is typically behind
+    // device path node (0x4, 0x4).
+    // TODO we need an abstraction in the UEFI crate for this.
+    let image_device_path_file_path = image_device_path
+        .node_iter()
+        .filter(|node| {
+            node.device_type() == DeviceType::MEDIA /* 0x4 */
+                && node.sub_type() == DeviceSubType::HARDWARE_VENDOR /* 0x4 */
+        })
+        .next()
+        .map(|node| unsafe { CStr16::from_ptr(node.data().as_ptr().cast()) })
+        // to Rust string
+        .map(|cstr16| cstr16.to_string().to_uppercase())
+        .expect("should have file-path portion in device path");
+
+    // On x86_64, this will be `\EFI\BOOT\BOOTX64.EFI` for example.
+    assert!(image_device_path_file_path
+        .as_str()
+        .starts_with(r"\EFI\BOOT\BOOT"));
+    assert!(image_device_path_file_path.as_str().ends_with(".EFI"));
+
+    // Variant A: FromBuffer
+    {
+        let mut fs = bt
+            .get_image_file_system(bt.image_handle())
+            .expect("should open file system");
+        let path = CString16::try_from(image_device_path_file_path.as_str()).unwrap();
+        let image_data = fs.read(&*path).expect("should read file content");
+        let load_source = LoadImageSource::FromBuffer {
+            buffer: image_data.as_slice(),
+            file_path: None,
+        };
+        let _ = bt
+            .load_image(bt.image_handle(), load_source)
+            .expect("should load image");
+
+        log::debug!("load_image with FromBuffer strategy works");
+    }
+    // Variant B: FromFilePath
+    {
+        let load_source = LoadImageSource::FromFilePath {
+            file_path: image_device_path,
+            from_boot_manager: false,
+        };
+        let _ = bt
+            .load_image(bt.image_handle(), load_source)
+            .expect("should load image");
+
+        log::debug!("load_image with FromFilePath strategy works");
+    }
+}