refactor: make GuestMemoryRegion a GPA-to-GVA mapping

Change GuestMemoryRegion::HostBaseType from () to usize so that
GuestMemoryRegion becomes a proper mapping: host_region carries
guest physical addresses (GPA) and guest_region carries guest
virtual addresses (GVA). For identity-mapped regions both are
the same. For non-PIE code the Code region's guest_region is
overridden to the ELF-declared virtual address.

Remove the guest_virt_addr field from MemoryRegion_ since its
role is now served by the guest_region/host_region split in
GuestMemoryRegion.

Use checked_add for the code VA overlap check.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 6f20a05d-6bee-4e2e-b320-12f8d9759bbc
Signed-off-by: cshung <3410332+cshung@users.noreply.github.com>

Author: cshung

src/hyperlight_host/src/hypervisor/crashdump.rs

@@ -474,7 +474,6 @@ mod test {
         let ptr = dummy_vec.as_ptr() as usize;
         let regions = vec![CrashDumpRegion {
             guest_region: 0x1000..0x2000,
-            guest_virt_addr: 0x1000,
             host_region: ptr..ptr + dummy_vec.len(),
             flags: MemoryRegionFlags::READ | MemoryRegionFlags::WRITE,
             region_type: crate::mem::memory_region::MemoryRegionType::Code,

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

@@ -426,7 +426,6 @@ mod tests {
                 guest_mmap_regions: vec![MemoryRegion {
                     host_region: mapped_mem as usize..mapped_mem.wrapping_add(size) as usize,
                     guest_region: BASE_VIRT..BASE_VIRT + size,
-                    guest_virt_addr: BASE_VIRT,
                     flags: MemoryRegionFlags::READ | MemoryRegionFlags::EXECUTE,
                     region_type: MemoryRegionType::Heap,
                 }],

src/hyperlight_host/src/hypervisor/hyperlight_vm/x86_64.rs

@@ -1495,15 +1495,15 @@ mod tests {
         let pt_buf = GuestPageTableBuffer::new(pt_base_gpa as usize);
 
         for rgn in layout
-            .get_memory_regions_::<GuestMemoryRegion>(())
+            .get_memory_regions_::<GuestMemoryRegion>(SandboxMemoryLayout::BASE_ADDRESS)
             .unwrap()
             .iter()
         {
             let readable = rgn.flags.contains(MemoryRegionFlags::READ);
             let writable = rgn.flags.contains(MemoryRegionFlags::WRITE);
             let executable = rgn.flags.contains(MemoryRegionFlags::EXECUTE);
             let mapping = Mapping {
-                phys_base: rgn.guest_region.start as u64,
+                phys_base: rgn.host_region.start as u64,
                 virt_base: rgn.guest_region.start as u64,
                 len: rgn.guest_region.len() as u64,
                 kind: MappingKind::Basic(BasicMapping {

src/hyperlight_host/src/mem/layout.rs

@@ -580,10 +580,16 @@ impl SandboxMemoryLayout {
         let load_addr = self.get_guest_code_address() as u64;
         let code_virt_base = if is_pie { load_addr } else { elf_base_va };
 
-        let mut regions = self.get_memory_regions_::<GuestMemoryRegion>(())?;
+        let mut regions = self.get_memory_regions_::<GuestMemoryRegion>(Self::BASE_ADDRESS)?;
 
         if !is_pie {
-            let code_virt_end = code_virt_base + loaded_size;
+            let code_virt_end = code_virt_base.checked_add(loaded_size).ok_or_else(|| {
+                new_error!(
+                    "Code mapping overflow: base {:#x} + size {:#x}",
+                    code_virt_base,
+                    loaded_size
+                )
+            })?;
             for rgn in regions.iter() {
                 if rgn.region_type == MemoryRegionType::Code {
                     continue;
@@ -603,10 +609,12 @@ impl SandboxMemoryLayout {
             }
         }
 
-        // Set the Code region's guest_virt_addr to code_virt_base.
+        // Override the Code region's GVA (guest_region) to code_virt_base.
+        // host_region retains the GPA from the builder.
         for rgn in regions.iter_mut() {
             if rgn.region_type == MemoryRegionType::Code {
-                rgn.guest_virt_addr = code_virt_base as usize;
+                let len = rgn.guest_region.len();
+                rgn.guest_region = code_virt_base as usize..(code_virt_base as usize + len);
             }
         }
 

src/hyperlight_host/src/mem/memory_region.rs

@@ -282,24 +282,26 @@ impl MemoryRegionKind for HostGuestMemoryRegion {
 pub(crate) struct GuestMemoryRegion {}
 
 impl MemoryRegionKind for GuestMemoryRegion {
-    type HostBaseType = ();
+    type HostBaseType = usize;
 
-    fn add(_base: Self::HostBaseType, _size: usize) -> Self::HostBaseType {}
+    fn add(base: Self::HostBaseType, size: usize) -> Self::HostBaseType {
+        base + size
+    }
 }
 
 /// represents a single memory region inside the guest. All memory within a region has
 /// the same memory permissions
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MemoryRegion_<K: MemoryRegionKind> {
-    /// the range of guest physical addresses
+    /// The range of guest addresses. For `GuestMemoryRegion` this is
+    /// the guest virtual address range (GVA). For `HostGuestMemoryRegion`
+    /// and `CrashDumpMemoryRegion` this is the guest physical address
+    /// range (GPA) or GVA depending on the variant.
     pub guest_region: Range<usize>,
-    /// the guest virtual address at which this region should be mapped.
-    /// For identity-mapped regions this equals `guest_region.start`.
-    /// For non-PIE code it is the ELF's declared virtual address.
-    pub guest_virt_addr: usize,
-    /// the range of host memory addresses
-    ///
-    /// Note that Range<()> = () x () = ().
+    /// The range of host-side addresses. For `HostGuestMemoryRegion` this
+    /// is the host virtual address range (HVA). For `GuestMemoryRegion`
+    /// this is the guest physical address range (GPA). For
+    /// `CrashDumpMemoryRegion` this is the HVA.
     pub host_region: Range<K::HostBaseType>,
     /// memory access flags for the given region
     pub flags: MemoryRegionFlags,
@@ -360,7 +362,6 @@ impl<K: MemoryRegionKind> MemoryRegionVecBuilder<K> {
             let host_end = <K as MemoryRegionKind>::add(self.host_base_virt_addr, size);
             self.regions.push(MemoryRegion_ {
                 guest_region: self.guest_base_phys_addr..guest_end,
-                guest_virt_addr: self.guest_base_phys_addr,
                 host_region: self.host_base_virt_addr..host_end,
                 flags,
                 region_type,
@@ -375,7 +376,6 @@ impl<K: MemoryRegionKind> MemoryRegionVecBuilder<K> {
         let guest_start = last_region.guest_region.end;
         let new_region = MemoryRegion_ {
             guest_region: guest_start..guest_start + size,
-            guest_virt_addr: guest_start,
             host_region: last_region.host_region.end..host_end,
             flags,
             region_type,

src/hyperlight_host/src/mem/mgr.rs

@@ -650,7 +650,6 @@ impl SandboxMemoryManager<HostSharedMemory> {
 
                         regions.push(CrashDumpRegion {
                             guest_region: virt_base..virt_end,
-                            guest_virt_addr: virt_base,
                             host_region: host_base..host_base + host_len,
                             flags,
                             region_type,

src/hyperlight_host/src/mem/shared_mem.rs

@@ -514,7 +514,6 @@ fn mapping_at(
 
     MemoryRegion {
         guest_region: guest_base..(guest_base + size),
-        guest_virt_addr: guest_base,
         host_region: s.host_region_base()
             ..<HostGuestMemoryRegion as MemoryRegionKind>::add(s.host_region_base(), size),
         region_type,

src/hyperlight_host/src/sandbox/file_mapping.rs

@@ -164,7 +164,6 @@ impl PreparedFileMapping {
                 Ok(MemoryRegion {
                     host_region: host_base..host_end,
                     guest_region: guest_start..guest_end,
-                    guest_virt_addr: guest_start,
                     flags: MemoryRegionFlags::READ | MemoryRegionFlags::EXECUTE,
                     region_type: MemoryRegionType::MappedFile,
                 })
@@ -185,7 +184,6 @@ impl PreparedFileMapping {
                     host_region: *mmap_base as usize
                         ..(*mmap_base as usize).wrapping_add(*mmap_size),
                     guest_region: guest_start..guest_end,
-                    guest_virt_addr: guest_start,
                     flags: MemoryRegionFlags::READ | MemoryRegionFlags::EXECUTE,
                     region_type: MemoryRegionType::MappedFile,
                 })

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -1587,7 +1587,6 @@ mod tests {
         MemoryRegion {
             host_region: mem.host_region_base()..mem.host_region_end(),
             guest_region: guest_base..(guest_base + len),
-            guest_virt_addr: guest_base,
             flags,
             region_type: MemoryRegionType::Heap,
         }

src/hyperlight_host/src/sandbox/snapshot/mod.rs

@@ -385,8 +385,8 @@ impl Snapshot {
             };
 
             let mapping = Mapping {
-                phys_base: rgn.guest_region.start as u64,
-                virt_base: rgn.guest_virt_addr as u64,
+                phys_base: rgn.host_region.start as u64,
+                virt_base: rgn.guest_region.start as u64,
                 len: rgn.guest_region.len() as u64,
                 kind,
             };