refactor: introduce struct VmCommon

This struct will hold all the fields that are common between the x86_64
and aarch64 definition of `struct ArchVm`. For now, this is only the
`VmFd`, but this will grow.

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

src/vmm/src/vstate/vm/aarch64.rs

@@ -1,17 +1,16 @@
 // Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use kvm_ioctls::VmFd;
 use serde::{Deserialize, Serialize};
 
-use super::VmError;
+use super::{VmCommon, VmError};
 use crate::Kvm;
 use crate::arch::aarch64::gic::GicState;
 
 /// Structure representing the current architecture's understand of what a "virtual machine" is.
 #[derive(Debug)]
 pub struct ArchVm {
-    pub(super) fd: VmFd,
+    pub(super) common: VmCommon,
     // On aarch64 we need to keep around the fd obtained by creating the VGIC device.
     irqchip_handle: Option<crate::arch::aarch64::gic::GICDevice>,
 }
@@ -30,9 +29,9 @@ pub enum ArchVmError {
 impl ArchVm {
     /// Create a new `Vm` struct.
     pub fn new(kvm: &Kvm) -> Result<ArchVm, VmError> {
-        let fd = Self::create_vm(kvm)?;
+        let common = Self::create_common(kvm)?;
         Ok(ArchVm {
-            fd,
+            common,
             irqchip_handle: None,
         })
     }
@@ -52,7 +51,7 @@ impl ArchVm {
     /// Creates the GIC (Global Interrupt Controller).
     pub fn setup_irqchip(&mut self, vcpu_count: u8) -> Result<(), ArchVmError> {
         self.irqchip_handle = Some(
-            crate::arch::aarch64::gic::create_gic(&self.fd, vcpu_count.into(), None)
+            crate::arch::aarch64::gic::create_gic(&self.fd(), vcpu_count.into(), None)
                 .map_err(ArchVmError::VmCreateGIC)?,
         );
         Ok(())

src/vmm/src/vstate/vm/mod.rs

@@ -24,6 +24,11 @@ pub use arch::{ArchVm as Vm, ArchVmError, VmState};
 use crate::Vcpu;
 use crate::vstate::vcpu::VcpuError;
 
+#[derive(Debug)]
+struct VmCommon {
+    fd: VmFd,
+}
+
 /// Errors associated with the wrappers over KVM ioctls.
 /// Needs `rustfmt::skip` to make multiline comments work
 #[rustfmt::skip]
@@ -43,7 +48,7 @@ pub enum VmError {
 
 /// Contains Vm functions that are usable across CPU architectures
 impl Vm {
-    fn create_vm(kvm: &crate::vstate::kvm::Kvm) -> Result<VmFd, VmError> {
+    fn create_common(kvm: &crate::vstate::kvm::Kvm) -> Result<VmCommon, VmError> {
         // It is known that KVM_CREATE_VM occasionally fails with EINTR on heavily loaded machines
         // with many VMs.
         //
@@ -65,18 +70,22 @@ impl Vm {
         // retry, they have to start Firecracker from scratch. Doing retries in Firecracker makes
         // recovery faster and improves reliability.
         const MAX_ATTEMPTS: u32 = 5;
-        for attempt in 1..=MAX_ATTEMPTS {
+        let mut attempt = 1;
+        let fd = loop {
             match kvm.fd.create_vm() {
-                Ok(fd) => return Ok(fd),
+                Ok(fd) => break fd,
                 Err(e) if e.errno() == libc::EINTR && attempt < MAX_ATTEMPTS => {
                     info!("Attempt #{attempt} of KVM_CREATE_VM returned EINTR");
                     // Exponential backoff (1us, 2us, 4us, and 8us => 15us in total)
                     std::thread::sleep(std::time::Duration::from_micros(2u64.pow(attempt - 1)));
                 }
                 Err(e) => return Err(VmError::CreateVm(e)),
             }
-        }
-        unreachable!();
+
+            attempt += 1;
+        };
+
+        Ok(VmCommon { fd })
     }
 
     /// Creates the specified number of [`Vcpu`]s.
@@ -127,15 +136,15 @@ impl Vm {
                 };
 
                 // SAFETY: Safe because the fd is a valid KVM file descriptor.
-                unsafe { self.fd.set_user_memory_region(memory_region) }
+                unsafe { self.fd().set_user_memory_region(memory_region) }
             })
             .map_err(VmError::SetUserMemoryRegion)?;
         Ok(())
     }
 
     /// Gets a reference to the kvm file descriptor owned by this VM.
     pub fn fd(&self) -> &VmFd {
-        &self.fd
+        &self.common.fd
     }
 }
 

src/vmm/src/vstate/vm/x86_64.rs

@@ -7,12 +7,12 @@ use kvm_bindings::{
     KVM_CLOCK_TSC_STABLE, KVM_IRQCHIP_IOAPIC, KVM_IRQCHIP_PIC_MASTER, KVM_IRQCHIP_PIC_SLAVE,
     KVM_PIT_SPEAKER_DUMMY, MsrList, kvm_clock_data, kvm_irqchip, kvm_pit_config, kvm_pit_state2,
 };
-use kvm_ioctls::{Cap, VmFd};
+use kvm_ioctls::Cap;
 use serde::{Deserialize, Serialize};
 
 use crate::arch::x86_64::msr::MsrError;
 use crate::utils::u64_to_usize;
-use crate::vstate::vm::VmError;
+use crate::vstate::vm::{VmCommon, VmError};
 
 /// Error type for [`Vm::restore_state`]
 #[allow(missing_docs)]
@@ -48,7 +48,7 @@ pub enum ArchVmError {
 /// Structure representing the current architecture's understand of what a "virtual machine" is.
 #[derive(Debug)]
 pub struct ArchVm {
-    pub(super) fd: VmFd,
+    pub(super) common: VmCommon,
     msrs_to_save: MsrList,
     /// Size in bytes requiring to hold the dynamically-sized `kvm_xsave` struct.
     ///
@@ -59,7 +59,7 @@ pub struct ArchVm {
 impl ArchVm {
     /// Create a new `Vm` struct.
     pub fn new(kvm: &crate::vstate::kvm::Kvm) -> Result<ArchVm, VmError> {
-        let fd = Self::create_vm(kvm)?;
+        let common = Self::create_common(kvm)?;
 
         let msrs_to_save = kvm.msrs_to_save().map_err(ArchVmError::GetMsrsToSave)?;
 
@@ -69,7 +69,7 @@ impl ArchVm {
         // https://github.com/torvalds/linux/commit/be50b2065dfa3d88428fdfdc340d154d96bf6848
         //
         // Cache the value in order not to call it at each vCPU creation.
-        let xsave2_size = match fd.check_extension_int(Cap::Xsave2) {
+        let xsave2_size = match common.fd.check_extension_int(Cap::Xsave2) {
             // Catch all negative values just in case although the possible negative return value
             // of ioctl() is only -1.
             ..=-1 => {
@@ -83,11 +83,13 @@ impl ArchVm {
             ret => Some(usize::try_from(ret).unwrap()),
         };
 
-        fd.set_tss_address(u64_to_usize(crate::arch::x86_64::layout::KVM_TSS_ADDRESS))
+        common
+            .fd
+            .set_tss_address(u64_to_usize(crate::arch::x86_64::layout::KVM_TSS_ADDRESS))
             .map_err(ArchVmError::SetTssAddress)?;
 
         Ok(ArchVm {
-            fd,
+            common,
             msrs_to_save,
             xsave2_size,
         })
@@ -113,27 +115,27 @@ impl ArchVm {
     /// - [`kvm_ioctls::VmFd::set_irqchip`] errors.
     /// - [`kvm_ioctls::VmFd::set_irqchip`] errors.
     pub fn restore_state(&mut self, state: &VmState) -> Result<(), ArchVmError> {
-        self.fd
+        self.fd()
             .set_pit2(&state.pitstate)
             .map_err(ArchVmError::SetPit2)?;
-        self.fd
+        self.fd()
             .set_clock(&state.clock)
             .map_err(ArchVmError::SetClock)?;
-        self.fd
+        self.fd()
             .set_irqchip(&state.pic_master)
             .map_err(ArchVmError::SetIrqChipPicMaster)?;
-        self.fd
+        self.fd()
             .set_irqchip(&state.pic_slave)
             .map_err(ArchVmError::SetIrqChipPicSlave)?;
-        self.fd
+        self.fd()
             .set_irqchip(&state.ioapic)
             .map_err(ArchVmError::SetIrqChipIoAPIC)?;
         Ok(())
     }
 
     /// Creates the irq chip and an in-kernel device model for the PIT.
     pub fn setup_irqchip(&self) -> Result<(), ArchVmError> {
-        self.fd
+        self.fd()
             .create_irq_chip()
             .map_err(ArchVmError::VmSetIrqChip)?;
         // We need to enable the emulation of a dummy speaker port stub so that writing to port 0x61
@@ -142,40 +144,40 @@ impl ArchVm {
             flags: KVM_PIT_SPEAKER_DUMMY,
             ..Default::default()
         };
-        self.fd
+        self.fd()
             .create_pit2(pit_config)
             .map_err(ArchVmError::VmSetIrqChip)
     }
 
     /// Saves and returns the Kvm Vm state.
     pub fn save_state(&self) -> Result<VmState, ArchVmError> {
-        let pitstate = self.fd.get_pit2().map_err(ArchVmError::VmGetPit2)?;
+        let pitstate = self.fd().get_pit2().map_err(ArchVmError::VmGetPit2)?;
 
-        let mut clock = self.fd.get_clock().map_err(ArchVmError::VmGetClock)?;
+        let mut clock = self.fd().get_clock().map_err(ArchVmError::VmGetClock)?;
         // This bit is not accepted in SET_CLOCK, clear it.
         clock.flags &= !KVM_CLOCK_TSC_STABLE;
 
         let mut pic_master = kvm_irqchip {
             chip_id: KVM_IRQCHIP_PIC_MASTER,
             ..Default::default()
         };
-        self.fd
+        self.fd()
             .get_irqchip(&mut pic_master)
             .map_err(ArchVmError::VmGetIrqChip)?;
 
         let mut pic_slave = kvm_irqchip {
             chip_id: KVM_IRQCHIP_PIC_SLAVE,
             ..Default::default()
         };
-        self.fd
+        self.fd()
             .get_irqchip(&mut pic_slave)
             .map_err(ArchVmError::VmGetIrqChip)?;
 
         let mut ioapic = kvm_irqchip {
             chip_id: KVM_IRQCHIP_IOAPIC,
             ..Default::default()
         };
-        self.fd
+        self.fd()
             .get_irqchip(&mut ioapic)
             .map_err(ArchVmError::VmGetIrqChip)?;