Inform openhcl about self hint and print it

Author: yupavlen-ms

openhcl/bootloader_fdt_parser/src/lib.rs

@@ -169,6 +169,8 @@ pub struct ParsedBootDtInfo {
     /// VTL2 range for private pool memory.
     #[inspect(iter_by_index)]
     pub private_pool_ranges: Vec<MemoryRangeWithNode>,
+    /// Source of DMA hint calculation.
+    pub dma_hint_self: bool,
 }
 
 fn err_to_owned(e: fdt::parser::Error<'_>) -> anyhow::Error {
@@ -207,6 +209,7 @@ struct OpenhclInfo {
     memory_allocation_mode: MemoryAllocationMode,
     isolation: IsolationType,
     private_pool_ranges: Vec<MemoryRangeWithNode>,
+    dma_hint_self: bool,
 }
 
 fn parse_memory_openhcl(node: &Node<'_>) -> anyhow::Result<AddressRange> {
@@ -394,6 +397,11 @@ fn parse_openhcl(node: &Node<'_>) -> anyhow::Result<OpenhclInfo> {
         .transpose()
         .context("unable to read vtl0-alias-map")?;
 
+    let dma_hint_self = matches!(
+        try_find_property(node, "dma-hint").and_then(|p| p.read_str().ok()),
+        Some("self")
+    );
+
     // Extract vmbus mmio information from the overall memory map.
     let vtl0_mmio = memory
         .iter()
@@ -416,6 +424,7 @@ fn parse_openhcl(node: &Node<'_>) -> anyhow::Result<OpenhclInfo> {
         memory_allocation_mode,
         isolation,
         private_pool_ranges,
+        dma_hint_self,
     })
 }
 
@@ -509,6 +518,7 @@ impl ParsedBootDtInfo {
         let mut isolation = IsolationType::None;
         let mut vtl2_reserved_range = MemoryRange::EMPTY;
         let mut private_pool_ranges = Vec::new();
+        let mut dma_hint_self = false;
 
         let parser = Parser::new(raw)
             .map_err(err_to_owned)
@@ -538,6 +548,7 @@ impl ParsedBootDtInfo {
                         memory_allocation_mode: n_memory_allocation_mode,
                         isolation: n_isolation,
                         private_pool_ranges: n_private_pool_ranges,
+                        dma_hint_self: n_dma_hint_self,
                     } = parse_openhcl(&child)?;
                     vtl0_mmio = n_vtl0_mmio;
                     config_ranges = n_config_ranges;
@@ -548,6 +559,7 @@ impl ParsedBootDtInfo {
                     isolation = n_isolation;
                     vtl2_reserved_range = n_vtl2_reserved_range;
                     private_pool_ranges = n_private_pool_ranges;
+                    dma_hint_self = n_dma_hint_self;
                 }
 
                 _ if child.name.starts_with("memory@") => {
@@ -580,6 +592,7 @@ impl ParsedBootDtInfo {
             isolation,
             vtl2_reserved_range,
             private_pool_ranges,
+            dma_hint_self,
         })
     }
 }
@@ -945,6 +958,7 @@ mod tests {
                 range: MemoryRange::new(0x60000..0x70000),
                 vnode: 0,
             }],
+            dma_hint_self: false,
         };
 
         let dt = build_dt(&orig_info).unwrap();

openhcl/openhcl_boot/src/dt.rs

@@ -483,6 +483,11 @@ pub fn write_dt(
         openhcl_builder = openhcl_builder.add_u64(p_vtl0_alias_map, data)?;
     }
 
