feat(virtio-mem): add static allocation of hotpluggable memory

Allocate the memory that will be used for hotplugging. Initially, this
memory will be registered with KVM, but that will change later when we
add dynamic slot support.

Signed-off-by: Riccardo Mancini <[email protected]>

Author: Manciukic

src/vmm/src/builder.rs

@@ -32,7 +32,7 @@ use crate::device_manager::{
 use crate::devices::acpi::vmgenid::VmGenIdError;
 use crate::devices::virtio::balloon::Balloon;
 use crate::devices::virtio::block::device::Block;
-use crate::devices::virtio::mem::VirtioMem;
+use crate::devices::virtio::mem::{VIRTIO_MEM_GUEST_ADDRESS, VirtioMem};
 use crate::devices::virtio::net::Net;
 use crate::devices::virtio::rng::Entropy;
 use crate::devices::virtio::vsock::{Vsock, VsockUnixBackend};
@@ -44,6 +44,7 @@ use crate::persist::{MicrovmState, MicrovmStateError};
 use crate::resources::VmResources;
 use crate::seccomp::BpfThreadMap;
 use crate::snapshot::Persist;
+use crate::utils::mib_to_bytes;
 use crate::vmm_config::instance_info::InstanceInfo;
 use crate::vmm_config::machine_config::MachineConfigError;
 use crate::vmm_config::memory_hotplug::MemoryHotplugConfig;
@@ -172,6 +173,18 @@ pub fn build_microvm_for_boot(
     let (mut vcpus, vcpus_exit_evt) = vm.create_vcpus(vm_resources.machine_config.vcpu_count)?;
     vm.register_dram_memory_regions(guest_memory)?;
 
+    // Allocate memory as soon as possible to make hotpluggable memory available to all consumers,
+    // before they clone the GuestMemoryMmap object
+    if let Some(memory_hotplug) = &vm_resources.memory_hotplug {
+        let hotplug_memory_region = vm_resources
+            .allocate_memory_region(
+                VIRTIO_MEM_GUEST_ADDRESS,
+                mib_to_bytes(memory_hotplug.total_size_mib),
+            )
+            .map_err(StartMicrovmError::GuestMemory)?;
+        vm.register_hotpluggable_memory_region(hotplug_memory_region)?;
+    }
+
     let mut device_manager = DeviceManager::new(
         event_manager,
         &vcpus_exit_evt,

src/vmm/src/resources.rs

@@ -536,6 +536,18 @@ impl VmResources {
             crate::arch::arch_memory_regions(mib_to_bytes(self.machine_config.mem_size_mib));
         self.allocate_memory_regions(&regions)
     }
+
+    /// Allocates a single guest memory region.
+    pub fn allocate_memory_region(
+        &self,
+        start: GuestAddress,
+        size: usize,
+    ) -> Result<GuestRegionMmap, MemoryError> {
+        Ok(self
+            .allocate_memory_regions(&[(start, size)])?
+            .pop()
+            .unwrap())
+    }
 }
 
 impl From<&VmResources> for VmmConfig {

src/vmm/src/vstate/memory.rs

@@ -57,6 +57,8 @@ pub enum MemoryError {
 pub enum GuestRegionType {
     /// Guest DRAM
     Dram,
+    /// Hotpluggable memory
+    Hotpluggable,
 }
 
 /// An extension to GuestMemoryRegion that stores the type of region, and the KVM slot
@@ -80,6 +82,14 @@ impl GuestRegionMmapExt {
         }
     }
 
+    pub(crate) fn hotpluggable_from_mmap_region(region: GuestRegionMmap, slot: u32) -> Self {
+        GuestRegionMmapExt {
+            inner: region,
+            region_type: GuestRegionType::Hotpluggable,
+            slot,
+        }
+    }
+
     pub(crate) fn from_state(
         region: GuestRegionMmap,
         state: &GuestMemoryRegionState,

src/vmm/src/vstate/vm.rs

@@ -222,6 +222,19 @@ impl Vm {
         Ok(())
     }
 
+    /// Register a new hotpluggable region to this [`Vm`].
+    pub fn register_hotpluggable_memory_region(
+        &mut self,
+        region: GuestRegionMmap,
+    ) -> Result<(), VmError> {
+        let arcd_region = Arc::new(GuestRegionMmapExt::hotpluggable_from_mmap_region(
+            region,
+            self.allocate_slot_ids(1)?,
+        ));
+
+        self._register_memory_region(arcd_region)
+    }
+
     /// Register a list of new memory regions to this [`Vm`].
     ///
     /// Note: regions and state.regions need to be in the same order.