add CI gdb test

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

Author: dblnz

.github/workflows/dep_rust.yml

@@ -115,6 +115,13 @@ jobs:
           RUST_LOG: debug
         run: just run-rust-examples-linux ${{ matrix.config }} ${{ matrix.hypervisor == 'mshv3' && 'mshv3' || ''}}
 
+      - name: Run Rust Gdb tests - linux
+        if: runner.os == 'Linux' && matrix.hypervisor == 'kvm'
+        env:
+          CARGO_TERM_COLOR: always
+          RUST_LOG: debug
+        run: just test-rust-gdb-debugging ${{ matrix.config }}
+
       ### Benchmarks ###
       - name: Install github-cli (Linux mariner)
         if: runner.os == 'Linux' && matrix.hypervisor == 'mshv'

Justfile

@@ -110,6 +110,11 @@ test-rust-feature-compilation-fail target=default-target:
     @# the following should fail on linux because one of kvm, mshv, or mshv3 feature must be specified, which is why the exit code is inverted with an !.
     {{ if os() == "linux" { "! cargo check -p hyperlight-host --no-default-features 2> /dev/null"} else { "" } }}
 
+# Test rust gdb debugging
+test-rust-gdb-debugging target=default-target: (build-rust target)
+    {{ set-trace-env-vars }} cargo test --profile={{ if target == "debug" { "dev" } else { target } }} --example guest-debugging --features gdb
+    {{ set-trace-env-vars }} cargo test --profile={{ if target == "debug" { "dev" } else { target } }} --features gdb -- test_gdb
+
 test target=default-target: (test-rust target)
 
 # RUST LINTING

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

@@ -80,3 +80,166 @@ fn main() -> hyperlight_host::Result<()> {
 
     Ok(())
 }
