openvmm: update command line params from test before servicing (#2446)

This PR adds support to update the CLI params for openhcl
post-configuration. The updated CLI params are used for the *next* boot.
This allows a test to update the CLI args used across servicing.

Author: gurasinghMS

openvmm/hvlite_core/src/worker/dispatch.rs

@@ -2951,6 +2951,17 @@ impl LoadedVm {
                     VmRpc::WriteMemory(rpc) => rpc.handle_failable_sync(|(gpa, bytes)| {
                         self.inner.gm.write_at(gpa, bytes.as_slice())
                     }),
+                    VmRpc::UpdateCliParams(rpc) => {
+                        rpc.handle_failable_sync(|params| match &mut self.inner.load_mode {
+                            LoadMode::Igvm { cmdline, .. } => {
+                                *cmdline = params;
+                                Ok(())
+                            }
+                            _ => anyhow::bail!(
+                                "Updating command line parameters is only supported for Igvm load mode"
+                            ),
+                        })
+                    }
                 },
                 Event::Halt(Err(_)) => break,
                 Event::Halt(Ok(reason)) => {

openvmm/hvlite_defs/src/rpc.rs

@@ -31,6 +31,9 @@ pub enum VmRpc {
     CompleteReloadIgvm(FailableRpc<bool, ()>),
     ReadMemory(FailableRpc<(u64, usize), Vec<u8>>),
     WriteMemory(FailableRpc<(u64, Vec<u8>), ()>),
+    /// Updates the command line parameters that will be passed to the boot shim
+    /// on the *next* VM load. This will replace the existing command line parameters.
+    UpdateCliParams(FailableRpc<String, ()>),
 }
 
 #[derive(Debug, MeshPayload, thiserror::Error)]
@@ -63,6 +66,7 @@ impl fmt::Debug for VmRpc {
             VmRpc::CompleteReloadIgvm(_) => "CompleteReloadIgvm",
             VmRpc::ReadMemory(_) => "ReadMemory",
             VmRpc::WriteMemory(_) => "WriteMemory",
+            VmRpc::UpdateCliParams(_) => "UpdateCliParams",
         };
         f.pad(s)
     }

petri/src/vm/hyperv/mod.rs

@@ -863,6 +863,10 @@ impl PetriVmRuntime for HyperVPetriRuntime {
         anyhow::bail!("restoring OpenHCL firmware separately is not yet supported on Hyper-V");
     }
 
+    async fn update_command_line(&mut self, _command_line: &str) -> anyhow::Result<()> {
+        anyhow::bail!("updating command line 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

@@ -1014,6 +1014,12 @@ impl<T: PetriVmmBackend> PetriVm<T> {
             .await
     }
 
+    /// Update the command line parameter of the running VM that will apply on next boot.
+    /// Will fail if the VM is not using IGVM load mode.
+    pub async fn update_command_line(&mut self, command_line: &str) -> anyhow::Result<()> {
+        self.runtime.update_command_line(command_line).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 or if this is called twice in succession
     pub async fn save_openhcl(
@@ -1122,6 +1128,9 @@ pub trait PetriVmRuntime: Send + Sync + 'static {
     /// 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<()>;
+    /// Update the command line parameter of the running VM that will apply on next boot.
+    /// Will fail if the VM is not using IGVM load mode.
+    async fn update_command_line(&mut self, command_line: &str) -> anyhow::Result<()>;
     /// If the backend supports it, get an inspect interface
     fn inspector(&self) -> Option<Self::VmInspector> {
         None

petri/src/vm/openvmm/runtime.rs

@@ -144,6 +144,10 @@ impl PetriVmRuntime for PetriVmOpenVmm {
         Self::restore_openhcl(self).await
     }
 
+    async fn update_command_line(&mut self, command_line: &str) -> anyhow::Result<()> {
+        Self::update_command_line(self, command_line).await
+    }
+
     fn inspector(&self) -> Option<OpenVmmInspector> {
         Some(OpenVmmInspector {
             worker: self.inner.worker.clone(),
@@ -240,6 +244,13 @@ impl PetriVmOpenVmm {
             &mut self
         ) -> anyhow::Result<()>
     );
+    petri_vm_fn!(
+        /// Updates the command line parameters of the running VM.
+        pub async fn update_command_line(
+            &mut self,
+            command_line: &str
+        ) -> anyhow::Result<()>
+    );
     petri_vm_fn!(
         /// Resets the hardware state of the VM, simulating a power cycle.
         pub async fn reset(&mut self) -> anyhow::Result<()>
@@ -407,6 +418,10 @@ impl PetriVmInner {
             .await
     }
 
+    async fn update_command_line(&mut self, command_line: &str) -> anyhow::Result<()> {
+        self.worker.update_command_line(command_line).await
+    }
+
     async fn restore_openhcl(&self) -> anyhow::Result<()> {
         let ged_send = self
             .resources

petri/src/worker.rs

@@ -83,6 +83,13 @@ impl Worker {
         hvlite_helpers::underhill::restore_underhill(&self.rpc, send).await
     }
 
+    pub(crate) async fn update_command_line(&self, command_line: &str) -> anyhow::Result<()> {
+        self.rpc
+            .call_failable(VmRpc::UpdateCliParams, command_line.to_string())
+            .await?;
+        Ok(())
+    }
+
     pub(crate) async fn inspect_all(&self) -> inspect::Node {
         let mut inspection = inspect::inspect("", &self.handle);
         inspection.resolve().await;