hyperv reset

Author: tjones60

Cargo.lock

@@ -9262,7 +9262,6 @@ dependencies = [
  "tracing",
  "unix_socket",
  "vm_resource",
- "vmm_core_defs",
  "vmm_test_macros",
  "vtl2_settings_proto",
  "x86defs",

petri/petri_artifacts_common/src/lib.rs

@@ -72,6 +72,8 @@ pub mod tags {
         /// 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_required: bool,
     }
 
     /// 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;
@@ -43,22 +42,18 @@ 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,
     is_openhcl: bool,
@@ -71,7 +66,14 @@ impl PetriVmmBackend for HyperVPetriBackend {
     type VmmConfig = ();
     type VmRuntime = HyperVPetriRuntime;
 
-    fn check_compat(firmware: &Firmware, arch: MachineArch) -> bool {
+    fn check_compat(firmware: &mut Firmware, arch: MachineArch) -> bool {
+        // Workaround for Ubuntu OpenHCL Hyper-V VMs automatically resetting
+        if matches!(firmware.os_flavor(), OsFlavor::Linux) && firmware.is_openhcl() {
+            if let Some(quirks) = firmware.quirks_mut() {
+                quirks.initial_reboot_required = true;
+            }
+        }
+
         arch == MachineArch::host()
             && !firmware.is_linux_direct()
             && !(firmware.is_pcat() && arch == MachineArch::Aarch64)
@@ -292,7 +294,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,7 +429,7 @@ impl PetriVmmBackend for HyperVPetriBackend {
         vm.start().await?;
 
         Ok(HyperVPetriRuntime {
-            vm: Arc::new(vm),
+            vm,
             log_tasks,
             temp_dir,
             is_openhcl: openhcl_config.is_some(),
@@ -440,19 +442,15 @@ impl PetriVmmBackend for HyperVPetriBackend {
 #[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> {
@@ -531,26 +529,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 +624,13 @@ async fn hyperv_serial_log_task(
 ) -> anyhow::Result<()> {
     let mut timer = None;
     loop {
-        match fs_err::OpenOptions::new()
+        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 +641,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