vstate: support serializing interrupts to snapshots

Vm object is now maintaining information about the interrupts (both
traditional IRQs and MSI-X vectors) that are being used by microVM
devices. Derive Serialize/Deserialize add logic for recreating objects
for relevant types.

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

Author: bchalios

src/vmm/src/arch/aarch64/vm.rs

@@ -1,12 +1,15 @@
 // Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
 use serde::{Deserialize, Serialize};
 
 use crate::Kvm;
 use crate::arch::aarch64::gic::GicState;
 use crate::vstate::memory::{GuestMemoryExtension, GuestMemoryState};
-use crate::vstate::vm::{VmCommon, VmError};
+use crate::vstate::vm::{RoutingEntry, VmCommon, VmError};
 
 /// Structure representing the current architecture's understand of what a "virtual machine" is.
 #[derive(Debug)]
@@ -74,6 +77,7 @@ impl ArchVm {
                 .get_irqchip()
                 .save_device(mpidrs)
                 .map_err(ArchVmError::SaveGic)?,
+            interrupts: self.common.interrupts.clone(),
         })
     }
 
@@ -86,6 +90,7 @@ impl ArchVm {
         self.get_irqchip()
             .restore_device(mpidrs, &state.gic)
             .map_err(ArchVmError::RestoreGic)?;
+        self.common.interrupts = state.interrupts.clone();
 
         Ok(())
     }
@@ -98,4 +103,6 @@ pub struct VmState {
     pub memory: GuestMemoryState,
     /// GIC state.
     pub gic: GicState,
+    /// Interrupts state
+    interrupts: Arc<Mutex<HashMap<u32, RoutingEntry>>>,
 }

src/vmm/src/vstate/vm.rs

@@ -20,6 +20,7 @@ use kvm_bindings::{
 };
 use kvm_ioctls::VmFd;
 use log::debug;
+use serde::{Deserialize, Serialize};
 use vm_device::interrupt::{InterruptSourceGroup, MsiIrqSourceConfig};
 use vmm_sys_util::errno;
 use vmm_sys_util::eventfd::EventFd;
@@ -49,7 +50,7 @@ pub enum InterruptError {
     Kvm(#[from] kvm_ioctls::Error),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize)]
 /// A struct representing an interrupt line used by some device of the microVM
 pub struct RoutingEntry {
     entry: kvm_irq_routing_entry,
@@ -112,6 +113,32 @@ impl MsiVectorGroup {
     pub fn num_vectors(&self) -> u16 {
         u16::try_from(self.irq_routes.len()).unwrap()
     }
+
+    /// Save the vectors state
+    pub fn state(&self) -> Vec<(u32, (u32, bool))> {
+        let mut state = vec![];
+        for (idx, irq_route) in &self.irq_routes {
+            state.push((
+                *idx,
+                (irq_route.gsi, irq_route.enabled.load(Ordering::Acquire)),
+            ));
+        }
+        state
+    }
+
+    /// Create a new group from state
+    pub fn from_state(
+        vm: Arc<Vm>,
+        state: &[(u32, (u32, bool))],
+    ) -> Result<MsiVectorGroup, InterruptError> {
+        let mut irq_routes = HashMap::new();
+
+        for (idx, (gsi, enabled)) in state {
+            irq_routes.insert(*idx, MsiVector::new(*gsi, *enabled)?);
+        }
+
+        Ok(MsiVectorGroup { vm, irq_routes })
+    }
 }
 
 impl InterruptSourceGroup for MsiVectorGroup {
@@ -207,7 +234,7 @@ pub struct VmCommon {
     /// The guest memory of this Vm.
     pub guest_memory: GuestMemoryMmap,
     /// Interrupts used by Vm's devices
-    interrupts: Arc<Mutex<HashMap<u32, RoutingEntry>>>,
+    pub interrupts: Arc<Mutex<HashMap<u32, RoutingEntry>>>,
 }
 
 /// Errors associated with the wrappers over KVM ioctls.