uefi-test-runner: test new protocol helpers on Handle

Author: phip1611

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

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use uefi::boot::{self, OpenProtocolParams};
+use uefi::proto::device_path::DevicePath;
+use uefi::proto::driver::ComponentName2;
 use uefi::proto::loaded_image::LoadedImage;
 use uefi::{Identify, proto};
 
@@ -44,6 +46,9 @@ pub fn test() {
     shim::test();
     shell::test();
     tcg::test();
+
+    // now test some convenience that combines several things
+    test_handle_convenience();
 }
 
 fn find_protocol() {
@@ -74,6 +79,32 @@ fn test_test_protocol() {
     );
 }
 
+fn test_handle_convenience() {
+    // Handles that implement the following protocols:
+    // - component name 2
+    // - device path
+    let handles = {
+        let mut cn2_handles = boot::find_handles::<ComponentName2>().unwrap();
+        let dvp_handles = boot::find_handles::<DevicePath>().unwrap();
+
+        cn2_handles.retain(|x| dvp_handles.contains(x));
+        cn2_handles
+    };
+    for handle in handles {
+        let dvp = handle.device_path().expect("should have device path");
+        let cn2 = handle
+            .component_name()
+            .expect("should have component name (v2)");
+        info!("handle: {:x?}", handle);
+        info!("|- dvp: {dvp}");
+        info!("|- cn2 driver: {}", cn2.driver_name("en").unwrap());
+        info!(
+            "|- cn2 controller: {}",
+            cn2.controller_name(handle, None, "en").unwrap()
+        );
+    }
+}
+
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 mod ata;
 mod console;

uefi-test-runner/src/proto/network/http.rs

@@ -2,24 +2,12 @@
 
 use alloc::vec::Vec;
 
-use uefi::proto::device_path::DevicePath;
-use uefi::proto::device_path::text::{AllowShortcuts, DisplayOnly};
 use uefi::proto::network::http::{HttpBinding, HttpHelper};
 use uefi::proto::network::ip4config2::Ip4Config2;
 use uefi::{Handle, boot};
 
 use uefi_raw::protocol::network::http::HttpStatusCode;
 
-pub fn print_handle_devpath(prefix: &str, handle: &Handle) {
-    let Ok(dp) = boot::open_protocol_exclusive::<DevicePath>(*handle) else {
-        info!("{prefix}no device path for handle");
-        return;
-    };
-    if let Ok(string) = dp.to_string16(DisplayOnly(true), AllowShortcuts(true)) {
-        info!("{prefix}{string}");
-    }
-}
-
 fn fetch_http(handle: Handle, url: &str) -> Option<Vec<u8>> {
     info!("http: fetching {url} ...");
 
@@ -91,7 +79,7 @@ pub fn test() {
         .expect("get nic handles");
 
     for h in handles.as_ref() {
-        print_handle_devpath("nic: ", h);
+        info!("nic: {}", h.device_path().expect("should have device path"));
 
         info!("Bring up interface (ip4 config2 protocol)");
         let mut ip4 = Ip4Config2::new(*h).expect("open ip4 config2 protocol");

uefi-test-runner/src/proto/nvme/pass_thru.rs

@@ -2,8 +2,6 @@
 
 use core::time::Duration;
 use uefi::boot;
-use uefi::proto::device_path::DevicePath;
-use uefi::proto::device_path::text::{AllowShortcuts, DisplayOnly};
 use uefi::proto::media::block::BlockIO;
 use uefi::proto::nvme::pass_thru::NvmePassThru;
 use uefi::proto::nvme::{NvmeQueueType, NvmeRequestBuilder};
@@ -17,19 +15,14 @@ pub fn test() {
 fn has_nvme_drive() -> bool {
     let block_io_handles = boot::find_handles::<BlockIO>().unwrap();
     for handle in block_io_handles {
-        let Ok(device_path) = boot::open_protocol_exclusive::<DevicePath>(handle) else {
-            continue;
-        };
-        let mut device_path = &*device_path;
+        let device_path_proto = handle.device_path().expect("should have device path");
+        let mut device_path = &*device_path_proto;
 
         let Ok(nvme_pt_handle) = boot::locate_device_path::<NvmePassThru>(&mut device_path) else {
             continue;
         };
         let nvme_pt = boot::open_protocol_exclusive::<NvmePassThru>(nvme_pt_handle).unwrap();
-        let device_path_str = device_path
-            .to_string16(DisplayOnly(true), AllowShortcuts(false))
-            .unwrap();
-        info!("- Successfully opened NVMe: {device_path_str}");
+        info!("- Successfully opened NVMe: {device_path_proto}");
         let mut nvme_ctrl = nvme_pt.controller();
 
         let request = NvmeRequestBuilder::new(nvme_pt.io_align(), 0x06, NvmeQueueType::ADMIN)