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 Debugging examples - linux
+        if: runner.os == 'Linux' && matrix.hypervisor == 'kvm'
+        env:
+          CARGO_TERM_COLOR: always
+          RUST_LOG: debug
+        run: just run-rust-examples-debugging ${{ matrix.config }}
+
       ### Benchmarks ###
       - name: Install github-cli (Linux mariner)
         if: runner.os == 'Linux' && matrix.hypervisor == 'mshv'

Justfile

@@ -159,6 +159,10 @@ run-rust-examples-linux target=default-target features="": (build-rust target) (
     {{ set-trace-env-vars }} cargo run --profile={{ if target == "debug" { "dev" } else { target } }} --example tracing {{ if features =="" {''} else { "--features " + features } }}
     {{ set-trace-env-vars }} cargo run --profile={{ if target == "debug" { "dev" } else { target } }} --example tracing {{ if features =="" {"--features function_call_metrics" } else {"--features function_call_metrics," + features} }}
 
+# Verify that the debugging works
+run-rust-examples-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
+
 # BENCHMARKING
 
 # Warning: can overwrite previous local benchmarks, so run this before running benchmarks

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());
+    }
+}