refactor: vmm: remove redundant allocate_system_memory wrapper

Following same logic from previous commit, remove this wrapper as well.

Signed-off-by: Egor Lazarchuk <yegorlz@amazon.co.uk>

Author: ShadowCurse

src/vmm/src/acpi/mod.rs

@@ -60,11 +60,10 @@ impl AcpiTableWriter<'_> {
     where
         S: Sdt,
     {
-        let addr = resource_allocator.allocate_system_memory(
-            table.len().try_into().unwrap(),
-            1,
-            AllocPolicy::FirstMatch,
-        )?;
+        let addr = resource_allocator
+            .system_memory
+            .allocate(table.len().try_into().unwrap(), 1, AllocPolicy::FirstMatch)?
+            .start();
 
         table
             .write_to_guest(self.mem, GuestAddress(addr))

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

@@ -124,8 +124,10 @@ pub fn setup_mptable(
     }
 
     let mp_size = compute_mp_size(num_cpus);
-    let mptable_addr =
-        resource_allocator.allocate_system_memory(mp_size as u64, 1, AllocPolicy::FirstMatch)?;
+    let mptable_addr = resource_allocator
+        .system_memory
+        .allocate(mp_size as u64, 1, AllocPolicy::FirstMatch)?
+        .start();
     debug!(
         "mptable: Allocated {mp_size} bytes for MPTable {num_cpus} vCPUs at address {:#010x}",
         mptable_addr

src/vmm/src/builder.rs

@@ -568,8 +568,10 @@ fn allocate_pvtime_region(
 ) -> Result<GuestAddress, StartMicrovmError> {
     let size = STEALTIME_STRUCT_MEM_SIZE * vcpu_count as u64;
     let addr = resource_allocator
-        .allocate_system_memory(size, STEALTIME_STRUCT_MEM_SIZE, policy)
-        .map_err(StartMicrovmError::AllocateResources)?;
+        .system_memory
+        .allocate(size, STEALTIME_STRUCT_MEM_SIZE, policy)
+        .map_err(StartMicrovmError::AllocateResources)?
+        .start();
     Ok(GuestAddress(addr))
 }
 

src/vmm/src/devices/acpi/vmclock.rs

@@ -77,12 +77,14 @@ impl VmClock {
     /// Create a new [`VmClock`] device for a newly booted VM
     pub fn new(resource_allocator: &mut ResourceAllocator) -> Result<VmClock, VmClockError> {
         let addr = resource_allocator
-            .allocate_system_memory(
+            .system_memory
+            .allocate(
                 VMCLOCK_SIZE as u64,
                 VMCLOCK_SIZE as u64,
                 AllocPolicy::LastMatch,
             )
-            .map_err(VmClockError::AllocateMemory)?;
+            .map_err(VmClockError::AllocateMemory)?
+            .start();
 
         let gsi = resource_allocator
             .allocate_gsi_legacy(1)

src/vmm/src/devices/acpi/vmgenid.rs

@@ -84,8 +84,10 @@ impl VmGenId {
             .map_err(VmGenIdError::AllocateGsi)?[0];
         // The generation ID needs to live in an 8-byte aligned buffer
         let addr = resource_allocator
-            .allocate_system_memory(VMGENID_MEM_SIZE, 8, vm_allocator::AllocPolicy::LastMatch)
-            .map_err(VmGenIdError::AllocateMemory)?;
+            .system_memory
+            .allocate(VMGENID_MEM_SIZE, 8, vm_allocator::AllocPolicy::LastMatch)
+            .map_err(VmGenIdError::AllocateMemory)?
+            .start();
 
         Self::from_parts(GuestAddress(addr), gsi)
     }

src/vmm/src/vstate/resources.rs

@@ -108,27 +108,6 @@ impl ResourceAllocator {
     pub fn allocate_gsi_msi(&mut self, gsi_count: u32) -> Result<Vec<u32>, vm_allocator::Error> {
         allocate_many_ids(&mut self.gsi_msi_allocator, gsi_count)
     }
-
-    /// Allocate a memory range for system data
-    ///
-    /// If it succeeds, it returns the first address of the allocated range
-    ///
-    /// # Arguments
-    ///
-    /// * `size` - The size in bytes of the memory to allocate
-    /// * `alignment` - The alignment of the address of the first byte
-    /// * `policy` - A [`vm_allocator::AllocPolicy`] variant for determining the allocation policy
-    pub fn allocate_system_memory(
-        &mut self,
-        size: u64,
-        alignment: u64,
-        policy: AllocPolicy,
-    ) -> Result<u64, vm_allocator::Error> {
-        Ok(self
-            .system_memory
-            .allocate(size, alignment, policy)?
-            .start())
-    }
 }
 
 impl<'a> Persist<'a> for ResourceAllocator {
@@ -150,8 +129,6 @@ impl<'a> Persist<'a> for ResourceAllocator {
 
 #[cfg(test)]
 mod tests {
-    use vm_allocator::AllocPolicy;
-
     use super::ResourceAllocator;
     use crate::arch::{self, GSI_LEGACY_NUM, GSI_LEGACY_START, GSI_MSI_NUM, GSI_MSI_START};
     use crate::snapshot::Persist;
@@ -263,23 +240,11 @@ mod tests {
         assert_eq!(irq_1, GSI_LEGACY_START + 1);
         let gsi_1 = allocator1.allocate_gsi_msi(1).unwrap()[0];
         assert_eq!(gsi_1, GSI_MSI_START + 1);
-        let system_mem = allocator1
-            .allocate_system_memory(0x42, 1, AllocPolicy::FirstMatch)
-            .unwrap();
-        assert_eq!(system_mem, arch::SYSTEM_MEM_START);
 
         let mut allocator2 = clone_allocator(&allocator1);
-        allocator2
-            .allocate_system_memory(0x42, 1, AllocPolicy::ExactMatch(system_mem))
-            .unwrap_err();
-
         let irq_2 = allocator2.allocate_gsi_legacy(1).unwrap()[0];
         assert_eq!(irq_2, GSI_LEGACY_START + 2);
         let gsi_2 = allocator2.allocate_gsi_msi(1).unwrap()[0];
         assert_eq!(gsi_2, GSI_MSI_START + 2);
-        let system_mem = allocator1
-            .allocate_system_memory(0x42, 1, AllocPolicy::FirstMatch)
-            .unwrap();
-        assert_eq!(system_mem, arch::SYSTEM_MEM_START + 0x42);
     }
 }