feat: Add PVTime support for ARM

Adds functionality for pvtime, which displays steal time
to guest on ARM machines. PVTime is persisted across
snapshots as well (snapshot ver updated).

- Added ipa per vCPU for mem region storing steal time info.
- Persists this ipa per vCPU across snapshots.
- Shared steal time mem region is setup on boot and restore
  from snapshot in builder.rs.

Signed-off-by: Dakshin Devanand <dakshind2005@gmail.com>

Author: DakshinD

src/vmm/src/arch/aarch64/vcpu.rs

@@ -11,6 +11,7 @@ use std::mem::offset_of;
 use kvm_bindings::*;
 use kvm_ioctls::{VcpuExit, VcpuFd, VmFd};
 use serde::{Deserialize, Serialize};
+use vm_memory::GuestAddress;
 
 use super::get_fdt_addr;
 use super::regs::*;
@@ -42,6 +43,8 @@ pub enum VcpuArchError {
     Fam(vmm_sys_util::fam::Error),
     /// {0}
     GetMidrEl1(String),
+    /// Failed to set/get device attributes for vCPU: {0}
+    DeviceAttribute(kvm_ioctls::Error),
 }
 
 /// Extract the Manufacturer ID from the host.
@@ -115,6 +118,8 @@ pub struct KvmVcpu {
     /// Vcpu peripherals, such as buses
     pub peripherals: Peripherals,
     kvi: kvm_vcpu_init,
+    /// IPA of steal_time region
+    pub pvtime_ipa: Option<GuestAddress>,
 }
 
 /// Vcpu peripherals
@@ -148,6 +153,7 @@ impl KvmVcpu {
             fd: kvm_vcpu,
             peripherals: Default::default(),
             kvi,
+            pvtime_ipa: None,
         })
     }
 
@@ -243,6 +249,8 @@ impl KvmVcpu {
         // the boot state and turned secondary vcpus on.
         state.kvi.features[0] &= !(1 << KVM_ARM_VCPU_POWER_OFF);
 
+        state.pvtime_ipa = self.pvtime_ipa.map(|guest_addr| guest_addr.0);
+
         Ok(state)
     }
 
@@ -276,6 +284,13 @@ impl KvmVcpu {
         }
         self.set_mpstate(state.mp_state)
             .map_err(KvmVcpuError::RestoreState)?;
+
+        // Assumes that steal time memory region was set up already
+        if let Some(pvtime_ipa) = state.pvtime_ipa {
+            self.enable_pvtime(GuestAddress(pvtime_ipa))
+                .map_err(KvmVcpuError::RestoreState)?;
+        }
+
         Ok(())
     }
 
