Add vCPU hotplug controller and extend GED

Define new ACPI devices related to hotplugging, including a hotplug
controller, a CPU container, and individual CPU devices. Add hotplugging
devices to GED.

Signed-off-by: James Curtis <[email protected]>

Author: JamesC1305

src/vmm/src/builder.rs

@@ -29,6 +29,8 @@ use vm_superio::Serial;
 
 #[cfg(target_arch = "x86_64")]
 use crate::acpi;
+#[cfg(target_arch = "x86_64")]
+use crate::arch::DeviceType;
 use crate::arch::InitrdConfig;
 #[cfg(target_arch = "aarch64")]
 use crate::construct_kvm_mpidrs;
@@ -48,6 +50,8 @@ use crate::device_manager::persist::{
 };
 use crate::device_manager::resources::ResourceAllocator;
 #[cfg(target_arch = "x86_64")]
+use crate::devices::acpi::cpu_container::{CpuContainer, CpuContainerError};
+#[cfg(target_arch = "x86_64")]
 use crate::devices::acpi::vmgenid::{VmGenId, VmGenIdError};
 use crate::devices::legacy::serial::SerialOut;
 #[cfg(target_arch = "aarch64")]
@@ -96,6 +100,9 @@ pub enum StartMicrovmError {
     /// Error creating VMGenID device: {0}
     #[cfg(target_arch = "x86_64")]
     CreateVMGenID(VmGenIdError),
+    /// Error creating CpuContainer device: {0}
+    #[cfg(target_arch = "x86_64")]
+    CreateCpuContainer(#[from] CpuContainerError),
     /// Invalid Memory Configuration: {0}
     GuestMemory(crate::vstate::memory::MemoryError),
     /// Cannot load initrd due to an invalid memory configuration.
@@ -156,6 +163,7 @@ fn create_vmm_and_vcpus(
     vcpu_count: u8,
     #[cfg(target_arch = "x86_64")] seccomp_filters: BpfThreadMap,
     kvm_capabilities: Vec<KvmCapability>,
+    boot_timer_enabled: bool,
 ) -> Result<(Vmm, Vec<Vcpu>), StartMicrovmError> {
     use self::StartMicrovmError::*;
 
@@ -172,14 +180,28 @@ fn create_vmm_and_vcpus(
         .map_err(VmmError::EventFd)
         .map_err(Internal)?;
 
-    let resource_allocator = ResourceAllocator::new()?;
+    let mut resource_allocator = ResourceAllocator::new()?;
 
     // Instantiate the MMIO device manager.
-    let mmio_device_manager = MMIODeviceManager::new();
+    let mut mmio_device_manager = MMIODeviceManager::new();
+
+    if boot_timer_enabled {
+        let boot_timer = crate::devices::pseudo::BootTimer::new(TimestampUs::default());
+
+        mmio_device_manager
+            .register_mmio_boot_timer(&mut resource_allocator, boot_timer)
+            .map_err(RegisterMmioDevice)?;
+    }
 
     // Instantiate ACPI device manager.
     #[cfg(target_arch = "x86_64")]
-    let acpi_device_manager = ACPIDeviceManager::new();
+    let acpi_device_manager = {
+        let cpu_container = Arc::new(Mutex::new(CpuContainer::new(
+            &mut resource_allocator,
+            vcpu_count,
+        )?));
+        ACPIDeviceManager::new(cpu_container)
+    };
 
     // For x86_64 we need to create the interrupt controller before calling `KVM_CREATE_VCPUS`
     // while on aarch64 we need to do it the other way around.
@@ -317,14 +339,18 @@ pub fn build_microvm_for_boot(
         #[cfg(target_arch = "x86_64")]
         seccomp_filters.clone(),
         cpu_template.kvm_capabilities.clone(),
+        vm_resources.boot_timer,
     )?;
 
     // The boot timer device needs to be the first device attached in order
     // to maintain the same MMIO address referenced in the documentation
     // and tests.
-    if vm_resources.boot_timer {
-        attach_boot_timer_device(&mut vmm, request_ts)?;
-    }
+    // if vm_resources.boot_timer {
+    //     attach_boot_timer_device(&mut vmm, request_ts)?;
+    // }
+
+    #[cfg(target_arch = "x86_64")]
+    attach_cpu_container_device(&mut vmm)?;
 
     if let Some(balloon) = vm_resources.balloon.get() {
         attach_balloon_device(&mut vmm, &mut boot_cmdline, balloon, event_manager)?;
@@ -488,6 +514,7 @@ pub fn build_microvm_from_snapshot(
         #[cfg(target_arch = "x86_64")]
         seccomp_filters.clone(),
         microvm_state.vm_state.kvm_cap_modifiers.clone(),
+        vm_resources.boot_timer,
     )?;
 
     #[cfg(target_arch = "x86_64")]
@@ -1048,6 +1075,8 @@ pub mod tests {
     use super::*;
     use crate::arch::DeviceType;
     use crate::device_manager::resources::ResourceAllocator;
+    #[cfg(target_arch = "x86_64")]
+    use crate::devices::acpi::cpu_container::CpuContainer;
     use crate::devices::virtio::block::CacheType;
     use crate::devices::virtio::rng::device::ENTROPY_DEV_ID;
     use crate::devices::virtio::vsock::{TYPE_VSOCK, VSOCK_DEV_ID};
@@ -1126,9 +1155,27 @@ pub mod tests {
 
         let mut vm = Vm::new(vec![]).unwrap();
         vm.memory_init(&guest_memory, false).unwrap();
+
+        #[cfg(target_arch = "x86_64")]
+        let mut resource_allocator = ResourceAllocator::new().unwrap();
+        #[cfg(target_arch = "aarch64")]
+        let resource_allocator = ResourceAllocator::new().unwrap();
+
         let mmio_device_manager = MMIODeviceManager::new();
+
+        #[cfg(target_arch = "x86_64")]
+        setup_interrupt_controller(&mut vm).unwrap();
+
         #[cfg(target_arch = "x86_64")]
-        let acpi_device_manager = ACPIDeviceManager::new();
+        let acpi_device_manager = {
+            let cpu_container = Arc::new(Mutex::new(
+                CpuContainer::new(&mut resource_allocator, 1)
+                    .map_err(StartMicrovmError::CreateCpuContainer)
+                    .unwrap(),
+            ));
+            ACPIDeviceManager::new(cpu_container)
+        };
+
         #[cfg(target_arch = "x86_64")]
         let pio_device_manager = PortIODeviceManager::new(
             Arc::new(Mutex::new(SerialWrapper {
@@ -1145,9 +1192,6 @@ pub mod tests {
         )
         .unwrap();
 
-        #[cfg(target_arch = "x86_64")]
-        setup_interrupt_controller(&mut vm).unwrap();
-
         #[cfg(target_arch = "aarch64")]
         {
             let exit_evt = EventFd::new(libc::EFD_NONBLOCK).unwrap();
@@ -1166,7 +1210,7 @@ pub mod tests {
             vcpus_exit_evt,
             #[cfg(target_arch = "x86_64")]
             seccomp_filters: crate::seccomp_filters::get_empty_filters(),
-            resource_allocator: ResourceAllocator::new().unwrap(),
+            resource_allocator,
             mmio_device_manager,
             #[cfg(target_arch = "x86_64")]
             pio_device_manager,

src/vmm/src/device_manager/acpi.rs

@@ -1,21 +1,28 @@
 // Copyright 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::sync::{Arc, Mutex};
+
 use acpi_tables::{aml, Aml};
 use kvm_ioctls::VmFd;
 
+use crate::devices::acpi::cpu_container::CpuContainer;
 use crate::devices::acpi::vmgenid::VmGenId;
 
 #[derive(Debug)]
 pub struct ACPIDeviceManager {
     /// VMGenID device
     pub vmgenid: Option<VmGenId>,
+    pub cpu_container: Arc<Mutex<CpuContainer>>,
 }
 
 impl ACPIDeviceManager {
     /// Create a new ACPIDeviceManager object
-    pub fn new() -> Self {
-        Self { vmgenid: None }
+    pub fn new(cpu_container: Arc<Mutex<CpuContainer>>) -> Self {
+        Self {
+            vmgenid: None,
+            cpu_container,
+        }
     }
 
     /// Attach a new VMGenID device to the microVM
@@ -31,6 +38,14 @@ impl ACPIDeviceManager {
         Ok(())
     }
 
+    pub fn notify_cpu_container(&mut self) -> Result<(), std::io::Error> {
+        self.cpu_container
+            .lock()
+            .expect("Poisoned lock")
+            .notify_guest()?;
+        Ok(())
+    }
+
     /// If it exists, notify guest VMGenID device that we have resumed from a snapshot.
     pub fn notify_vmgenid(&mut self) -> Result<(), std::io::Error> {
         if let Some(vmgenid) = &mut self.vmgenid {
@@ -42,44 +57,89 @@ impl ACPIDeviceManager {
 
 impl Aml for ACPIDeviceManager {
     fn append_aml_bytes(&self, v: &mut Vec<u8>) {
-        // If we have a VMGenID device, create the AML for the device and GED interrupt handler
-        self.vmgenid.as_ref().inspect(|vmgenid| {
-            // AML for GED
-            aml::Device::new(
-                "_SB_.GED_".into(),
-                vec![
-                    &aml::Name::new("_HID".into(), &"ACPI0013"),
-                    &aml::Name::new(
-                        "_CRS".into(),
-                        &aml::ResourceTemplate::new(vec![&aml::Interrupt::new(
+        // Depending on what devices are available, generate AML for GED.
+        let locked_container = self.cpu_container.lock().expect("Poisoned lock");
+        match self.vmgenid.as_ref() {
+            Some(vmgenid) => {
+                aml::Device::new(
+                    "_SB_.GED_".into(),
+                    vec![
+                        &aml::Name::new("_HID".into(), &"ACPI0013"),
+                        &aml::Name::new(
+                            "_CRS".into(),
+                            &aml::ResourceTemplate::new(vec![
+                                &aml::Interrupt::new(
+                                    true,
+                                    true,
+                                    false,
+                                    false,
+                                    locked_container.gsi,
+                                ),
+                                &aml::Interrupt::new(true, true, false, false, vmgenid.gsi),
+                            ]),
+                        ),
+                        &aml::Method::new(
+                            "_EVT".into(),
+                            1,
                             true,
+                            vec![
+                                &aml::If::new(
+                                    #[allow(clippy::cast_possible_truncation)]
+                                    &aml::Equal::new(&aml::Arg(0), &(locked_container.gsi as u8)),
+                                    vec![&aml::MethodCall::new(
+                                        aml::Path::new("\\_SB_.CPUS.CSCN"),
+                                        vec![],
+                                    )],
+                                ),
+                                &aml::If::new(
+                                    #[allow(clippy::cast_possible_truncation)]
+                                    &aml::Equal::new(&aml::Arg(0), &(vmgenid.gsi as u8)),
+                                    vec![&aml::Notify::new(
+                                        &aml::Path::new("\\_SB_.VGEN"),
+                                        &0x80usize,
+                                    )],
+                                ),
+                            ],
+                        ),
+                    ],
+                )
+                .append_aml_bytes(v);
+                locked_container.append_aml_bytes(v);
+                vmgenid.append_aml_bytes(v);
+            }
+            None => {
+                aml::Device::new(
+                    "_SB_.GED_".into(),
+                    vec![
+                        &aml::Name::new("_HID".into(), &"ACPI0013"),
+                        &aml::Name::new(
+                            "_CRS".into(),
+                            &aml::ResourceTemplate::new(vec![&aml::Interrupt::new(
+                                true,
+                                true,
+                                false,
+                                false,
+                                locked_container.gsi,
+                            )]),
+                        ),
+                        &aml::Method::new(
+                            "_EVT".into(),
+                            1,
                             true,
-                            false,
-                            false,
-                            vmgenid.gsi,
-                        )]),
-                    ),
-                    &aml::Method::new(
-                        "_EVT".into(),
-                        1,
-                        true,
-                        vec![&aml::If::new(
-                            // We know that the maximum IRQ number fits in a u8. We have up to 32
-                            // IRQs in x86 and up to 128 in ARM (look into
-                            // `vmm::crate::arch::layout::IRQ_MAX`)
-                            #[allow(clippy::cast_possible_truncation)]
-                            &aml::Equal::new(&aml::Arg(0), &(vmgenid.gsi as u8)),
-                            vec![&aml::Notify::new(
-                                &aml::Path::new("\\_SB_.VGEN"),
-                                &0x80usize,
+                            vec![&aml::If::new(
+                                #[allow(clippy::cast_possible_truncation)]
+                                &aml::Equal::new(&aml::Arg(0), &(locked_container.gsi as u8)),
+                                vec![&aml::MethodCall::new(
+                                    aml::Path::new("\\_SB_.CPUS.CSCN"),
+                                    vec![],
+                                )],
                             )],
-                        )],
-                    ),
-                ],
-            )
-            .append_aml_bytes(v);
-            // AML for VMGenID itself.
-            vmgenid.append_aml_bytes(v);
-        });
+                        ),
+                    ],
+                )
+                .append_aml_bytes(v);
+                locked_container.append_aml_bytes(v);
+            }
+        }
     }
 }

src/vmm/src/device_manager/persist.rs

@@ -19,6 +19,8 @@ use super::resources::ResourceAllocator;
 #[cfg(target_arch = "aarch64")]
 use crate::arch::DeviceType;
 #[cfg(target_arch = "x86_64")]
+use crate::devices::acpi::cpu_container::CpuContainer;
+#[cfg(target_arch = "x86_64")]
 use crate::devices::acpi::vmgenid::{VMGenIDState, VMGenIdConstructorArgs, VmGenId, VmGenIdError};
 use crate::devices::virtio::balloon::persist::{BalloonConstructorArgs, BalloonState};
 use crate::devices::virtio::balloon::{Balloon, BalloonError};
@@ -241,6 +243,7 @@ pub struct ACPIDeviceManagerConstructorArgs<'a> {
     pub mem: &'a GuestMemoryMmap,
     pub resource_allocator: &'a mut ResourceAllocator,
     pub vm: &'a VmFd,
+    pub cpu_container: Arc<Mutex<CpuContainer>>,
 }
 
 #[cfg(target_arch = "x86_64")]
@@ -268,7 +271,7 @@ impl<'a> Persist<'a> for ACPIDeviceManager {
         constructor_args: Self::ConstructorArgs,
         state: &Self::State,
     ) -> std::result::Result<Self, Self::Error> {
-        let mut dev_manager = ACPIDeviceManager::new();
+        let mut dev_manager = ACPIDeviceManager::new(constructor_args.cpu_container.clone());
         if let Some(vmgenid_args) = &state.vmgenid {
             let vmgenid = VmGenId::restore(
                 VMGenIdConstructorArgs {