petri: add support for Hyper-V + SCSI-to-SCSI relay, use it (#2171)

In doing #2137, I realized that I had done almost all the work required
to do scsi-to-scsi relay for the Hyper-V backend.

petri:
- Add infra to set VTL2 settings for a Hyper-V test backend.
- Return the SCSI controller VSID when one is added (required to
reference that controller in VTL2 settings...).
- Add a `hyperv_test` macro, so that the test can get access to the
Hyper-V Petri backend (like `openvmm_test`).

vmm_tests:
- Write a test that uses this infra.

Author: mattkur

Cargo.lock

@@ -9286,6 +9286,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "disk_backend_resources",
+ "disk_vhd1",
  "futures",
  "get_resources",
  "guid",

petri/src/vm/hyperv/hyperv.psm1

@@ -181,6 +181,25 @@ function Get-VmCommandLine
     [System.Text.Encoding]::UTF8.GetString($vssd.FirmwareParameters)
 }
 
+function Get-VmScsiControllerProperties
+{
+    [CmdletBinding()]
+    Param (
+        [Parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
+        [System.Object]
+        $Controller
+    )
+
+    $vm = Get-VM -Id $Controller.VMId;
+    $ControllerNumber = $Controller.ControllerNumber;
+
+    $vssd = Get-VmSystemSettings $Vm;
+    $rasds = $vssd | Get-CimAssociatedInstance -ResultClassName "Msvm_ResourceAllocationSettingData" | Where-Object { $_.ResourceSubType -eq "Microsoft:Hyper-V:Synthetic SCSI Controller" };
+    $rasd = $rasds[$ControllerNumber];
+
+    return "$ControllerNumber,$($rasd.VirtualSystemIdentifiers[0])"
+}
+
 function Set-VmScsiControllerTargetVtl
 {
     [CmdletBinding()]
@@ -464,4 +483,64 @@ function Get-GuestStateFile
     $guestStateFile = $vssd.GuestStateFile
 
     return "$guestStateDataRoot\$guestStateFile"
-}
+}
+
+function Set-Vtl2Settings {
+    [CmdletBinding()]
+    param (
+        [Parameter(Position = 0, Mandatory = $true)]
+        [Guid] $VmId,
+
+        [Parameter(Mandatory = $true)]
+        [ValidateNotNullOrEmpty()]
+        [string]$Namespace,
+
+        [Parameter(Mandatory = $true)]
+        [string]$SettingsFile,
+
+        [string]$ClientName = 'Petri'
+    )
+
+    $settingsContent = Get-Content -Raw -Path $SettingsFile
+
+    $guestManagement = Get-VmGuestManagementService
+
+    $options = New-Object Microsoft.Management.Infrastructure.Options.CimOperationOptions
+    $options.SetCustomOption("ClientName", $ClientName, $false)
+
+    # Parameter - VmId
+    $p1 = [Microsoft.Management.Infrastructure.CimMethodParameter]::Create("VmId", $VmId.ToString(), [Microsoft.Management.Infrastructure.cimtype]::String, [Microsoft.Management.Infrastructure.CimFlags]::In)
+
+    # Parameter - Namespace
+    $p2 = [Microsoft.Management.Infrastructure.CimMethodParameter]::Create("Namespace", $Namespace, [Microsoft.Management.Infrastructure.cimtype]::String, [Microsoft.Management.Infrastructure.CimFlags]::In)
+
+    # Parameter - Settings
+    # The input is a byte buffer with the size prepended.
+    # Size is a uint32 in network byte order (i.e. Big Endian)
+    # Size includes the size itself and the payload.
+
+    $bytes = [system.Text.Encoding]::UTF8.GetBytes($settingsContent)
+
+    $header = [System.BitConverter]::GetBytes([uint32]($bytes.Length + 4))
+    if ([System.BitConverter]::IsLittleEndian) {
+        [System.Array]::Reverse($header)
+    }
+    $bytes = $header + $bytes
+
+    $p3 = [Microsoft.Management.Infrastructure.CimMethodParameter]::Create("Settings", $bytes, [Microsoft.Management.Infrastructure.cimtype]::UInt8Array, [Microsoft.Management.Infrastructure.CimFlags]::In)
+
+    $result = $guestManagement | Invoke-CimMethod -MethodName GetManagementVtlSettings -Arguments @{"VmId" = $VmId.ToString(); "Namespace" = $Namespace } |
+    Trace-CimMethodExecution -CimInstance $guestManagement -MethodName "GetManagementVtlSettings"
+    $updateId = $result.CurrentUpdateId
+
+    $p4 = [Microsoft.Management.Infrastructure.CimMethodParameter]::Create("CurrentUpdateId", $updateId, [Microsoft.Management.Infrastructure.cimtype]::UInt64, [Microsoft.Management.Infrastructure.CimFlags]::In)
+
+    $params = New-Object Microsoft.Management.Infrastructure.CimMethodParametersCollection
+    $params.Add($p1); $params.Add($p2); $params.Add($p3); $params.Add($p4)
+
+    $cimSession = New-CimSession
+    $cimSession.InvokeMethod("root\virtualization\v2", $guestManagement, "SetManagementVtlSettings", $params, $options) |
+    Trace-CimMethodExecution -CimInstance $guestManagement -MethodName "SetManagementVtlSettings" | Out-Null
+
+    $cimSession | Remove-CimSession | Out-Null
+}

