uefi: impl Display for DevicePath, DevicePathNode, and ScopedProtocol

For device paths, it is very convenient to use the DevicePathToText
protocol to visualize/print the device path. By providing a
convenient Display impl, we improve the ergonomics of device paths
significantly and reducing boilerplate.

Author: phip1611

uefi/CHANGELOG.md

@@ -11,6 +11,11 @@
 - Added `proto::device_path::DevicePathUtilities::duplicate_path()`.
 - Added `proto::pci::enumeration::PciTree::device_path()`.
 - Added `revision()` and `device_type_guid()` to `Serial` protocol
+- Implemented `Display` for `DevicePath`, `DevicePathNode` and `ScopedProtocol`,
+  enabling a easy and convenient way to visualize a device path. For example,
+  this may print `PciRoot(0x0)/Pci(0x6,0x0)/MAC(525400000001,0x1)`.
+  `ScopedProtocol` only implements `Display` if the underlying protocol also
+  implements `Display`.
 
 ## Changed
 - export all `text::{input, output}::*` types

uefi/src/boot.rs

@@ -45,6 +45,7 @@ use crate::table::Revision;
 use crate::util::opt_nonnull_to_ptr;
 use crate::{Char16, Error, Event, Guid, Handle, Result, Status, StatusExt, table};
 use core::ffi::c_void;
+use core::fmt::{Display, Formatter};
 use core::mem::MaybeUninit;
 use core::ops::{Deref, DerefMut};
 use core::ptr::{self, NonNull};
@@ -1619,6 +1620,20 @@ impl<P: Protocol + ?Sized> ScopedProtocol<P> {
     }
 }
 
+// Forward Display impl to inner protocol:
+impl<P: Protocol + ?Sized + Display> Display for ScopedProtocol<P> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        match self.get() {
+            Some(proto) => {
+                write!(f, "{proto}")
+            }
+            None => {
+                write!(f, "<none>")
+            }
+        }
+    }
+}
+
 impl<P: Protocol + ?Sized> Drop for ScopedProtocol<P> {
     fn drop(&mut self) {
         let bt = boot_services_raw_panicking();

uefi/src/proto/device_path/mod.rs

@@ -323,6 +323,20 @@ impl DevicePathNode {
     }
 }
 
+#[cfg(feature = "alloc")]
+impl Display for DevicePathNode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        if boot::are_boot_services_active() {
+            let cstring16 = self
+                .to_string16(DisplayOnly(true), AllowShortcuts(true))
+                .unwrap();
+            write!(f, "{}", cstring16)
+        } else {
+            write!(f, "<device path node: {} bytes>", self.data.len())
+        }
+    }
+}
+
 impl Debug for DevicePathNode {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         f.debug_struct("DevicePathNode")
@@ -459,8 +473,7 @@ impl ToOwned for DevicePathInstance {
 ///     let device_path: ScopedProtocol<DevicePath>
 ///         = open_protocol_exclusive::<DevicePath>(device_handle).unwrap();
 ///     log::debug!(
-///         "Device path: {}",
-///         device_path.to_string16(DisplayOnly(true), AllowShortcuts(true)).unwrap()
+///         "Device path: {device_path}",
 ///     );
 /// }
 /// ```
@@ -640,6 +653,20 @@ impl DevicePath {
     }
 }
 
+#[cfg(feature = "alloc")]
+impl Display for DevicePath {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        if boot::are_boot_services_active() {
+            let cstring16 = self
+                .to_string16(DisplayOnly(true), AllowShortcuts(true))
+                .unwrap();
+            write!(f, "{}", cstring16)
+        } else {
+            write!(f, "<device path: {} bytes>", self.data.len())
+        }
+    }
+}
+
 impl Debug for DevicePath {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         f.debug_struct("DevicePath")