integrate vm-memory with dirty page tracking

src/arch/src/aarch64/fdt.rs

@@ -460,7 +460,8 @@ mod tests {
     #[test]
     fn test_create_fdt_with_devices() {
         let regions = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000);
-        let mem = GuestMemoryMmap::from_ranges(&regions).expect("Cannot initialize memory");
+        let mem = vm_memory::test_utils::create_anon_guest_memory(&regions, false)
+            .expect("Cannot initialize memory");
 
         let dev_info: HashMap<(DeviceType, std::string::String), MMIODeviceInfo> = [
             (
@@ -499,7 +500,8 @@ mod tests {
     #[test]
     fn test_create_fdt() {
         let regions = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000);
-        let mem = GuestMemoryMmap::from_ranges(&regions).expect("Cannot initialize memory");
+        let mem = vm_memory::test_utils::create_anon_guest_memory(&regions, false)
+            .expect("Cannot initialize memory");
         let kvm = Kvm::new().unwrap();
         let vm = kvm.create_vm().unwrap();
         let gic = create_gic(&vm, 1, None).unwrap();
@@ -557,7 +559,8 @@ mod tests {
     #[test]
     fn test_create_fdt_with_initrd() {
         let regions = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000);
-        let mem = GuestMemoryMmap::from_ranges(&regions).expect("Cannot initialize memory");
+        let mem = vm_memory::test_utils::create_anon_guest_memory(&regions, false)
+            .expect("Cannot initialize memory");
         let kvm = Kvm::new().unwrap();
         let vm = kvm.create_vm().unwrap();
         let gic = create_gic(&vm, 1, None).unwrap();

src/arch/src/aarch64/mod.rs

@@ -128,15 +128,18 @@ mod tests {
     #[test]
     fn test_get_fdt_addr() {
         let regions = arch_memory_regions(layout::FDT_MAX_SIZE - 0x1000);
-        let mem = GuestMemoryMmap::from_ranges(&regions).expect("Cannot initialize memory");
+        let mem = vm_memory::test_utils::create_anon_guest_memory(&regions, false)
+            .expect("Cannot initialize memory");
         assert_eq!(get_fdt_addr(&mem), layout::DRAM_MEM_START);
 
         let regions = arch_memory_regions(layout::FDT_MAX_SIZE);
-        let mem = GuestMemoryMmap::from_ranges(&regions).expect("Cannot initialize memory");
+        let mem = vm_memory::test_utils::create_anon_guest_memory(&regions, false)
+            .expect("Cannot initialize memory");
         assert_eq!(get_fdt_addr(&mem), layout::DRAM_MEM_START);
 
         let regions = arch_memory_regions(layout::FDT_MAX_SIZE + 0x1000);
-        let mem = GuestMemoryMmap::from_ranges(&regions).expect("Cannot initialize memory");
+        let mem = vm_memory::test_utils::create_anon_guest_memory(&regions, false)
+            .expect("Cannot initialize memory");
         assert_eq!(get_fdt_addr(&mem), 0x1000 + layout::DRAM_MEM_START);
     }
 }

src/arch/src/aarch64/regs.rs

@@ -461,7 +461,8 @@ mod tests {
         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_ranges(&regions).expect("Cannot initialize memory");
+        let mem = vm_memory::test_utils::create_anon_guest_memory(&regions, false)
+            .expect("Cannot initialize memory");
 
         let res = setup_boot_regs(&vcpu, 0, 0x0, &mem);
         assert!(res.is_err());

src/arch/src/x86_64/mod.rs

@@ -219,7 +219,9 @@ mod tests {
     #[test]
     fn test_system_configuration() {
         let no_vcpus = 4;
-        let gm = GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
+        let gm =
+            vm_memory::test_utils::create_anon_guest_memory(&[(GuestAddress(0), 0x10000)], false)
+                .unwrap();
         let config_err = configure_system(&gm, GuestAddress(0), 0, &None, 1);
         assert!(config_err.is_err());
         assert_eq!(
@@ -230,19 +232,19 @@ 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_ranges(&arch_mem_regions).unwrap();
+        let gm = vm_memory::test_utils::create_anon_guest_memory(&arch_mem_regions, false).unwrap();
         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_ranges(&arch_mem_regions).unwrap();
+        let gm = vm_memory::test_utils::create_anon_guest_memory(&arch_mem_regions, false).unwrap();
         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_ranges(&arch_mem_regions).unwrap();
+        let gm = vm_memory::test_utils::create_anon_guest_memory(&arch_mem_regions, false).unwrap();
         configure_system(&gm, GuestAddress(0), 0, &None, no_vcpus).unwrap();
     }
 

src/arch/src/x86_64/mptable.rs

@@ -307,10 +307,10 @@ mod tests {
     #[test]
     fn bounds_check() {
         let num_cpus = 4;
-        let mem = GuestMemoryMmap::from_ranges(&[(
-            GuestAddress(MPTABLE_START),
-            compute_mp_size(num_cpus),
-        )])
+        let mem = vm_memory::test_utils::create_guest_memory_unguarded(
+            &[(GuestAddress(MPTABLE_START), compute_mp_size(num_cpus))],
+            false,
+        )
         .unwrap();
 
         setup_mptable(&mem, num_cpus).unwrap();
@@ -319,10 +319,10 @@ mod tests {
     #[test]
     fn bounds_check_fails() {
         let num_cpus = 4;
-        let mem = GuestMemoryMmap::from_ranges(&[(
-            GuestAddress(MPTABLE_START),
-            compute_mp_size(num_cpus) - 1,
-        )])
+        let mem = vm_memory::test_utils::create_guest_memory_unguarded(
+            &[(GuestAddress(MPTABLE_START), compute_mp_size(num_cpus) - 1)],
+            false,
+        )
         .unwrap();
 
         assert!(setup_mptable(&mem, num_cpus).is_err());
@@ -331,10 +331,10 @@ mod tests {
     #[test]
     fn mpf_intel_checksum() {
         let num_cpus = 1;
-        let mem = GuestMemoryMmap::from_ranges(&[(
-            GuestAddress(MPTABLE_START),
-            compute_mp_size(num_cpus),
-        )])
+        let mem = vm_memory::test_utils::create_guest_memory_unguarded(
+            &[(GuestAddress(MPTABLE_START), compute_mp_size(num_cpus))],
+            false,
+        )
         .unwrap();
 
         setup_mptable(&mem, num_cpus).unwrap();
@@ -350,10 +350,10 @@ mod tests {
     #[test]
     fn mpc_table_checksum() {
         let num_cpus = 4;
-        let mem = GuestMemoryMmap::from_ranges(&[(
-            GuestAddress(MPTABLE_START),
-            compute_mp_size(num_cpus),
-        )])
+        let mem = vm_memory::test_utils::create_guest_memory_unguarded(
+            &[(GuestAddress(MPTABLE_START), compute_mp_size(num_cpus))],
+            false,
+        )
         .unwrap();
 
         setup_mptable(&mem, num_cpus).unwrap();
@@ -383,10 +383,13 @@ mod tests {
 
     #[test]
     fn cpu_entry_count() {
-        let mem = GuestMemoryMmap::from_ranges(&[(
-            GuestAddress(MPTABLE_START),
-            compute_mp_size(MAX_SUPPORTED_CPUS as u8),
-        )])
+        let mem = vm_memory::test_utils::create_guest_memory_unguarded(
+            &[(
+                GuestAddress(MPTABLE_START),
+                compute_mp_size(MAX_SUPPORTED_CPUS as u8),
+            )],
+            false,
+        )
         .unwrap();
 
         for i in 0..MAX_SUPPORTED_CPUS as u8 {
@@ -420,10 +423,10 @@ mod tests {
     #[test]
     fn cpu_entry_count_max() {
         let cpus = MAX_SUPPORTED_CPUS + 1;
-        let mem = GuestMemoryMmap::from_ranges(&[(
-            GuestAddress(MPTABLE_START),
-            compute_mp_size(cpus as u8),
-        )])
+        let mem = vm_memory::test_utils::create_guest_memory_unguarded(
+            &[(GuestAddress(MPTABLE_START), compute_mp_size(cpus as u8))],
+            false,
+        )
         .unwrap();
 
         let result = setup_mptable(&mem, cpus as u8).unwrap_err();

src/arch/src/x86_64/regs.rs

@@ -196,8 +196,18 @@ mod tests {
     use vm_memory::{Bytes, GuestAddress, GuestMemoryMmap};
 
     fn create_guest_mem(mem_size: Option<u64>) -> GuestMemoryMmap {
-        GuestMemoryMmap::from_ranges(&[(GuestAddress(0), mem_size.unwrap_or(0x10000) as usize)])
+        let page_size = 0x10000usize;
+        let mem_size = mem_size.unwrap_or(page_size as u64) as usize;
+        if mem_size % page_size == 0 {
+            vm_memory::test_utils::create_anon_guest_memory(&[(GuestAddress(0), mem_size)], false)
+                .unwrap()
+        } else {
+            vm_memory::test_utils::create_guest_memory_unguarded(
+                &[(GuestAddress(0), mem_size)],
+                false,
+            )
             .unwrap()
+        }
     }
 
     fn read_u64(gm: &GuestMemoryMmap, offset: u64) -> u64 {

src/devices/src/virtio/balloon/device.rs

@@ -1021,7 +1021,13 @@ pub(crate) mod tests {
         // Assert that we can't update an inactive device.
         assert!(balloon.update_size(1).is_err());
         // Switch the state to active.
-        balloon.device_state = DeviceState::Activated(GuestMemoryMmap::new());
+        balloon.device_state = DeviceState::Activated(
+            vm_memory::test_utils::create_guest_memory_unguarded(
+                &[(GuestAddress(0x0), 0x1)],
+                false,
+            )
+            .unwrap(),
+        );
 
         assert_eq!(balloon.num_pages(), 0);
         assert_eq!(balloon.actual_pages(), 0);

src/devices/src/virtio/balloon/utils.rs

@@ -179,7 +179,11 @@ mod tests {
     #[test]
     fn test_remove_range() {
         let page_size: usize = 0x1000;
-        let mem = GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 2 * page_size)]).unwrap();
+        let mem = vm_memory::test_utils::create_anon_guest_memory(
+            &[(GuestAddress(0), 2 * page_size)],
+            false,
+        )
+        .unwrap();
 
         // Fill the memory with ones.
         let ones = vec![1u8; 2 * page_size];
@@ -223,7 +227,11 @@ mod tests {
     #[test]
     fn test_remove_range_on_restored() {
         let page_size: usize = 0x1000;
-        let mem = GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 2 * page_size)]).unwrap();
+        let mem = vm_memory::test_utils::create_anon_guest_memory(
+            &[(GuestAddress(0), 2 * page_size)],
+            false,
+        )
+        .unwrap();
 
         // Fill the memory with ones.
         let ones = vec![1u8; 2 * page_size];

src/devices/src/virtio/block/request.rs

@@ -332,13 +332,13 @@ mod tests {
 
     use crate::virtio::queue::tests::*;
     use crate::virtio::test_utils::{VirtQueue, VirtqDesc};
-    use vm_memory::{Address, GuestAddress, GuestMemory};
+    use vm_memory::{test_utils::create_anon_guest_memory, Address, GuestAddress, GuestMemory};
 
     const NUM_DISK_SECTORS: u64 = 1024;
 
     #[test]
     fn test_read_request_header() {
-        let mem = GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x1000)]).unwrap();
+        let mem = create_anon_guest_memory(&[(GuestAddress(0), 0x1000)], false).unwrap();
         let addr = GuestAddress(0);
         let sector = 123_454_321;
 
@@ -539,7 +539,7 @@ mod tests {
 
     #[test]
     fn test_parse_generic() {
-        let mem = &GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
+        let mem = &create_anon_guest_memory(&[(GuestAddress(0), 0x10000)], false).unwrap();
         let mut queue = RequestVirtQueue::new(GuestAddress(0), &mem);
 
         // Write only request type descriptor.
@@ -589,7 +589,7 @@ mod tests {
 
     #[test]
     fn test_parse_in() {
-        let mem = &GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
+        let mem = &create_anon_guest_memory(&[(GuestAddress(0), 0x10000)], false).unwrap();
         let mut queue = RequestVirtQueue::new(GuestAddress(0), &mem);
 
         let request_header = RequestHeader::new(VIRTIO_BLK_T_IN, 99);
@@ -620,7 +620,7 @@ mod tests {
 
     #[test]
     fn test_parse_out() {
-        let mem = &GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
+        let mem = &create_anon_guest_memory(&[(GuestAddress(0), 0x10000)], false).unwrap();
         let mut queue = RequestVirtQueue::new(GuestAddress(0), &mem);
 
         let request_header = RequestHeader::new(VIRTIO_BLK_T_OUT, 100);
@@ -648,7 +648,7 @@ mod tests {
 
     #[test]
     fn test_parse_flush() {
-        let mem = &GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
+        let mem = &create_anon_guest_memory(&[(GuestAddress(0), 0x10000)], false).unwrap();
         let mut queue = RequestVirtQueue::new(GuestAddress(0), &mem);
 
         // Flush request with a data descriptor.
@@ -668,7 +668,7 @@ mod tests {
 
     #[test]
     fn test_parse_get_id() {
-        let mem = &GuestMemoryMmap::from_ranges(&[(GuestAddress(0), 0x10000)]).unwrap();
+        let mem = &create_anon_guest_memory(&[(GuestAddress(0), 0x10000)], false).unwrap();
         let mut queue = RequestVirtQueue::new(GuestAddress(0), &mem);
 
         let request_header = RequestHeader::new(VIRTIO_BLK_T_GET_ID, 15);
@@ -830,10 +830,13 @@ mod tests {
         let status_addr = data_addr.checked_add(next_desc_dist).unwrap();
 
         let mem_end = status_addr.checked_add(max_desc_len).unwrap();
-        let mem: GuestMemoryMmap = GuestMemoryMmap::from_ranges(&[(
-            GuestAddress(base_addr),
-            (mem_end.0 - base_addr).try_into().unwrap(),
-        )])
+        let mem: GuestMemoryMmap = create_anon_guest_memory(
+            &[(
+                GuestAddress(base_addr),
+                (mem_end.0 - base_addr).try_into().unwrap(),
+            )],
+            false,
+        )
         .unwrap();
 
         let mut rq = RequestVirtQueue::new(GuestAddress(base_addr), &mem);