petri: hyper-v reset support (microsoft#1916)

Add support for guest resets for the Hyper-V petri backend. Refactors
some of the framebuffer code to make this possible. Enables Hyper-V
reboot tests that are now possible due to this change. Also includes
some other minor Petri refactoring to move more logic into
backend-agnostic code.

Author: tjones60

Cargo.lock

@@ -8898,7 +8898,6 @@ dependencies = [
  "cfg-if",
  "disk_backend_resources",
  "futures",
- "get_resources",
  "guid",
  "hvdef",
  "hvlite_defs",
@@ -8925,7 +8924,6 @@ dependencies = [
  "unix_socket",
  "virtio_resources",
  "vm_resource",
- "vmm_core_defs",
  "vmm_test_macros",
  "vtl2_settings_proto",
  "x86defs",

petri/petri_artifacts_common/src/lib.rs

@@ -64,14 +64,45 @@ pub mod tags {
     }
 
     /// Quirks needed to boot a guest.
-    #[derive(Default, Copy, Clone, Debug)]
-    pub struct GuestQuirks {
+    #[derive(Default, Clone, Debug)]
+    pub struct GuestQuirksInner {
         /// How long to wait after the shutdown IC reports ready before sending
         /// the shutdown command.
         ///
         /// This is necessary because some guests will ignore shutdown requests
         /// that arrive too early in the boot process.
         pub hyperv_shutdown_ic_sleep: Option<std::time::Duration>,
+        /// Some guests reboot automatically soon after first boot.
+        pub initial_reboot: Option<InitialRebootCondition>,
+    }
+
+    /// Some guests may automatically reboot only in certain configurations
+    #[derive(Clone, Copy, Debug)]
+    pub enum InitialRebootCondition {
+        /// This guest always reboots on this VMM.
+        Always,
+        /// This guest only reboot when using OpenHCL and UEFI on this VMM.
+        WithOpenHclUefi,
+        // TODO: add WithTpm here once with_tpm() is backend-agnostic.
+    }
+
+    /// Quirks needed to boot a guest, allowing for differences based on backend
+    #[derive(Default, Clone, Debug)]
+    pub struct GuestQuirks {
+        /// Quirks when running in OpenVMM
+        pub openvmm: GuestQuirksInner,
+        /// Quirks when running in Hyper-V
+        pub hyperv: GuestQuirksInner,
+    }
+
+    impl GuestQuirks {
+        /// Use the same quirks for all backends
+        pub fn for_all_backends(quirks: GuestQuirksInner) -> GuestQuirks {
+            GuestQuirks {
+                openvmm: quirks.clone(),
+                hyperv: quirks,
+            }
+        }
     }
 
     /// Artifact is a OpenHCL IGVM file

petri/src/vm/hyperv/hyperv.psm1

@@ -432,4 +432,20 @@ function Get-VmScreenshot
     [IO.File]::WriteAllBytes($Path, $image.ImageData)
 
     return "$x,$y"
+}
+
+function Set-TurnOffOnGuestRestart
+{
+    [CmdletBinding()]
+    Param (
+        [Parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
+        [System.Object]
+        $Vm,
+
+        [bool] $Enable
+    )
+
+    $vssd = Get-Vssd $Vm
+    $vssd.TurnOffOnGuestRestart = $Enable
+    Set-VmSystemSettings $vssd
 }

petri/src/vm/hyperv/mod.rs

@@ -13,15 +13,14 @@ use crate::IsolationType;
 use crate::NoPetriVmInspector;
 use crate::OpenHclConfig;
 use crate::OpenHclServicingFlags;
+use crate::PetriHaltReason;
 use crate::PetriVmConfig;
-use crate::PetriVmFramebufferAccess;
 use crate::PetriVmResources;
 use crate::PetriVmRuntime;
 use crate::PetriVmmBackend;
 use crate::SecureBootTemplate;
 use crate::ShutdownKind;
 use crate::UefiConfig;
-use crate::VmScreenshotMeta;
 use crate::disk_image::AgentImage;
 use crate::hyperv::powershell::HyperVSecureBootTemplate;
 use crate::kmsg_log_task;
@@ -38,32 +37,31 @@ use pal_async::socket::PolledSocket;
 use pal_async::task::Spawn;
 use pal_async::task::Task;
 use pal_async::timer::PolledTimer;
+use petri_artifacts_common::tags::GuestQuirks;
+use petri_artifacts_common::tags::GuestQuirksInner;
 use petri_artifacts_common::tags::MachineArch;
 use petri_artifacts_common::tags::OsFlavor;
 use petri_artifacts_core::ArtifactResolver;
 use petri_artifacts_core::ResolvedArtifact;
 use pipette_client::PipetteClient;
-use std::fs;
 use std::io::ErrorKind;
 use std::io::Write;
 use std::path::Path;
-use std::sync::Arc;
-use std::sync::Weak;
 use std::time::Duration;
 use vm::HyperVVM;
-use vmm_core_defs::HaltReason;
 
 /// The Hyper-V Petri backend
 pub struct HyperVPetriBackend {}
 
 /// Resources needed at runtime for a Hyper-V Petri VM
 pub struct HyperVPetriRuntime {
-    vm: Arc<HyperVVM>,
+    vm: HyperVVM,
     log_tasks: Vec<Task<anyhow::Result<()>>>,
     temp_dir: tempfile::TempDir,
+    driver: DefaultDriver,
+
     is_openhcl: bool,
     is_isolated: bool,
-    driver: DefaultDriver,
 }
 
 #[async_trait]
@@ -77,6 +75,10 @@ impl PetriVmmBackend for HyperVPetriBackend {
             && !(firmware.is_pcat() && arch == MachineArch::Aarch64)
     }
 
+    fn select_quirks(quirks: GuestQuirks) -> GuestQuirksInner {
+        quirks.hyperv
+    }
+
     fn new(_resolver: &ArtifactResolver<'_>) -> Self {
         HyperVPetriBackend {}
     }
@@ -187,7 +189,6 @@ impl PetriVmmBackend for HyperVPetriBackend {
             guest_state_isolation_type,
             memory.startup_bytes,
             log_source.log_file("hyperv")?,
-            firmware.expected_boot_event(),
             driver.clone(),
         )
         .await?;
@@ -292,7 +293,7 @@ impl PetriVmmBackend for HyperVPetriBackend {
                     // location at runtime.
                     let imc_hive = temp_dir.path().join("imc.hiv");
                     {
-                        let mut imc_hive_file = fs::File::create_new(&imc_hive)?;
+                        let mut imc_hive_file = fs_err::File::create_new(&imc_hive)?;
                         imc_hive_file
                             .write_all(include_bytes!("../../../guest-bootstrap/imc.hiv"))
                             .context("failed to write imc hive")?;
@@ -427,32 +428,28 @@ impl PetriVmmBackend for HyperVPetriBackend {
         vm.start().await?;
 
         Ok(HyperVPetriRuntime {
-            vm: Arc::new(vm),
+            vm,
             log_tasks,
             temp_dir,
+            driver: driver.clone(),
             is_openhcl: openhcl_config.is_some(),
             is_isolated: firmware.isolation().is_some(),
-            driver: driver.clone(),
         })
     }
 }
 
 #[async_trait]
 impl PetriVmRuntime for HyperVPetriRuntime {
     type VmInspector = NoPetriVmInspector;
-    type VmFramebufferAccess = HyperVFramebufferAccess;
+    type VmFramebufferAccess = vm::HyperVFramebufferAccess;
 
     async fn teardown(mut self) -> anyhow::Result<()> {
         futures::future::join_all(self.log_tasks.into_iter().map(|t| t.cancel())).await;
-        Arc::into_inner(self.vm)
-            .context("all references to the Hyper-V VM object have not been closed")?
-            .remove()
-            .await
+        self.vm.remove().await
     }
 
-    async fn wait_for_halt(&mut self) -> anyhow::Result<HaltReason> {
-        self.vm.wait_for_halt().await?;
-        Ok(HaltReason::PowerOff) // TODO: Get actual halt reason
+    async fn wait_for_halt(&mut self, allow_reset: bool) -> anyhow::Result<PetriHaltReason> {
+        self.vm.wait_for_halt(allow_reset).await
     }
 
     async fn wait_for_agent(&mut self, set_high_vtl: bool) -> anyhow::Result<PipetteClient> {
@@ -501,10 +498,6 @@ impl PetriVmRuntime for HyperVPetriRuntime {
         })
     }
 
-    async fn wait_for_successful_boot_event(&mut self) -> anyhow::Result<()> {
-        self.vm.wait_for_successful_boot_event().await
-    }
-
     async fn wait_for_boot_event(&mut self) -> anyhow::Result<FirmwareEvent> {
         self.vm.wait_for_boot_event().await
     }
@@ -531,26 +524,8 @@ impl PetriVmRuntime for HyperVPetriRuntime {
         self.vm.restart_openhcl(flags).await
     }
 
-    fn take_framebuffer_access(&mut self) -> Option<HyperVFramebufferAccess> {
-        (!self.is_isolated).then(|| HyperVFramebufferAccess {
-            vm: Arc::downgrade(&self.vm),
-        })
-    }
-}
-
-/// Interface to the Hyper-V framebuffer
-pub struct HyperVFramebufferAccess {
-    vm: Weak<HyperVVM>,
-}
-
-#[async_trait]
-impl PetriVmFramebufferAccess for HyperVFramebufferAccess {
-    async fn screenshot(&mut self, image: &mut Vec<u8>) -> anyhow::Result<VmScreenshotMeta> {
-        self.vm
-            .upgrade()
-            .context("VM no longer exists")?
-            .screenshot(image)
-            .await
+    fn take_framebuffer_access(&mut self) -> Option<vm::HyperVFramebufferAccess> {
+        (!self.is_isolated).then(|| self.vm.get_framebuffer_access())
     }
 }
 
@@ -644,13 +619,15 @@ async fn hyperv_serial_log_task(
 ) -> anyhow::Result<()> {
     let mut timer = None;
     loop {
-        match fs_err::OpenOptions::new()
+        // using `std::fs` here instead of `fs_err` since `raw_os_error` always
+        // returns `None` for `fs_err` errors.
+        match std::fs::OpenOptions::new()
             .read(true)
             .write(true)
             .open(&serial_pipe_path)
         {
             Ok(file) => {
-                let pipe = PolledPipe::new(&driver, file.into()).expect("failed to create pipe");
+                let pipe = PolledPipe::new(&driver, file).expect("failed to create pipe");
                 // connect/disconnect messages logged internally
                 _ = crate::log_task(log_file.clone(), pipe, &serial_pipe_path).await;
             }
@@ -661,7 +638,7 @@ async fn hyperv_serial_log_task(
                 if !(err.kind() == ErrorKind::NotFound
                     || matches!(err.raw_os_error(), Some(ERROR_PIPE_BUSY)))
                 {
-                    tracing::warn!("{err:#}")
+                    tracing::warn!("failed to open {serial_pipe_path}: {err:#}",)
                 }
                 // Wait a bit and try again.
                 timer