[trace] Add tests for read_guest_memory_by_gva

Signed-off-by: Doru Blânzeanu <dblnz@pm.me>

Author: dblnz

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -1429,4 +1429,98 @@ mod tests {
             drop(sbox);
         }
     }
+
+    /// Helper: create a MultiUseSandbox from the simple guest with default config.
+    #[cfg(feature = "trace_guest")]
+    fn sandbox_for_gva_tests() -> MultiUseSandbox {
+        let path = simple_guest_as_string().unwrap();
+        UninitializedSandbox::new(GuestBinary::FilePath(path), None)
+            .unwrap()
+            .evolve()
+            .unwrap()
+    }
+
+    /// Helper: read memory at `gva` of length `len` from the guest side via
+    /// `ReadMappedBuffer(gva, len, false)` and from the host side via
+    /// `read_guest_memory_by_gva`, then assert both views are identical.
+    #[cfg(feature = "trace_guest")]
+    fn assert_gva_read_matches(sbox: &mut MultiUseSandbox, gva: u64, len: usize) {
+        // Guest reads via its own page tables
+        let expected: Vec<u8> = sbox
+            .call("ReadMappedBuffer", (gva, len as u64, true))
+            .unwrap();
+        assert_eq!(expected.len(), len);
+
+        // Host reads by walking the same page tables
+        let root_pt = sbox.vm.get_root_pt().unwrap();
+        let actual = sbox
+            .mem_mgr
+            .read_guest_memory_by_gva(gva, len, root_pt)
+            .unwrap();
+
+        assert_eq!(
+            actual, expected,
+            "read_guest_memory_by_gva at GVA {:#x} (len {}) differs from guest ReadMappedBuffer",
+            gva, len,
+        );
+    }
+
+    /// Test reading a small buffer (< 1 page) from guest memory via GVA.
+    /// Uses the guest code section which is already identity-mapped.
+    #[test]
+    #[cfg(feature = "trace_guest")]
+    fn read_guest_memory_by_gva_single_page() {
+        let mut sbox = sandbox_for_gva_tests();
+        let code_gva = sbox.mem_mgr.layout.get_guest_code_address() as u64;
+        assert_gva_read_matches(&mut sbox, code_gva, 128);
+    }
+
+    /// Test reading exactly one full page (4096 bytes) from guest memory.
+    /// Uses the guest code section
+    #[test]
+    #[cfg(feature = "trace_guest")]
+    fn read_guest_memory_by_gva_full_page() {
+        let mut sbox = sandbox_for_gva_tests();
+        let code_gva = sbox.mem_mgr.layout.get_guest_code_address() as u64;
+        assert_gva_read_matches(&mut sbox, code_gva, 4096);
+    }
+
+    /// Test that a read starting at an odd (non-page-aligned) address and
+    /// spanning two page boundaries returns correct data.
+    #[test]
+    #[cfg(feature = "trace_guest")]
+    fn read_guest_memory_by_gva_unaligned_cross_page() {
+        let mut sbox = sandbox_for_gva_tests();
+        let code_gva = sbox.mem_mgr.layout.get_guest_code_address() as u64;
+        // Start 1 byte before the second page boundary and read 4097 bytes
+        // (spans 2 full page boundaries).
+        let start = code_gva + 4096 - 1;
+        println!(
+            "Testing unaligned cross-page read starting at {:#x} spanning 4097 bytes",
+            start
+        );
+        assert_gva_read_matches(&mut sbox, start, 4097);
+    }
+
+    /// Test reading exactly two full pages (8192 bytes) from guest memory.
+    #[test]
+    #[cfg(feature = "trace_guest")]
+    fn read_guest_memory_by_gva_two_full_pages() {
+        let mut sbox = sandbox_for_gva_tests();
+        let code_gva = sbox.mem_mgr.layout.get_guest_code_address() as u64;
+        assert_gva_read_matches(&mut sbox, code_gva, 4096 * 2);
+    }
+
+    /// Test reading a region that spans across a page boundary: starts
+    /// 100 bytes before the end of the first page and reads 200 bytes
+    /// into the second page.
+    #[test]
+    #[cfg(feature = "trace_guest")]
+    fn read_guest_memory_by_gva_cross_page_boundary() {
+        let mut sbox = sandbox_for_gva_tests();
+        let code_gva = sbox.mem_mgr.layout.get_guest_code_address() as u64;
+        // Start 100 bytes before the first page boundary, read across it.
+        let start = code_gva + 4096 - 100;
+        assert_gva_read_matches(&mut sbox, start, 200);
+    }
 }