Merge pull request #28 from jplatte/snafu

superblock: Convert to snafu and split up the Error type

Author: ermo

Cargo.lock

@@ -20,6 +20,7 @@ nix = { version = "0.30.1", features = ["fs", "mount"] }
 phf = "0.11"
 serde = { version = "1.0" }
 serde_json = "1.0"
+snafu = "0.8.5"
 test-log = "0.2.17"
 thiserror = "2.0.3"
 uuid = { version = "1.12.1", features = ["v8"] }

Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 [dependencies]
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
-thiserror.workspace = true
+snafu.workspace = true
 uuid = { workspace = true, features = ["v8"] }
 zerocopy = { workspace = true, features = ["derive", "std"] }
 

crates/superblock/Cargo.toml

@@ -7,7 +7,7 @@
 //! This module provides functionality for reading and parsing BTRFS filesystem superblocks,
 //! which contain critical metadata about the filesystem including UUIDs and labels.
 
-use crate::{Detection, Error};
+use crate::{Detection, UnicodeError};
 use uuid::Uuid;
 use zerocopy::*;
 
@@ -117,12 +117,12 @@ impl Detection for Btrfs {
 
 impl Btrfs {
     /// Return the encoded UUID for this superblock as a string
-    pub fn uuid(&self) -> Result<String, Error> {
+    pub fn uuid(&self) -> Result<String, UnicodeError> {
         Ok(Uuid::from_bytes(self.fsid).hyphenated().to_string())
     }
 
     /// Return the volume label as a string
-    pub fn label(&self) -> Result<String, Error> {
+    pub fn label(&self) -> Result<String, UnicodeError> {
         Ok(str::from_utf8(&self.label)?.trim_end_matches('\0').to_owned())
     }
 }

crates/superblock/src/btrfs.rs

@@ -8,7 +8,7 @@
 //! The superblock contains critical metadata about the filesystem including UUID, volume label,
 //! and various configuration parameters.
 
-use crate::{Detection, Error};
+use crate::{Detection, UnicodeError};
 use uuid::Uuid;
 use zerocopy::*;
 
@@ -209,12 +209,12 @@ impl Detection for Ext4 {
 
 impl Ext4 {
     /// Return the encoded UUID for this superblock
-    pub fn uuid(&self) -> Result<String, Error> {
+    pub fn uuid(&self) -> Result<String, UnicodeError> {
         Ok(Uuid::from_bytes(self.uuid).hyphenated().to_string())
     }
 
     /// Return the volume label as valid utf8
-    pub fn label(&self) -> Result<String, super::Error> {
+    pub fn label(&self) -> Result<String, UnicodeError> {
         Ok(str::from_utf8(&self.volume_name)?.into())
     }
 }

crates/superblock/src/ext4.rs

@@ -13,7 +13,7 @@
 //! - Encryption settings
 //! - Device information
 
-use crate::{Detection, Error};
+use crate::{Detection, UnicodeError};
 use uuid::Uuid;
 use zerocopy::*;
 
@@ -163,14 +163,14 @@ pub const START_POSITION: u64 = 1024;
 
 impl F2FS {
     /// Returns the filesystem UUID as a hyphenated string
-    pub fn uuid(&self) -> Result<String, Error> {
+    pub fn uuid(&self) -> Result<String, UnicodeError> {
         Ok(Uuid::from_bytes(self.uuid).hyphenated().to_string())
     }
 
     /// Returns the volume label as a UTF-16 decoded string
     ///
     /// Handles null termination and invalid UTF-16 sequences
-    pub fn label(&self) -> Result<String, Error> {
+    pub fn label(&self) -> Result<String, UnicodeError> {
         // Convert the array of U16<LittleEndian> to u16
         let vol = self.volume_name.map(|x| x.get());
         let prelim_label = String::from_utf16(&vol)?;

crates/superblock/src/f2fs.rs

@@ -10,7 +10,7 @@
 //! - Volume name and UUID
 //! - Encryption settings
 
-use crate::{Detection, Error};
+use crate::{Detection, UnicodeError};
 use zerocopy::*;
 
 /// Starting position of superblock in bytes
@@ -120,26 +120,26 @@ pub enum FatType {
 }
 
 impl Fat {
-    pub fn fat_type(&self) -> Result<FatType, Error> {
+    pub fn fat_type(&self) -> FatType {
         // this is how the linux kernel does it in https://github.com/torvalds/linux/blob/master/fs/fat/inode.c
         if self.fat_length == 0 && self.fat32().fat32_length != 0 {
-            Ok(FatType::Fat32)
+            FatType::Fat32
         } else {
-            Ok(FatType::Fat16)
+            FatType::Fat16
         }
     }
 
     /// Returns the filesystem id
-    pub fn uuid(&self) -> Result<String, Error> {
-        match self.fat_type()? {
+    pub fn uuid(&self) -> Result<String, UnicodeError> {
+        Ok(match self.fat_type() {
             FatType::Fat16 => vol_id(self.fat16().common.vol_id),
             FatType::Fat32 => vol_id(self.fat32().common.vol_id),
-        }
+        })
     }
 
     /// Returns the volume label
-    pub fn label(&self) -> Result<String, Error> {
-        match self.fat_type()? {
+    pub fn label(&self) -> Result<String, UnicodeError> {
+        match self.fat_type() {
             FatType::Fat16 => vol_label(&self.fat16().common.vol_label),
             FatType::Fat32 => vol_label(&self.fat32().common.vol_label),
         }
@@ -163,10 +163,10 @@ fn first_n_bytes<const N: usize, const M: usize>(arr: &[u8; M]) -> &[u8; N] {
     <&[u8; N]>::try_from(&arr[..N]).unwrap()
 }
 
-fn vol_label(vol_label: &[u8; 11]) -> Result<String, Error> {
+fn vol_label(vol_label: &[u8; 11]) -> Result<String, UnicodeError> {
     Ok(String::from_utf8_lossy(vol_label).trim_end_matches(' ').to_string())
 }
 
-fn vol_id(vol_id: U32<LittleEndian>) -> Result<String, Error> {
-    Ok(format!("{:04X}-{:04X}", vol_id >> 16, vol_id & 0xFFFF))
+fn vol_id(vol_id: U32<LittleEndian>) -> String {
+    format!("{:04X}-{:04X}", vol_id >> 16, vol_id & 0xFFFF)
 }

crates/superblock/src/fat.rs

@@ -9,7 +9,7 @@
 
 use std::io::{self, BufRead, Cursor, Read, Seek};
 
-use thiserror::Error;
+use snafu::{ResultExt, Snafu};
 use zerocopy::FromBytes;
 
 pub mod btrfs;
@@ -38,35 +38,31 @@ pub trait Detection: Sized + FromBytes {
 }
 
 /// Errors that can occur when reading superblocks
-#[derive(Debug, Error)]
+#[derive(Debug, Snafu)]
 pub enum Error {
+    /// An I/O error occurred
+    #[snafu(display("io"))]
+    Io { source: io::Error },
+
     /// No known filesystem superblock was detected
-    #[error("unknown superblock")]
+    #[snafu(display("unknown superblock"))]
     UnknownSuperblock,
+}
 
-    /// Invalid JSON
-    #[error("invalid json")]
-    InvalidJson(#[from] serde_json::Error),
-
-    /// The requested feature is not implemented for this filesystem type
-    #[error("unsupported feature")]
-    UnsupportedFeature,
-
+/// Errors that can occur when decoding strings from FS metadata
+#[derive(Debug, Snafu)]
+pub enum UnicodeError {
     /// Error decoding UTF-8 string data
-    #[error("invalid utf8 in decode: {0}")]
-    Utf8Decoding(#[from] std::str::Utf8Error),
+    #[snafu(display("{source}"), context(false))]
+    InvalidUtf8 { source: std::str::Utf8Error },
 
     /// Error decoding UTF-16 string data
-    #[error("invalid utf16 in decode: {0}")]
-    Utf16Decoding(#[from] std::string::FromUtf16Error),
-
-    /// An I/O error occurred
-    #[error("io: {0}")]
-    IO(#[from] io::Error),
+    #[snafu(display("{source}"), context(false))]
+    InvalidUtf16 { source: std::string::FromUtf16Error },
 }
 
 /// Attempts to detect a superblock of the given type from the reader
-pub fn detect_superblock<T: Detection, R: BufRead + Seek>(reader: &mut R) -> Result<Option<T>, Error> {
+pub fn detect_superblock<T: Detection, R: BufRead + Seek>(reader: &mut R) -> io::Result<Option<T>> {
     reader.seek(io::SeekFrom::Start(T::MAGIC_OFFSET))?;
     let mut magic_buf = vec![0u8; std::mem::size_of::<T::Magic>()];
     reader.read_exact(&mut magic_buf)?;
@@ -139,7 +135,7 @@ impl Superblock {
     }
 
     /// Returns the filesystem UUID if available
-    pub fn uuid(&self) -> Result<String, Error> {
+    pub fn uuid(&self) -> Result<String, UnicodeError> {
         match self {
             Superblock::Btrfs(block) => block.uuid(),
             Superblock::Ext4(block) => block.uuid(),
@@ -151,7 +147,7 @@ impl Superblock {
     }
 
     /// Returns the volume label if available
-    pub fn label(&self) -> Result<String, Error> {
+    pub fn label(&self) -> Result<String, UnicodeError> {
         match self {
             Superblock::Btrfs(block) => block.label(),
             Superblock::Ext4(block) => block.label(),
@@ -170,25 +166,22 @@ impl Superblock {
     pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
         let mut cursor = Cursor::new(bytes);
 
-        // Try each filesystem type in order of likelihood
-        if let Some(sb) = detect_superblock::<ext4::Ext4, _>(&mut cursor)? {
-            return Ok(Self::Ext4(Box::new(sb)));
-        }
-        if let Some(sb) = detect_superblock::<btrfs::Btrfs, _>(&mut cursor)? {
-            return Ok(Self::Btrfs(Box::new(sb)));
-        }
-        if let Some(sb) = detect_superblock::<f2fs::F2FS, _>(&mut cursor)? {
-            return Ok(Self::F2FS(Box::new(sb)));
-        }
-        if let Some(sb) = detect_superblock::<xfs::Xfs, _>(&mut cursor)? {
-            return Ok(Self::Xfs(Box::new(sb)));
-        }
-        if let Some(sb) = detect_superblock::<luks2::Luks2, _>(&mut cursor)? {
-            return Ok(Self::Luks2(Box::new(sb)));
-        }
-        if let Some(sb) = detect_superblock::<fat::Fat, _>(&mut cursor)? {
-            return Ok(Self::Fat(Box::new(sb)));
+        macro_rules! try_detect {
+            ($variant:ident, $ty:ty) => {
+                if let Some(sb) = detect_superblock::<$ty, _>(&mut cursor).context(IoSnafu)? {
+                    return Ok(Self::$variant(Box::new(sb)));
+                }
+            };
         }
+
+        // Try each filesystem type in order of likelihood
+        try_detect!(Ext4, ext4::Ext4);
+        try_detect!(Btrfs, btrfs::Btrfs);
+        try_detect!(F2FS, f2fs::F2FS);
+        try_detect!(Xfs, xfs::Xfs);
+        try_detect!(Luks2, luks2::Luks2);
+        try_detect!(Fat, fat::Fat);
+
         Err(Error::UnknownSuperblock)
     }
 
@@ -199,8 +192,8 @@ impl Superblock {
     pub fn from_reader<R: Read + Seek>(reader: &mut R) -> Result<Self, Error> {
         // Preallocate a fixed buffer for the largest superblock we need to read
         let mut bytes = vec![0u8; 128 * 1024]; // 128KB covers all superblock offsets
-        reader.rewind()?;
-        reader.read_exact(&mut bytes)?;
+        reader.rewind().context(IoSnafu)?;
+        reader.read_exact(&mut bytes).context(IoSnafu)?;
 
         Self::from_bytes(&bytes)
     }

crates/superblock/src/lib.rs

@@ -11,8 +11,28 @@
 //! like encryption parameters, key slots and segment information in JSON format.
 //!
 
+use std::io;
+
+use snafu::Snafu;
+
 mod config;
 mod superblock;
 
 pub use config::*;
 pub use superblock::*;
+
+/// Errors that can occur when parsing LUKS config
+#[derive(Debug, Snafu)]
+pub enum ConfigError {
+    /// An I/O error occurred
+    #[snafu(display("io"))]
+    Io { source: io::Error },
+
+    /// Invalid JSON
+    #[snafu(display("invalid json"))]
+    InvalidJson { source: serde_json::Error },
+
+    /// Error decoding UTF-8 string data
+    #[snafu(display("invalid utf8 in decode"))]
+    InvalidUtf8 { source: std::str::Utf8Error },
+}