Add file backed ReadonlySharedMemory

Signed-off-by: Ludvig Liljenberg <4257730+ludfjig@users.noreply.github.com>

Author: ludfjig

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

@@ -1497,7 +1497,8 @@ mod tests {
             [layout.get_guest_code_offset()..layout.get_guest_code_offset() + code.len()]
             .copy_from_slice(code);
         layout.write_peb(&mut snapshot_contents).unwrap();
-        let ro_mem = ReadonlySharedMemory::from_bytes(&snapshot_contents).unwrap();
+        let ro_mem =
+            ReadonlySharedMemory::from_bytes(&snapshot_contents, snapshot_pt_start).unwrap();
 
         let scratch_mem = ExclusiveSharedMemory::new(config.get_scratch_size()).unwrap();
         let mem_mgr = SandboxMemoryManager::new(

src/hyperlight_host/src/mem/layout.rs

@@ -232,9 +232,15 @@ pub(crate) struct SandboxMemoryLayout {
     pub(crate) init_data_permissions: Option<MemoryRegionFlags>,
     /// The size of the scratch region in physical memory.
     pub(crate) scratch_size: usize,
-    /// The size of the snapshot region in physical memory.
+    /// Size of the primary guest memory region at `BASE_ADDRESS`
+    /// (code, PEB, heap, init data). For a snapshot-backed layout
+    /// this is also the guest-visible prefix of the host snapshot
+    /// mapping.
     pub(crate) snapshot_size: usize,
-    /// The size of the page tables (None if not yet set).
+    /// Size of the page-table region. Sits at the tail of the host
+    /// snapshot mapping but is never mapped to the guest from there.
+    /// On restore the host copies it into scratch, where the guest
+    /// sees it at `SNAPSHOT_PT_GVA`. `None` until page tables are built.
     pub(crate) pt_size: Option<usize>,
 }
 
@@ -497,7 +503,12 @@ impl SandboxMemoryLayout {
         }
     }
 
-    /// Sets the size of the memory region used for page tables
+    /// Record the size of the page-table tail appended to the
+    /// snapshot blob. The PT bytes live at the end of the blob and
+    /// the host mapping, outside the guest mapping of the snapshot
+    /// region, and are copied into the scratch region on restore.
+    /// `snapshot_size` (the guest-visible prefix of the blob) is an
+    /// independent field and must be set separately.
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub(crate) fn set_pt_size(&mut self, size: usize) -> Result<()> {
         let min_fixed_scratch = hyperlight_common::layout::min_scratch_size(
@@ -508,8 +519,6 @@ impl SandboxMemoryLayout {
         if self.scratch_size < min_scratch {
             return Err(MemoryRequestTooSmall(self.scratch_size, min_scratch));
         }
-        let old_pt_size = self.pt_size.unwrap_or(0);
-        self.snapshot_size = self.snapshot_size - old_pt_size + size;
         self.pt_size = Some(size);
         Ok(())
     }

src/hyperlight_host/src/mem/memory_region.rs

@@ -153,12 +153,14 @@ pub enum MemoryRegionType {
 impl MemoryRegionType {
     /// Derives the [`SurrogateMapping`] from this region type.
     ///
-    /// `MappedFile` regions use read-only file-backed mappings with no
-    /// guard pages; all other region types use the standard sandbox
-    /// shared memory mapping with guard pages.
+    /// `MappedFile` and `Snapshot` regions use read-only file-backed
+    /// mappings with no guard pages. All other region types use the
+    /// standard sandbox shared memory mapping with guard pages.
     pub fn surrogate_mapping(&self) -> SurrogateMapping {
         match self {
-            MemoryRegionType::MappedFile => SurrogateMapping::ReadOnlyFile,
+            MemoryRegionType::MappedFile | MemoryRegionType::Snapshot => {
+                SurrogateMapping::ReadOnlyFile
+            }
             _ => SurrogateMapping::SandboxMemory,
         }
     }

src/hyperlight_host/src/mem/mgr.rs

@@ -723,7 +723,7 @@ impl SandboxMemoryManager<HostSharedMemory> {
         use crate::mem::memory_region::HostGuestMemoryRegion;
 
         let snapshot_base = SandboxMemoryLayout::BASE_ADDRESS;
-        let snapshot_size = self.shared_mem.mem_size();
+        let snapshot_size = self.layout.snapshot_size;
         let snapshot_host = self.shared_mem.base_addr();
 
         let scratch_size = self.scratch_mem.mem_size();