+    if partition_info.dma_hint_self {
+        let p_dma_hint = openhcl_builder.add_string("dma-hint")?;
+        openhcl_builder = openhcl_builder.add_str(p_dma_hint, "self")?;
+    }
+
     #[derive(Debug, Copy, Clone, PartialEq, Eq)]
     struct Vtl2MemoryEntry {
         range: MemoryRange,

openhcl/openhcl_boot/src/host_params/dt.rs

@@ -456,6 +456,7 @@ impl PartitionInfo {
             .vtl2_used_ranges
             .extend(flatten_ranges(used_ranges.iter().copied()));
 
+        let mut vtl2_dma_hint_self = false;
         // Decide if we will reserve memory for a VTL2 private pool. Parse this
         // from the final command line, or the host provided device tree value.
         let vtl2_gpa_pool_size = {
@@ -472,6 +473,7 @@ impl PartitionInfo {
             {
                 // If host did not provide the DMA hint value, re-evaluate
                 // it internally if conditions satisfy.
+                vtl2_dma_hint_self = true;
                 vtl2_calculate_dma_hint(parsed.cpu_count(), storage)
             } else {
                 hostval
@@ -512,6 +514,7 @@ impl PartitionInfo {
                 .extend(flatten_ranges(used_ranges.iter().copied()));
 
             storage.vtl2_pool_memory = pool;
+            storage.dma_hint_self = vtl2_dma_hint_self;
         }
 
         // If we can trust the host, use the provided alias map
@@ -540,6 +543,7 @@ impl PartitionInfo {
             entropy,
             vtl0_alias_map: _,
             nvme_keepalive,
+            dma_hint_self,
         } = storage;
 
         assert!(!vtl2_used_ranges.is_empty());
@@ -562,6 +566,7 @@ impl PartitionInfo {
         *gic = parsed.gic.clone();
         *entropy = parsed.entropy.clone();
         *nvme_keepalive = parsed.nvme_keepalive;
+        *dma_hint_self = vtl2_dma_hint_self;
 
         Ok(Some(storage))
     }

openhcl/openhcl_boot/src/host_params/mod.rs

@@ -95,6 +95,8 @@ pub struct PartitionInfo {
     pub vtl0_alias_map: Option<u64>,
     /// Host is compatible with DMA preservation / NVMe keep-alive.
     pub nvme_keepalive: bool,
+    /// DMA hint was calculated in boot-shim instead of host.
+    pub dma_hint_self: bool,
 }
 
 impl PartitionInfo {
@@ -126,6 +128,7 @@ impl PartitionInfo {
             entropy: None,
             vtl0_alias_map: None,
             nvme_keepalive: false,
+            dma_hint_self: false,
         }
     }
 

openhcl/openhcl_boot/src/main.rs

@@ -956,6 +956,7 @@ mod test {
             entropy: None,
             vtl0_alias_map: None,
             nvme_keepalive: false,
+            dma_hint_self: false,
         }
     }
 

openhcl/openhcl_dma_manager/src/lib.rs

@@ -407,6 +407,20 @@ impl OpenhclDmaManager {
 
         Ok(())
     }
+
+    /// Return shared pool size in bytes.
+    pub fn shared_pool_size(&self) -> u64 {
+        self.shared_pool
+            .as_ref()
+            .map_or(0, |pool| pool.total_size())
+    }
+
+    /// Return private pool size in bytes.
+    pub fn private_pool_size(&self) -> u64 {
+        self.private_pool
+            .as_ref()
+            .map_or(0, |pool| pool.total_size())
+    }
 }
 
 /// A spawner for creating DMA clients.

openhcl/underhill_core/src/worker.rs

@@ -1518,6 +1518,14 @@ async fn new_underhill_vm(
             .context("failed to restore global dma manager")?;
     }
 
+    // Print important info about DMA sizes.
+    tracing::info!(
+        dma_hint_self = boot_info.dma_hint_self,
+        shared_pool_size = shared_pool_size,
+        private_pool_size = dma_manager.private_pool_size(),
+        "dma pool"
+    );
+
     // Test with the highest VTL for which we have a GuestMemory object
     let highest_vtl_gm = gm.vtl1().unwrap_or(gm.vtl0());
 

vm/page_pool_alloc/src/lib.rs

@@ -504,6 +504,7 @@ pub struct PagePool {
     inner: Arc<PagePoolInner>,
     #[inspect(iter_by_index)]
     ranges: Vec<MemoryRange>,
+    total_len: u64,
 }
 
 impl PagePool {
@@ -557,6 +558,7 @@ impl PagePool {
                 mapping,
             }),
             ranges: memory.to_vec(),
+            total_len: total_len as u64,
         })
     }
 
@@ -621,6 +623,11 @@ impl PagePool {
             Ok(())
         }
     }
+
+    /// Returns the total size of the pool in bytes.
+    pub fn total_size(&self) -> u64 {
+        self.total_len
+    }
 }
 
 /// A spawner for [`PagePoolAllocator`] instances.