Add test set the the registers on kvm

Signed-off-by: James Sturtevant <[email protected]>

Author: jsturtevant

Cargo.lock

@@ -90,6 +90,7 @@ proptest = "1.7.0"
 tempfile = "3.22.0"
 crossbeam-queue = "0.3.12"
 tracing-serde = "0.2.0"
+serial_test = "3.1.1"
 hyperlight-testing = { workspace = true }
 env_logger = "0.11.8"
 tracing-forest = { version = "0.2.0", features = ["uuid", "chrono", "smallvec", "serde", "env-filter"] }

src/hyperlight_host/Cargo.toml

@@ -20,6 +20,7 @@ use hyperlight_host::sandbox::SandboxConfiguration;
 #[cfg(gdb)]
 use hyperlight_host::sandbox::config::DebugInfo;
 use hyperlight_host::{MultiUseSandbox, UninitializedSandbox};
+use serial_test::serial;
 
 /// Build a sandbox configuration that enables GDB debugging when the `gdb` feature is enabled.
 fn get_sandbox_cfg() -> Option<SandboxConfiguration> {
@@ -72,6 +73,13 @@ fn main() -> hyperlight_host::Result<()> {
     let mut multi_use_sandbox: MultiUseSandbox = uninitialized_sandbox.evolve()?;
 
     // Call guest function
+    multi_use_sandbox_dbg
+        .call::<()>(
+            "UseSSE2Registers",
+             (),
+        )
+        .unwrap();
+
     let message =
         "Hello, World! I am executing inside of a VM with debugger attached :)\n".to_string();
     multi_use_sandbox_dbg
@@ -106,44 +114,23 @@ mod tests {
 
     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");
+    fn write_cmds_file(cmd_file_path: &str, cmd: &str) -> io::Result<()> {
+
         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 on
-
-                break hyperlight_main
-                    commands
-                    echo \"Stopped at hyperlight_main breakpoint\\n\"
-                    backtrace
-                    continue
-                end
-
-                continue
-
-                set logging off
-                quit
-            "
-            )
-            .as_bytes(),
+            cmd.as_bytes(),
         )?;
 
         writer.flush()
     }
 
-    fn run_guest_and_gdb(cmd_file_path: &str, out_file_path: &str) -> Result<()> {
+    fn run_guest_and_gdb(cmd_file_path: &str, out_file_path: &str, cmd: &str, checker: fn(String) -> bool) -> Result<()> {
         // write gdb commands to file
 
-        write_cmds_file(&cmd_file_path, &out_file_path)
+        write_cmds_file(&cmd_file_path, cmd)
             .expect("Failed to write gdb commands to file");
 
         #[cfg(mshv2)] // mshv3 is a default feature is mutually exclusive with the mshv2 feature
@@ -215,17 +202,17 @@ mod tests {
             }
         }
 
-        check_output(&out_file_path)
+        check_output(&out_file_path, checker)
     }
 
-    fn check_output(out_file_path: &str) -> Result<()> {
+    fn check_output(out_file_path: &str, checker: fn(contents: String) -> bool) -> 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") {
+        if checker(contents) {
             Ok(())
         } else {
             Err(new_error!(
@@ -247,12 +234,84 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_gdb_end_to_end() {
         let out_dir = std::env::var("OUT_DIR").expect("Failed to get out dir");
+        let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("Failed to get manifest 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);
+        let cmd = format!(
+                "file {manifest_dir}/../tests/rust_guests/bin/debug/simpleguest
+                target remote :8080
+
+                set pagination off
+                set logging file {out_file_path}
+                set logging on
+
+                break hyperlight_main
+                    commands
+                    echo \"Stopped at hyperlight_main breakpoint\\n\"
+                    backtrace
+
+                    continue
+                end
+
+                continue
+
+                set logging off
+                quit
+            "
+            );
+
+        let checker = |contents: String| {contents.contains("Stopped at hyperlight_main breakpoint")};
+
+        let result = run_guest_and_gdb(&cmd_file_path, &out_file_path, &cmd, checker);
+
+        // 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());
+    }
+
+    #[test]
+    #[serial]
+    fn test_gdb_sse_check() {
+        let out_dir = std::env::var("OUT_DIR").expect("Failed to get out dir");
+        let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("Failed to get manifest dir");
+        let out_file_path = format!("{out_dir}/gdb-sse.output");
+        let cmd_file_path = format!("{out_dir}/gdb-sse--commands.txt");
+
+        let cmd = format!(
+                "file {manifest_dir}/../tests/rust_guests/bin/debug/simpleguest
+                target remote :8080
+
+                set pagination off
+                set logging file {out_file_path}
+                set logging on
+
+                break main.rs:simpleguest::use_sse2_registers
+                commands 1
+                    print $xmm1.v4_float
+                    break +2
+                    commands 2
+                        print $xmm1.v4_float
+                        continue
+                    end
+                    continue
+                end
+                
+
+                continue
+
+                set logging off
+                quit
+            "
+            );
+
+        let checker = |contents: String| {contents.contains("$2 = [1.20000005, 0, 0, 0]")};
+        let result = run_guest_and_gdb(&cmd_file_path, &out_file_path, &cmd, checker);
 
         // cleanup
         let cleanup_result = cleanup(&out_file_path, &cmd_file_path);

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

@@ -207,7 +207,6 @@ impl GuestDebug for KvmDebug {
         }
 
         // Read MXCSR from XSAVE (MXCSR is at byte offset 24 -> u32 index 6)
-        // Todo maybe I could use xsave to read the registers too instead of a separate call to get_fpu
         match vcpu_fd.get_xsave() {
             Ok(xsave) => {
                 regs.mxcsr = xsave.region[6];
@@ -262,6 +261,36 @@ impl GuestDebug for KvmDebug {
 
         vcpu_fd
             .set_regs(&new_regs)
-            .map_err(|e| new_error!("Could not write guest registers: {:?}", e))
+            .map_err(|e| new_error!("Could not write guest registers: {:?}", e))?;
+
+        // load existing values and replace the xmm registers
+        let mut fpu =  match vcpu_fd.get_fpu() {
+            Ok(fpu) => {
+                fpu
+            },
+            Err(e) => {
+                return Err(new_error!("Could not write guest registers: {:?}", e));
+            }
+        };
+
+        // Convert XMM registers from [u128; 16] (our internal representation)
+        // to [[u8; 16]; 16] (KVM FPU representation) using little-endian byte order.
+        fpu.xmm = regs.xmm.map(u128::to_le_bytes);
+        vcpu_fd.set_fpu(&fpu).map_err(|e| new_error!("Could not write guest registers: {:?}", e))?;
+
+        // Update MXCSR using XSAVE region entry 6 (MXCSR) if available.
+        let mut xsave = match vcpu_fd.get_xsave() {
+            Ok(xsave) => {
+               xsave
+            }
+            Err(e) => {
+                return Err(new_error!("Could not write guest registers: {:?}", e));
+            }
+        };
+
+        xsave.region[6] = regs.mxcsr;
+        unsafe { vcpu_fd.set_xsave(&xsave).map_err(|e| new_error!("Could not write guest registers: {:?}", e))? };
+
+        Ok(())
     }
 }