Migrate errors to the modern thiserror

.travis.yml

@@ -1,8 +1,7 @@
 language: rust
 
 rust:
-  - nightly-2018-07-24  # pinned toolchain for clippy
-  - 1.24.0              # minimum supported toolchain
+  - 1.35.0     # minimum supported toolchain
   - stable
   - beta
   - nightly
@@ -13,11 +12,11 @@ matrix:
 
 env:
   global:
-    - CLIPPY_RUST_VERSION=nightly-2018-07-24
+    - CLIPPY_RUST_VERSION=1.35.0
 
 before_script:
   - bash -c 'if [[ "$TRAVIS_RUST_VERSION" == "$CLIPPY_RUST_VERSION" ]]; then
-      rustup component add clippy-preview;
+      rustup component add clippy;
     fi'
 
 script:

Cargo.toml

@@ -17,8 +17,7 @@ exclude = [
 libc = "0.2"
 # Public dependencies, exposed through library API.
 either = "1.5"
-errno = "0.2"
-error-chain = {version = "0.12", default-features = false}
+thiserror = "1"
 
 [package.metadata.release]
 sign-commit = true

src/errors.rs

@@ -1,21 +1,25 @@
 //! Error handling.
 
-use errno;
-use std::{ffi, io};
-
-error_chain!{
-    errors {
-        /// Syscall error, as `errno(3)`.
-        Sys(errno: errno::Errno) {
-            description("syscall failed")
-            display("{}", errno)
-        }
-    }
+/// Enumeration of errors possible in this library
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    /// Cannot convert the `name` argument to a C String!
+    #[error("cannot convert `name` to a C string")]
+    NameCStringConversion(#[source] std::ffi::NulError),
+    /// Cannot create the memfd
+    #[error("cannot create memfd")]
+    Create(#[source] std::io::Error),
+    /// Cannot add new seals to the memfd
+    #[error("cannot add seals to the memfd")]
+    AddSeals(#[source] std::io::Error),
+    /// Cannot read the seals of a memfd
+    #[error("cannot read seals for a memfd")]
+    GetSeals(#[source] std::io::Error),
+}
 
-    // doc attributes are required to workaround
-    // https://github.com/rust-lang-nursery/error-chain/issues/63
-    foreign_links {
-        Io(io::Error) #[doc = "I/O error."];
-        NulChar(ffi::NulError) #[doc = "NULL byte in conversion to C string."];
-    }
+#[cfg(test)]
+#[test]
+fn error_send_sync() {
+    fn assert_error<E: std::error::Error + Send + Sync + 'static>() {}
+    assert_error::<Error>();
 }

src/lib.rs

@@ -7,9 +7,8 @@
 //!
 //! ```rust
 //! use memfd;
-//! # use memfd::errors::Result;
 //!
-//! fn new_sized_memfd() -> Result<memfd::Memfd> {
+//! fn new_sized_memfd() -> Result<memfd::Memfd, Box<dyn std::error::Error>> {
 //!     // Create a sealable memfd.
 //!     let opts = memfd::MemfdOptions::default().allow_sealing(true);
 //!     let mfd = opts.create("sized-1K")?;
@@ -24,7 +23,7 @@
 //!     mfd.add_seals(&seals)?;
 //!
 //!     // Prevent further sealing changes.
-//!     mfd.add_seal(memfd::FileSeal::SealSeal);
+//!     mfd.add_seal(memfd::FileSeal::SealSeal)?;
 //!
 //!     Ok(mfd)
 //! }
@@ -33,15 +32,14 @@
 #![deny(missing_docs)]
 
 extern crate either;
-extern crate errno;
-#[macro_use]
-extern crate error_chain;
 extern crate libc;
+extern crate thiserror;
 
-pub mod errors;
+mod errors;
 mod memfd;
 mod nr;
 mod sealing;
 
+pub use errors::Error;
 pub use memfd::{HugetlbSize, Memfd, MemfdOptions};
 pub use sealing::{FileSeal, SealsHashSet};

src/memfd.rs

@@ -1,6 +1,4 @@
 use either;
-use errno;
-use errors;
 use libc;
 use nr;
 use sealing;
@@ -62,18 +60,16 @@ impl MemfdOptions {
     }
 
     /// Create a memfd according to configuration.
-    pub fn create<T: AsRef<str>>(&self, name: T) -> errors::Result<Memfd> {
-        let cname = ffi::CString::new(name.as_ref())?;
+    pub fn create<T: AsRef<str>>(&self, name: T) -> Result<Memfd, crate::Error> {
+        let cname =
+            ffi::CString::new(name.as_ref()).map_err(crate::Error::NameCStringConversion)?;
         let name_ptr = cname.as_ptr();
         let flags = self.bitflags();
 
         // UNSAFE(lucab): name_ptr points to memory owned by cname.
         let r = unsafe { libc::syscall(libc::SYS_memfd_create, name_ptr, flags) };
         if r < 0 {
-            return Err(
-                errors::Error::from_kind(errors::ErrorKind::Sys(errno::errno()))
-                    .chain_err(|| "memfd_create error"),
-            );
+            return Err(crate::Error::Create(std::io::Error::last_os_error()));
         };
 
         // UNSAFE(lucab): returned from kernel, checked for non-negative value.
@@ -168,44 +164,38 @@ impl Memfd {
     }
 
     /// Return the current set of seals.
-    pub fn seals(&self) -> errors::Result<sealing::SealsHashSet> {
+    pub fn seals(&self) -> Result<sealing::SealsHashSet, crate::Error> {
         let flags = Self::file_get_seals(&self.file)?;
         Ok(sealing::bitflags_to_seals(flags))
     }
 
     /// Add a single seal to the existing set of seals.
-    pub fn add_seal(&self, seal: sealing::FileSeal) -> errors::Result<()> {
+    pub fn add_seal(&self, seal: sealing::FileSeal) -> Result<(), crate::Error> {
         use std::iter::FromIterator;
 
         let set = sealing::SealsHashSet::from_iter(vec![seal]);
         self.add_seals(&set)
     }
 
     /// Add some seals to the existing set of seals.
-    pub fn add_seals(&self, seals: &sealing::SealsHashSet) -> errors::Result<()> {
+    pub fn add_seals(&self, seals: &sealing::SealsHashSet) -> Result<(), crate::Error> {
         let fd = self.file.as_raw_fd();
         let flags = sealing::seals_to_bitflags(seals);
         // UNSAFE(lucab): required syscall.
         let r = unsafe { libc::syscall(libc::SYS_fcntl, fd, libc::F_ADD_SEALS, flags) };
         if r < 0 {
-            return Err(
-                errors::Error::from_kind(errors::ErrorKind::Sys(errno::errno()))
-                    .chain_err(|| "F_ADD_SEALS error"),
-            );
+            return Err(crate::Error::AddSeals(std::io::Error::last_os_error()));
         };
         Ok(())
     }
 
     /// Return the current sealing bitflags.
-    fn file_get_seals(fp: &fs::File) -> errors::Result<u64> {
+    fn file_get_seals(fp: &fs::File) -> Result<u64, crate::Error> {
         let fd = fp.as_raw_fd();
         // UNSAFE(lucab): required syscall.
         let r = unsafe { libc::syscall(libc::SYS_fcntl, fd, libc::F_GET_SEALS) };
         if r < 0 {
-            return Err(
-                errors::Error::from_kind(errors::ErrorKind::Sys(errno::errno()))
-                    .chain_err(|| "F_GET_SEALS error"),
-            );
+            return Err(crate::Error::GetSeals(std::io::Error::last_os_error()));
         };
 
         Ok(r as u64)