fix: thiserror::Error

Implements the`thiserror::Error` derive macro.

Signed-off-by: Jonathan Woollett-Light <[email protected]>

Author: Jonathan Woollett-Light

Cargo.toml

@@ -20,6 +20,7 @@ backend-atomic = ["arc-swap"]
 [dependencies]
 libc = "0.2.39"
 arc-swap = { version = "1.0.0", optional = true }
+thiserror = "1.0.40"
 
 [target.'cfg(windows)'.dependencies.winapi]
 version = "0.3"

coverage_config_x86_64.json

@@ -1,5 +1,5 @@
 {
-  "coverage_score": 89.7,
+  "coverage_score": 91.1,
   "exclude_path": "mmap_windows.rs",
   "crate_features": "backend-mmap,backend-atomic,backend-bitmap"
 }

rust-vmm-ci

@@ -42,7 +42,6 @@
 //! `VolatileSlice`, `VolatileRef`, or `VolatileArrayRef`.
 
 use std::convert::From;
-use std::fmt::{self, Display};
 use std::fs::File;
 use std::io::{self, Read, Write};
 use std::ops::{BitAnd, BitOr, Deref};
@@ -59,17 +58,22 @@ static MAX_ACCESS_CHUNK: usize = 4096;
 
 /// Errors associated with handling guest memory accesses.
 #[allow(missing_docs)]
-#[derive(Debug)]
+#[derive(Debug, thiserror::Error)]
 pub enum Error {
     /// Failure in finding a guest address in any memory regions mapped by this guest.
+    #[error("Guest memory error: invalid guest address {}",.0.raw_value())]
     InvalidGuestAddress(GuestAddress),
     /// Couldn't read/write from the given source.
+    #[error("Guest memory error: {0}")]
     IOError(io::Error),
     /// Incomplete read or write.
+    #[error("Guest memory error: only used {completed} bytes in {expected} long buffer")]
     PartialBuffer { expected: usize, completed: usize },
     /// Requested backend address is out of range.
+    #[error("Guest memory error: invalid backend address")]
     InvalidBackendAddress,
     /// Host virtual address not available.
+    #[error("Guest memory error: host virtual address not available")]
     HostAddressNotAvailable,
 }
 
@@ -95,30 +99,6 @@ impl From<volatile_memory::Error> for Error {
 /// Result of guest memory operations.
 pub type Result<T> = std::result::Result<T, Error>;
 
-impl std::error::Error for Error {}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Guest memory error: ")?;
-        match self {
-            Error::InvalidGuestAddress(addr) => {
-                write!(f, "invalid guest address {}", addr.raw_value())
-            }
-            Error::IOError(error) => write!(f, "{}", error),
-            Error::PartialBuffer {
-                expected,
-                completed,
-            } => write!(
-                f,
-                "only used {} bytes in {} long buffer",
-                completed, expected,
-            ),
-            Error::InvalidBackendAddress => write!(f, "invalid backend address"),
-            Error::HostAddressNotAvailable => write!(f, "host virtual address not available"),
-        }
-    }
-}
-
 /// Represents a guest physical address (GPA).
 ///
 /// # Notes:

src/guest_memory.rs

@@ -13,8 +13,6 @@
 //! This implementation is mmap-ing the memory of the guest into the current process.
 
 use std::borrow::Borrow;
-use std::error;
-use std::fmt;
 use std::io::{Read, Write};
 #[cfg(unix)]
 use std::io::{Seek, SeekFrom};
@@ -51,43 +49,26 @@ impl NewBitmap for () {
 }
 
 /// Errors that can occur when creating a memory map.
-#[derive(Debug)]
+#[derive(Debug, thiserror::Error)]
 pub enum Error {
     /// Adding the guest base address to the length of the underlying mapping resulted
     /// in an overflow.
+    #[error("Adding the guest base address to the length of the underlying mapping resulted in an overflow")]
     InvalidGuestRegion,
     /// Error creating a `MmapRegion` object.
+    #[error("{0}")]
     MmapRegion(MmapRegionError),
     /// No memory region found.
+    #[error("No memory region found")]
     NoMemoryRegion,
     /// Some of the memory regions intersect with each other.
+    #[error("Some of the memory regions intersect with each other")]
     MemoryRegionOverlap,
     /// The provided memory regions haven't been sorted.
+    #[error("The provided memory regions haven't been sorted")]
     UnsortedMemoryRegions,
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::InvalidGuestRegion => write!(
-                f,
-                "Adding the guest base address to the length of the underlying mapping \
-                 resulted in an overflow"
-            ),
-            Error::MmapRegion(e) => write!(f, "{}", e),
-            Error::NoMemoryRegion => write!(f, "No memory region found"),
-            Error::MemoryRegionOverlap => {
-                write!(f, "Some of the memory regions intersect with each other")
-            }
-            Error::UnsortedMemoryRegions => {
-                write!(f, "The provided memory regions haven't been sorted")
-            }
-        }
-    }
-}
-
-impl error::Error for Error {}
-
 // TODO: use this for Windows as well after we redefine the Error type there.
 #[cfg(unix)]
 /// Checks if a mapping of `size` bytes fits at the provided `file_offset`.

src/mmap.rs

