refactor: Consolidate test-only memory creation utilities

Consolidates the jungle of functions out unit tests use to allocate
(mock) guest memory into three central utility functions. The main
intention behind this is to (mostly) prevent unit tests from calling
GuestMemoryMmap::from_raw_regions because that function will gain a huge
pages related parameter, and I dont want to have to touch 349082 files
in the feature commit that introduces it. This will also make it easier
to later on switch our unittests to use memfd based memory instead of
anonymous memory once vhost snapshot support is done.

After this commit, the only places that directly use from_raw_regions
are the tests in memory.rs itself (because they test from_raw_regions,
and not the utility wrappers), and any call sites that deviate from the
defaults chosen in test_utils.rs (e.g. if something wants dirty page
tracking).

The test being removed in this commit duplicates test_from_raw_regions
in memory.rs.

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

Author: roypat

src/vmm/src/arch/aarch64/fdt.rs

@@ -427,8 +427,8 @@ mod tests {
 
     use super::*;
     use crate::arch::aarch64::gic::create_gic;
-    use crate::arch::aarch64::{arch_memory_regions, layout};
-    use crate::vstate::memory::{GuestMemoryExtension, GuestMemoryMmap};
+    use crate::arch::aarch64::layout;
+    use crate::utilities::test_utils::arch_mem;
 
     const LEN: u64 = 4096;
 
@@ -460,9 +460,7 @@ mod tests {
 
     #[test]
     fn test_create_fdt_with_devices() {
-        let regions = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000);
-        let mem =
-            GuestMemoryMmap::from_raw_regions(&regions, false).expect("Cannot initialize memory");
+        let mem = arch_mem(layout::FDT_MAX_SIZE + 0x1000);
 
         let dev_info: HashMap<(DeviceType, std::string::String), MMIODeviceInfo> = [
             (
@@ -500,9 +498,7 @@ mod tests {
 
     #[test]
     fn test_create_fdt() {
-        let regions = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000);
-        let mem =
-            GuestMemoryMmap::from_raw_regions(&regions, false).expect("Cannot initialize memory");
+        let mem = arch_mem(layout::FDT_MAX_SIZE + 0x1000);
         let kvm = Kvm::new().unwrap();
         let vm = kvm.create_vm().unwrap();
         let gic = create_gic(&vm, 1, None).unwrap();
@@ -558,9 +554,7 @@ mod tests {
 
     #[test]
     fn test_create_fdt_with_initrd() {
-        let regions = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000);
-        let mem =
-            GuestMemoryMmap::from_raw_regions(&regions, false).expect("Cannot initialize memory");
+        let mem = arch_mem(layout::FDT_MAX_SIZE + 0x1000);
         let kvm = Kvm::new().unwrap();
         let vm = kvm.create_vm().unwrap();
         let gic = create_gic(&vm, 1, None).unwrap();

src/vmm/src/arch/aarch64/mod.rs

@@ -114,7 +114,7 @@ fn get_fdt_addr(mem: &GuestMemoryMmap) -> u64 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::vstate::memory::GuestMemoryExtension;
+    use crate::utilities::test_utils::arch_mem;
 
     #[test]
     fn test_regions_lt_1024gb() {
@@ -134,19 +134,13 @@ mod tests {
 
     #[test]
     fn test_get_fdt_addr() {
-        let regions = arch_memory_regions(layout::FDT_MAX_SIZE - 0x1000);
-        let mem =
-            GuestMemoryMmap::from_raw_regions(&regions, false).expect("Cannot initialize memory");
+        let mem = arch_mem(layout::FDT_MAX_SIZE - 0x1000);
         assert_eq!(get_fdt_addr(&mem), layout::DRAM_MEM_START);
 
-        let regions = arch_memory_regions(layout::FDT_MAX_SIZE);
-        let mem =
-            GuestMemoryMmap::from_raw_regions(&regions, false).expect("Cannot initialize memory");
+        let mem = arch_mem(layout::FDT_MAX_SIZE);
         assert_eq!(get_fdt_addr(&mem), layout::DRAM_MEM_START);
 
-        let regions = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000);
-        let mem =
-            GuestMemoryMmap::from_raw_regions(&regions, false).expect("Cannot initialize memory");
+        let mem = arch_mem(layout::FDT_MAX_SIZE + 0x1000);
         assert_eq!(get_fdt_addr(&mem), 0x1000 + layout::DRAM_MEM_START);
     }
 }

src/vmm/src/arch/aarch64/vcpu.rs

@@ -218,17 +218,15 @@ mod tests {
     use kvm_ioctls::Kvm;
 
     use super::*;
-    use crate::arch::aarch64::{arch_memory_regions, layout};
-    use crate::vstate::memory::GuestMemoryExtension;
+    use crate::arch::aarch64::layout;
+    use crate::utilities::test_utils::arch_mem;
 
     #[test]
     fn test_setup_regs() {
         let kvm = Kvm::new().unwrap();
         let vm = kvm.create_vm().unwrap();
         let vcpu = vm.create_vcpu(0).unwrap();
-        let regions = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000);
-        let mem =
-            GuestMemoryMmap::from_raw_regions(&regions, false).expect("Cannot initialize memory");
+        let mem = arch_mem(layout::FDT_MAX_SIZE + 0x1000);
 
         let res = setup_boot_regs(&vcpu, 0, 0x0, &mem);
         assert!(matches!(

src/vmm/src/arch/x86_64/mod.rs

@@ -210,7 +210,7 @@ mod tests {
     use linux_loader::loader::bootparam::boot_e820_entry;
 
     use super::*;
-    use crate::vstate::memory::GuestMemoryExtension;
+    use crate::utilities::test_utils::{arch_mem, single_region_mem};
 
     #[test]
     fn regions_lt_4gb() {
@@ -231,7 +231,7 @@ mod tests {
     #[test]
     fn test_system_configuration() {
         let no_vcpus = 4;
-        let gm = GuestMemoryMmap::from_raw_regions(&[(GuestAddress(0), 0x10000)], false).unwrap();
+        let gm = single_region_mem(0x10000);
         let config_err = configure_system(&gm, GuestAddress(0), 0, &None, 1);
         assert_eq!(
             config_err.unwrap_err(),
@@ -240,20 +240,17 @@ mod tests {
 
         // Now assigning some memory that falls before the 32bit memory hole.
         let mem_size = 128 << 20;
-        let arch_mem_regions = arch_memory_regions(mem_size);
-        let gm = GuestMemoryMmap::from_raw_regions(&arch_mem_regions, false).unwrap();
+        let gm = arch_mem(mem_size);
         configure_system(&gm, GuestAddress(0), 0, &None, no_vcpus).unwrap();
 
         // Now assigning some memory that is equal to the start of the 32bit memory hole.
         let mem_size = 3328 << 20;
-        let arch_mem_regions = arch_memory_regions(mem_size);
-        let gm = GuestMemoryMmap::from_raw_regions(&arch_mem_regions, false).unwrap();
+        let gm = arch_mem(mem_size);
         configure_system(&gm, GuestAddress(0), 0, &None, no_vcpus).unwrap();
 
         // Now assigning some memory that falls after the 32bit memory hole.
         let mem_size = 3330 << 20;
-        let arch_mem_regions = arch_memory_regions(mem_size);
-        let gm = GuestMemoryMmap::from_raw_regions(&arch_mem_regions, false).unwrap();
+        let gm = arch_mem(mem_size);
         configure_system(&gm, GuestAddress(0), 0, &None, no_vcpus).unwrap();
     }
 

src/vmm/src/arch/x86_64/mptable.rs

@@ -299,7 +299,8 @@ pub fn setup_mptable(mem: &GuestMemoryMmap, num_cpus: u8) -> Result<(), MptableE
 mod tests {
 
     use super::*;
-    use crate::vstate::memory::{Bytes, GuestMemoryExtension};
+    use crate::utilities::test_utils::single_region_mem_at;
+    use crate::vstate::memory::Bytes;
 
     fn table_entry_size(type_: u8) -> usize {
         match u32::from(type_) {
@@ -315,35 +316,23 @@ mod tests {
     #[test]
     fn bounds_check() {
         let num_cpus = 4;
-        let mem = GuestMemoryMmap::from_raw_regions(
-            &[(GuestAddress(MPTABLE_START), compute_mp_size(num_cpus))],
-            false,
-        )
-        .unwrap();
+        let mem = single_region_mem_at(MPTABLE_START, compute_mp_size(num_cpus));
 
         setup_mptable(&mem, num_cpus).unwrap();
     }
 
     #[test]
     fn bounds_check_fails() {
         let num_cpus = 4;
-        let mem = GuestMemoryMmap::from_raw_regions(
-            &[(GuestAddress(MPTABLE_START), compute_mp_size(num_cpus) - 1)],
-            false,
-        )
-        .unwrap();
+        let mem = single_region_mem_at(MPTABLE_START, compute_mp_size(num_cpus) - 1);
 
         setup_mptable(&mem, num_cpus).unwrap_err();
     }
 
     #[test]
     fn mpf_intel_checksum() {
         let num_cpus = 1;
-        let mem = GuestMemoryMmap::from_raw_regions(
-            &[(GuestAddress(MPTABLE_START), compute_mp_size(num_cpus))],
-            false,
-        )
-        .unwrap();
+        let mem = single_region_mem_at(MPTABLE_START, compute_mp_size(num_cpus));
 
         setup_mptable(&mem, num_cpus).unwrap();
 
@@ -355,11 +344,7 @@ mod tests {
     #[test]
     fn mpc_table_checksum() {
         let num_cpus = 4;
-        let mem = GuestMemoryMmap::from_raw_regions(
-            &[(GuestAddress(MPTABLE_START), compute_mp_size(num_cpus))],
-            false,
-        )
-        .unwrap();
+        let mem = single_region_mem_at(MPTABLE_START, compute_mp_size(num_cpus));
 
         setup_mptable(&mem, num_cpus).unwrap();
 
@@ -381,11 +366,7 @@ mod tests {
     #[test]
     fn mpc_entry_count() {
         let num_cpus = 1;
-        let mem = GuestMemoryMmap::from_raw_regions(
-            &[(GuestAddress(MPTABLE_START), compute_mp_size(num_cpus))],
-            false,
-        )
-        .unwrap();
+        let mem = single_region_mem_at(MPTABLE_START, compute_mp_size(num_cpus));
 
         setup_mptable(&mem, num_cpus).unwrap();
 
@@ -413,14 +394,7 @@ mod tests {
 
     #[test]
     fn cpu_entry_count() {
-        let mem = GuestMemoryMmap::from_raw_regions(
-            &[(
-                GuestAddress(MPTABLE_START),
-                compute_mp_size(MAX_SUPPORTED_CPUS),
-            )],
-            false,
-        )
-        .unwrap();
+        let mem = single_region_mem_at(MPTABLE_START, compute_mp_size(MAX_SUPPORTED_CPUS));
 
         for i in 0..MAX_SUPPORTED_CPUS {
             setup_mptable(&mem, i).unwrap();
@@ -451,11 +425,7 @@ mod tests {
     #[test]
     fn cpu_entry_count_max() {
         let cpus = MAX_SUPPORTED_CPUS + 1;
-        let mem = GuestMemoryMmap::from_raw_regions(
-            &[(GuestAddress(MPTABLE_START), compute_mp_size(cpus))],
-            false,
-        )
-        .unwrap();
+        let mem = single_region_mem_at(MPTABLE_START, compute_mp_size(cpus));
 
         let result = setup_mptable(&mem, cpus).unwrap_err();
         assert_eq!(result, MptableError::TooManyCpus);

src/vmm/src/arch/x86_64/regs.rs

@@ -238,17 +238,13 @@ fn setup_page_tables(mem: &GuestMemoryMmap, sregs: &mut kvm_sregs) -> Result<(),
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::cast_possible_truncation)]
+
     use kvm_ioctls::Kvm;
-    use utils::u64_to_usize;
 
     use super::*;
-    use crate::vstate::memory::{Bytes, GuestAddress, GuestMemoryExtension, GuestMemoryMmap};
-
-    fn create_guest_mem(mem_size: Option<u64>) -> GuestMemoryMmap {
-        let page_size = 0x10000usize;
-        let mem_size = u64_to_usize(mem_size.unwrap_or(page_size as u64));
-        GuestMemoryMmap::from_raw_regions(&[(GuestAddress(0), mem_size)], false).unwrap()
-    }
+    use crate::utilities::test_utils::single_region_mem;
+    use crate::vstate::memory::{Bytes, GuestAddress, GuestMemoryMmap};
 
     fn read_u64(gm: &GuestMemoryMmap, offset: u64) -> u64 {
         let read_addr = GuestAddress(offset);
@@ -335,7 +331,7 @@ mod tests {
         let kvm = Kvm::new().unwrap();
         let vm = kvm.create_vm().unwrap();
         let vcpu = vm.create_vcpu(0).unwrap();
-        let gm = create_guest_mem(None);
+        let gm = single_region_mem(0x10000);
 
         vcpu.set_sregs(&Default::default()).unwrap();
         setup_sregs(&gm, &vcpu).unwrap();
@@ -352,7 +348,7 @@ mod tests {
     #[test]
     fn test_write_gdt_table() {
         // Not enough memory for the gdt table to be written.
-        let gm = create_guest_mem(Some(BOOT_GDT_OFFSET));
+        let gm = single_region_mem(BOOT_GDT_OFFSET as usize);
         let gdt_table: [u64; BOOT_GDT_MAX] = [
             gdt_entry(0, 0, 0),            // NULL
             gdt_entry(0xa09b, 0, 0xfffff), // CODE
@@ -362,9 +358,8 @@ mod tests {
         write_gdt_table(&gdt_table, &gm).unwrap_err();
 
         // We allocate exactly the amount needed to write four u64 to `BOOT_GDT_OFFSET`.
-        let gm = create_guest_mem(Some(
-            BOOT_GDT_OFFSET + (mem::size_of::<u64>() * BOOT_GDT_MAX) as u64,
-        ));
+        let gm =
+            single_region_mem(BOOT_GDT_OFFSET as usize + (mem::size_of::<u64>() * BOOT_GDT_MAX));
 
         let gdt_table: [u64; BOOT_GDT_MAX] = [
             gdt_entry(0, 0, 0),            // NULL
@@ -378,19 +373,19 @@ mod tests {
     #[test]
     fn test_write_idt_table() {
         // Not enough memory for the a u64 value to fit.
-        let gm = create_guest_mem(Some(BOOT_IDT_OFFSET));
+        let gm = single_region_mem(BOOT_IDT_OFFSET as usize);
         let val = 0x100;
         write_idt_value(val, &gm).unwrap_err();
 
-        let gm = create_guest_mem(Some(BOOT_IDT_OFFSET + mem::size_of::<u64>() as u64));
+        let gm = single_region_mem(BOOT_IDT_OFFSET as usize + mem::size_of::<u64>());
         // We have allocated exactly the amount neded to write an u64 to `BOOT_IDT_OFFSET`.
         write_idt_value(val, &gm).unwrap();
     }
 
     #[test]
     fn test_configure_segments_and_sregs() {
         let mut sregs: kvm_sregs = Default::default();
-        let gm = create_guest_mem(None);
+        let gm = single_region_mem(0x10000);
         configure_segments_and_sregs(&gm, &mut sregs).unwrap();
 
         validate_segments_and_sregs(&gm, &sregs);
@@ -399,16 +394,16 @@ mod tests {
     #[test]
     fn test_setup_page_tables() {
         let mut sregs: kvm_sregs = Default::default();
-        let gm = create_guest_mem(Some(PML4_START));
+        let gm = single_region_mem(PML4_START as usize);
         setup_page_tables(&gm, &mut sregs).unwrap_err();
 
-        let gm = create_guest_mem(Some(PDPTE_START));
+        let gm = single_region_mem(PDPTE_START as usize);
         setup_page_tables(&gm, &mut sregs).unwrap_err();
 
-        let gm = create_guest_mem(Some(PDE_START));
+        let gm = single_region_mem(PDE_START as usize);
         setup_page_tables(&gm, &mut sregs).unwrap_err();
 
-        let gm = create_guest_mem(None);
+        let gm = single_region_mem(0x10000);
         setup_page_tables(&gm, &mut sregs).unwrap();
 
         validate_page_tables(&gm, &sregs);