libvirt: Fix decimal vs binary unit handling in memory conversion

The previous implementation incorrectly treated decimal units (KB, MB, GB
- powers of 1000) the same as binary units (KiB, MiB, GiB - powers of
1024). Per libvirt specification, these are distinct unit types.

Updated convert_memory_to_mb() to:
- Properly distinguish decimal vs binary units
- Use u128 for calculations to prevent overflow with TB values
- Add comprehensive test coverage for both unit types

Fixed test assertion for KB unit (1048576 KB = 1000 MiB, not 1024 MiB).

Assisted-by: Claude Code

Signed-off-by: Colin Walters <walters@verbum.org>

Author: cgwalters

crates/kit/src/utils.rs

@@ -174,21 +174,32 @@ pub(crate) fn parse_memory_to_mb(memory_str: &str) -> Result<u32> {
     }
 }
 
-/// Convert memory value with unit to megabytes
-/// Handles libvirt-style units (KiB, MiB, GiB, etc.) and short forms (K, M, G)
+/// Convert memory value with unit to megabytes (MiB)
+/// Handles libvirt-style units distinguishing between decimal (KB, MB, GB - powers of 1000)
+/// and binary (KiB, MiB, GiB - powers of 1024) units per libvirt specification
 pub(crate) fn convert_memory_to_mb(value: u32, unit: &str) -> u32 {
-    match unit {
-        "B" => value / (1024 * 1024),
-        "KB" | "k" => value / 1024,
-        "KiB" | "K" => value / 1024,
-        "MB" | "M" => value,
-        "MiB" => value,
-        "GB" | "G" => value * 1024,
-        "GiB" => value * 1024,
-        "TB" | "T" => value * 1024 * 1024,
-        "TiB" => value * 1024 * 1024,
-        _ => value / 1024, // Default to KiB if unknown
-    }
+    // Use u128 for calculations to prevent overflow with large units like TB
+    let value_u128 = value as u128;
+    let mib_u128 = 1024 * 1024;
+
+    let mb = match unit {
+        // Binary prefixes (powers of 1024), converting to MiB
+        "k" | "K" | "KiB" => value_u128 / 1024,
+        "M" | "MiB" => value_u128,
+        "G" | "GiB" => value_u128 * 1024,
+        "T" | "TiB" => value_u128 * 1024 * 1024,
+
+        // Decimal prefixes (powers of 1000), converting to MiB
+        "B" | "bytes" => value_u128 / mib_u128,
+        "KB" => (value_u128 * 1_000) / mib_u128,
+        "MB" => (value_u128 * 1_000_000) / mib_u128,
+        "GB" => (value_u128 * 1_000_000_000) / mib_u128,
+        "TB" => (value_u128 * 1_000_000_000_000) / mib_u128,
+
+        // Libvirt default is KiB for memory
+        _ => value_u128 / 1024,
+    };
+    mb as u32
 }
 
 #[cfg(test)]
@@ -197,21 +208,25 @@ mod tests {
 
     #[test]
     fn test_convert_memory_to_mb() {
-        // Test KiB (libvirt default)
+        // Test binary units (powers of 1024)
         assert_eq!(convert_memory_to_mb(4194304, "KiB"), 4096);
         assert_eq!(convert_memory_to_mb(2097152, "KiB"), 2048);
-
-        // Test MiB
         assert_eq!(convert_memory_to_mb(2048, "MiB"), 2048);
         assert_eq!(convert_memory_to_mb(4096, "MiB"), 4096);
-
-        // Test GiB
         assert_eq!(convert_memory_to_mb(4, "GiB"), 4096);
         assert_eq!(convert_memory_to_mb(2, "GiB"), 2048);
 
-        // Test short forms
+        // Test short forms (binary)
         assert_eq!(convert_memory_to_mb(4, "G"), 4096);
         assert_eq!(convert_memory_to_mb(2048, "M"), 2048);
         assert_eq!(convert_memory_to_mb(2097152, "K"), 2048);
+
+        // Test decimal units (powers of 1000)
+        assert_eq!(convert_memory_to_mb(1048576, "KB"), 1000);
+        assert_eq!(convert_memory_to_mb(1024, "MB"), 976);
+        assert_eq!(convert_memory_to_mb(4, "GB"), 3814);
+
+        // Test default/unknown unit (defaults to KiB)
+        assert_eq!(convert_memory_to_mb(4194304, "unknown"), 4096);
     }
 }

crates/kit/src/xml_utils.rs

@@ -397,9 +397,9 @@ mod tests {
         let dom = parse_xml_dom(xml).unwrap();
         assert_eq!(dom.parse_memory_mb(), Some(4096));
 
-        // Test KB
+        // Test KB (decimal unit: 1000-based)
         let xml = r#"<memory unit='KB'>1048576</memory>"#;
         let dom = parse_xml_dom(xml).unwrap();
-        assert_eq!(dom.parse_memory_mb(), Some(1024));
+        assert_eq!(dom.parse_memory_mb(), Some(1000));
     }
 }