Use BootTimer to measure hotplug latency

Change the boot timer timestamp to be public, so that the timer can also
be used for measuring hotplugging

Signed-off-by: James Curtis <jxcurtis@amazon.co.uk>

Author: JamesC1305

src/vmm/src/devices/pseudo/boot_timer.rs

@@ -10,7 +10,7 @@ const MAGIC_VALUE_SIGNAL_GUEST_BOOT_COMPLETE: u8 = 123;
 /// Pseudo device to record the kernel boot time.
 #[derive(Debug)]
 pub struct BootTimer {
-    start_ts: TimestampUs,
+    pub start_ts: TimestampUs,
 }
 
 impl BootTimer {

src/vmm/src/lib.rs

@@ -600,6 +600,92 @@ impl Vmm {
         Ok(cpu_configs)
     }
 
+    /// Adds new vCPUs to VMM.
+    #[cfg(target_arch = "x86_64")]
+    pub fn hotplug_vcpus(
+        &mut self,
+        config: HotplugVcpuConfig,
+    ) -> Result<MachineConfigUpdate, HotplugVcpuError> {
+        use crate::logger::IncMetric;
+        if config.add < 1 {
+            return Err(HotplugVcpuError::VcpuCountTooLow);
+        } else if self
+            .vcpus_handles
+            .len()
+            .checked_add(config.add.into())
+            .ok_or(HotplugVcpuError::VcpuCountTooHigh)?
+            > MAX_SUPPORTED_VCPUS.into()
+        {
+            return Err(HotplugVcpuError::VcpuCountTooHigh);
+        }
+
+        if let Some(kvm_config) = self.vcpu_config.as_mut() {
+            kvm_config.vcpu_count += config.add;
+        }
+        // Create and start new vcpus
+        let mut vcpus = Vec::with_capacity(config.add.into());
+
+        #[allow(clippy::cast_possible_truncation)]
+        let start_idx = self.vcpus_handles.len().try_into().unwrap();
+        if let Some(devices::BusDevice::CpuContainer(cont)) =
+            self.get_bus_device(DeviceType::CpuContainer, "CpuContainer")
+        {
+            let mut locked_container = cont.lock().expect("Poisoned lock");
+            for cpu_idx in start_idx..(start_idx + config.add) {
+                let exit_evt = self
+                    .vcpus_exit_evt
+                    .try_clone()
+                    .map_err(HotplugVcpuError::EventFd)?;
+                let mut vcpu =
+                    Vcpu::new(cpu_idx, &self.vm, exit_evt).map_err(HotplugVcpuError::VcpuCreate)?;
+                if let Some(kvm_config) = self.vcpu_config.as_ref() {
+                    vcpu.kvm_vcpu.hotplug_configure(kvm_config)?;
+                } else {
+                    return Err(HotplugVcpuError::RestoredFromSnapshot);
+                }
+                locked_container.cpu_devices[cpu_idx as usize].inserting = true;
+                vcpus.push(vcpu);
+            }
+        }
+
+        self.start_vcpus(
+            vcpus,
+            self.seccomp_filters
+                .get("vcpu")
+                .ok_or_else(|| HotplugVcpuError::MissingSeccompFilters("vcpu".to_string()))?
+                .clone(),
+        )
+        .map_err(HotplugVcpuError::VcpuStart)?;
+
+        #[allow(clippy::cast_lossless)]
+        METRICS.hotplug.vcpus_added.add(config.add.into());
+
+        // Update VM config to reflect new CPUs added
+        #[allow(clippy::cast_possible_truncation)]
+        let new_machine_config = MachineConfigUpdate {
+            vcpu_count: Some(self.vcpus_handles.len() as u8),
+            mem_size_mib: None,
+            smt: None,
+            cpu_template: None,
+            track_dirty_pages: None,
+            huge_pages: None,
+        };
+
+        self.resume_vcpu_threads(start_idx.into())?;
+
+        self.acpi_device_manager.notify_cpu_container()?;
+
+        #[cfg(test)]
+        if let Some(devices::BusDevice::BootTimer(timer)) =
+            self.get_bus_device(DeviceType::BootTimer, "BootTimer")
+        {
+            let mut locked_timer = timer.lock().expect("Poisoned lock");
+            locked_timer.start_ts = utils::time::TimestampUs::default();
+        }
+
+        Ok(new_machine_config)
+    }
+
     /// Retrieves the KVM dirty bitmap for each of the guest's memory regions.
     pub fn reset_dirty_bitmap(&self) {
         self.guest_memory