Implements core::error::Error on error types

Author: ultimaweapon

Cargo.toml

@@ -9,6 +9,7 @@ rust-version = "1.81"
 
 [dependencies]
 bitflags = "2.4"
+thiserror = { version = "2.0.9", default-features = false }
 zfi-macros = { version = "0.1", path = "macros" }
 
 [dev-dependencies]

README.md

@@ -205,6 +205,9 @@ Keep in mind that you need to put everything your test needed in the same functi
 - `Image::current()` was replaced with `zfi::current_image()`.
 - All getters on `SystemTable` no longer return a static lifetime.
 - `EfiStr` and `EfiString` to longer implement `Display`. Use `EfiStr::display()` instead.
+- `Display` implementation of `DebugFileError`, `FileCreateError` and `FileSetLenError` no longer print the nested error. Use `core::error::Error::source()` to obtains the inner error instead.
+- `Path` no longer implement `Display`. Use `Path::display()` instead.
+- `PathNode` no longer implement `Display`. Currently no alternative is provided yet. Please create the issue if you want this feature so I can prioritize it.
 
 ## License
 

src/debug.rs

@@ -5,7 +5,8 @@ use crate::{
 use alloc::borrow::ToOwned;
 use alloc::boxed::Box;
 use core::cell::RefCell;
-use core::fmt::{Display, Formatter, Write};
+use core::fmt::Write;
+use thiserror::Error;
 
 /// Prints to the debug log, with a newline.
 ///
@@ -87,25 +88,17 @@ impl Write for DebugFile {
 }
 
 /// Represents an error when [`DebugFile`] constructing is failed.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum DebugFileError {
+    #[error("the location of the current image is not supported")]
     UnsupportedImageLocation,
-    OpenRootFailed(&'static Path, Status),
+
+    #[error("cannot open the root directory of {}", .0.display())]
+    OpenRootFailed(&'static Path, #[source] Status),
+
+    #[error("file extension contains unsupported character")]
     UnsupportedExtension,
-    CreateFileFailed(EfiString, FileCreateError),
-}
 
-impl Display for DebugFileError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            Self::UnsupportedImageLocation => {
-                f.write_str("the location of the current image is not supported")
-            }
-            Self::OpenRootFailed(p, e) => write!(f, "cannot open the root directory of {p} -> {e}"),
-            Self::UnsupportedExtension => {
-                f.write_str("file extension contains unsupported character")
-            }
-            Self::CreateFileFailed(p, e) => write!(f, "cannot create {p} -> {e}"),
-        }
-    }
+    #[error("cannot create {}", .0.display())]
+    CreateFileFailed(EfiString, #[source] FileCreateError),
 }

src/filesystem.rs

@@ -3,9 +3,9 @@ use alloc::alloc::{alloc, dealloc, handle_alloc_error};
 use alloc::boxed::Box;
 use bitflags::bitflags;
 use core::alloc::Layout;
-use core::fmt::{Display, Formatter};
 use core::mem::zeroed;
 use core::ptr::null_mut;
+use thiserror::Error;
 
 /// Represents an `EFI_SIMPLE_FILE_SYSTEM_PROTOCOL`.
 #[repr(C)]
@@ -364,35 +364,24 @@ impl FileInfo {
 }
 
 /// Represents an error when [`File::create()`] is failed.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum FileCreateError {
+    #[error(transparent)]
     CreateFailed(Status),
-    TruncateFailed(FileSetLenError),
-}
 
-impl Display for FileCreateError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            Self::CreateFailed(e) => e.fmt(f),
-            Self::TruncateFailed(e) => write!(f, "cannot truncate the file -> {e}"),
-        }
-    }
+    #[error("cannot truncate the file")]
+    TruncateFailed(#[source] FileSetLenError),
 }
 
 /// Represents an error when [`File::set_len()`] is failed.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum FileSetLenError {
-    GetInfoFailed(Status),
+    #[error("cannot get the current info")]
+    GetInfoFailed(#[source] Status),
+
+    #[error("file is a directory")]
     FileIsDirectory,
-    SetInfoFailed(Status),
-}
 
-impl Display for FileSetLenError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            Self::GetInfoFailed(e) => write!(f, "cannot get the current info -> {e}"),
-            Self::FileIsDirectory => f.write_str("file is a directory"),
-            Self::SetInfoFailed(e) => write!(f, "cannot set file info -> {e}"),
-        }
-    }
+    #[error("cannot set file info")]
+    SetInfoFailed(#[source] Status),
 }

src/lib.rs

@@ -72,7 +72,10 @@ pub unsafe fn init(
 
     // Check EFI version.
     if st.hdr().revision() < TableRevision::new(1, 1) {
-        panic!("UEFI version is too old to run {}", im.proto().file_path());
+        panic!(
+            "UEFI version is too old to run {}",
+            im.proto().file_path().display()
+        );
     }
 
     // Initialize debug log.

src/path.rs

@@ -1,7 +1,7 @@
 use crate::EfiStr;
 use alloc::borrow::{Cow, ToOwned};
 use core::borrow::Borrow;
-use core::fmt::{Display, Formatter};
+use core::fmt::Formatter;
 use core::ops::Deref;
 use core::ptr::read_unaligned;
 use core::slice::from_raw_parts;
@@ -63,6 +63,10 @@ impl Path {
     pub const fn as_bytes(&self) -> &[u8] {
         &self.0
     }
+
+    pub const fn display(&self) -> impl core::fmt::Display + '_ {
+        Display(self)
+    }
 }
 
 impl PartialEq<PathBuf> for Path {
@@ -88,13 +92,19 @@ impl<'a> IntoIterator for &'a Path {
     }
 }
 
-impl Display for Path {
+/// Provides [`core::fmt::Display`] implementation to print [`Path`].
+struct Display<'a>(&'a Path);
+
+impl<'a> core::fmt::Display for Display<'a> {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        for (i, n) in self.into_iter().enumerate() {
+        for (i, n) in self.0.into_iter().enumerate() {
             if i != 0 {
                 f.write_str("/")?;
             }
-            n.read().fmt(f)?;
+
+            match n.read() {
+                PathNode::MediaFilePath(v) => write!(f, "{}", v.display())?,
+            }
         }
 
         Ok(())
@@ -164,14 +174,6 @@ pub enum PathNode<'a> {
     MediaFilePath(&'a EfiStr),
 }
 
-impl Display for PathNode<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            PathNode::MediaFilePath(p) => p.fmt(f),
-        }
-    }
-}
-
 /// An iterator over device path nodes.
 pub struct PathNodes<'a>(&'a [u8]);
 

src/status.rs

@@ -1,3 +1,4 @@
+use core::error::Error;
 use core::fmt::{Display, Formatter};
 
 /// Represents an `EFI_STATUS`.
@@ -35,6 +36,8 @@ impl Status {
     }
 }
 
+impl Error for Status {}
+
 impl Display for Status {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         match *self {

src/string.rs

@@ -6,6 +6,7 @@ use core::mem::transmute;
 use core::ops::Deref;
 use core::slice::{from_raw_parts, IterMut};
 use core::str::FromStr;
+use thiserror::Error;
 
 /// A borrowed EFI string. The string is always have NUL at the end.
 ///
@@ -212,8 +213,11 @@ impl PartialEq<u8> for EfiChar {
 }
 
 /// Represents an error when an [`EfiString`] cnostruction is failed.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum EfiStringError {
+    #[error("the value contains NUL character")]
     HasNul(usize),
+
+    #[error("the value contains character outside Basic Multilingual Plane")]
     UnsupportedChar(usize, char),
 }