vmm: pause/resume VM during the VM events

For MSHV we always create frozen partition, so we
resume the VM during boot. Also during pause and resume
VM events we call hypervisor specific API.

Signed-off-by: Muminul Islam <muislam@microsoft.com>

vmm/src/vm.rs

@@ -319,6 +319,9 @@ pub enum Error {
 
     #[error("Error injecting NMI")]
     ErrorNmi,
+    #[cfg(feature = "mshv")]
+    #[error("Error unfreezing the VM: {0}")]
+    UnfreezeVm(#[source] hypervisor::HypervisorVmError),
 }
 pub type Result<T> = result::Result<T, Error>;
 
@@ -2173,6 +2176,11 @@ impl Vm {
             self.vm.tdx_finalize().map_err(Error::FinalizeTdx)?;
         }
 
+        // Unfreeze the vm for MSHV
+        #[cfg(feature = "mshv")]
+        if current_state == VmState::Created {
+            self.vm.resume().map_err(Error::UnfreezeVm)?;
+        }
         self.cpu_manager
             .lock()
             .unwrap()
@@ -2487,6 +2495,11 @@ impl Pausable for Vm {
         self.cpu_manager.lock().unwrap().pause()?;
         self.device_manager.lock().unwrap().pause()?;
 
+        #[cfg(feature = "mshv")]
+        self.vm
+            .pause()
+            .map_err(|e| MigratableError::Pause(anyhow!("Could not freeze the VM: {}", e)))?;
+
         *state = new_state;
 
         event!("vm", "paused");
@@ -2495,6 +2508,8 @@ impl Pausable for Vm {
 
     fn resume(&mut self) -> std::result::Result<(), MigratableError> {
         event!("vm", "resuming");
+        #[cfg(feature = "mshv")]
+        let current_state = self.get_state().unwrap();
         let mut state = self
             .state
             .try_write()
@@ -2514,6 +2529,13 @@ impl Pausable for Vm {
                 })?;
             }
         }
+        #[cfg(feature = "mshv")]
+        if current_state == VmState::Paused {
+            self.vm.resume().map_err(|e| {
+                MigratableError::Resume(anyhow!("Could not unfreeze the VM: {}", e))
+            })?;
+        }
+
         self.device_manager.lock().unwrap().resume()?;
 
         // And we're back to the Running state.