add support for interrupts

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

Author: dblnz

src/hyperlight_host/src/hypervisor/gdb/event_loop.rs

@@ -14,12 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+use gdbstub::common::Signal;
 use gdbstub::conn::ConnectionExt;
 use gdbstub::stub::run_blocking::{self, WaitForStopReasonError};
 use gdbstub::stub::{BaseStopReason, DisconnectReason, GdbStub, SingleThreadStopReason};
+use libc::{pthread_kill, SIGRTMIN};
 
 use super::x86_64_target::HyperlightSandboxTarget;
-use super::{DebugResponse, VcpuStopReason};
+use super::{DebugResponse, GdbTargetError, VcpuStopReason};
 
 pub struct GdbBlockingEventLoop;
 
@@ -48,7 +50,15 @@ impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
                         VcpuStopReason::DoneStep => BaseStopReason::DoneStep,
                         VcpuStopReason::SwBp => BaseStopReason::SwBreak(()),
                         VcpuStopReason::HwBp => BaseStopReason::HwBreak(()),
+                        // This is a consequence of the GDB client sending an interrupt signal
+                        // to the target thread
+                        VcpuStopReason::Interrupt => BaseStopReason::SignalWithThread {
+                            tid: (),
+                            signal: Signal(SIGRTMIN() as u8),
+                        },
                         VcpuStopReason::Unknown => {
+                            log::warn!("Unknown stop reason - resuming execution");
+
                             target
                                 .resume_vcpu()
                                 .map_err(WaitForStopReasonError::Target)?;
@@ -87,8 +97,20 @@ impl run_blocking::BlockingEventLoop for GdbBlockingEventLoop {
     /// This function is called when the GDB client sends an interrupt signal.
     /// Passing `None` defers sending a stop reason to later (e.g. when the target stops).
     fn on_interrupt(
-        _target: &mut Self::Target,
+        target: &mut Self::Target,
     ) -> Result<Option<Self::StopReason>, <Self::Target as gdbstub::target::Target>::Error> {
+        log::info!("Received interrupt from GDB client - sending signal to target thread");
+
+        // Send a signal to the target thread to interrupt it
+        let ret = unsafe { pthread_kill(target.get_thread_id(), SIGRTMIN()) };
+
+        log::info!("pthread_kill returned {}", ret);
+
+        if ret < 0 && ret != libc::ESRCH {
+            log::error!("Failed to send signal to target thread");
+            return Err(GdbTargetError::SendSignalError);
+        }
+
         Ok(None)
     }
 }

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

@@ -39,6 +39,8 @@ pub enum GdbTargetError {
     CannotReceiveMsg,
     #[error("Error encountered when sending message")]
     CannotSendMsg,
+    #[error("Error encountered when sending a signal to the hypervisor thread")]
+    SendSignalError,
     #[error("Encountered an unexpected message over communication channel")]
     UnexpectedMessage,
     #[error("Unexpected error encountered")]
@@ -93,6 +95,7 @@ pub enum VcpuStopReason {
     DoneStep,
     HwBp,
     SwBp,
+    Interrupt,
     Unknown,
 }
 
@@ -178,6 +181,7 @@ impl<T, U> DebugCommChannel<T, U> {
 /// Creates a thread that handles gdb protocol
 pub fn create_gdb_thread(
     port: u16,
+    thread_id: u64,
 ) -> Result<DebugCommChannel<DebugResponse, DebugMsg>, GdbTargetError> {
     let (gdb_conn, hyp_conn) = DebugCommChannel::unbounded();
     let socket = format!("localhost:{}", port);
@@ -195,7 +199,7 @@ pub fn create_gdb_thread(
             let conn: Box<dyn ConnectionExt<Error = io::Error>> = Box::new(conn);
             let debugger = GdbStub::new(conn);
 
-            let mut target = HyperlightSandboxTarget::new(hyp_conn);
+            let mut target = HyperlightSandboxTarget::new(hyp_conn, thread_id);
 
             // Waits for vCPU to stop at entrypoint breakpoint
             let res = target.recv()?;

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

@@ -35,11 +35,16 @@ use super::{DebugCommChannel, DebugMsg, DebugResponse, GdbTargetError, X86_64Reg
 pub struct HyperlightSandboxTarget {
     /// Hypervisor communication channels
     hyp_conn: DebugCommChannel<DebugMsg, DebugResponse>,
+    /// Thread ID
+    thread_id: u64,
 }
 
 impl HyperlightSandboxTarget {
-    pub fn new(hyp_conn: DebugCommChannel<DebugMsg, DebugResponse>) -> Self {
-        HyperlightSandboxTarget { hyp_conn }
+    pub fn new(hyp_conn: DebugCommChannel<DebugMsg, DebugResponse>, thread_id: u64) -> Self {
+        HyperlightSandboxTarget {
+            hyp_conn,
+            thread_id,
+        }
     }
 
     /// Sends a command over the communication channel and waits for response
@@ -55,6 +60,11 @@ impl HyperlightSandboxTarget {
         self.hyp_conn.send(ev)
     }
 
+    /// Returns the thread ID
+    pub fn get_thread_id(&self) -> u64 {
+        self.thread_id
+    }
+
     /// Waits for a response over the communication channel
     pub fn recv(&self) -> Result<DebugResponse, GdbTargetError> {
         self.hyp_conn.recv()
@@ -366,6 +376,8 @@ impl SwBreakpoint for HyperlightSandboxTarget {
 }
 
 impl SingleThreadResume for HyperlightSandboxTarget {
+    /// Resumes the execution of the vCPU
+    /// Note: We do not handle signals passed to this method
     fn resume(&mut self, _signal: Option<Signal>) -> Result<(), Self::Error> {
         log::debug!("Resume");
         self.resume_vcpu()
@@ -376,9 +388,9 @@ impl SingleThreadResume for HyperlightSandboxTarget {
 }
 
 impl SingleThreadSingleStep for HyperlightSandboxTarget {
-    fn step(&mut self, signal: Option<Signal>) -> Result<(), Self::Error> {
-        assert!(signal.is_none());
-
+    /// Steps the vCPU execution by
+    /// Note: We do not handle signals passed to this method
+    fn step(&mut self, _signal: Option<Signal>) -> Result<(), Self::Error> {
         log::debug!("Step");
         match self.send_command(DebugMsg::Step)? {
             DebugResponse::Step => Ok(()),
@@ -404,7 +416,7 @@ mod tests {
     fn test_gdb_target() {
         let (gdb_conn, hyp_conn) = DebugCommChannel::unbounded();
 
-        let mut target = HyperlightSandboxTarget::new(hyp_conn);
+        let mut target = HyperlightSandboxTarget::new(hyp_conn, 0);
 
         // Check response to read registers - send the response first to not be blocked
         // by the recv call in the target

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -634,7 +634,7 @@ impl KVMDriver {
         #[cfg(gdb)]
         let (debug, gdb_conn) = {
             if let Some(DebugInfo { port }) = debug_info {
-                let gdb_conn = create_gdb_thread(*port);
+                let gdb_conn = create_gdb_thread(*port, unsafe { pthread_self() });
 
                 // in case the gdb thread creation fails, we still want to continue
                 // without gdb
@@ -875,7 +875,13 @@ impl Hypervisor for KVMDriver {
                 HyperlightExit::Debug(reason)
             }
             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 => 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))]
                 libc::EINTR => HyperlightExit::Cancelled(),
                 libc::EAGAIN => HyperlightExit::Retry(),
                 _ => {