petri: add NVMe emulator support for Hyper-V

Author: babayet2

petri/src/vm/hyperv/hyperv.psm1

@@ -222,6 +222,19 @@ function New-CustomVM
         # }
         [hashtable] $ScsiControllers = $null,
 
+        # must be a hashtable with format:
+        # NvmeControllers => {
+        #     Vsid => {
+        #         Vtl,
+        #         Drives => {
+        #             Nsid => DiskPath,
+        #             ...
+        #         }
+        #     },
+        #     ...
+        # }
+        [hashtable] $NvmeControllers = $null,
+
         # must be a hashtable with format:
         # IdeControllers => {
         #     ControllerNumber => {
@@ -352,6 +365,26 @@ function New-CustomVM
         }
     }
 
+    if ($NvmeControllers) {
+        Import-Module HvlDeviceHost
+        foreach ($controller in $NvmeControllers.GetEnumerator()) {
+            $vsid = $controller.Name
+            $targetVtl = $controller.Value["Vtl"]
+            $drives = $controller.Value["Drives"]
+            # Sort drives by NSID to produce ordered VHD paths — the emulator
+            # assigns NSIDs 1..N by argument order.
+            #
+            # TODO explicit NSID mapping when emulator supports --nsid
+            $sortedDrives = $drives.GetEnumerator() | Sort-Object { [int]$_.Name }
+            $vhdPaths = @($sortedDrives | ForEach-Object { $_.Value })
+            $resourceSettings += New-NvmeEmulatorRasd `
+                -VhdPaths $vhdPaths `
+                -TargetVtl $targetVtl `
+                -Vsid ([Guid]$vsid) `
+                | ConvertTo-CimEmbeddedString
+        }
+    }
+
     $vm = ($vmms | Invoke-CimMethod -Name "DefineSystem" -Arguments @{
         "SystemSettings"   = ($vssd | ConvertTo-CimEmbeddedString);
         "ResourceSettings" = $resourceSettings
@@ -1418,4 +1451,4 @@ function Get-CimInstancePath {
     )
 
     return $path
-}
+}

petri/src/vm/hyperv/mod.rs

@@ -221,8 +221,8 @@ impl PetriVmmBackend for HyperVPetriBackend {
             }
         }
 
