vmclock: add support for Aarch64

Expose VMClock device to guest via DT and enable compiling the vmclock
for ARM architectures.

Keep VMClock tests only on x86 until we get support from the guest
kernel.

Signed-off-by: Babis Chalios <[email protected]>

Author: bchalios

src/vmm/src/arch/aarch64/fdt.rs

@@ -20,6 +20,7 @@ use crate::arch::{
 use crate::device_manager::DeviceManager;
 use crate::device_manager::mmio::MMIODeviceInfo;
 use crate::device_manager::pci_mngr::PciDevices;
+use crate::devices::acpi::vmclock::{VMCLOCK_SIZE, VmClock};
 use crate::devices::acpi::vmgenid::{VMGENID_MEM_SIZE, VmGenId};
 use crate::initrd::InitrdConfig;
 use crate::vstate::memory::{Address, GuestMemory, GuestMemoryMmap, GuestRegionType};
@@ -97,6 +98,7 @@ pub fn create_fdt(
     create_psci_node(&mut fdt_writer)?;
     create_devices_node(&mut fdt_writer, device_manager)?;
     create_vmgenid_node(&mut fdt_writer, &device_manager.acpi_devices.vmgenid)?;
+    create_vmclock_node(&mut fdt_writer, &device_manager.acpi_devices.vmclock)?;
     create_pci_nodes(&mut fdt_writer, &device_manager.pci_devices)?;
 
     // End Header node.
@@ -287,6 +289,18 @@ fn create_vmgenid_node(fdt: &mut FdtWriter, vmgenid: &VmGenId) -> Result<(), Fdt
     Ok(())
 }
 
+fn create_vmclock_node(fdt: &mut FdtWriter, vmclock: &VmClock) -> Result<(), FdtError> {
+    let vmclock_node = fdt.begin_node(&format!("ptp@{}", vmclock.guest_address.0))?;
+    fdt.property_string("compatible", "amazon,vmclock")?;
+    fdt.property_array_u64("reg", &[vmclock.guest_address.0, VMCLOCK_SIZE as u64])?;
+    fdt.property_array_u32(
+        "interrupts",
+        &[GIC_FDT_IRQ_TYPE_SPI, vmclock.gsi, IRQ_TYPE_EDGE_RISING],
+    )?;
+    fdt.end_node(vmclock_node)?;
+    Ok(())
+}
+
 fn create_gic_node(fdt: &mut FdtWriter, gic_device: &GICDevice) -> Result<(), FdtError> {
     let interrupt = fdt.begin_node("intc")?;
     fdt.property_string("compatible", gic_device.fdt_compatibility())?;

src/vmm/src/arch/aarch64/output_GICv3.dtb

@@ -287,7 +287,6 @@ pub fn build_microvm_for_boot(
     )?;
 
     device_manager.attach_vmgenid_device(&vm)?;
-    #[cfg(target_arch = "x86_64")]
     device_manager.attach_vmclock_device(&vm)?;
 
     #[cfg(target_arch = "aarch64")]

src/vmm/src/arch/aarch64/output_initrd_GICv3.dtb

@@ -6,7 +6,6 @@ use acpi_tables::{Aml, aml};
 use vm_memory::GuestMemoryError;
 
 use crate::Vm;
-#[cfg(target_arch = "x86_64")]
 use crate::devices::acpi::vmclock::VmClock;
 use crate::devices::acpi::vmgenid::VmGenId;
 use crate::vstate::resources::ResourceAllocator;
@@ -24,7 +23,6 @@ pub struct ACPIDeviceManager {
     /// VMGenID device
     pub vmgenid: VmGenId,
     /// VMclock device
-    #[cfg(target_arch = "x86_64")]
     pub vmclock: VmClock,
 }
 
@@ -33,7 +31,6 @@ impl ACPIDeviceManager {
     pub fn new(resource_allocator: &mut ResourceAllocator) -> Self {
         ACPIDeviceManager {
             vmgenid: VmGenId::new(resource_allocator),
-            #[cfg(target_arch = "x86_64")]
             vmclock: VmClock::new(resource_allocator),
         }
     }
@@ -44,7 +41,6 @@ impl ACPIDeviceManager {
         Ok(())
     }
 
-    #[cfg(target_arch = "x86_64")]
     pub fn attach_vmclock(&self, vm: &Vm) -> Result<(), ACPIDeviceError> {
         vm.register_irq(&self.vmclock.interrupt_evt, self.vmclock.gsi)?;
         self.vmclock.activate(vm.guest_memory())?;

src/vmm/src/builder.rs

@@ -237,7 +237,6 @@ impl DeviceManager {
         Ok(())
     }
 
-    #[cfg(target_arch = "x86_64")]
     pub(crate) fn attach_vmclock_device(&mut self, vm: &Vm) -> Result<(), AttachDeviceError> {
         self.acpi_devices.attach_vmclock(vm)?;
         Ok(())
@@ -465,7 +464,6 @@ impl<'a> Persist<'a> for DeviceManager {
         // Restore ACPI devices
         let mut acpi_devices = ACPIDeviceManager::restore(constructor_args.vm, &state.acpi_state)?;
         acpi_devices.vmgenid.notify_guest()?;
-        #[cfg(target_arch = "x86_64")]
         acpi_devices
             .vmclock
             .post_load_update(constructor_args.vm.guest_memory());

src/vmm/src/device_manager/acpi.rs

@@ -15,7 +15,6 @@ use super::mmio::*;
 #[cfg(target_arch = "aarch64")]
 use crate::arch::DeviceType;
 use crate::device_manager::acpi::ACPIDeviceError;
-#[cfg(target_arch = "x86_64")]
 use crate::devices::acpi::vmclock::{VmClock, VmClockState};
 use crate::devices::acpi::vmgenid::{VMGenIDState, VmGenId};
 #[cfg(target_arch = "aarch64")]
@@ -169,7 +168,6 @@ impl fmt::Debug for MMIODevManagerConstructorArgs<'_> {
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 pub struct ACPIDeviceManagerState {
     vmgenid: VMGenIDState,
-    #[cfg(target_arch = "x86_64")]
     vmclock: VmClockState,
 }
 
@@ -181,7 +179,6 @@ impl<'a> Persist<'a> for ACPIDeviceManager {
     fn save(&self) -> Self::State {
         ACPIDeviceManagerState {
             vmgenid: self.vmgenid.save(),
-            #[cfg(target_arch = "x86_64")]
             vmclock: self.vmclock.save(),
         }
     }
@@ -191,11 +188,9 @@ impl<'a> Persist<'a> for ACPIDeviceManager {
             // Safe to unwrap() here, this will never return an error.
             vmgenid: VmGenId::restore((), &state.vmgenid).unwrap(),
             // Safe to unwrap() here, this will never return an error.
-            #[cfg(target_arch = "x86_64")]
             vmclock: VmClock::restore((), &state.vmclock).unwrap(),
         };
 
-        #[cfg(target_arch = "x86_64")]
         vm.register_irq(
             &acpi_devices.vmclock.interrupt_evt,
             acpi_devices.vmclock.gsi,

src/vmm/src/device_manager/mod.rs

@@ -27,7 +27,7 @@ use crate::vstate::resources::ResourceAllocator;
 unsafe impl ByteValued for vmclock_abi {}
 
 // We are reserving a physical page to expose the [`VmClock`] data
-const VMCLOCK_SIZE: u32 = 0x1000;
+pub const VMCLOCK_SIZE: u32 = 0x1000;
 
 // Write a value in `vmclock_abi` both in the Firecracker-managed state
 // and inside guest memory address that corresponds to it.

src/vmm/src/device_manager/persist.rs

@@ -18,9 +18,9 @@ def max_devices(uvm):
     match platform.machine():
         case "aarch64":
             # On aarch64, IRQs are available from 32 to 127. We always use one IRQ each for
-            # the VMGenID, RTC and serial devices, so the maximum number of devices supported
-            # at the same time is 93.
-            return 93
+            # the VMGenID, VMClock, RTC and serial devices, so the maximum number of devices
+            # supported at the same time is 92.
+            return 92
         case "x86_64":
             # IRQs are available from 5 to 23. We always use one IRQ for VMGenID and VMClock
             # devices, so the maximum number of devices supported at the same time is 17.