add a way to signal a non fatal error on the hypervisor side

- when using visual studio code, sometimes it requests to read from
  unexpected addresses which can cause an error on the hypervisor side.
  This fix signals this to the gdb thread which marks it as a non-fatal
  error

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 occured 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

@@ -122,6 +122,7 @@ pub enum DebugResponse {
     AddSwBreakpoint(bool),
     Continue,
     DisableDebug,
+    ErrorOccured,
     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::ErrorOccured => {
+                log::error!("Error occured");
+                Err(GdbTargetError::UnexpectedError)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(GdbTargetError::UnexpectedMessage)
@@ -134,6 +138,10 @@ impl SingleThreadBase for HyperlightSandboxTarget {
 
                 Ok(v.len())
             }
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -151,6 +159,10 @@ impl SingleThreadBase for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::WriteAddr(gva, v))? {
             DebugResponse::WriteAddr => Ok(()),
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -188,6 +200,10 @@ impl SingleThreadBase for HyperlightSandboxTarget {
 
                 Ok(())
             }
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                Err(TargetError::NonFatal)
+            }
 
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
@@ -225,6 +241,10 @@ impl SingleThreadBase for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::WriteRegisters(regs))? {
             DebugResponse::WriteRegisters => Ok(()),
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -246,6 +266,10 @@ impl SectionOffsets for HyperlightSandboxTarget {
                 text_seg: text,
                 data_seg: None,
             }),
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                Err(GdbTargetError::UnexpectedError)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(GdbTargetError::UnexpectedMessage)
@@ -273,6 +297,10 @@ impl HwBreakpoint for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::AddHwBreakpoint(addr))? {
             DebugResponse::AddHwBreakpoint(rsp) => Ok(rsp),
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -289,6 +317,10 @@ impl HwBreakpoint for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::RemoveHwBreakpoint(addr))? {
             DebugResponse::RemoveHwBreakpoint(rsp) => Ok(rsp),
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -307,6 +339,10 @@ impl SwBreakpoint for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::AddSwBreakpoint(addr))? {
             DebugResponse::AddSwBreakpoint(rsp) => Ok(rsp),
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -323,6 +359,10 @@ impl SwBreakpoint for HyperlightSandboxTarget {
 
         match self.send_command(DebugMsg::RemoveSwBreakpoint(addr))? {
             DebugResponse::RemoveSwBreakpoint(rsp) => Ok(rsp),
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                Err(TargetError::NonFatal)
+            }
             msg => {
                 log::error!("Unexpected message received: {:?}", msg);
                 Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
@@ -348,9 +388,12 @@ impl SingleThreadSingleStep for HyperlightSandboxTarget {
         log::debug!("Step");
         match self.send_command(DebugMsg::Step)? {
             DebugResponse::Step => Ok(()),
+            DebugResponse::ErrorOccured => {
+                log::error!("Error occured");
+                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::uninitialized::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;
@@ -208,19 +210,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)
             }
@@ -916,7 +912,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::ErrorOccured,
+                Err(e) => {
+                    return Err(e);
+                }
+            };
 
             // If the command was either step or continue, we need to run the vcpu
             let cont = matches!(