pr feedback + tests

Author: mattkur

openhcl/openhcl_boot/src/host_params/dt/dma_hint.rs

@@ -36,6 +36,7 @@ use igvm_defs::PAGE_SIZE_4K;
 ///
 /// The table is sorted by VP count, then by assigned memory.
 /// (vp_count, vtl2_memory_mb, dma_hint_mb)
+#[cfg(not(debug_assertions))]
 const LOOKUP_TABLE: &[(u16, u16, u16); 38] = &[
     (2, 96, 2),
     (2, 98, 4),
@@ -77,6 +78,16 @@ const LOOKUP_TABLE: &[(u16, u16, u16); 38] = &[
     (896, 12912, 0), // (516) Needs to be validated as the vNIC number is unknown. (TODO, as part of network device keepalive support).
 ];
 
+/// TEST ONLY variant of the lookup table above. Since the IGVM manifest specifies additional
+/// VTL2 memory for dev (well above what is required for release configs), allow the heuristics
+/// to still kick in.
+#[cfg(debug_assertions)]
+const LOOKUP_TABLE: &[(u16, u16, u16); 3] = &[
+    (4, 496, 32),    // 4 VP, default memory for dev, allocate some memory for DMA.
+    (16, 768, 128), // 16 VP "heavy", with extra memory above what is required for dev, allocate some memory for DMA.
+    (32, 1024, 256), // 32 VP "very heavy", with extra memory above what is required for dev, allocate some memory for DMA.
+];
+
 const ONE_MB: u64 = 1024 * 1024;
 
 /// Maximum allowed memory size for DMA hint calculation (1 TiB).

openhcl/openhcl_boot/src/host_params/dt/mod.rs

@@ -534,14 +534,15 @@ fn topology_from_host_dt(
 
         if dt_page_count.is_some() || cmdline_page_count.is_some() {
             // Any external source defined the pool size, use the maximum of all external sources.
-            max(dt_page_count.unwrap_or(0), cmdline_page_count.unwrap_or(0))
+            let external = max(dt_page_count.unwrap_or(0), cmdline_page_count.unwrap_or(0));
+            if external == 0 { None } else { Some(external) }
         } else {
             // No external source defined the pool size, use heuristics to decide.
             let mem_size = vtl2_ram.iter().map(|e| e.range.len()).sum();
-            vtl2_calculate_dma_hint(parsed.cpu_count(), mem_size)
+            Some(vtl2_calculate_dma_hint(parsed.cpu_count(), mem_size))
         }
     };
-    if vtl2_gpa_pool_size != 0 {
+    if let Some(vtl2_gpa_pool_size) = vtl2_gpa_pool_size {
         // Reserve the specified number of pages for the pool. Use the used
         // ranges to figure out which VTL2 memory is free to allocate from.
         let pool_size_bytes = vtl2_gpa_pool_size * HV_PAGE_SIZE;

vmm_tests/vmm_tests/tests/tests/x86_64/openhcl_uefi.rs

@@ -165,7 +165,7 @@ async fn nvme_relay(config: PetriVmBuilder<OpenVmmPetriBackend>) -> Result<(), a
 ///
 /// Use the private pool override to test the private pool dma path.
 #[openvmm_test(openhcl_uefi_x64[nvme](vhd(ubuntu_2504_server_x64)))]
-async fn nvme_relay_private_pool(
+async fn nvme_relay_explicit_private_pool(
     config: PetriVmBuilder<OpenVmmPetriBackend>,
 ) -> Result<(), anyhow::Error> {
     // Number of pages to reserve as a private pool.
@@ -183,14 +183,43 @@ async fn nvme_relay_private_pool(
     .await
 }
 
+/// Test an OpenHCL uefi VM with a NVME disk assigned to VTL2 that boots
+/// linux, with vmbus relay. This should expose a disk to VTL0 via vmbus.
+///
+/// There _should_ be enough private pool memory for the NVMe driver to
+/// allocate all of its buffers contiguously.
+#[cfg(debug_assertions)]
+#[openvmm_test(openhcl_uefi_x64[nvme](vhd(ubuntu_2504_server_x64)))]
+async fn nvme_relay_heuristic_16vp_768mb_heavy(
+    config: PetriVmBuilder<OpenVmmPetriBackend>,
+) -> Result<(), anyhow::Error> {
+    nvme_relay_test_core(
+        config,
+        "",
+        Some(ProcessorTopology {
+            vp_count: 16,
+            ..Default::default()
+        }),
+        Some(hvlite_defs::config::Vtl2BaseAddressType::Vtl2Allocate {
+            size: Some(768 * 1024 * 1024),
+        }),
+        Some(ExpectedNvmeDeviceProperties {
+            save_restore_supported: true,
+            qsize: 256, // private pool should allow contiguous allocations.
+            nvme_keepalive: false,
+        }),
+    )
+    .await
+}
+
 /// Test an OpenHCL uefi VM with a NVME disk assigned to VTL2 that boots
 /// linux, with vmbus relay. This should expose a disk to VTL0 via vmbus.
 ///
 /// There _should_ be enough private pool memory for the NVMe driver to
 /// allocate all of its buffers contiguously.
 #[cfg(not(debug_assertions))]
 #[openvmm_test(openhcl_uefi_x64[nvme](vhd(ubuntu_2504_server_x64)))]
-async fn nvme_relay_private_16vp_256mb(
+async fn nvme_relay_heuristic_release_16vp_256mb_heavy(
     config: PetriVmBuilder<OpenVmmPetriBackend>,
 ) -> Result<(), anyhow::Error> {
     nvme_relay_test_core(
@@ -222,7 +251,7 @@ async fn nvme_relay_private_16vp_256mb(
 /// of the heuristics exactly, but there should still be private pool memory.
 #[cfg(not(debug_assertions))]
 #[openvmm_test(openhcl_uefi_x64[nvme](vhd(ubuntu_2504_server_x64)))]
-async fn nvme_relay_private_32vp_500mb(
+async fn nvme_relay_heuristic_release_32vp_500mb_very_heavy(
     config: PetriVmBuilder<OpenVmmPetriBackend>,
 ) -> Result<(), anyhow::Error> {
     nvme_relay_test_core(