-        // Map SCSI
-        let mut scsi_controllers = HashMap::new();
+        // Map VMBus storage controllers (SCSI and NVMe).
+        let mut storage_controllers = HashMap::new();
         for (
             vsid,
             VmbusStorageController {
@@ -232,9 +232,16 @@ impl PetriVmmBackend for HyperVPetriBackend {
             },
         ) in config.vmbus_storage_controllers.iter()
         {
-            if !matches!(controller_type, crate::VmbusStorageType::Scsi) {
-                todo!("other storage types for hyper-v")
-            }
+            let vtl_num = match target_vtl {
+                crate::Vtl::Vtl0 => 0u8,
+                crate::Vtl::Vtl2 => 2u8,
+                _ => {
+                    anyhow::bail!(
+                        "unsupported VTL {:?} for storage controller",
+                        target_vtl
+                    )
+                }
+            };
 
             let mut hyperv_drives = HashMap::new();
             for (lun, Drive { disk, is_dvd }) in drives {
@@ -246,10 +253,47 @@ impl PetriVmmBackend for HyperVPetriBackend {
                     },
                 );
             }
-            scsi_controllers.insert(
+
+            let vmbus_controller_type = match controller_type {
+                crate::VmbusStorageType::Scsi => powershell::HyperVVmbusStorageType::Scsi,
+                crate::VmbusStorageType::Nvme => {
+                    // Validate NVMe constraints on drives.
+                    for (nsid, drive) in &hyperv_drives {
+                        if drive.is_dvd {
+                            anyhow::bail!("NVMe emulator does not support DVD drives");
+                        }
+                        if drive.disk.is_none() {
+                            anyhow::bail!("NVMe drive cannot be empty (NSID {})", nsid);
+                        }
+                    }
+                    // The emulator assigns NSIDs sequentially (1..N) by VHD
+                    // argument order. Validate keys are exactly 1..N.
+                    //
+                    // TODO the emulator should accept NSID/VHD pairs
+                    let expected: Vec<u32> = (1..=hyperv_drives.len() as u32).collect();
+                    let mut actual: Vec<u32> = hyperv_drives.keys().copied().collect();
+                    actual.sort();
+                    anyhow::ensure!(
+                        actual == expected,
+                        "NVMe namespace IDs must be 1..{}, got {:?}",
+                        expected.len(),
+                        actual
+                    );
+                    powershell::HyperVVmbusStorageType::Nvme
+                }
+                _ => {
+                    todo!(
+                        "storage type {:?} not yet supported for hyper-v",
+                        controller_type
+                    )
+                }
+            };
+
+            storage_controllers.insert(
                 *vsid,
-                powershell::HyperVScsiController {
-                    target_vtl: *target_vtl,
+                powershell::HyperVVmbusStorageController {
+                    controller_type: vmbus_controller_type,
+                    target_vtl: vtl_num,
                     drives: hyperv_drives,
                 },
             );
@@ -338,8 +382,7 @@ impl PetriVmmBackend for HyperVPetriBackend {
             firmware_file: igvm_file.clone(),
             firmware_parameters: openhcl_command_line,
             guest_state_path,
-            scsi_controllers,
-            ide_controllers,
+            storage_controllers,
             com_3: supports_com3,
             imc_hiv,
             management_vtl_settings,

petri/src/vm/hyperv/powershell.rs

@@ -8,7 +8,6 @@ use crate::OpenHclServicingFlags;
 use crate::PetriVmConfig;
 use crate::PetriVmProperties;
 use crate::VmScreenshotMeta;
-use crate::Vtl;
 use crate::run_host_cmd;
 use crate::vm::append_cmdline;
 use anyhow::Context;
@@ -290,8 +289,8 @@ pub struct HyperVNewCustomVMArgs {
     pub hw_threads_per_core: Option<u64>,
     /// Processors per socket
     pub max_processors_per_numa_node: Option<u64>,
-    /// SCSI controllers and associated drives/disks
-    pub scsi_controllers: HashMap<Guid, HyperVScsiController>,
+    /// VMBus storage controllers (SCSI and NVMe), keyed by VSID
+    pub storage_controllers: HashMap<Guid, HyperVVmbusStorageController>,
     /// IDE controllers and associated drives/disks
     pub ide_controllers: HashMap<u32, HashMap<u8, HyperVDrive>>,
     /// Temporary file containing initial machine configuration data
@@ -306,11 +305,22 @@ pub struct HyperVNewCustomVMArgs {
     pub management_vtl_settings: Option<NamedTempFile>,
 }
 
-/// Hyper-V SCSI controller
-pub struct HyperVScsiController {
-    /// The VTL to assign the storage controller to
-    pub target_vtl: Vtl,
-    /// Drives (with any inserted disks) attached to this storage controller
+/// VMBus storage controller type
+pub enum HyperVVmbusStorageType {
+    /// SCSI controller (Msvm_ResourceAllocationSettingData)
+    Scsi,
+    /// NVMe emulator controller (created via closed-source HvlDeviceHost module)
+    Nvme,
+}
+
+/// VMBus storage controller configuration (SCSI or NVMe), keyed by VSID.
+pub struct HyperVVmbusStorageController {
+    /// Controller type
+    pub controller_type: HyperVVmbusStorageType,
+    /// Target VTL (0 or 2)
+    pub target_vtl: u8,
+    /// Drives attached to this controller, keyed by LUN (SCSI) or namespace ID (NVMe).
+    /// For NVMe, keys must be exactly 1..N.
     pub drives: HashMap<u32, HyperVDrive>,
 }
 
@@ -565,7 +575,7 @@ impl HyperVNewCustomVMArgs {
             firmware_file: None,
             firmware_parameters: None,
             guest_state_path: None,
-            scsi_controllers: HashMap::new(),
+            storage_controllers: HashMap::new(),
             ide_controllers: HashMap::new(),
             com_3: false,
             imc_hiv: None,
@@ -596,9 +606,23 @@ pub async fn run_new_customvm(ps_mod: &Path, args: HyperVNewCustomVMArgs) -> any
         }
     });
 
-    let scsi_controllers = (!args.scsi_controllers.is_empty()).then(|| {
-        ps::HashTable::new(args.scsi_controllers.into_iter().map(
-            |(vsid, HyperVScsiController { target_vtl, drives })| {
+    // Partition storage controllers into SCSI and NVMe.
+    let mut scsi_map: HashMap<Guid, HyperVVmbusStorageController> = HashMap::new();
+    let mut nvme_map: HashMap<Guid, HyperVVmbusStorageController> = HashMap::new();
+    for (vsid, controller) in args.storage_controllers {
+        match controller.controller_type {
+            HyperVVmbusStorageType::Scsi => {
+                scsi_map.insert(vsid, controller);
+            }
+            HyperVVmbusStorageType::Nvme => {
+                nvme_map.insert(vsid, controller);
+            }
+        }
+    }
+
+    let scsi_controllers = (!scsi_map.is_empty()).then(|| {
+        ps::HashTable::new(scsi_map.into_iter().map(
+            |(vsid, HyperVVmbusStorageController { target_vtl, drives, .. })| {
                 (
                     format!("\"{vsid}\""),
                     ps::Value::new(ps::HashTable::new([
@@ -645,11 +669,48 @@ pub async fn run_new_customvm(ps_mod: &Path, args: HyperVNewCustomVMArgs) -> any
             ))
         });
 
+    // Serialize NVMe controllers as a hashtable keyed by VSID.
+    // Each value: @{ Vtl = N; Drives = @{ Nsid = "DiskPath"; ... } }
+    // New-CustomVM imports HvlDeviceHost internally and calls New-NvmeEmulatorRasd.
+    let nvme_controllers = (!nvme_map.is_empty()).then(|| {
+        ps::HashTable::new(nvme_map.into_iter().map(
+            |(vsid, HyperVVmbusStorageController { target_vtl, drives, .. })| {
+                // Sort drives by key (namespace ID) to produce ordered VHD
+                // paths — the emulator assigns NSIDs 1..N by argument order.
+                let mut sorted_drives: Vec<_> = drives.into_iter().collect();
+                sorted_drives.sort_by_key(|(nsid, _)| *nsid);
+                (
+                    // VSID without braces — VMMS InitializeValues calls
+                    // UuidFromString which rejects the {}-wrapped format.
+                    format!("\"{vsid}\""),
+                    ps::Value::new(ps::HashTable::new([
+                        ("Vtl", ps::Value::new(target_vtl as u32)),
+                        (
+                            "Drives",
+                            ps::Value::new(ps::HashTable::new(sorted_drives.into_iter().map(
+                                |(nsid, HyperVDrive { disk, .. })| {
+                                    (
+                                        nsid.to_string(),
+                                        ps::Value::new(
+                                            disk.expect("NVMe drives must have disk paths"),
+                                        ),
+                                    )
+                                },
+                            ))),
+                        ),
+                    ])),
+                )
+            },
+        ))
+    });
+
+    let builder = PowerShellBuilder::new()
+        .cmdlet("Import-Module")
+        .positional(ps_mod)
+        .next();
+
     let vmid = run_host_cmd(
-        PowerShellBuilder::new()
-            .cmdlet("Import-Module")
-            .positional(ps_mod)
-            .next()
+        builder
             .cmdlet("New-CustomVM")
             .arg("VMName", args.name)
             .arg_opt("Generation", args.generation)
@@ -686,6 +747,7 @@ pub async fn run_new_customvm(ps_mod: &Path, args: HyperVNewCustomVMArgs) -> any
             )
             .arg_opt("ScsiControllers", scsi_controllers)
             .arg_opt("IdeControllers", ide_controllers)
+            .arg_opt("NvmeControllers", nvme_controllers)
             .arg_opt("ImcHive", args.imc_hiv.as_ref().map(|f| f.path()))
             .arg("Com1", args.com_1)
             .arg("Com3", args.com_3)

vmm_tests/vmm_tests/tests/tests/x86_64/storage.rs

@@ -381,7 +381,83 @@ async fn storvsp_hyperv<T: PetriVmmBackend>(
     Ok(())
 }
 
-/// Test an OpenHCL Linux Stripe VM with two SCSI disk assigned to VTL2 via NVMe Emulator
+/// Test a Hyper-V OpenHCL Linux VM with an NVMe emulator device assigned to
+/// VTL2, relayed to VTL0 via SCSI. Validates that the guest can discover and
+/// perform IO on the disk.
+#[cfg(windows)]
+#[vmm_test(unstable_hyperv_openhcl_uefi_x64(vhd(ubuntu_2504_server_x64)))]
+async fn storvsp_nvme_hyperv<T: PetriVmmBackend>(
+    config: PetriVmBuilder<T>,
+) -> Result<(), anyhow::Error> {
+    let vtl0_nvme_lun = 0;
+    let nvme_nsid = 1;
+    let nvme_vsid = Guid::new_random();
+    let scsi_instance = Guid::new_random();
+    const NVME_DISK_SECTORS: u64 = 0x5_0000;
+    const SECTOR_SIZE: u64 = 512;
+    const EXPECTED_NVME_DISK_SIZE_BYTES: u64 = NVME_DISK_SECTORS * SECTOR_SIZE;
+
+    // Assumptions made by test infra & routines:
+    //
+    // 1. Some test-infra added disks are 64MiB in size. Since we find disks by size,
+    // ensure that our test disks are a different size.
+    // 2. Disks under test need to be at least 100MiB for the IO tests (see [`test_storage_linux`]),
+    // with some arbitrary buffer (5MiB in this case).
+    static_assertions::const_assert_ne!(EXPECTED_NVME_DISK_SIZE_BYTES, 64 * 1024 * 1024);
+    static_assertions::const_assert!(EXPECTED_NVME_DISK_SIZE_BYTES > 105 * 1024 * 1024);
+
+    let mut vhd =
+        tempfile::NamedTempFile::with_suffix("nvme.vhd").context("create temp nvme vhd")?;
+    vhd.as_file()
+        .set_len(EXPECTED_NVME_DISK_SIZE_BYTES)
+        .context("set file length")?;
+
+    disk_vhd1::Vhd1Disk::make_fixed(vhd.as_file_mut()).context("make fixed")?;
+
+    // Close the handle without deleting the file, so Hyper-V can open it.
+    let vhd_path = vhd.into_temp_path();
+
+    let (vm, agent) = config
+        .with_vmbus_redirect(true)
+        .add_vmbus_storage_controller(&nvme_vsid, petri::Vtl::Vtl2, petri::VmbusStorageType::Nvme)
+        .add_vmbus_drive(
+            petri::Drive::new(Some(petri::Disk::Persistent(vhd_path.to_path_buf())), false),
+            &nvme_vsid,
+            Some(nvme_nsid),
+        )
+        .add_vtl2_storage_controller(
+            Vtl2StorageControllerBuilder::new(ControllerType::Scsi)
+                .with_instance_id(scsi_instance)
+                .add_lun(
+                    Vtl2LunBuilder::disk()
+                        .with_location(vtl0_nvme_lun)
+                        .with_physical_device(Vtl2StorageBackingDeviceBuilder::new(
+                            ControllerType::Nvme,
+                            nvme_vsid,
+                            nvme_nsid,
+                        )),
+                )
+                .build(),
+        )
+        .run()
+        .await?;
+
+    test_storage_linux(
+        &agent,
+        scsi_instance,
+        vec![ExpectedGuestDevice {
+            lun: vtl0_nvme_lun,
+            disk_size_sectors: NVME_DISK_SECTORS as usize,
+            friendly_name: "nvme".to_string(),
+        }],
+    )
+    .await?;
+
+    agent.power_off().await?;
+    vm.wait_for_clean_teardown().await?;
+
+    Ok(())
+}
 #[openvmm_test(
     openhcl_linux_direct_x64,
     openhcl_uefi_x64(vhd(ubuntu_2504_server_x64))