Ctrl+c in gdb works on kvm and whp

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

src/hyperlight_host/Cargo.toml

@@ -116,7 +116,7 @@ cfg_aliases = "0.2.1"
 built = { version = "0.8.0", optional = true, features = ["chrono", "git2"] }
 
 [features]
-default = ["kvm", "mshv2", "seccomp", "build-metadata"]
+default = ["kvm", "mshv2", "seccomp", "build-metadata", "gdb"]
 seccomp = ["dep:seccompiler"]
 function_call_metrics = []
 executable_heap = []

src/hyperlight_host/examples/guest-debugging/main.rs

@@ -68,6 +68,7 @@ fn main() -> hyperlight_host::Result<()> {
         Some(vec![ParameterValue::String(message.clone())]),
     );
 
+    println!("result {:?}", result);
     assert!(result.is_ok());
 
     Ok(())

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

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-mod arch;
+pub(crate) mod arch;
 mod event_loop;
 mod x86_64_target;
 
@@ -79,7 +79,6 @@ pub enum VcpuStopReason {
     EntryPointBp,
     HwBp,
     SwBp,
-    #[allow(dead_code)] // TODO confirm with doru if this really is needed
     Interrupt,
     Unknown,
 }

src/hyperlight_host/src/hypervisor/hyperlight_vm.rs

@@ -34,7 +34,7 @@ use super::mshv::MshvVm;
 use super::regs::{
     CommonFpu, CommonRegisters, FP_CONTROL_WORD_DEFAULT, FP_TAG_WORD_DEFAULT, MXCSR_DEFAULT,
 };