@@ -439,6 +454,38 @@ impl KvmVcpu {
     pub fn set_mpstate(&self, state: kvm_mp_state) -> Result<(), VcpuArchError> {
         self.fd.set_mp_state(state).map_err(VcpuArchError::SetMp)
     }
+
+    /// Check if pvtime (steal time on ARM) is supported for vcpu
+    pub fn supports_pvtime(&self) -> bool {
+        let pvtime_device_attr = kvm_bindings::kvm_device_attr {
+            group: kvm_bindings::KVM_ARM_VCPU_PVTIME_CTRL,
+            attr: kvm_bindings::KVM_ARM_VCPU_PVTIME_IPA as u64,
+            addr: 0,
+            flags: 0,
+        };
+
+        // Use kvm_has_device_attr to check if PVTime is supported
+        self.fd.has_device_attr(&pvtime_device_attr).is_ok()
+    }
+
+    /// Enables pvtime for vcpu
+    pub fn enable_pvtime(&mut self, ipa: GuestAddress) -> Result<(), VcpuArchError> {
+        self.pvtime_ipa = Some(ipa);
+
+        // Use KVM syscall (kvm_set_device_attr) to register the vCPU with the steal_time region
+        let vcpu_device_attr = kvm_bindings::kvm_device_attr {
+            group: KVM_ARM_VCPU_PVTIME_CTRL,
+            attr: KVM_ARM_VCPU_PVTIME_IPA as u64,
+            addr: &ipa.0 as *const u64 as u64, // userspace address of attr data
+            flags: 0,
+        };
+
+        self.fd
+            .set_device_attr(&vcpu_device_attr)
+            .map_err(VcpuArchError::DeviceAttribute)?;
+
+        Ok(())
+    }
 }
 
 impl Peripherals {
@@ -467,6 +514,8 @@ pub struct VcpuState {
     pub mpidr: u64,
     /// kvi states for vcpu initialization.
     pub kvi: kvm_vcpu_init,
+    /// ipa for steal_time region
+    pub pvtime_ipa: Option<u64>,
 }
 
 impl Debug for VcpuState {

src/vmm/src/builder.rs

@@ -15,6 +15,8 @@ use linux_loader::cmdline::Cmdline as LoaderKernelCmdline;
 use userfaultfd::Uffd;
 use utils::time::TimestampUs;
 #[cfg(target_arch = "aarch64")]
+use vm_memory::GuestAddress;
+#[cfg(target_arch = "aarch64")]
 use vm_superio::Rtc;
 use vm_superio::Serial;
 use vmm_sys_util::eventfd::EventFd;
@@ -82,6 +84,9 @@ pub enum StartMicrovmError {
     CreateLegacyDevice(device_manager::legacy::LegacyDeviceError),
     /// Error creating VMGenID device: {0}
     CreateVMGenID(VmGenIdError),
+    /// Error enabling pvtime on vcpu: {0}
+    #[cfg(target_arch = "aarch64")]
+    EnablePVTime(crate::arch::VcpuArchError),
     /// Invalid Memory Configuration: {0}
     GuestMemory(crate::vstate::memory::MemoryError),
     /// Error with initrd initialization: {0}.
@@ -289,6 +294,13 @@ pub fn build_microvm_for_boot(
 
     attach_vmgenid_device(&mut vmm)?;
 
+    #[cfg(target_arch = "aarch64")]
+    if vcpus[0].kvm_vcpu.supports_pvtime() {
+        setup_pvtime(&mut vmm, &mut vcpus)?;
+    } else {
+        log::warn!("Vcpus do not support pvtime, steal time will not be reported to guest");
+    }
+
     configure_system_for_boot(
         &mut vmm,
         vcpus.as_mut(),
@@ -449,6 +461,16 @@ pub fn build_microvm_from_snapshot(
         }
     }
 
+    // Restore allocator state
+    #[cfg(target_arch = "aarch64")]
+    if let Some(pvtime_ipa) = vcpus[0].kvm_vcpu.pvtime_ipa {
+        allocate_pvtime_region(
+            &mut vmm,
+            vcpus.len(),
+            vm_allocator::AllocPolicy::ExactMatch(pvtime_ipa.0),
+        )?;
+    }
+
     // Restore vcpus kvm state.
     for (vcpu, state) in vcpus.iter_mut().zip(microvm_state.vcpu_states.iter()) {
         vcpu.kvm_vcpu
@@ -552,6 +574,44 @@ pub fn setup_serial_device(
     Ok(serial)
 }
 
+/// 64 bytes due to alignment requirement in 3.1 of https://www.kernel.org/doc/html/v5.8/virt/kvm/devices/vcpu.html#attribute-kvm-arm-vcpu-pvtime-ipa
+#[cfg(target_arch = "aarch64")]
+const STEALTIME_STRUCT_MEM_SIZE: u64 = 64;
+
+/// Helper method to allocate steal time region
+#[cfg(target_arch = "aarch64")]
+fn allocate_pvtime_region(
+    vmm: &mut Vmm,
+    vcpu_count: usize,
+    policy: vm_allocator::AllocPolicy,
+) -> Result<GuestAddress, StartMicrovmError> {
+    let size = STEALTIME_STRUCT_MEM_SIZE * vcpu_count as u64;
+    let addr = vmm
+        .resource_allocator
+        .allocate_system_memory(size, STEALTIME_STRUCT_MEM_SIZE, policy)
+        .map_err(StartMicrovmError::AllocateResources)?;
+    Ok(GuestAddress(addr))
+}
+
+/// Sets up pvtime for all vcpus
+#[cfg(target_arch = "aarch64")]
+fn setup_pvtime(vmm: &mut Vmm, vcpus: &mut [Vcpu]) -> Result<(), StartMicrovmError> {
+    // Alloc sys mem for steal time region
+    let pvtime_mem: GuestAddress =
+        allocate_pvtime_region(vmm, vcpus.len(), vm_allocator::AllocPolicy::LastMatch)?;
+
+    // Register all vcpus with pvtime device
+    for (i, vcpu) in vcpus.iter_mut().enumerate() {
+        vcpu.kvm_vcpu
+            .enable_pvtime(GuestAddress(
+                pvtime_mem.0 + i as u64 * STEALTIME_STRUCT_MEM_SIZE,
+            ))
+            .map_err(StartMicrovmError::EnablePVTime)?;
+    }
+
+    Ok(())
+}
+
 #[cfg(target_arch = "aarch64")]
 fn attach_legacy_devices_aarch64(
     event_manager: &mut EventManager,

src/vmm/src/persist.rs

@@ -148,7 +148,7 @@ pub enum CreateSnapshotError {
 }
 
 /// Snapshot version
-pub const SNAPSHOT_VERSION: Version = Version::new(6, 0, 0);
+pub const SNAPSHOT_VERSION: Version = Version::new(7, 0, 0);
 
 /// Creates a Microvm snapshot.
 pub fn create_snapshot(