petri/src/vm/hyperv/mod.rs

@@ -59,6 +59,22 @@ use vmgs_resources::GuestStateEncryptionPolicy;
 /// The Hyper-V Petri backend
 pub struct HyperVPetriBackend {}
 
+/// Represents a SCSI Controller addeded to a VM.
+#[derive(Debug)]
+pub struct HyperVScsiController {
+    /// An identifier provided by the test to identify this controller.
+    pub test_id: String,
+
+    /// The controller number assigned by Hyper-V.
+    pub controller_number: u32,
+
+    /// The target VTL this controller is mapped to (supplied by test).
+    pub target_vtl: u32,
+
+    /// The VSID assigned by Hyper-V for this controller.
+    pub vsid: guid::Guid,
+}
+
 /// Resources needed at runtime for a Hyper-V Petri VM
 pub struct HyperVPetriRuntime {
     vm: HyperVVM,
@@ -68,11 +84,63 @@ pub struct HyperVPetriRuntime {
 
     is_openhcl: bool,
     is_isolated: bool,
+
+    /// Last VTL2 settings set on this VM.
+    vtl2_settings: Option<vtl2_settings_proto::Vtl2Settings>,
+
+    /// Test-added SCSI controllers.
+    /// TODO (future PR): push this into `PetriVmConfig` and use in
+    /// openvmm as well.
+    additional_scsi_controllers: Vec<HyperVScsiController>,
+}
+
+/// Additional configuration for a Hyper-V VM.
+#[derive(Default, Debug)]
+pub struct HyperVPetriConfig {
+    /// VTL2 settings to configure on the VM before petri powers it on.
+    initial_vtl2_settings: Option<vtl2_settings_proto::Vtl2Settings>,
+
+    /// Test-added SCSI controllers (targeting specific VTLs).
+    /// A tuple if test-identifier and targetvtl. Test-identifier
+    /// is used so that the test can find a specific controller, if that
+    /// is important to the test. These are resolved into a list of
+    /// [`HyperVScsiController`] objects stored in the runtime.
+    additional_scsi_controllers: Vec<(String, u32)>,
+}
+
+impl HyperVPetriConfig {
+    /// Add custom VTL 2 settings.
+    // TODO: At some point we want to replace uses of this with nicer with_disk,
+    // with_nic, etc. methods. And unify this with the same function definition
+    // as the openvmm backend.
+    pub fn with_custom_vtl2_settings(
+        mut self,
+        f: impl FnOnce(&mut vtl2_settings_proto::Vtl2Settings),
+    ) -> Self {
+        if self.initial_vtl2_settings.is_none() {
+            self.initial_vtl2_settings = Some(vtl2_settings_proto::Vtl2Settings {
+                version: vtl2_settings_proto::vtl2_settings_base::Version::V1.into(),
+                fixed: None,
+                dynamic: Some(Default::default()),
+                namespace_settings: Default::default(),
+            });
+        }
+
+        f(self.initial_vtl2_settings.as_mut().unwrap());
+        self
+    }
+
+    /// Add an additional SCSI controller to the VM.
+    /// Will be added before the VM starts.
+    pub fn with_additional_scsi_controller(mut self, test_id: String, target_vtl: u32) -> Self {
+        self.additional_scsi_controllers.push((test_id, target_vtl));
+        self
+    }
 }
 
 #[async_trait]
 impl PetriVmmBackend for HyperVPetriBackend {
-    type VmmConfig = ();
+    type VmmConfig = HyperVPetriConfig;
     type VmRuntime = HyperVPetriRuntime;
 
     fn check_compat(firmware: &Firmware, arch: MachineArch) -> bool {
@@ -95,10 +163,6 @@ impl PetriVmmBackend for HyperVPetriBackend {
         modify_vmm_config: Option<impl FnOnce(Self::VmmConfig) -> Self::VmmConfig + Send>,
         resources: &PetriVmResources,
     ) -> anyhow::Result<Self::VmRuntime> {
-        if modify_vmm_config.is_some() {
-            panic!("specified modify_vmm_config, but that is not supported for hyperv");
-        }
-
         let PetriVmConfig {
             name,
             arch,
@@ -327,7 +391,7 @@ impl PetriVmmBackend for HyperVPetriBackend {
             BootDeviceType::Ide => Some((powershell::ControllerType::Ide, 0)),
             BootDeviceType::Scsi => Some((
                 powershell::ControllerType::Scsi,
-                vm.add_scsi_controller(0).await?,
+                vm.add_scsi_controller(0).await?.0,
             )),
             BootDeviceType::Nvme => todo!("NVMe boot device not yet supported for Hyper-V"),
         } {
@@ -384,7 +448,7 @@ impl PetriVmmBackend for HyperVPetriBackend {
                     vm.set_imc(&imc_hive).await?;
                 }
 
-                let controller_number = vm.add_scsi_controller(0).await?;
+                let controller_number = vm.add_scsi_controller(0).await?.0;
                 vm.add_vhd(
                     &agent_disk_path,
                     powershell::ControllerType::Scsi,
@@ -437,7 +501,7 @@ impl PetriVmmBackend for HyperVPetriBackend {
                 if build_and_persist_agent_image(&agent_image, &agent_disk_path)
                     .context("vtl2 agent disk")?
                 {
-                    let controller_number = vm.add_scsi_controller(2).await?;
+                    let controller_number = vm.add_scsi_controller(2).await?.0;
                     vm.add_vhd(
                         &agent_disk_path,
                         powershell::ControllerType::Scsi,
@@ -507,6 +571,32 @@ impl PetriVmmBackend for HyperVPetriBackend {
             hyperv_serial_log_task(driver.clone(), serial_pipe_path, serial_log_file),
         ));
 
+        let mut added_controllers = Vec::new();
+        let mut vtl2_settings = None;
+
+        // TODO: If OpenHCL is being used, then translate storage through it.
+        // (requires changes above where VHDs are added)
+        if let Some(modify_vmm_config) = modify_vmm_config {
+            let config = modify_vmm_config(HyperVPetriConfig::default());
+
+            tracing::debug!(?config, "additional hyper-v config");
+
+            for (test_id, target_vtl) in config.additional_scsi_controllers {
+                let (controller_number, vsid) = vm.add_scsi_controller(target_vtl).await?;
+                added_controllers.push(HyperVScsiController {
+                    test_id,
+                    controller_number,
+                    target_vtl,
+                    vsid,
+                });
+            }
+
+            if let Some(settings) = &config.initial_vtl2_settings {
+                vm.set_base_vtl2_settings(settings).await?;
+                vtl2_settings = Some(settings.clone());
+            }
+        }
+
         vm.start().await?;
 
         Ok(HyperVPetriRuntime {
@@ -516,10 +606,63 @@ impl PetriVmmBackend for HyperVPetriBackend {
             driver: driver.clone(),
             is_openhcl: openhcl_config.is_some(),
             is_isolated: firmware.isolation().is_some(),
+            additional_scsi_controllers: added_controllers,
+            vtl2_settings,
         })
     }
 }
 
+impl HyperVPetriRuntime {
+    /// Gets the VTL2 settings in the `Base` namespace.
+    ///
+    /// TODO: For now, this is just a copy of whatever was last set via petri.
+    /// The function signature (`async`, return `Result`) is to allow for
+    /// future changes to actually query the VM for the current settings.
+    pub async fn get_base_vtl2_settings(
+        &self,
+    ) -> anyhow::Result<Option<vtl2_settings_proto::Vtl2Settings>> {
+        Ok(self.vtl2_settings.clone())
+    }
+
+    /// Get the list of additional SCSI controllers added to this VM (those
+    /// configured to be added by the test, as opposed to the petri framework).
+    pub fn get_additional_scsi_controllers(&self) -> &[HyperVScsiController] {
+        &self.additional_scsi_controllers
+    }
+
+    /// Set the VTL2 settings in the `Base` namespace (fixed settings, storage
+    /// settings, etc).
+    pub async fn set_base_vtl2_settings(
+        &mut self,
+        settings: &vtl2_settings_proto::Vtl2Settings,
+    ) -> anyhow::Result<()> {
+        let r = self.vm.set_base_vtl2_settings(settings).await;
+        if r.is_ok() {
+            self.vtl2_settings = Some(settings.clone());
+        }
+        r
+    }
+
+    /// Adds a VHD with the optionally specified location (a.k.a LUN) to the
+    /// optionally specified controller.
+    pub async fn add_vhd(
+        &mut self,
+        vhd: impl AsRef<Path>,
+        controller_type: powershell::ControllerType,
+        controller_location: Option<u32>,
+        controller_number: Option<u32>,
+    ) -> anyhow::Result<()> {
+        self.vm
+            .add_vhd(
+                vhd.as_ref(),
+                controller_type,
+                controller_location,
+                controller_number,
+            )
+            .await
+    }
+}
+
 #[async_trait]
 impl PetriVmRuntime for HyperVPetriRuntime {
     type VmInspector = NoPetriVmInspector;