refactor: Have all memory creation method take similar arguments

Have all of them operate on some sort of list of (GuestAddress, usize)
tuples, for consistency.

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

src/vmm/src/persist.rs

@@ -529,7 +529,8 @@ fn guest_memory_from_file(
     track_dirty_pages: bool,
 ) -> Result<GuestMemoryMmap, GuestMemoryFromFileError> {
     let mem_file = File::open(mem_file_path)?;
-    let guest_mem = GuestMemoryMmap::snapshot_file(mem_file, mem_state, track_dirty_pages)?;
+    let guest_mem =
+        GuestMemoryMmap::snapshot_file(mem_file, mem_state.regions(), track_dirty_pages)?;
     Ok(guest_mem)
 }
 

src/vmm/src/resources.rs

@@ -456,16 +456,14 @@ impl VmResources {
         // because that would require running a backend process. If in the future we converge to
         // a single way of backing guest memory for vhost-user and non-vhost-user cases,
         // that would not be worth the effort.
+        let regions = crate::arch::arch_memory_regions(self.machine_config.mem_size_mib << KIB_TO_BYTES_SHIFT);
         if vhost_user_device_used {
             GuestMemoryMmap::memfd_backed(
-                self.machine_config.mem_size_mib,
+                regions.as_ref(),
                 self.machine_config.track_dirty_pages,
                 self.machine_config.huge_pages,
             )
         } else {
-            let regions = crate::arch::arch_memory_regions(
-                self.machine_config.mem_size_mib << KIB_TO_BYTES_SHIFT,
-            );
             GuestMemoryMmap::anonymous(
                 regions.into_iter(),
                 self.machine_config.track_dirty_pages,

src/vmm/src/vstate/memory.rs

@@ -22,7 +22,6 @@ use vm_memory::{Error as VmMemoryError, GuestMemoryError, WriteVolatile};
 use vmm_sys_util::errno;
 
 use crate::DirtyBitmap;
-use crate::arch::arch_memory_regions;
 use crate::utils::{KIB_TO_BYTES_SHIFT, get_page_size, u64_to_usize};
 use crate::vmm_config::machine_config::HugePageConfig;
 
@@ -67,15 +66,15 @@ where
 
     /// Creates a GuestMemoryMmap with `size` in MiB backed by a memfd.
     fn memfd_backed(
-        mem_size_mib: usize,
+        regions: &[(GuestAddress, usize)],
         track_dirty_pages: bool,
         huge_pages: HugePageConfig,
     ) -> Result<Self, MemoryError> {
-        let memfd_file = create_memfd(mem_size_mib, huge_pages.into())?.into_file();
-        let regions = arch_memory_regions(mem_size_mib << KIB_TO_BYTES_SHIFT).into_iter();
+        let size = regions.iter().map(|(_, size)| size).sum();
+        let memfd_file = create_memfd(size, huge_pages.into())?.into_file();
 
         Self::create(
-            regions,
+            regions.iter().copied(),
             libc::MAP_SHARED | huge_pages.mmap_flags(),
             Some(memfd_file),
             track_dirty_pages,
@@ -100,15 +99,10 @@ where
     /// and a `state` containing mapping information.
     fn snapshot_file(
         file: File,
-        state: &GuestMemoryState,
+        regions: impl Iterator<Item = (GuestAddress, usize)>,
         track_dirty_pages: bool,
     ) -> Result<Self, MemoryError> {
-        Self::create(
-            state.regions(),
-            libc::MAP_PRIVATE,
-            Some(file),
-            track_dirty_pages,
-        )
+        Self::create(regions, libc::MAP_PRIVATE, Some(file), track_dirty_pages)
     }
 
     /// Describes GuestMemoryMmap through a GuestMemoryState struct.
@@ -327,10 +321,9 @@ impl GuestMemoryExtension for GuestMemoryMmap {
 }
 
 fn create_memfd(
-    size: usize,
+    mem_size: usize,
     hugetlb_size: Option<memfd::HugetlbSize>,
 ) -> Result<memfd::Memfd, MemoryError> {
-    let mem_size = size << KIB_TO_BYTES_SHIFT;
     // Create a memfd.
     let opts = memfd::MemfdOptions::default()
         .hugetlb(hugetlb_size)
@@ -570,7 +563,7 @@ mod tests {
         guest_memory.dump(&mut memory_file).unwrap();
 
         let restored_guest_memory =
-            GuestMemoryMmap::snapshot_file(memory_file, &memory_state, false).unwrap();
+            GuestMemoryMmap::snapshot_file(memory_file, memory_state.regions(), false).unwrap();
 
         // Check that the region contents are the same.
         let mut restored_region = vec![0u8; page_size * 2];
@@ -629,7 +622,7 @@ mod tests {
 
         // We can restore from this because this is the first dirty dump.
         let restored_guest_memory =
-            GuestMemoryMmap::snapshot_file(file, &memory_state, false).unwrap();
+            GuestMemoryMmap::snapshot_file(file, memory_state.regions(), false).unwrap();
 
         // Check that the region contents are the same.
         let mut restored_region = vec![0u8; region_size];