+
+#[cfg(gdb)]
+#[cfg(test)]
+mod tests {
+    use std::fs::File;
+    use std::io;
+    use std::process::{Command, Stdio};
+    use std::time::Duration;
+
+    use hyperlight_host::{new_error, Result};
+    use io::{BufReader, BufWriter, Read, Write};
+
+    use super::*;
+
+    fn write_cmds_file(cmd_file_path: &str, out_file_path: &str) -> io::Result<()> {
+        let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("Failed to get manifest dir");
+        let file = File::create(cmd_file_path)?;
+        let mut writer = BufWriter::new(file);
+
+        // write from string to file
+        writer.write_all(
+            format!(
+                "file {manifest_dir}/../tests/rust_guests/bin/debug/simpleguest
+                target remote :8080
+
+                set pagination off
+                set logging file {out_file_path}
+                set logging enabled on
+
+                break hyperlight_main
+                    commands
+                    echo \"Stopped at hyperlight_main breakpoint\\n\"
+                    backtrace
+                    continue
+                end
+
+                continue
+
+                set logging enabled off
+                quit
+            "
+            )
+            .as_bytes(),
+        )?;
+
+        writer.flush()
+    }
+
+    fn run_guest_and_gdb(cmd_file_path: &str, out_file_path: &str) -> Result<()> {
+        // write gdb commands to file
+
+        write_cmds_file(&cmd_file_path, &out_file_path)
+            .expect("Failed to write gdb commands to file");
+
+        let mut guest_child = Command::new("cargo")
+            .arg("run")
+            .arg("--example")
+            .arg("guest-debugging")
+            .arg("--features")
+            .arg("gdb")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .spawn()
+            .map_err(|e| new_error!("Failed to start guest process: {}", e))?;
+
+        // wait 3 seconds for the gdb to connect
+        thread::sleep(Duration::from_secs(3));
+
+        let mut gdb = Command::new("rust-gdb")
+            .arg("--nw")
+            .arg("-x")
+            .arg(cmd_file_path)
+            .spawn()
+            .map_err(|e| new_error!("Failed to start gdb process: {}", e))?;
+
+        // wait 3 seconds for the gdb to connect
+        thread::sleep(Duration::from_secs(10));
+
+        // check if the guest process has finished
+        match guest_child.try_wait() {
+            Ok(Some(status)) => {
+                if !status.success() {
+                    Err(new_error!(
+                        "Guest process exited with non-zero status: {}",
+                        status
+                    ))?;
+                }
+            }
+            Ok(None) => {
+                guest_child
+                    .kill()
+                    .map_err(|e| new_error!("Failed to kill child process: {}", e))?;
+            }
+            Err(e) => {
+                Err(new_error!("error attempting to wait guest: {}", e))?;
+            }
+        }
+
+        // check if the gdb process has finished
+        match gdb.try_wait() {
+            Ok(Some(status)) => {
+                if !status.success() {
+                    Err(new_error!(
+                        "Gdb process exited with non-zero status: {}",
+                        status
+                    ))?;
+                }
+            }
+            Ok(None) => {
+                gdb.kill()
+                    .map_err(|e| new_error!("Failed to kill guest process: {}", e))?;
+            }
+            Err(e) => {
+                Err(new_error!("error attempting to wait gdb: {}", e))?;
+            }
+        }
+
+        check_output(&out_file_path)
+    }
+
+    fn check_output(out_file_path: &str) -> Result<()> {
+        let results = File::open(out_file_path)
+            .map_err(|e| new_error!("Failed to open gdb.output file: {}", e))?;
+        let mut reader = BufReader::new(results);
+        let mut contents = String::new();
+        reader.read_to_string(&mut contents).unwrap();
+
+        if contents.contains("Stopped at hyperlight_main breakpoint") {
+            Ok(())
+        } else {
+            Err(new_error!(
+                "Failed to find expected output in gdb.output file"
+            ))
+        }
+    }
+
+    fn cleanup(out_file_path: &str, cmd_file_path: &str) -> Result<()> {
+        let res1 = std::fs::remove_file(out_file_path)
+            .map_err(|e| new_error!("Failed to remove gdb.output file: {}", e));
+        let res2 = std::fs::remove_file(cmd_file_path)
+            .map_err(|e| new_error!("Failed to remove gdb-commands.txt file: {}", e));
+
+        res1?;
+        res2?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_gdb_end_to_end() {
+        let out_dir = std::env::var("OUT_DIR").expect("Failed to get out dir");
+        let out_file_path = format!("{out_dir}/gdb.output");
+        let cmd_file_path = format!("{out_dir}/gdb-commands.txt");
+
+        let result = run_guest_and_gdb(&cmd_file_path, &out_file_path);
+
+        // cleanup
+        let cleanup_result = cleanup(&out_file_path, &cmd_file_path);
+        assert!(cleanup_result.is_ok(), "{}", cleanup_result.unwrap_err());
+        // check if the test passed - done at the end to ensure cleanup is done
+        assert!(result.is_ok(), "{}", result.unwrap_err());
+    }
+}

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

@@ -208,3 +208,29 @@ pub fn create_gdb_thread(
 
     Ok(gdb_conn)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_gdb_debug_comm_channel() {
+        let (gdb_conn, hyp_conn) = DebugCommChannel::<DebugMsg, DebugResponse>::unbounded();
+
+        let msg = DebugMsg::ReadRegisters;
+        let res = gdb_conn.send(msg);
+        assert!(res.is_ok());
+
+        let res = hyp_conn.recv();
+        assert!(res.is_ok());
+
+        let res = gdb_conn.try_recv();
+        assert!(res.is_err());
+
+        let res = hyp_conn.send(DebugResponse::ReadRegisters(X86_64Regs::default()));
+        assert!(res.is_ok());
+
+        let res = gdb_conn.recv();
+        assert!(res.is_ok());
+    }
+}

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

@@ -393,3 +393,46 @@ impl SingleThreadSingleStep for HyperlightSandboxTarget {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use gdbstub_arch::x86::reg::X86_64CoreRegs;
+
+    use super::*;
+
+    #[test]
+    fn test_gdb_target() {
+        let (gdb_conn, hyp_conn) = DebugCommChannel::unbounded();
+
+        let mut target = HyperlightSandboxTarget::new(hyp_conn);
+
+        // Check response to read registers - send the response first to not be blocked
+        // by the recv call in the target
+        let msg = DebugResponse::ReadRegisters(X86_64Regs::default());
+        let res = gdb_conn.send(msg);
+        assert!(res.is_ok());
+
+        let mut regs = X86_64CoreRegs::default();
+        assert!(
+            target.read_registers(&mut regs).is_ok(),
+            "Failed to read registers"
+        );
+
+        // Check response to write registers
+        let msg = DebugResponse::WriteRegisters;
+        let res = gdb_conn.send(msg);
+        assert!(res.is_ok());
+        assert!(
+            target.write_registers(&regs).is_ok(),
+            "Failed to write registers"
+        );
+
+        // Check response when the channel is dropped
+        drop(gdb_conn);
+        assert!(
+            target.read_registers(&mut regs).is_err(),
+            "Succeeded to read registers when
+            expected to fail"
+        );
+    }
+}