refactor: vmm: remove redundant allocate_32bit_mmio_memory wrapper

This wrapper was used only once in the code and it generally does not
follow the patter of using underlying allocators directly like the rest
of the code does.

The alternative to removing this is to do a exact opposite and find all
places where allocators are used directly and make them use wrappers.
This will not provide any benefits since wrappers have no logic in them
and will only increase the line count and indirection overhead.

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

Author: ShadowCurse

src/vmm/src/device_manager/mmio.rs

@@ -161,12 +161,13 @@ impl MMIODeviceManager {
             _ => return Err(MmioError::InvalidIrqConfig),
         };
 
+        let range = resource_allocator.mmio32_memory.allocate(
+            MMIO_LEN,
+            MMIO_LEN,
+            AllocPolicy::FirstMatch,
+        )?;
         let device_info = MMIODeviceInfo {
-            addr: resource_allocator.allocate_32bit_mmio_memory(
-                MMIO_LEN,
-                MMIO_LEN,
-                AllocPolicy::FirstMatch,
-            )?,
+            addr: range.start(),
             len: MMIO_LEN,
             gsi,
         };

src/vmm/src/vstate/resources.rs

@@ -109,27 +109,6 @@ impl ResourceAllocator {
         allocate_many_ids(&mut self.gsi_msi_allocator, gsi_count)
     }
 
-    /// Allocate a memory range in 32-bit MMIO address space
-    ///
-    /// 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_32bit_mmio_memory(
-        &mut self,
-        size: u64,
-        alignment: u64,
-        policy: AllocPolicy,
-    ) -> Result<u64, vm_allocator::Error> {
-        Ok(self
-            .mmio32_memory
-            .allocate(size, alignment, policy)?
-            .start())
-    }
-
     /// Allocate a memory range in 64-bit MMIO address space
     ///
     /// If it succeeds, it returns the first address of the allocated range
@@ -305,10 +284,6 @@ 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 mmio32_mem = allocator1
-            .allocate_32bit_mmio_memory(0x42, 1, AllocPolicy::FirstMatch)
-            .unwrap();
-        assert_eq!(mmio32_mem, arch::MEM_32BIT_DEVICES_START);
         let mmio64_mem = allocator1
             .allocate_64bit_mmio_memory(0x42, 1, AllocPolicy::FirstMatch)
             .unwrap();
@@ -319,9 +294,6 @@ mod tests {
         assert_eq!(system_mem, arch::SYSTEM_MEM_START);
 
         let mut allocator2 = clone_allocator(&allocator1);
-        allocator2
-            .allocate_32bit_mmio_memory(0x42, 1, AllocPolicy::ExactMatch(mmio32_mem))
-            .unwrap_err();
         allocator2
             .allocate_64bit_mmio_memory(0x42, 1, AllocPolicy::ExactMatch(mmio64_mem))
             .unwrap_err();
@@ -333,10 +305,6 @@ mod tests {
         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 mmio32_mem = allocator1
-            .allocate_32bit_mmio_memory(0x42, 1, AllocPolicy::FirstMatch)
-            .unwrap();
-        assert_eq!(mmio32_mem, arch::MEM_32BIT_DEVICES_START + 0x42);
         let mmio64_mem = allocator1
             .allocate_64bit_mmio_memory(0x42, 1, AllocPolicy::FirstMatch)
             .unwrap();

src/vmm/src/vstate/vm.rs

@@ -1084,9 +1084,10 @@ pub(crate) mod tests {
 
             let gsi = resource_allocator.allocate_gsi_msi(1).unwrap()[0];
             let range = resource_allocator
-                .allocate_32bit_mmio_memory(1024, 1024, AllocPolicy::FirstMatch)
+                .mmio32_memory
+                .allocate(1024, 1024, AllocPolicy::FirstMatch)
                 .unwrap();
-            (gsi, range)
+            (gsi, range.start())
         };
 
         let state = vm.save_state().unwrap();
@@ -1100,11 +1101,13 @@ pub(crate) mod tests {
         assert_eq!(gsi + 1, gsi_new);
 
         resource_allocator
-            .allocate_32bit_mmio_memory(1024, 1024, AllocPolicy::ExactMatch(range))
+            .mmio32_memory
+            .allocate(1024, 1024, AllocPolicy::ExactMatch(range))
             .unwrap_err();
         let range_new = resource_allocator
-            .allocate_32bit_mmio_memory(1024, 1024, AllocPolicy::FirstMatch)
+            .mmio32_memory
+            .allocate(1024, 1024, AllocPolicy::FirstMatch)
             .unwrap();
-        assert_eq!(range + 1024, range_new);
+        assert_eq!(range + 1024, range_new.start());
     }
 }