Replace float point with integers

Author: yupavlen-ms

Cargo.lock

@@ -4753,6 +4753,7 @@ dependencies = [
  "sha2",
  "sidecar_defs",
  "tdcall",
+ "test_with_tracing",
  "underhill_confidentiality",
  "x86defs",
  "zerocopy 0.8.23",

openhcl/openhcl_boot/Cargo.toml

@@ -37,3 +37,6 @@ minimal_rt_build.workspace = true
 
 [lints]
 workspace = true
+
+[dev-dependencies]
+test_with_tracing.workspace = true

openhcl/openhcl_boot/src/dt.rs

@@ -9,7 +9,6 @@ use crate::ReservedMemoryType;
 use crate::host_params::COMMAND_LINE_SIZE;
 use crate::host_params::PartitionInfo;
 use crate::host_params::shim_params::IsolationType;
-use crate::log; // YSP
 use crate::sidecar::SidecarConfig;
 use crate::single_threaded::off_stack;
 use arrayvec::ArrayString;
@@ -212,7 +211,6 @@ pub fn write_dt(
     let p_enable_method = builder.add_string("enable-method")?;
 
     let num_cpus = partition_info.cpus.len();
-    log!("YSP: num_cpus2 = {}", num_cpus);
 
     let mut root_builder = builder
         .start_node("")?

openhcl/openhcl_boot/src/host_params/dma_hint.rs

@@ -3,7 +3,6 @@
 
 //! Calculate DMA hint value if not provided by host.
 
-use crate::log;
 use igvm_defs::{MemoryMapEntryType, PAGE_SIZE_4K};
 use super::PartitionInfo;
 
@@ -60,10 +59,14 @@ const LOOKUP_TABLE: &'static [DmaLookupStruct] = &[
     },
 ];
 