-use super::vm::{HyperlightExit, Vm};
+use super::vm::{DebugExit, HyperlightExit, Vm};
 use super::{
     HyperlightVm, CR0_AM, CR0_ET, CR0_MP, CR0_NE, CR0_PE, CR0_PG, CR0_WP, CR4_OSFXSR,
     CR4_OSXMMEXCPT, CR4_PAE, EFER_LMA, EFER_LME, EFER_NX, EFER_SCE,
@@ -502,11 +502,29 @@ impl HyperlightVm for HyperlightSandbox {
         loop {
             match self.vm.run_vcpu() {
                 #[cfg(gdb)]
-                Ok(HyperlightExit::Debug { dr6, exception }) => {
-                    let stop_reason =
-                        arch::vcpu_stop_reason(self.vm.as_mut(), self.entrypoint, dr6, exception)?;
-                    if let Err(e) = self.handle_debug(dbg_mem_access_fn.clone(), stop_reason) {
-                        log_then_return!(e);
+                Ok(HyperlightExit::Debug(debug_exit)) => {
+                    match debug_exit {
+                        DebugExit::Debug { dr6, exception } => {
+                            // Handle debug event (breakpoints)
+                            let stop_reason = arch::vcpu_stop_reason(
+                                self.vm.as_mut(),
+                                self.entrypoint,
+                                dr6,
+                                exception,
+                            )?;
+                            if let Err(e) =
+                                self.handle_debug(dbg_mem_access_fn.clone(), stop_reason)
+                            {
+                                log_then_return!(e);
+                            }
+                        }
+                        DebugExit::Interrupt => {
+                            if let Err(e) = self
+                                .handle_debug(dbg_mem_access_fn.clone(), VcpuStopReason::Interrupt)
+                            {
+                                log_then_return!(e);
+                            }
+                        }
                     }
                 }
 
@@ -580,7 +598,6 @@ impl HyperlightVm for HyperlightSandbox {
                         }
                     }
                 }
-
                 Ok(HyperlightExit::Cancelled()) => {
                     // Shutdown is returned when the host has cancelled execution
                     // After termination, the main thread will re-initialize the VM

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -26,8 +26,7 @@ use kvm_ioctls::{Kvm, VcpuExit, VcpuFd, VmFd};
 use tracing::{instrument, Span};
 
 use super::regs::{CommonFpu, CommonRegisters, CommonSpecialRegisters};
-use super::vm::Vm;
-use super::HyperlightExit;
+use super::vm::{DebugExit, HyperlightExit, Vm};
 use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
 use crate::{log_then_return, new_error, Result};
 
@@ -145,18 +144,18 @@ impl Vm for KvmVm {
             Ok(VcpuExit::MmioWrite(addr, _)) => Ok(HyperlightExit::MmioWrite(addr)),
             #[cfg(gdb)]
             // KVM provides architecture specific information about the vCPU state when exiting
-            Ok(VcpuExit::Debug(debug_exit)) => Ok(HyperlightExit::Debug {
+            Ok(VcpuExit::Debug(debug_exit)) => Ok(HyperlightExit::Debug(DebugExit::Debug {
                 dr6: debug_exit.dr6,
                 exception: debug_exit.exception,
-            }),
+            })),
             Err(e) => match e.errno() {
                 // In case of the gdb feature, the timeout is not enabled, this
                 // exit is because of a signal sent from the gdb thread to the
-                // hypervisor thread to cancel execution
-                // #[cfg(gdb)]
-                // libc::EINTR => Ok(HyperlightExit::Debug(VcpuStopReason::Interrupt)),
-                // we send a signal to the thread to cancel execution this results in EINTR being returned by KVM so we return Cancelled
-                // #[cfg(not(gdb))]
+                // hypervisor thread to cancel execution (e.g. Ctrl+C from GDB)
+                #[cfg(gdb)]
+                libc::EINTR => Ok(HyperlightExit::Debug(DebugExit::Interrupt)),
+                // we send a signal to the thread to cancel execution. This results in EINTR being returned
+                #[cfg(not(gdb))]
                 libc::EINTR => Ok(HyperlightExit::Cancelled()),
                 libc::EAGAIN => Ok(HyperlightExit::Retry()),
                 _ => {

src/hyperlight_host/src/hypervisor/mshv.rs

@@ -52,8 +52,8 @@ use tracing::{instrument, Span};
 #[cfg(gdb)]
 use super::handlers::DbgMemAccessHandlerCaller;
 use super::regs::{CommonFpu, CommonRegisters, CommonSpecialRegisters};
-use super::vm::Vm;
-use super::HyperlightExit;
+use super::vm::{HyperlightExit, Vm};
+use crate::hypervisor::vm::DebugExit;
 use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
 use crate::{log_then_return, new_error, Result};
 
@@ -236,18 +236,24 @@ impl Vm for MshvVm {
                 EXCEPTION_INTERCEPT => {
                     let exception_message = m.to_exception_info()?;
                     let DebugRegisters { dr6, .. } = self.vcpu_fd.get_debug_regs()?;
-                    HyperlightExit::Debug {
+                    HyperlightExit::Debug(DebugExit::Debug {
                         dr6,
                         exception: exception_message.exception_vector as u32,
-                    }
+                    })
                 }
                 other => {
                     crate::debug!("mshv Other Exit: Exit: {:#?} \n {:#?}", other, &self);
                     log_then_return!("unknown Hyper-V run message type {:?}", other);
                 }
             },
             Err(e) => match e.errno() {
-                // we send a signal to the thread to cancel execution this results in EINTR being returned by KVM so we return Cancelled
+                // In case of the gdb feature, the timeout is not enabled, this
+                // exit is because of a signal sent from the gdb thread to the
+                // hypervisor thread to cancel execution (e.g. Ctrl+C from GDB)
+                #[cfg(gdb)]
+                libc::EINTR => HyperlightExit::Debug(DebugExit::Interrupt),
+                // we send a signal to the thread to cancel execution. This results in EINTR being returned
+                #[cfg(not(gdb))]
                 libc::EINTR => HyperlightExit::Cancelled(),
                 libc::EAGAIN => HyperlightExit::Retry(),
                 _ => {

src/hyperlight_host/src/hypervisor/vm.rs

@@ -78,11 +78,19 @@ pub(crate) trait Vm: Send + Sync + Debug {
     ) -> Result<()>;
 }
 
+#[derive(Debug)]
+pub(super) enum DebugExit {
+    /// The vCPU has exited due to a debug event (usually breakpoint)
+    Debug { dr6: u64, exception: u32 },
+    /// The user has requested to stop the VM during execution (e.g. via Ctrl+C inside GDB)
+    Interrupt,
+}
+
 /// Possible exit reasons of a VM's vCPU
 pub(super) enum HyperlightExit {
     #[cfg(gdb)]
     /// The vCPU has exited due to a debug event
-    Debug { dr6: u64, exception: u32 },
+    Debug(DebugExit),
     /// The vCPU has halted
     Halt(),
     /// The vCPU has issued a write to the given port with the given value
@@ -92,6 +100,7 @@ pub(super) enum HyperlightExit {
     /// The vCPU tried to write to the given (unmapped) addr
     MmioWrite(u64),
     /// The vCPU execution has been cancelled
+    #[allow(dead_code)]
     Cancelled(),
     /// The vCPU has exited for a reason that is not handled by Hyperlight
     Unknown(String),

src/tests/rust_guests/simpleguest/src/main.rs

@@ -96,6 +96,7 @@ fn print_output(message: &str) -> Result<Vec<u8>> {
 }
 
 fn simple_print_output(function_call: &FunctionCall) -> Result<Vec<u8>> {
+    loop {}
     if let ParameterValue::String(message) = function_call.parameters.clone().unwrap()[0].clone() {
         print_output(&message)
     } else {