add a way to report a non-fatal error to gdb

- sometimes gdb tries to read from an address where the vcpu translate
  method fails, so we need to handle that in such a way that the
  hypervisor handler doesn't crash

Signed-off-by: Doru Blânzeanu <[email protected]>

Author: dblnz

src/hyperlight_host/src/error.rs

@@ -275,6 +275,11 @@ pub enum HyperlightError {
     #[error("SystemTimeError {0:?}")]
     SystemTimeError(#[from] SystemTimeError),
 
+    /// Error occurred when translating guest address
+    #[error("An error occurred when translating guest address: {0:?}")]
+    #[cfg(gdb)]
+    TranslateGuestAddress(u64),
+
     /// Error occurred converting a slice to an array
     #[error("TryFromSliceError {0:?}")]
     TryFromSliceError(#[from] TryFromSliceError),

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

@@ -120,6 +120,7 @@ pub enum DebugResponse {
     AddSwBreakpoint(bool),
     Continue,
     DisableDebug,
+    ErrorOccurred,
     GetCodeSectionOffset(u64),
     ReadAddr(Vec<u8>),
     ReadRegisters(X86_64Regs),

src/hyperlight_host/src/hypervisor/gdb/x86_64_target.rs

@@ -87,6 +87,10 @@ impl HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::DisableDebug)? {
             DebugResponse::DisableDebug => Ok(()),
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(GdbTargetError::UnexpectedError)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(GdbTargetError::UnexpectedMessage)
@@ -129,6 +133,10 @@ impl SingleThreadBase for HyperlightSandboxTarget {
 
                 Ok(v.len())
             }
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -146,6 +154,10 @@ impl SingleThreadBase for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::WriteAddr(gva, v))? {
             DebugResponse::WriteAddr => Ok(()),
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -182,6 +194,10 @@ impl SingleThreadBase for HyperlightSandboxTarget {
 
                 Ok(())
             }
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(TargetError::NonFatal)
+            }
 
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
@@ -219,6 +235,10 @@ impl SingleThreadBase for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::WriteRegisters(regs))? {
             DebugResponse::WriteRegisters => Ok(()),
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -240,6 +260,10 @@ impl SectionOffsets for HyperlightSandboxTarget {
                 text_seg: text,
                 data_seg: None,
             }),
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(GdbTargetError::UnexpectedError)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(GdbTargetError::UnexpectedMessage)
@@ -267,6 +291,10 @@ impl HwBreakpoint for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::AddHwBreakpoint(addr))? {
             DebugResponse::AddHwBreakpoint(rsp) => Ok(rsp),
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -283,6 +311,10 @@ impl HwBreakpoint for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::RemoveHwBreakpoint(addr))? {
             DebugResponse::RemoveHwBreakpoint(rsp) => Ok(rsp),
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -301,6 +333,10 @@ impl SwBreakpoint for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::AddSwBreakpoint(addr))? {
             DebugResponse::AddSwBreakpoint(rsp) => Ok(rsp),
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -317,6 +353,10 @@ impl SwBreakpoint for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::RemoveSwBreakpoint(addr))? {
             DebugResponse::RemoveSwBreakpoint(rsp) => Ok(rsp),
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -342,6 +382,10 @@ impl SingleThreadSingleStep for HyperlightSandboxTarget {
         log::debug!("Step");
         match self.send_command(DebugMsg::Step)? {
             DebugResponse::Step => Ok(()),
+            DebugResponse::ErrorOccurred => {
+                log::error!("Error occurred");
+                Err(GdbTargetError::UnexpectedError)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(GdbTargetError::UnexpectedMessage)

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -39,6 +39,8 @@ use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
 use crate::mem::ptr::{GuestPtr, RawPtr};
 #[cfg(gdb)]
 use crate::sandbox::config::DebugInfo;
+#[cfg(gdb)]
+use crate::HyperlightError;
 use crate::{log_then_return, new_error, Result};
 
 /// Return `true` if the KVM API is available, version 12, and has UserMemory capability, or `false` otherwise
@@ -79,7 +81,7 @@ mod debug {
     use crate::hypervisor::gdb::{DebugMsg, DebugResponse, VcpuStopReason, X86_64Regs};
     use crate::hypervisor::handlers::DbgMemAccessHandlerCaller;
     use crate::mem::layout::SandboxMemoryLayout;
-    use crate::{new_error, Result};
+    use crate::{new_error, HyperlightError, Result};
 
     /// Software Breakpoint size in memory
     pub const SW_BP_SIZE: usize = 1;
@@ -217,19 +219,13 @@ mod debug {
 
         /// Translates the guest address to physical address
         fn translate_gva(&self, gva: u64) -> Result<u64> {
-            let tr = self.vcpu_fd.translate_gva(gva).map_err(|e| {
-                new_error!(
-                    "Could not translate guest virtual address {:X}: {:?}",
-                    gva,
-                    e
-                )
-            })?;
+            let tr = self
+                .vcpu_fd
+                .translate_gva(gva)
+                .map_err(|_| HyperlightError::TranslateGuestAddress(gva))?;
 
             if tr.valid == 0 {
-                Err(new_error!(
-                    "Could not translate guest virtual address {:X}",
-                    gva
-                ))
+                Err(HyperlightError::TranslateGuestAddress(gva))
             } else {
                 Ok(tr.physical_address)
             }
@@ -919,7 +915,16 @@ impl Hypervisor for KVMDriver {
             // Wait for a message from gdb
             let req = self.recv_dbg_msg()?;
 
-            let response = self.process_dbg_request(req, dbg_mem_access_fn.clone())?;
+            let result = self.process_dbg_request(req, dbg_mem_access_fn.clone());
+
+            let response = match result {
+                Ok(response) => response,
+                // Treat non fatal errors separately so the guest doesn't fail
+                Err(HyperlightError::TranslateGuestAddress(_)) => DebugResponse::ErrorOccurred,
+                Err(e) => {
+                    return Err(e);
+                }
+            };
 
             // If the command was either step or continue, we need to run the vcpu
             let cont = matches!(