+/// Round up to next 2MiB.
+fn round_up_to_2mb(pages_4k: u64) -> u64 {
+    (pages_4k + 511) & !(511)
+}
+
 /// Returns calculated DMA hint value, in 4k pages.
 pub fn vtl2_calculate_dma_hint(vp_count: usize, storage: &PartitionInfo) -> u64 {
     let mut dma_hint_4k = 0;
-    log!("YSP: vp_count = {}", vp_count);
     let mem_size = storage
         .vtl2_ram
         .iter()
@@ -73,16 +76,16 @@ pub fn vtl2_calculate_dma_hint(vp_count: usize, storage: &PartitionInfo) -> u64
     // Sanity check for the calculated memory size.
     if mem_size > 0 && mem_size < 0xFFFFFFFF00000 {
         let mem_size_mb = (mem_size / 1048576) as u32;
-        log!("YSP: mem_size_mb = {}", mem_size_mb);
 
         let mut min_vtl2_memory_mb = 1000000;
         let mut max_vtl2_memory_mb = 0;
-        // TODO: If we won't allow floats in boot-shim, replace with scaled integers
-        let mut min_ratio: f32 = 0.1;
-        let mut max_ratio: f32 = 0.01;
+
+        // To avoid using floats, scale ratios to 1:1000.
+        let mut min_ratio_1000th = 100000;
+        let mut max_ratio_1000th = 1000;
 
         let mut min_vp_count = 1;
-        let mut max_vp_count = 4096;
+        let mut max_vp_count = vp_count as u32;
 
         for f in LOOKUP_TABLE {
             if f.vp_count == vp_count as u32 {
@@ -94,8 +97,8 @@ pub fn vtl2_calculate_dma_hint(vp_count: usize, storage: &PartitionInfo) -> u64
                     // Prepare for possible extrapolation.
                     min_vtl2_memory_mb = min_vtl2_memory_mb.min(f.vtl2_memory_mb);
                     max_vtl2_memory_mb = max_vtl2_memory_mb.max(f.vtl2_memory_mb);
-                    min_ratio = min_ratio.min(f.dma_hint_mb as f32 / f.vtl2_memory_mb as f32);
-                    max_ratio = max_ratio.max(f.dma_hint_mb as f32 / f.vtl2_memory_mb as f32);
+                    min_ratio_1000th = min_ratio_1000th.min(f.vtl2_memory_mb as u32 * 1000 / f.dma_hint_mb as u32);
+                    max_ratio_1000th = max_ratio_1000th.max(f.vtl2_memory_mb as u32 * 1000 / f.dma_hint_mb as u32);
                 }
             } else if f.vp_count < vp_count as u32 {
                 // Find the nearest VP counts if exact match is not in the table.
@@ -112,19 +115,20 @@ pub fn vtl2_calculate_dma_hint(vp_count: usize, storage: &PartitionInfo) -> u64
             .iter()
             .filter(|e| e.vp_count == min_vp_count || e.vp_count == max_vp_count)
             .for_each(|f| {
-                // Prepare for possible extrapolation.
                 min_vtl2_memory_mb = min_vtl2_memory_mb.min(f.vtl2_memory_mb);
                 max_vtl2_memory_mb = max_vtl2_memory_mb.max(f.vtl2_memory_mb);
-                min_ratio = min_ratio.min(f.dma_hint_mb as f32 / f.vtl2_memory_mb as f32);
-                max_ratio = max_ratio.max(f.dma_hint_mb as f32 / f.vtl2_memory_mb as f32);
+                min_ratio_1000th = min_ratio_1000th.min(f.vtl2_memory_mb as u32 * 1000 / f.dma_hint_mb as u32);
+                max_ratio_1000th = max_ratio_1000th.max(f.vtl2_memory_mb as u32 * 1000 / f.dma_hint_mb as u32);
             });
         }
-        
+
         if dma_hint_4k == 0 {
             // If we didn't find an exact match for our vp_count, try to extrapolate.
-            dma_hint_4k = (mem_size_mb as f32 * ((min_ratio + max_ratio) / 2.0)) as u64 *
-                1048576 /
-                PAGE_SIZE_4K;
+            dma_hint_4k = (mem_size_mb as u64 * 1000u64 * (1048576u64 / PAGE_SIZE_4K)) /
+                ((min_ratio_1000th + max_ratio_1000th) as u64 / 2u64);
+
+            // And then round up to 2MiB.
+            dma_hint_4k = round_up_to_2mb(dma_hint_4k);
         }
     }
 
@@ -136,6 +140,7 @@ mod test {
     use super::*;
     use crate::host_params::MemoryEntry;
     use crate::MemoryRange;
+    use test_with_tracing::test;
 
     #[test]
     fn test_vtl2_calculate_dma_hint() {
@@ -164,7 +169,23 @@ mod test {
             mem_type: MemoryMapEntryType::VTL2_PROTECTABLE,
             vnode: 0,
         });
-        // TODO: Unfinished, maybe the return value is incorrect.
-        assert_eq!(vtl2_calculate_dma_hint(112, &storage), 2048);
+        assert_eq!(vtl2_calculate_dma_hint(112, &storage), 2560);
+
+        // Test unusual VP count.
+        storage.vtl2_ram.clear();
+        storage.vtl2_ram.push(MemoryEntry {
+            range: MemoryRange::new(0x0..0x6000000),
+            mem_type: MemoryMapEntryType::VTL2_PROTECTABLE,
+            vnode: 0,
+        });
+        assert_eq!(vtl2_calculate_dma_hint(52, &storage), 2048);
+
+        storage.vtl2_ram.clear();
+        storage.vtl2_ram.push(MemoryEntry {
+            range: MemoryRange::new(0x0..0x8000000),
+            mem_type: MemoryMapEntryType::VTL2_PROTECTABLE,
+            vnode: 0,
+        });
+        assert_eq!(vtl2_calculate_dma_hint(52, &storage), 2560);
     }
 }

openhcl/openhcl_boot/src/host_params/dt.rs

@@ -338,7 +338,6 @@ impl PartitionInfo {
         let parsed = ParsedDeviceTree::parse(dt, &mut *dt_storage).map_err(DtError::DeviceTree)?;
 
         let command_line = params.command_line();
-        log!("YSP: device_dma_page_count {}", parsed.device_dma_page_count.unwrap_or(0));
 
         // Always write the measured command line.
         write!(
@@ -360,7 +359,6 @@ impl PartitionInfo {
 
         match parsed.memory_allocation_mode {
             MemoryAllocationMode::Host => {
-                log!("YSP: MemoryAllocationMode::Host");
                 storage.vtl2_ram.clear();
                 storage
                     .vtl2_ram
@@ -372,7 +370,6 @@ impl PartitionInfo {
                 memory_size,
                 mmio_size,
             } => {
-                log!("YSP: MemoryAllocationMode::Vtl2");
                 storage.vtl2_ram.clear();
                 storage
                     .vtl2_ram
@@ -515,7 +512,6 @@ impl PartitionInfo {
 
             storage.vtl2_pool_memory = pool;
         }
-        log!("YSP: vtl2_gpa_pool_size {}", vtl2_gpa_pool_size);
 
         // If we can trust the host, use the provided alias map
         if can_trust_host {