Convert mem::shared_mem module to use thiserror structured errors

It will be used from the hvf code, which needs to return a structured
error itself.

Signed-off-by: Lucy Menon <168595099+syntactically@users.noreply.github.com>

Author: syntactically

src/hyperlight_host/src/error.rs

@@ -42,9 +42,6 @@ pub enum HyperlightError {
     /// Anyhow error
     #[error("Anyhow Error was returned: {0}")]
     AnyhowError(#[from] anyhow::Error),
-    /// Memory access out of bounds
-    #[error("Offset: {0} out of bounds, Max is: {1}")]
-    BoundsCheckFailed(u64, usize),
 
     /// Checked Add Overflow
     #[error("Couldn't add offset to base address. Offset: {0}, Base Address: {1}")]
@@ -154,18 +151,6 @@ pub enum HyperlightError {
     #[error("Memory Access Violation at address {0:#x} of type {1}, but memory is marked as {2}")]
     MemoryAccessViolation(u64, MemoryRegionFlags, MemoryRegionFlags),
 
-    /// Memory Allocation Failed.
-    #[error("Memory Allocation Failed with OS Error {0:?}.")]
-    MemoryAllocationFailed(Option<i32>),
-
-    /// Memory Protection Failed
-    #[error("Memory Protection Failed with OS Error {0:?}.")]
-    MemoryProtectionFailed(Option<i32>),
-
-    /// Memory region size mismatch
-    #[error("Memory region size mismatch: host size {0:?}, guest size {1:?} region {2:?}")]
-    MemoryRegionSizeMismatch(usize, usize, String),
-
     /// The memory request exceeds the maximum size allowed
     #[error("Memory requested {0} exceeds maximum size allowed {1}")]
     MemoryRequestTooBig(usize, usize),
@@ -179,14 +164,6 @@ pub enum HyperlightError {
     #[error("Metric Not Found {0:?}.")]
     MetricNotFound(&'static str),
 
-    /// mmap Failed.
-    #[error("mmap failed with os error {0:?}")]
-    MmapFailed(Option<i32>),
-
-    /// mprotect Failed.
-    #[error("mprotect failed with os error {0:?}")]
-    MprotectFailed(Option<i32>),
-
     /// No Hypervisor was found for Sandbox.
     #[error("No Hypervisor was found for Sandbox")]
     NoHypervisorFound(),
@@ -240,6 +217,10 @@ pub enum HyperlightError {
     #[error("Failed To Convert Return Value {0:?} to {1:?}")]
     ReturnValueConversionFailure(ReturnValue, &'static str),
 
+    /// Error creating or operating on memory shared with the guest
+    #[error("Failed to execute shared memory operation: {0}")]
+    SharedMemory(#[from] crate::mem::shared_mem::SharedMemoryError),
+
     /// Tried to restore a snapshot into a sandbox whose memory
     /// layout is not compatible with the snapshot's.
     #[error("Snapshot memory layout is not compatible with this sandbox")]
@@ -347,7 +328,6 @@ impl HyperlightError {
             | HyperlightError::PoisonedSandbox
             | HyperlightError::ExecutionAccessViolation(_)
             | HyperlightError::MemoryAccessViolation(_, _, _)
-            | HyperlightError::MemoryRegionSizeMismatch(_, _, _)
             // HyperlightVmError::Restore is already handled manually in restore(), but we mark it
             // as poisoning here too for defense in depth.
             | HyperlightError::HyperlightVmError(HyperlightVmError::Restore(_)) => true,
@@ -365,7 +345,6 @@ impl HyperlightError {
 
             // All other errors do not poison the sandbox.
             HyperlightError::AnyhowError(_)
-            | HyperlightError::BoundsCheckFailed(_, _)
             | HyperlightError::CheckedAddOverflow(_, _)
             | HyperlightError::CStringConversionError(_)
             | HyperlightError::Error(_)
@@ -386,13 +365,9 @@ impl HyperlightError {
             | HyperlightError::InvalidFlatBuffer(_)
             | HyperlightError::JsonConversionFailure(_)
             | HyperlightError::LockAttemptFailed(_)
-            | HyperlightError::MemoryAllocationFailed(_)
-            | HyperlightError::MemoryProtectionFailed(_)
             | HyperlightError::MemoryRequestTooBig(_, _)
             | HyperlightError::MemoryRequestTooSmall(_, _)
             | HyperlightError::MetricNotFound(_)
-            | HyperlightError::MmapFailed(_)
-            | HyperlightError::MprotectFailed(_)
             | HyperlightError::NoHypervisorFound()
             | HyperlightError::NoMemorySnapshot
             | HyperlightError::ParameterValueConversionFailure(_, _)
@@ -409,7 +384,8 @@ impl HyperlightError {
             | HyperlightError::UnexpectedParameterValueType(_, _)
             | HyperlightError::UnexpectedReturnValueType(_, _)
             | HyperlightError::UTF8StringConversionFailure(_)
-            | HyperlightError::VectorCapacityIncorrect(_, _, _) => false,
+            | HyperlightError::VectorCapacityIncorrect(_, _, _)
+            | HyperlightError::SharedMemory(_) => false,
 
             #[cfg(target_os = "windows")]
             HyperlightError::CrossBeamReceiveError(_) => false,

src/hyperlight_host/src/hypervisor/gdb/mod.rs

@@ -159,12 +159,12 @@ impl<'a> DebugMemoryView<'a> {
                 .mem_mgr
                 .shared_mem
                 .copy_from_slice(data, resolved.offset)
-                .map_err(|e| DebugMemoryAccessError::CopyFailed(Box::new(e))),
+                .map_err(|e| DebugMemoryAccessError::CopyFailed(Box::new(e.into()))),
             BaseGpaRegion::Scratch(()) => self
                 .mem_mgr
                 .scratch_mem
                 .copy_from_slice(data, resolved.offset)
-                .map_err(|e| DebugMemoryAccessError::CopyFailed(Box::new(e))),
+                .map_err(|e| DebugMemoryAccessError::CopyFailed(Box::new(e.into()))),
             _ => Err(DebugMemoryAccessError::WriteToReadOnly),
         }
     }

src/hyperlight_host/src/hypervisor/virtual_machine/mod.rs

@@ -178,7 +178,7 @@ pub(crate) enum VmExit {
 }
 
 /// VM error
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, thiserror::Error)]
 pub enum VmError {
     #[error("Failed to create vm: {0}")]
     CreateVm(#[from] CreateVmError),
@@ -241,7 +241,7 @@ pub enum CreateVmError {
 }
 
 /// RunVCPU error
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, thiserror::Error)]
 pub enum RunVcpuError {
     #[error("Failed to decode message type: {0}")]
     DecodeIOMessage(u32),
@@ -343,7 +343,7 @@ pub enum RegisterError {
     ConversionFailed(String),
 }
 
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, thiserror::Error)]
 pub enum ResetVcpuError {
     #[error("Single-operation vcpu reset not supported on this hypervisor")]
     NotSupported,
@@ -356,7 +356,7 @@ pub enum ResetVcpuError {
 }
 
 /// Map memory error
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, thiserror::Error)]
 pub enum MapMemoryError {
     #[cfg(target_os = "windows")]
     #[error("Address conversion failed: {0}")]
@@ -381,7 +381,7 @@ pub enum MapMemoryError {
 }
 
 /// Unmap memory error
-#[derive(Debug, Clone, thiserror::Error)]
+#[derive(Debug, thiserror::Error)]
 pub enum UnmapMemoryError {
     #[error("Hypervisor error: {0}")]
     Hypervisor(HypervisorError),

src/hyperlight_host/src/mem/layout.rs

@@ -158,7 +158,7 @@ pub(crate) trait ReadableSharedMemory {
 #[cfg(readable_shared_mem)]
 impl ReadableSharedMemory for &HostSharedMemory {
     fn copy_to_slice(&self, slice: &mut [u8], offset: usize) -> Result<()> {
-        HostSharedMemory::copy_to_slice(self, slice, offset)
+        Ok(HostSharedMemory::copy_to_slice(self, slice, offset)?)
     }
 }
 /// Coherence workaround for the blanket impl below.

src/hyperlight_host/src/mem/mgr.rs

@@ -390,10 +390,12 @@ impl SandboxMemoryManager<HostSharedMemory> {
     /// Reads a host function call from memory
     #[instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace")]
     pub(crate) fn get_host_function_call(&mut self) -> Result<FunctionCall> {
-        self.scratch_mem.try_pop_buffer_into::<FunctionCall>(
-            self.layout.get_output_data_buffer_scratch_host_offset(),
-            self.layout.output_data_size(),
-        )
+        self.scratch_mem
+            .try_pop_buffer_into::<FunctionCall>(
+                self.layout.get_output_data_buffer_scratch_host_offset(),
+                self.layout.output_data_size(),
+            )
+            .map_err(From::from)
     }
 
     /// Writes a host function call result to memory
@@ -405,11 +407,13 @@ impl SandboxMemoryManager<HostSharedMemory> {
         let mut builder = FlatBufferBuilder::new();
         let data = res.encode(&mut builder);
 
-        self.scratch_mem.push_buffer(
-            self.layout.get_input_data_buffer_scratch_host_offset(),
-            self.layout.input_data_size(),
-            data,
-        )
+        self.scratch_mem
+            .push_buffer(
+                self.layout.get_input_data_buffer_scratch_host_offset(),
+                self.layout.input_data_size(),
+                data,
+            )
+            .map_err(From::from)
     }
 
     /// Writes a guest function call to memory
@@ -434,19 +438,23 @@ impl SandboxMemoryManager<HostSharedMemory> {
     /// A function call result can be either an error or a successful return value.
     #[instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace")]
     pub(crate) fn get_guest_function_call_result(&mut self) -> Result<FunctionCallResult> {
-        self.scratch_mem.try_pop_buffer_into::<FunctionCallResult>(
-            self.layout.get_output_data_buffer_scratch_host_offset(),
-            self.layout.output_data_size(),
-        )
+        self.scratch_mem
+            .try_pop_buffer_into::<FunctionCallResult>(
+                self.layout.get_output_data_buffer_scratch_host_offset(),
+                self.layout.output_data_size(),
+            )
+            .map_err(From::from)
     }
 
     /// Read guest log data from the `SharedMemory` contained within `self`
     #[instrument(err(Debug), skip_all, parent = Span::current(), level= "Trace")]
     pub(crate) fn read_guest_log_data(&mut self) -> Result<GuestLogData> {
-        self.scratch_mem.try_pop_buffer_into::<GuestLogData>(
-            self.layout.get_output_data_buffer_scratch_host_offset(),
-            self.layout.output_data_size(),
-        )
+        self.scratch_mem
+            .try_pop_buffer_into::<GuestLogData>(
+                self.layout.get_output_data_buffer_scratch_host_offset(),
+                self.layout.output_data_size(),
+            )
+            .map_err(From::from)
     }
 
     pub(crate) fn clear_io_buffers(&mut self) {
@@ -527,7 +535,9 @@ impl SandboxMemoryManager<HostSharedMemory> {
     fn update_scratch_bookkeeping_item(&mut self, offset: u64, value: u64) -> Result<()> {
         let scratch_size = self.scratch_mem.mem_size();
         let base_offset = scratch_size - offset as usize;
-        self.scratch_mem.write::<u64>(base_offset, value)
+        self.scratch_mem
+            .write::<u64>(base_offset, value)
+            .map_err(From::from)
     }
 
     fn update_scratch_bookkeeping(&mut self) -> Result<()> {