@@ -10,8 +10,6 @@
 
 //! Helper structure for working with mmaped memory regions in Unix.
 
-use std::error;
-use std::fmt;
 use std::io;
 use std::os::unix::io::AsRawFd;
 use std::ptr::null_mut;
@@ -23,55 +21,34 @@ use crate::mmap::{check_file_offset, NewBitmap};
 use crate::volatile_memory::{self, VolatileMemory, VolatileSlice};
 
 /// Error conditions that may arise when creating a new `MmapRegion` object.
-#[derive(Debug)]
+#[derive(Debug, thiserror::Error)]
 pub enum Error {
     /// The specified file offset and length cause overflow when added.
+    #[error("The specified file offset and length cause overflow when added")]
     InvalidOffsetLength,
     /// The specified pointer to the mapping is not page-aligned.
+    #[error("The specified pointer to the mapping is not page-aligned")]
     InvalidPointer,
     /// The forbidden `MAP_FIXED` flag was specified.
+    #[error("The forbidden `MAP_FIXED` flag was specified")]
     MapFixed,
     /// Mappings using the same fd overlap in terms of file offset and length.
+    #[error("Mappings using the same fd overlap in terms of file offset and length")]
     MappingOverlap,
     /// A mapping with offset + length > EOF was attempted.
+    #[error("The specified file offset and length is greater then file length")]
     MappingPastEof,
     /// The `mmap` call returned an error.
+    #[error("{0}")]
     Mmap(io::Error),
     /// Seeking the end of the file returned an error.
+    #[error("Error seeking the end of the file: {0}")]
     SeekEnd(io::Error),
     /// Seeking the start of the file returned an error.
+    #[error("Error seeking the start of the file: {0}")]
     SeekStart(io::Error),
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::InvalidOffsetLength => write!(
-                f,
-                "The specified file offset and length cause overflow when added"
-            ),
-            Error::InvalidPointer => write!(
-                f,
-                "The specified pointer to the mapping is not page-aligned",
-            ),
-            Error::MapFixed => write!(f, "The forbidden `MAP_FIXED` flag was specified"),
-            Error::MappingOverlap => write!(
-                f,
-                "Mappings using the same fd overlap in terms of file offset and length"
-            ),
-            Error::MappingPastEof => write!(
-                f,
-                "The specified file offset and length is greater then file length"
-            ),
-            Error::Mmap(error) => write!(f, "{}", error),
-            Error::SeekEnd(error) => write!(f, "Error seeking the end of the file: {}", error),
-            Error::SeekStart(error) => write!(f, "Error seeking the start of the file: {}", error),
-        }
-    }
-}
-
-impl error::Error for Error {}
-
 pub type Result<T> = result::Result<T, Error>;
 
 /// A factory struct to build `MmapRegion` objects.

src/mmap_unix.rs

@@ -24,8 +24,6 @@
 //! not reordered or elided the access.
 
 use std::cmp::min;
-use std::error;
-use std::fmt;
 use std::io::{self, Read, Write};
 use std::marker::PhantomData;
 use std::mem::{align_of, size_of};
@@ -43,54 +41,28 @@ use copy_slice_impl::copy_slice;
 
 /// `VolatileMemory` related errors.
 #[allow(missing_docs)]
-#[derive(Debug)]
+#[derive(Debug, thiserror::Error)]
 pub enum Error {
     /// `addr` is out of bounds of the volatile memory slice.
+    #[error("address 0x{addr:x} is out of bounds")]
     OutOfBounds { addr: usize },
     /// Taking a slice at `base` with `offset` would overflow `usize`.
+    #[error("address 0x{base:x} offset by 0x{offset:x} would overflow")]
     Overflow { base: usize, offset: usize },
     /// Taking a slice whose size overflows `usize`.
+    #[error("{nelements:?} elements of size {size:?} would overflow a usize")]
     TooBig { nelements: usize, size: usize },
     /// Trying to obtain a misaligned reference.
+    #[error("address 0x{addr:x} is not aligned to {alignment:?}")]
     Misaligned { addr: usize, alignment: usize },
     /// Writing to memory failed
+    #[error("{0}")]
     IOError(io::Error),
     /// Incomplete read or write
+    #[error("only used {completed} bytes in {expected} long buffer")]
     PartialBuffer { expected: usize, completed: usize },
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::OutOfBounds { addr } => write!(f, "address 0x{:x} is out of bounds", addr),
-            Error::Overflow { base, offset } => write!(
-                f,
-                "address 0x{:x} offset by 0x{:x} would overflow",
-                base, offset
-            ),
-            Error::TooBig { nelements, size } => write!(
-                f,
-                "{:?} elements of size {:?} would overflow a usize",
-                nelements, size
-            ),
-            Error::Misaligned { addr, alignment } => {
-                write!(f, "address 0x{:x} is not aligned to {:?}", addr, alignment)
-            }
-            Error::IOError(error) => write!(f, "{}", error),
-            Error::PartialBuffer {
-                expected,
-                completed,
-            } => write!(
-                f,
-                "only used {} bytes in {} long buffer",
-                completed, expected
-            ),
-        }
-    }
-}
-
-impl error::Error for Error {}
-
 /// Result of volatile memory operations.
 pub type Result<T> = result::Result<T, Error>;