refactor(acpi): Encapsule post-restore logic within restore()

Since the restore and its post-restore steps must always be executed
together.  Move the post-restore logic into restore() so the flow is
self-contained.  This prevents the restore and its post-restore handling
from being accidentally separated in the future.

Signed-off-by: Takahiro Itazuri <itazur@amazon.com>

Author: zulinx86

src/vmm/src/device_manager/acpi.rs

@@ -16,6 +16,8 @@ pub enum ACPIDeviceError {
     RegisterIrq(#[from] kvm_ioctls::Error),
     /// Could not write to guest memory: {0}
     WriteGuestMemory(#[from] GuestMemoryError),
+    /// Could not notify guest: {0}
+    NotifyGuest(#[from] std::io::Error),
 }
 
 #[derive(Debug)]

src/vmm/src/device_manager/mod.rs

@@ -412,8 +412,6 @@ pub enum DevicePersistError {
     AcpiRestore(#[from] ACPIDeviceError),
     /// Error restoring PCI devices: {0}
     PciRestore(#[from] PciManagerError),
-    /// Error notifying VMGenID device: {0}
-    VmGenidUpdate(#[from] std::io::Error),
     /// Error resetting serial console: {0}
     SerialRestore(#[from] EmulateSerialInitError),
     /// Error inserting device in bus: {0}
@@ -479,11 +477,7 @@ impl<'a> Persist<'a> for DeviceManager {
         let mmio_devices = MMIODeviceManager::restore(mmio_ctor_args, &state.mmio_state)?;
 
         // Restore ACPI devices
-        let mut acpi_devices = ACPIDeviceManager::restore(constructor_args.vm, &state.acpi_state)?;
-        acpi_devices.vmgenid.notify_guest()?;
-        acpi_devices
-            .vmclock
-            .post_load_update(constructor_args.vm.guest_memory());
+        let acpi_devices = ACPIDeviceManager::restore(constructor_args.vm, &state.acpi_state)?;
 
         // Restore PCI devices
         let pci_ctor_args = PciDevicesConstructorArgs {

src/vmm/src/device_manager/persist.rs

@@ -183,15 +183,19 @@ impl<'a> Persist<'a> for ACPIDeviceManager {
     }
 
     fn restore(vm: Self::ConstructorArgs, state: &Self::State) -> Result<Self, Self::Error> {
-        let acpi_devices = ACPIDeviceManager {
+        let mut acpi_devices = 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.
             vmclock: VmClock::restore((), &state.vmclock).unwrap(),
         };
 
         acpi_devices.attach_vmgenid(vm)?;
+        acpi_devices.vmgenid.do_post_restore()?;
+
         acpi_devices.attach_vmclock(vm)?;
+        acpi_devices.vmclock.do_post_restore(vm.guest_memory());
+
         Ok(acpi_devices)
     }
 }

src/vmm/src/devices/acpi/vmclock.rs

@@ -104,8 +104,8 @@ impl VmClock {
         Ok(())
     }
 
-    /// Bump the VM generation counter
-    pub fn post_load_update(&mut self, mem: &GuestMemoryMmap) {
+    /// Bump the VM generation counter and notify guest after snapshot restore
+    pub fn do_post_restore(&mut self, mem: &GuestMemoryMmap) {
         write_vmclock_field!(self, mem, seq_count, self.inner.seq_count | 1);
 
         // This fence ensures guest sees all previous writes. It is matched to a
@@ -263,7 +263,7 @@ mod tests {
 
         let state = vmclock.save();
         let mut vmclock_new = VmClock::restore((), &state).unwrap();
-        vmclock_new.post_load_update(&mem);
+        vmclock_new.do_post_restore(&mem);
 
         let guest_data_new: vmclock_abi = mem.read_obj(VMCLOCK_TEST_GUEST_ADDR).unwrap();
         assert_ne!(guest_data_new, vmclock.inner);

src/vmm/src/devices/acpi/vmgenid.rs

@@ -84,11 +84,11 @@ impl VmGenId {
         u128::from_le_bytes(gen_id_bytes)
     }
 
-    /// Send an ACPI notification to guest device.
+    /// Notify guest after snapshot restore
     ///
     /// This will only have effect if we have updated the generation ID in guest memory, i.e. when
     /// re-creating the device after snapshot resumption.
-    pub fn notify_guest(&mut self) -> Result<(), std::io::Error> {
+    pub fn do_post_restore(&self) -> Result<(), std::io::Error> {
         self.interrupt_evt
             .trigger()
             .inspect_err(|err| error!("vmgenid: could not send guest notification: {err}"))?;