xenstore: move error type and make use of result type aliases

hypha/src/error.rs

@@ -7,7 +7,6 @@ use std::fmt::{Display, Formatter};
 use std::num::ParseIntError;
 use std::path::StripPrefixError;
 use xenclient::XenClientError;
-use xenstore::bus::XsdBusError;
 
 pub type Result<T> = std::result::Result<T, HyphaError>;
 
@@ -117,8 +116,8 @@ impl From<uuid::Error> for HyphaError {
     }
 }
 
-impl From<XsdBusError> for HyphaError {
-    fn from(value: XsdBusError) -> Self {
+impl From<xenstore::error::Error> for HyphaError {
+    fn from(value: xenstore::error::Error) -> Self {
         HyphaError::new(value.to_string().as_str())
     }
 }

xen/xenclient/src/lib.rs

@@ -20,7 +20,6 @@ use uuid::Uuid;
 use xencall::sys::CreateDomain;
 use xencall::{XenCall, XenCallError};
 use xenevtchn::EventChannelError;
-use xenstore::bus::XsdBusError;
 use xenstore::client::{
     XsPermission, XsdClient, XsdInterface, XS_PERM_NONE, XS_PERM_READ, XS_PERM_READ_WRITE,
 };
@@ -61,8 +60,8 @@ impl From<std::io::Error> for XenClientError {
     }
 }
 
-impl From<XsdBusError> for XenClientError {
-    fn from(value: XsdBusError) -> Self {
+impl From<xenstore::error::Error> for XenClientError {
+    fn from(value: xenstore::error::Error) -> Self {
         XenClientError::new(value.to_string().as_str())
     }
 }

xen/xenstore/examples/list.rs

@@ -1,8 +1,8 @@
-use xenstore::bus::XsdBusError;
 use xenstore::client::{XsdClient, XsdInterface};
+use xenstore::error::Result;
 use xenstore::sys::XSD_ERROR_EINVAL;
 
-fn list_recursive(client: &mut XsdClient, level: usize, path: &str) -> Result<(), XsdBusError> {
+fn list_recursive(client: &mut XsdClient, level: usize, path: &str) -> Result<()> {
     let children = match client.list(path) {
         Ok(children) => children,
         Err(error) => {
@@ -28,7 +28,7 @@ fn list_recursive(client: &mut XsdClient, level: usize, path: &str) -> Result<()
     Ok(())
 }
 
-fn main() -> Result<(), XsdBusError> {
+fn main() -> Result<()> {
     let mut client = XsdClient::open()?;
     list_recursive(&mut client, 0, "/")?;
     Ok(())

xen/xenstore/src/bus.rs

@@ -1,15 +1,11 @@
+use crate::error::{Error, Result};
 use crate::sys::{XsdMessageHeader, XSD_ERROR};
-use std::ffi::{CString, FromVecWithNulError, IntoStringError, NulError};
+use std::ffi::CString;
 use std::fs::metadata;
-use std::io;
 use std::io::{Read, Write};
 use std::mem::size_of;
 use std::net::Shutdown;
-use std::num::ParseIntError;
 use std::os::unix::net::UnixStream;
-use std::str::Utf8Error;
-use std::string::FromUtf8Error;
-use thiserror::Error;
 
 const XEN_BUS_PATHS: &[&str] = &["/var/run/xenstored/socket"];
 
@@ -23,30 +19,6 @@ fn find_bus_path() -> Option<String> {
     None
 }
 
-#[derive(Error, Debug)]
-pub enum XsdBusError {
-    #[error("io issue encountered")]
-    Io(#[from] io::Error),
-    #[error("utf8 string decode failed")]
-    Utf8DecodeString(#[from] FromUtf8Error),
-    #[error("utf8 str decode failed")]
-    Utf8DecodeStr(#[from] Utf8Error),
-    #[error("unable to decode cstring as utf8")]
-    Utf8DecodeCstring(#[from] IntoStringError),
-    #[error("nul byte found in string")]
-    NulByteFoundString(#[from] NulError),
-    #[error("unable to find nul byte in vec")]
-    VecNulByteNotFound(#[from] FromVecWithNulError),
-    #[error("unable to parse integer")]
-    ParseInt(#[from] ParseIntError),
-    #[error("bus was not found on any available path")]
-    BusNotFound,
-    #[error("store responded with error: `{0}`")]
-    ResponseError(String),
-    #[error("invalid permissions provided")]
-    InvalidPermissions,
-}
-
 pub struct XsdSocket {
     handle: UnixStream,
 }
@@ -58,11 +30,11 @@ pub struct XsdResponse {
 }
 
 impl XsdResponse {
-    pub fn parse_string(&self) -> Result<String, XsdBusError> {
+    pub fn parse_string(&self) -> Result<String> {
         Ok(CString::from_vec_with_nul(self.payload.clone())?.into_string()?)
     }
 
-    pub fn parse_string_vec(&self) -> Result<Vec<String>, XsdBusError> {
+    pub fn parse_string_vec(&self) -> Result<Vec<String>> {
         let mut strings: Vec<String> = Vec::new();
         let mut buffer: Vec<u8> = Vec::new();
         for b in &self.payload {
@@ -77,22 +49,22 @@ impl XsdResponse {
         Ok(strings)
     }
 
-    pub fn parse_bool(&self) -> Result<bool, XsdBusError> {
+    pub fn parse_bool(&self) -> Result<bool> {
         Ok(true)
     }
 }
 
 impl XsdSocket {
-    pub fn dial() -> Result<XsdSocket, XsdBusError> {
+    pub fn dial() -> Result<XsdSocket> {
         let path = match find_bus_path() {
             Some(path) => path,
-            None => return Err(XsdBusError::BusNotFound),
+            None => return Err(Error::BusNotFound),
         };
         let stream = UnixStream::connect(path)?;
         Ok(XsdSocket { handle: stream })
     }
 
-    pub fn send(&mut self, tx: u32, typ: u32, buf: &[u8]) -> Result<XsdResponse, XsdBusError> {
+    pub fn send(&mut self, tx: u32, typ: u32, buf: &[u8]) -> Result<XsdResponse> {
         let header = XsdMessageHeader {
             typ,
             req: 0,
@@ -108,29 +80,19 @@ impl XsdSocket {
         self.handle.read_exact(payload.as_mut_slice())?;
         if result_header.typ == XSD_ERROR {
             let error = CString::from_vec_with_nul(payload)?;
-            return Err(XsdBusError::ResponseError(error.into_string()?));
+            return Err(Error::ResponseError(error.into_string()?));
         }
         let response = XsdResponse { header, payload };
         Ok(response)
     }
 
-    pub fn send_single(
-        &mut self,
-        tx: u32,
-        typ: u32,
-        string: &str,
-    ) -> Result<XsdResponse, XsdBusError> {
+    pub fn send_single(&mut self, tx: u32, typ: u32, string: &str) -> Result<XsdResponse> {
         let text = CString::new(string)?;
         let buf = text.as_bytes_with_nul();
         self.send(tx, typ, buf)
     }
 
-    pub fn send_multiple(
-        &mut self,
-        tx: u32,
-        typ: u32,
-        array: &[&str],
-    ) -> Result<XsdResponse, XsdBusError> {
+    pub fn send_multiple(&mut self, tx: u32, typ: u32, array: &[&str]) -> Result<XsdResponse> {
         let mut buf: Vec<u8> = Vec::new();
         for item in array {
             buf.extend_from_slice(item.as_bytes());

xen/xenstore/src/client.rs

@@ -1,4 +1,5 @@
-use crate::bus::{XsdBusError, XsdSocket};
+use crate::bus::XsdSocket;
+use crate::error::{Error, Result};
 use crate::sys::{
     XSD_DIRECTORY, XSD_GET_DOMAIN_PATH, XSD_INTRODUCE, XSD_MKDIR, XSD_READ, XSD_RM, XSD_SET_PERMS,
     XSD_TRANSACTION_END, XSD_TRANSACTION_START, XSD_WRITE,
@@ -22,35 +23,35 @@ pub struct XsPermission {
 }
 
 impl XsPermission {
-    pub fn encode(&self) -> Result<String, XsdBusError> {
+    pub fn encode(&self) -> Result<String> {
         let c = match self.perms {
             XS_PERM_READ_WRITE => 'b',
             XS_PERM_WRITE => 'w',
             XS_PERM_READ => 'r',
             XS_PERM_NONE => 'n',
-            _ => return Err(XsdBusError::InvalidPermissions),
+            _ => return Err(Error::InvalidPermissions),
         };
         Ok(format!("{}{}", c, self.id))
     }
 }
 
 pub trait XsdInterface {
-    fn list(&mut self, path: &str) -> Result<Vec<String>, XsdBusError>;
-    fn read(&mut self, path: &str) -> Result<Vec<u8>, XsdBusError>;
-    fn read_string(&mut self, path: &str) -> Result<String, XsdBusError>;
-    fn write(&mut self, path: &str, data: Vec<u8>) -> Result<bool, XsdBusError>;
-    fn write_string(&mut self, path: &str, data: &str) -> Result<bool, XsdBusError>;
-    fn mkdir(&mut self, path: &str) -> Result<bool, XsdBusError>;
-    fn rm(&mut self, path: &str) -> Result<bool, XsdBusError>;
-    fn set_perms(&mut self, path: &str, perms: &[XsPermission]) -> Result<bool, XsdBusError>;
+    fn list(&mut self, path: &str) -> Result<Vec<String>>;
+    fn read(&mut self, path: &str) -> Result<Vec<u8>>;
+    fn read_string(&mut self, path: &str) -> Result<String>;
+    fn write(&mut self, path: &str, data: Vec<u8>) -> Result<bool>;
+    fn write_string(&mut self, path: &str, data: &str) -> Result<bool>;
+    fn mkdir(&mut self, path: &str) -> Result<bool>;
+    fn rm(&mut self, path: &str) -> Result<bool>;
+    fn set_perms(&mut self, path: &str, perms: &[XsPermission]) -> Result<bool>;
 
-    fn mknod(&mut self, path: &str, perms: &[XsPermission]) -> Result<bool, XsdBusError> {
+    fn mknod(&mut self, path: &str, perms: &[XsPermission]) -> Result<bool> {
         let result1 = self.write_string(path, "")?;
         let result2 = self.set_perms(path, perms)?;
         Ok(result1 && result2)
     }
 
-    fn read_string_optional(&mut self, path: &str) -> Result<Option<String>, XsdBusError> {
+    fn read_string_optional(&mut self, path: &str) -> Result<Option<String>> {
         Ok(match self.read_string(path) {
             Ok(value) => Some(value),
             Err(error) => {
@@ -63,7 +64,7 @@ pub trait XsdInterface {
         })
     }
 
-    fn list_any(&mut self, path: &str) -> Result<Vec<String>, XsdBusError> {
+    fn list_any(&mut self, path: &str) -> Result<Vec<String>> {
         Ok(match self.list(path) {
             Ok(value) => value,
             Err(error) => {
@@ -78,24 +79,24 @@ pub trait XsdInterface {
 }
 
 impl XsdClient {
-    pub fn open() -> Result<XsdClient, XsdBusError> {
+    pub fn open() -> Result<XsdClient> {
         let socket = XsdSocket::dial()?;
         Ok(XsdClient { socket })
     }
 
-    fn list(&mut self, tx: u32, path: &str) -> Result<Vec<String>, XsdBusError> {
+    fn list(&mut self, tx: u32, path: &str) -> Result<Vec<String>> {
         trace!("list tx={tx} path={path}");
         let response = self.socket.send_single(tx, XSD_DIRECTORY, path)?;
         response.parse_string_vec()
     }
 
-    fn read(&mut self, tx: u32, path: &str) -> Result<Vec<u8>, XsdBusError> {
+    fn read(&mut self, tx: u32, path: &str) -> Result<Vec<u8>> {
         trace!("read tx={tx} path={path}");
         let response = self.socket.send_single(tx, XSD_READ, path)?;
         Ok(response.payload)
     }
 
-    fn write(&mut self, tx: u32, path: &str, data: Vec<u8>) -> Result<bool, XsdBusError> {
+    fn write(&mut self, tx: u32, path: &str, data: Vec<u8>) -> Result<bool> {
         trace!("write tx={tx} path={path} data={:?}", data);
         let mut buffer = Vec::new();
         let path = CString::new(path)?;
@@ -105,12 +106,12 @@ impl XsdClient {
         response.parse_bool()
     }
 
-    fn mkdir(&mut self, tx: u32, path: &str) -> Result<bool, XsdBusError> {
+    fn mkdir(&mut self, tx: u32, path: &str) -> Result<bool> {
         trace!("mkdir tx={tx} path={path}");
         self.socket.send_single(tx, XSD_MKDIR, path)?.parse_bool()
     }
 
-    fn rm(&mut self, tx: u32, path: &str) -> Result<bool, XsdBusError> {
+    fn rm(&mut self, tx: u32, path: &str) -> Result<bool> {
         trace!("rm tx={tx} path={path}");
         let result = self.socket.send_single(tx, XSD_RM, path);
         if let Err(error) = result {
@@ -122,12 +123,7 @@ impl XsdClient {
         result.unwrap().parse_bool()
     }
 
-    fn set_perms(
-        &mut self,
-        tx: u32,
-        path: &str,
-        perms: &[XsPermission],
-    ) -> Result<bool, XsdBusError> {
+    fn set_perms(&mut self, tx: u32, path: &str, perms: &[XsPermission]) -> Result<bool> {
         trace!("set_perms tx={tx} path={path} perms={:?}", perms);
         let mut items: Vec<String> = Vec::new();
         items.push(path.to_string());
@@ -139,7 +135,7 @@ impl XsdClient {
         response.parse_bool()
     }
 
-    pub fn transaction(&mut self) -> Result<XsdTransaction, XsdBusError> {
+    pub fn transaction(&mut self) -> Result<XsdTransaction> {
         trace!("transaction start");
         let response = self.socket.send_single(0, XSD_TRANSACTION_START, "")?;
         let str = response.parse_string()?;
@@ -147,19 +143,14 @@ impl XsdClient {
         Ok(XsdTransaction { client: self, tx })
     }
 
-    pub fn get_domain_path(&mut self, domid: u32) -> Result<String, XsdBusError> {
+    pub fn get_domain_path(&mut self, domid: u32) -> Result<String> {
         let response =
             self.socket
                 .send_single(0, XSD_GET_DOMAIN_PATH, domid.to_string().as_str())?;
         response.parse_string()
     }
 
-    pub fn introduce_domain(
-        &mut self,
-        domid: u32,
-        mfn: u64,
-        evtchn: u32,
-    ) -> Result<bool, XsdBusError> {
+    pub fn introduce_domain(&mut self, domid: u32, mfn: u64, evtchn: u32) -> Result<bool> {
         trace!("introduce domain domid={domid} mfn={mfn} evtchn={evtchn}");
         let response = self.socket.send_multiple(
             0,
@@ -180,75 +171,75 @@ pub struct XsdTransaction<'a> {
 }
 
 impl XsdInterface for XsdClient {
-    fn list(&mut self, path: &str) -> Result<Vec<String>, XsdBusError> {
+    fn list(&mut self, path: &str) -> Result<Vec<String>> {
         self.list(0, path)
     }
 
-    fn read(&mut self, path: &str) -> Result<Vec<u8>, XsdBusError> {
+    fn read(&mut self, path: &str) -> Result<Vec<u8>> {
         self.read(0, path)
     }
 
-    fn read_string(&mut self, path: &str) -> Result<String, XsdBusError> {
+    fn read_string(&mut self, path: &str) -> Result<String> {
         Ok(String::from_utf8(self.read(0, path)?)?)
     }
 
-    fn write(&mut self, path: &str, data: Vec<u8>) -> Result<bool, XsdBusError> {
+    fn write(&mut self, path: &str, data: Vec<u8>) -> Result<bool> {
         self.write(0, path, data)
     }
 
-    fn write_string(&mut self, path: &str, data: &str) -> Result<bool, XsdBusError> {
+    fn write_string(&mut self, path: &str, data: &str) -> Result<bool> {
         self.write(0, path, data.as_bytes().to_vec())
     }
 
-    fn mkdir(&mut self, path: &str) -> Result<bool, XsdBusError> {
+    fn mkdir(&mut self, path: &str) -> Result<bool> {
         self.mkdir(0, path)
     }
 
-    fn rm(&mut self, path: &str) -> Result<bool, XsdBusError> {
+    fn rm(&mut self, path: &str) -> Result<bool> {
         self.rm(0, path)
     }
 
-    fn set_perms(&mut self, path: &str, perms: &[XsPermission]) -> Result<bool, XsdBusError> {
+    fn set_perms(&mut self, path: &str, perms: &[XsPermission]) -> Result<bool> {
         self.set_perms(0, path, perms)
     }
 }
 
 impl XsdInterface for XsdTransaction<'_> {
-    fn list(&mut self, path: &str) -> Result<Vec<String>, XsdBusError> {
+    fn list(&mut self, path: &str) -> Result<Vec<String>> {
         self.client.list(self.tx, path)
     }
 
-    fn read(&mut self, path: &str) -> Result<Vec<u8>, XsdBusError> {
+    fn read(&mut self, path: &str) -> Result<Vec<u8>> {
         self.client.read(self.tx, path)
     }
 
-    fn read_string(&mut self, path: &str) -> Result<String, XsdBusError> {
+    fn read_string(&mut self, path: &str) -> Result<String> {
         Ok(String::from_utf8(self.client.read(self.tx, path)?)?)
     }
 
-    fn write(&mut self, path: &str, data: Vec<u8>) -> Result<bool, XsdBusError> {
+    fn write(&mut self, path: &str, data: Vec<u8>) -> Result<bool> {
         self.client.write(self.tx, path, data)
     }
 
-    fn write_string(&mut self, path: &str, data: &str) -> Result<bool, XsdBusError> {
+    fn write_string(&mut self, path: &str, data: &str) -> Result<bool> {
         self.client.write(self.tx, path, data.as_bytes().to_vec())
     }
 
-    fn mkdir(&mut self, path: &str) -> Result<bool, XsdBusError> {
+    fn mkdir(&mut self, path: &str) -> Result<bool> {
         self.client.mkdir(self.tx, path)
     }
 
-    fn rm(&mut self, path: &str) -> Result<bool, XsdBusError> {
+    fn rm(&mut self, path: &str) -> Result<bool> {
         self.client.rm(self.tx, path)
     }
 
-    fn set_perms(&mut self, path: &str, perms: &[XsPermission]) -> Result<bool, XsdBusError> {
+    fn set_perms(&mut self, path: &str, perms: &[XsPermission]) -> Result<bool> {
         self.client.set_perms(self.tx, path, perms)
     }
 }
 
 impl XsdTransaction<'_> {
-    pub fn end(&mut self, abort: bool) -> Result<bool, XsdBusError> {
+    pub fn end(&mut self, abort: bool) -> Result<bool> {
         let abort_str = if abort { "F" } else { "T" };
 
         trace!("transaction end abort={}", abort);
@@ -258,11 +249,11 @@ impl XsdTransaction<'_> {
             .parse_bool()
     }
 
-    pub fn commit(&mut self) -> Result<bool, XsdBusError> {
+    pub fn commit(&mut self) -> Result<bool> {
         self.end(false)
     }
 
-    pub fn abort(&mut self) -> Result<bool, XsdBusError> {
+    pub fn abort(&mut self) -> Result<bool> {
         self.end(true)
     }
 }

xen/xenstore/src/error.rs

@@ -0,0 +1,31 @@
+use std::ffi::{FromVecWithNulError, IntoStringError, NulError};
+use std::io;
+use std::num::ParseIntError;
+use std::str::Utf8Error;
+use std::string::FromUtf8Error;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error("io issue encountered")]
+    Io(#[from] io::Error),
+    #[error("utf8 string decode failed")]
+    Utf8DecodeString(#[from] FromUtf8Error),
+    #[error("utf8 str decode failed")]
+    Utf8DecodeStr(#[from] Utf8Error),
+    #[error("unable to decode cstring as utf8")]
+    Utf8DecodeCstring(#[from] IntoStringError),
+    #[error("nul byte found in string")]
+    NulByteFoundString(#[from] NulError),
+    #[error("unable to find nul byte in vec")]
+    VecNulByteNotFound(#[from] FromVecWithNulError),
+    #[error("unable to parse integer")]
+    ParseInt(#[from] ParseIntError),
+    #[error("bus was not found on any available path")]
+    BusNotFound,
+    #[error("store responded with error: `{0}`")]
+    ResponseError(String),
+    #[error("invalid permissions provided")]
+    InvalidPermissions,
+}
+
+pub type Result<T> = std::result::Result<T, Error>;

xen/xenstore/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod bus;
 pub mod client;
+pub mod error;
 pub mod sys;

xen/xenstore/src/sys.rs

@@ -1,6 +1,6 @@
-use bytemuck::{Pod, Zeroable};
 /// Handwritten protocol definitions for XenStore.
 /// Used xen/include/public/io/xs_wire.h as a reference.
+use bytemuck::{Pod, Zeroable};
 use libc;
 
 #[derive(Copy, Clone, Pod, Zeroable, Debug)]