Merge branch 'main' into add-dd-test

Author: mattkur

openvmm/hvlite_helpers/src/underhill.rs

@@ -9,8 +9,8 @@ use get_resources::ged::GuestServicingFlags;
 use hvlite_defs::rpc::VmRpc;
 use mesh::rpc::RpcSend;
 
-/// Replace the running version of Underhill.
-pub async fn service_underhill(
+/// Save the running state of Underhill and stage the new version.
+pub async fn save_underhill(
     vm_send: &mesh::Sender<VmRpc>,
     send: &mesh::Sender<GuestEmulationRequest>,
     flags: GuestServicingFlags,
@@ -37,9 +37,16 @@ pub async fn service_underhill(
         // Clear the staged IGVM file.
         tracing::debug!(?r, "save state failed, clearing staged IGVM file");
         let _ = vm_send.call(VmRpc::CompleteReloadIgvm, false).await;
-        return r;
     }
 
+    r
+}
+
+/// Restore Underhill from a previously saved state. This should always be called after save_underhill.
+pub async fn restore_underhill(
+    vm_send: &mesh::Sender<VmRpc>,
+    send: &mesh::Sender<GuestEmulationRequest>,
+) -> anyhow::Result<()> {
     // Reload the IGVM file and reset VTL2 state.
     tracing::debug!("reloading IGVM file");
     vm_send

openvmm/openvmm_entry/src/lib.rs

@@ -2798,13 +2798,18 @@ async fn run_control(driver: &DefaultDriver, mesh: &VmmMesh, opt: Options) -> an
                         let path = igvm.context("no igvm file loaded")?;
                         let file = fs_err::File::open(path)?;
                         start = Instant::now();
-                        hvlite_helpers::underhill::service_underhill(
+                        hvlite_helpers::underhill::save_underhill(
                             &vm_rpc,
                             ged_rpc.as_ref().context("no GED")?,
                             GuestServicingFlags::default(),
                             file.into(),
                         )
                         .await?;
+                        hvlite_helpers::underhill::restore_underhill(
+                            &vm_rpc,
+                            ged_rpc.as_ref().context("no GED")?,
+                        )
+                        .await?;
                     }
                     let end = Instant::now();
                     Ok(end - start)

petri/src/vm/hyperv/mod.rs

@@ -537,6 +537,18 @@ impl PetriVmRuntime for HyperVPetriRuntime {
         self.vm.restart_openhcl(flags).await
     }
 
+    async fn save_openhcl(
+        &mut self,
+        _new_openhcl: &ResolvedArtifact,
+        _flags: OpenHclServicingFlags,
+    ) -> anyhow::Result<()> {
+        anyhow::bail!("saving OpenHCL firmware separately is not yet supported on Hyper-V");
+    }
+
+    async fn restore_openhcl(&mut self) -> anyhow::Result<()> {
+        anyhow::bail!("restoring OpenHCL firmware separately is not yet supported on Hyper-V");
+    }
+
     fn take_framebuffer_access(&mut self) -> Option<vm::HyperVFramebufferAccess> {
         (!self.is_isolated).then(|| self.vm.get_framebuffer_access())
     }

petri/src/vm/mod.rs

@@ -835,6 +835,22 @@ impl<T: PetriVmmBackend> PetriVm<T> {
             .await
     }
 
+    /// Instruct the OpenHCL to save the state of the VTL2 paravisor. Will fail if the VM
+    /// is not running OpenHCL. Will also fail if the VM is not running of if this is called twice in succession
+    pub async fn save_openhcl(
+        &mut self,
+        new_openhcl: ResolvedArtifact<impl IsOpenhclIgvm>,
+        flags: OpenHclServicingFlags,
+    ) -> anyhow::Result<()> {
+        self.runtime.save_openhcl(&new_openhcl.erase(), flags).await
+    }
+
+    /// Instruct the OpenHCL to restore the state of the VTL2 paravisor. Will fail if the VM
+    /// is not running OpenHCL. Will also fail if the VM is running of if this is called without prior save
+    pub async fn restore_openhcl(&mut self) -> anyhow::Result<()> {
+        self.runtime.restore_openhcl().await
+    }
+
     /// Get VM's guest OS flavor
     pub fn arch(&self) -> MachineArch {
         self.arch
@@ -926,6 +942,17 @@ pub trait PetriVmRuntime: Send + Sync + 'static {
         new_openhcl: &ResolvedArtifact,
         flags: OpenHclServicingFlags,
     ) -> anyhow::Result<()>;
+    /// Instruct the OpenHCL to save the state of the VTL2 paravisor. Will fail if the VM
+    /// is not running OpenHCL. Will also fail if the VM is not running or if this is called twice in succession
+    /// without a call to `restore_openhcl`.
+    async fn save_openhcl(
+        &mut self,
+        new_openhcl: &ResolvedArtifact,
+        flags: OpenHclServicingFlags,
+    ) -> anyhow::Result<()>;
+    /// Instruct the OpenHCL to restore the state of the VTL2 paravisor. Will fail if the VM
+    /// is not running OpenHCL. Will also fail if the VM is running or if this is called without prior save.
+    async fn restore_openhcl(&mut self) -> anyhow::Result<()>;
     /// If the backend supports it, get an inspect interface
     fn inspector(&self) -> Option<Self::VmInspector> {
         None

petri/src/vm/openvmm/runtime.rs

@@ -130,7 +130,20 @@ impl PetriVmRuntime for PetriVmOpenVmm {
         new_openhcl: &ResolvedArtifact,
         flags: OpenHclServicingFlags,
     ) -> anyhow::Result<()> {
-        Self::restart_openhcl(self, new_openhcl, flags).await
+        Self::save_openhcl(self, new_openhcl, flags).await?;
+        Self::restore_openhcl(self).await
+    }
+
+    async fn save_openhcl(
+        &mut self,
+        new_openhcl: &ResolvedArtifact,
+        flags: OpenHclServicingFlags,
+    ) -> anyhow::Result<()> {
+        Self::save_openhcl(self, new_openhcl, flags).await
+    }
+
+    async fn restore_openhcl(&mut self) -> anyhow::Result<()> {
+        Self::restore_openhcl(self).await
     }
 
     fn inspector(&self) -> Option<OpenVmmInspector> {
@@ -212,13 +225,19 @@ impl PetriVmOpenVmm {
         pub async fn wait_for_kvp(&mut self) -> anyhow::Result<mesh::Sender<hyperv_ic_resources::kvp::KvpRpc>>
     );
     petri_vm_fn!(
-        /// Restarts OpenHCL.
-        pub async fn restart_openhcl(
+        /// Stages the new OpenHCL file and saves the existing state.
+        pub async fn save_openhcl(
             &mut self,
             new_openhcl: &ResolvedArtifact,
             flags: OpenHclServicingFlags
         ) -> anyhow::Result<()>
     );
+    petri_vm_fn!(
+        /// Restores OpenHCL from a previously saved state.
+        pub async fn restore_openhcl(
+            &mut self
+        ) -> anyhow::Result<()>
+    );
     petri_vm_fn!(
         /// Resets the hardware state of the VM, simulating a power cycle.
         pub async fn reset(&mut self) -> anyhow::Result<()>
@@ -369,7 +388,7 @@ impl PetriVmInner {
         Ok(send)
     }
 
-    async fn restart_openhcl(
+    async fn save_openhcl(
         &self,
         new_openhcl: &ResolvedArtifact,
         flags: OpenHclServicingFlags,
@@ -382,10 +401,20 @@ impl PetriVmInner {
 
         let igvm_file = fs_err::File::open(new_openhcl).context("failed to open igvm file")?;
         self.worker
-            .restart_openhcl(ged_send, flags, igvm_file.into())
+            .save_openhcl(ged_send, flags, igvm_file.into())
             .await
     }
 
+    async fn restore_openhcl(&self) -> anyhow::Result<()> {
+        let ged_send = self
+            .resources
+            .ged_send
+            .as_ref()
+            .context("openhcl not configured")?;
+
+        self.worker.restore_openhcl(ged_send).await
+    }
+
     async fn modify_vtl2_settings(
         &mut self,
         f: impl FnOnce(&mut Vtl2Settings),

petri/src/worker.rs

@@ -58,13 +58,13 @@ impl Worker {
         self.rpc.call_failable(VmRpc::PulseSaveRestore, ()).await
     }
 
-    pub(crate) async fn restart_openhcl(
+    pub(crate) async fn save_openhcl(
         &self,
         send: &mesh::Sender<get_resources::ged::GuestEmulationRequest>,
         flags: OpenHclServicingFlags,
         file: std::fs::File,
     ) -> anyhow::Result<()> {
-        hvlite_helpers::underhill::service_underhill(
+        hvlite_helpers::underhill::save_underhill(
             &self.rpc,
             send,
             GuestServicingFlags {
@@ -75,6 +75,13 @@ impl Worker {
         .await
     }
 
+    pub(crate) async fn restore_openhcl(
+        &self,
+        send: &mesh::Sender<get_resources::ged::GuestEmulationRequest>,
+    ) -> anyhow::Result<()> {
+        hvlite_helpers::underhill::restore_underhill(&self.rpc, send).await
+    }
+
     pub(crate) async fn inspect_all(&self) -> inspect::Node {
         let mut inspection = inspect::inspect("", &self.handle);
         inspection.resolve().await;