test: add load_image integration test

Author: phip1611

CHANGELOG.md

@@ -5,7 +5,7 @@
 ### Added
 - `DevicePath::to_boxed`, `DevicePath::to_owned`, and `DevicePath::as_bytes`
 - `DevicePathInstance::to_boxed`, `DevicePathInstance::to_owned`, and `DevicePathInstance::as_bytes`
-- `DevicePathNode::data`
+- `DevicePathNode::data`, `DevicePathNode::data_u16`, and corresponding `Borrow<T>` implementations
 
 ### Changed
 

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

@@ -1,19 +1,22 @@
+use alloc::string::ToString;
 use uefi::proto::console::text::Output;
-use uefi::table::boot::{BootServices, SearchType};
+use uefi::proto::device_path::{DevicePath, DeviceSubType, DeviceType, LoadedImageDevicePath};
+use uefi::table::boot::{BootServices, LoadImageSource, SearchType};
 use uefi::table::{Boot, SystemTable};
-use uefi::Identify;
+use uefi::{CStr16, CString16, Identify};
+
+mod memory;
+mod misc;
 
 pub fn test(st: &SystemTable<Boot>) {
     let bt = st.boot_services();
     info!("Testing boot services");
     memory::test(bt);
     misc::test(st);
     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");
 
@@ -36,3 +39,72 @@ 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 protocol [`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()
+        .find(|node| {
+            node.device_type() == DeviceType::MEDIA /* 0x4 */
+                && node.sub_type() == DeviceSubType::HARDWARE_VENDOR /* 0x4 */
+        })
+        .map(|node| {
+            CStr16::from_u16_with_nul(node.data_u16().unwrap()).expect("should be valid CCtr16")
+        })
+        // 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");
+    }
+}

uefi/src/data_types/strs.rs

@@ -211,10 +211,8 @@ impl CStr16 {
         Self::from_u16_with_nul_unchecked(slice::from_raw_parts(ptr, len + 1))
     }
 
-    /// Creates a C string wrapper from a u16 slice
-    ///
-    /// Since not every u16 value is a valid UCS-2 code point, this function
-    /// must do a bit more validity checking than CStr::from_bytes_with_nul
+    /// Creates a `&CStr16` from a u16 slice, if the slice contains exactly
+    /// one terminating null-byte and all chars are valid UCS-2 chars.
     pub fn from_u16_with_nul(codes: &[u16]) -> Result<&Self, FromSliceWithNulError> {
         for (pos, &code) in codes.iter().enumerate() {
             match code.try_into() {
@@ -234,7 +232,7 @@ impl CStr16 {
         Err(FromSliceWithNulError::NotNulTerminated)
     }
 
-    /// Unsafely creates a C string wrapper from a u16 slice.
+    /// Unsafely creates a `&CStr16` from a u16 slice.
     ///
     /// # Safety
     ///
@@ -287,11 +285,13 @@ impl CStr16 {
         Self::from_u16_with_nul(&buf[..index + 1]).map_err(|err| match err {
             FromSliceWithNulError::InvalidChar(p) => FromStrWithBufError::InvalidChar(p),
             FromSliceWithNulError::InteriorNul(p) => FromStrWithBufError::InteriorNul(p),
-            FromSliceWithNulError::NotNulTerminated => unreachable!(),
+            FromSliceWithNulError::NotNulTerminated => {
+                unreachable!()
+            }
         })
     }
 
-    /// Create a [`CStr16`] from an [`UnalignedSlice`] using an aligned
+    /// Create a `&CStr16` from an [`UnalignedSlice`] using an aligned
     /// buffer for storage. The lifetime of the output is tied to `buf`,
     /// not `src`.
     pub fn from_unaligned_slice<'buf>(
@@ -562,6 +562,13 @@ mod tests {
         assert_eq!(<CStr8 as Borrow<[u8]>>::borrow(string), &[b'a', 0]);
     }
 
+    #[test]
+    fn test_cstr16_from_slice() {
+        let s1 = CStr16::from_u8_with_nul(&[65, 0, 66, 0, 67, 0, 0, 0]).unwrap();
+        let s2 = CStr16::from_u16_with_nul(&[65, 66, 67, 0]).unwrap();
+        assert_eq!(s1, s2)
+    }
+
     #[test]
     fn test_cstr16_num_bytes() {
         let s = CStr16::from_u16_with_nul(&[65, 66, 67, 0]).unwrap();

uefi/src/proto/device_path/mod.rs

@@ -84,6 +84,7 @@ pub use device_path_gen::{
 use {alloc::borrow::ToOwned, alloc::boxed::Box};
 
 use crate::proto::{unsafe_protocol, ProtocolPointer};
+use core::borrow::Borrow;
 use core::ffi::c_void;
 use core::fmt::{self, Debug, Formatter};
 use core::mem;
@@ -184,6 +185,21 @@ impl DevicePathNode {
         &self.data
     }
 
+    /// Returns the payload data of this node as u16 slice,
+    /// if the slice can be mapped to a `u16` slice..
+    #[must_use]
+    pub fn data_u16(&self) -> Option<&[u16]> {
+        let multiple_of_u16 = self.data.len() % 2 != 0;
+        let aligned = self.data.as_ptr() as u64 & 0xf != 0;
+        if !multiple_of_u16 || !aligned {
+            None
+        } else {
+            Some(unsafe {
+                core::slice::from_raw_parts(self.data.as_ptr().cast(), self.data.len() / 2)
+            })
+        }
+    }
+
     /// Convert from a generic [`DevicePathNode`] reference to an enum
     /// of more specific node types.
     pub fn as_enum(&self) -> Result<DevicePathNodeEnum, NodeConversionError> {
@@ -206,6 +222,18 @@ impl PartialEq for DevicePathNode {
     }
 }
 
+impl Borrow<[u8]> for DevicePathNode {
+    fn borrow(&self) -> &[u8] {
+        self.data()
+    }
+}
+
+impl Borrow<[u16]> for DevicePathNode {
+    fn borrow(&self) -> &[u16] {
+        self.data_u16().expect("should be convertable to u16 slice")
+    }
+}
+
 /// A single device path instance that ends with either an [`END_INSTANCE`]
 /// or [`END_ENTIRE`] node. Use [`DevicePath::instance_iter`] to get the
 /// path instances in a [`DevicePath`].