More general error types.

Author: veluca93

pixie-uefi/Cargo.lock

@@ -16,7 +16,6 @@ coverage = ["dep:minicov"]
 anstyle = { version = "1.0.13", default-features = false }
 blake3 = { version = "1.8.2", default-features = false, features = ["prefer_intrinsics", "no_avx512", "pure"] }
 core_detect = "1.0.0"
-derive_more = { version = "2.0.1", features = ["from"], default-features = false }
 futures = { version = "0.3.29", default-features = false, features = ["alloc", "async-await"] }
 gpt_disk_io = "0.16.2"
 log = "0.4.28"

pixie-uefi/Cargo.toml

@@ -5,7 +5,7 @@ use crate::{
     },
     MIN_MEMORY,
 };
-use alloc::{boxed::Box, collections::BTreeMap, rc::Rc, string::ToString, vec::Vec};
+use alloc::{boxed::Box, collections::BTreeMap, rc::Rc, vec::Vec};
 use core::{cell::RefCell, mem, net::SocketAddrV4};
 use futures::future::{select, Either};
 use log::info;
@@ -64,7 +64,7 @@ fn handle_packet(
     received.remove(&hash).unwrap();
     last_seen.retain(|x| x != &hash);
 
-    let data = decompress(&cdata, size).map_err(|e| Error::Generic(e.to_string()))?;
+    let data = decompress(&cdata, size)?;
     assert_eq!(data.len(), size);
 
     Ok(Some((pos, data)))

pixie-uefi/src/flash.rs

@@ -1,7 +1,4 @@
-use super::{
-    error::{Error, Result},
-    UefiOS,
-};
+use super::{error::Result, UefiOS};
 use alloc::{
     string::{String, ToString},
     vec::Vec,
@@ -170,19 +167,14 @@ impl Disk {
 
     pub fn partitions(&mut self) -> Result<Vec<DiskPartition>> {
         let block_size = self.block_size().to_u64();
-        let mut disk = gpt_disk_io::Disk::new(self).map_err(|e| Error::Generic(e.to_string()))?;
+        let mut disk = gpt_disk_io::Disk::new(self)?;
         let mut buf = [0; 1 << 14];
-        let header = disk
-            .read_primary_gpt_header(&mut buf)
-            .map_err(|e| Error::Generic(e.to_string()))?;
+        let header = disk.read_primary_gpt_header(&mut buf)?;
         // TODO(veluca): bubble up this error.
-        let part_array_layout = header
-            .get_partition_entry_array_layout()
-            .map_err(|e| Error::Generic(e.to_string()))?;
+        let part_array_layout = header.get_partition_entry_array_layout()?;
         let mut buf = [0; 1 << 14];
         let x = disk
-            .gpt_partition_entry_array_iter(part_array_layout, &mut buf)
-            .map_err(|e| Error::Generic(e.to_string()))?
+            .gpt_partition_entry_array_iter(part_array_layout, &mut buf)?
             .filter_map(|part| {
                 let part = if let Err(err) = part {
                     return Some(Err(err));
@@ -201,8 +193,7 @@ impl Disk {
                     None
                 }
             })
-            .collect::<Result<_, _>>()
-            .map_err(|e| Error::Generic(e.to_string()))?;
+            .collect::<Result<_, _>>()?;
 
         Ok(x)
     }

pixie-uefi/src/os/disk.rs

@@ -1,31 +1,39 @@
 use alloc::{borrow::ToOwned, string::String};
 use core::fmt::{Display, Formatter};
-use derive_more::From;
-use smoltcp::socket::{
-    tcp::{self, ConnectError, RecvError},
-    udp::{self, BindError},
-};
+use gpt_disk_io::gpt_disk_types;
 
 pub type Result<T, E = Error> = core::result::Result<T, E>;
 
-#[derive(Debug, From)]
-pub enum Error {
-    Connect(#[from] ConnectError),
-    TcpSend(#[from] tcp::SendError),
-    UdpSend(#[from] udp::SendError),
-    Recv(#[from] RecvError),
-    Bind(#[from] BindError),
-    Postcard(#[from] postcard::Error),
-    Uefi(#[from] uefi::Error),
-    Generic(String),
-}
+#[derive(Debug)]
+pub struct Error(pub String);
 
 impl Error {
     pub fn msg(s: &str) -> Error {
-        Error::Generic(s.to_owned())
+        Self(s.to_owned())
     }
 }
 
+macro_rules! err {
+    ($ty: ty) => {
+        impl From<$ty> for Error {
+            fn from(value: $ty) -> Self {
+                Self(format!("{}: {value}", stringify!($ty)))
+            }
+        }
+    };
+}
+
+err!(uefi::Error);
+err!(smoltcp::socket::tcp::ConnectError);
+err!(smoltcp::socket::tcp::RecvError);
+err!(smoltcp::socket::tcp::SendError);
+err!(smoltcp::socket::udp::BindError);
+err!(smoltcp::socket::udp::SendError);
+err!(postcard::Error);
+err!(lz4_flex::block::DecompressError);
+err!(gpt_disk_io::DiskError<Error>);
+err!(gpt_disk_types::GptPartitionEntrySizeError);
+
 impl Display for Error {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), core::fmt::Error> {
         write!(fmt, "{self:?}")

pixie-uefi/src/os/error.rs

@@ -340,7 +340,7 @@ impl UefiOS {
         let mut name_buf = vec![0u16; name.len() * 2 + 16];
         let name = CStr16::from_str_with_buf(name, &mut name_buf).unwrap();
         let (var, attrs) = uefi::runtime::get_variable_boxed(name, vendor)
-            .map_err(|e| Error::Generic(format!("Error getting variable: {e:?}")))?;
+            .map_err(|e| Error(format!("Error getting variable: {e:?}")))?;
         Ok((var.to_vec(), attrs))
     }
 
@@ -355,7 +355,7 @@ impl UefiOS {
         let mut name_buf = vec![0u16; name.len() * 2 + 16];
         let name = CStr16::from_str_with_buf(name, &mut name_buf).unwrap();
         uefi::runtime::set_variable(name, vendor, attrs, data)
-            .map_err(|e| Error::Generic(format!("Error setting variable: {e:?}")))?;
+            .map_err(|e| Error(format!("Error setting variable: {e:?}")))?;
         Ok(())
     }
 

pixie-uefi/src/os/mod.rs

@@ -341,7 +341,7 @@ impl TcpStream {
             let socket = net.socket_set.get_mut::<TcpSocket>(self.handle);
             let sent = socket.send_slice(&data[pos..]);
             if let Err(err) = sent {
-                return Poll::Ready(Err(Error::TcpSend(err)));
+                return Poll::Ready(Err(err.into()));
             }
             pos += sent.unwrap();
             if pos < data.len() {
@@ -374,7 +374,7 @@ impl TcpStream {
                 return Poll::Ready(Ok(0));
             }
             if let Err(err) = recvd {
-                return Poll::Ready(Err(Error::Recv(err)));
+                return Poll::Ready(Err(err.into()));
             }
             if recvd.unwrap() == 0 {
                 socket.register_recv_waker(cx.waker());

pixie-uefi/src/os/net.rs

@@ -1,9 +1,6 @@
 use super::{le16, le32, le64};
 use crate::{
-    os::{
-        disk::Disk,
-        error::{Error, Result},
-    },
+    os::{disk::Disk, error::Result},
     store::ChunkInfo,
 };
 use alloc::vec::Vec;
@@ -42,8 +39,7 @@ pub async fn get_ntfs_chunks(disk: &Disk, start: u64, end: u64) -> Result<Option
     let bitmap_entry_address = mft_address + 6 * bytes_per_file_record;
     let mut bitmap_entry = [0u8; 1024];
     disk.read(start + bitmap_entry_address as u64, &mut bitmap_entry)
-        .await
-        .map_err(|e| Error::Generic(format!("failed to read bitmap entry: {e}")))?;
+        .await?;
 
     let mut attribute_offset = le16(&bitmap_entry, 0x14) as usize;
     while le32(&bitmap_entry, attribute_offset) != 0x80 {
@@ -75,9 +71,7 @@ pub async fn get_ntfs_chunks(disk: &Disk, start: u64, end: u64) -> Result<Option
         let mut buf = vec![0u8; bytes_per_cluster];
         for i in 0..length {
             let x = start + (offset + i) as u64 * bytes_per_cluster as u64;
-            disk.read(x, &mut buf).await.map_err(|e| {
-                Error::Generic(format!("failed to read bitmap content at {x}: {e}"))
-            })?;
+            disk.read(x, &mut buf).await?;
 
             for &byte in &buf {
                 for bit in 0..8 {

pixie-uefi/src/parse_disk/ntfs.rs

@@ -115,7 +115,7 @@ pub async fn register(os: UefiOS, server_addr: SocketAddrV4) -> Result<()> {
                     data.station.image = images[(images
                         .iter()
                         .position(|x| x == &data.station.image)
-                        .ok_or(Error::Generic("Invalid image name".into()))?
+                        .ok_or(Error::msg("Invalid image name"))?
                         + images.len()
                         - 1)
                         % images.len()]