AMD cpuid improvements

- set the extended apic id
- fix the number of threads per core
- set the number of nodes per processor

Signed-off-by: Serban Iorga <[email protected]>

Author: Serban Iorga

cpuid/src/cpu_leaf.rs

@@ -88,14 +88,6 @@ pub mod leaf_0x4 {
     }
 }
 
-// Extended Cache Topology Leaf
-pub mod leaf_0x8000001d {
-    pub const LEAF_NUM: u32 = 0x8000_001d;
-
-    // inherit eax from leaf_cache_parameters
-    pub use cpu_leaf::leaf_cache_parameters::eax;
-}
-
 // Thermal and Power Management Leaf
 pub mod leaf_0x6 {
     pub const LEAF_NUM: u32 = 0x6;
@@ -250,3 +242,42 @@ pub mod leaf_0x80000008 {
         pub const NUM_THREADS_BITRANGE: BitRange = bit_range!(7, 0);
     }
 }
+
+// Extended Cache Topology Leaf
+pub mod leaf_0x8000001d {
+    pub const LEAF_NUM: u32 = 0x8000_001d;
+
+    // inherit eax from leaf_cache_parameters
+    pub use cpu_leaf::leaf_cache_parameters::eax;
+}
+
+// Extended APIC ID Leaf
+pub mod leaf_0x8000001e {
+    pub const LEAF_NUM: u32 = 0x8000_001e;
+
+    pub mod eax {
+        use bit_helper::BitRange;
+
+        pub const EXTENDED_APIC_ID_BITRANGE: BitRange = bit_range!(31, 0);
+    }
+
+    pub mod ebx {
+        use bit_helper::BitRange;
+
+        // The number of threads per core - 1
+        pub const THREADS_PER_CORE_BITRANGE: BitRange = bit_range!(15, 8);
+        pub const CORE_ID_BITRANGE: BitRange = bit_range!(7, 0);
+    }
+
+    pub mod ecx {
+        use bit_helper::BitRange;
+
+        // The number of nodes per processor. Possible values:
+        // 0 -> 1 node per processor
+        // 1 -> 2 nodes per processor
+        // 2 -> Reserved
+        // 3 -> 4 nodes per processor
+        pub const NODES_PER_PROCESSOR_BITRANGE: BitRange = bit_range!(10, 8);
+        pub const NODE_ID_BITRANGE: BitRange = bit_range!(7, 0);
+    }
+}

cpuid/src/transformer/amd.rs

@@ -15,6 +15,9 @@ const LARGEST_EXTENDED_FN: u32 = 0x8000_001f;
 // This value allows at most 64 logical threads within a package.
 // See also the documentation for leaf_0x80000008::ecx::THREAD_ID_SIZE_BITRANGE
 const THREAD_ID_MAX_SIZE: u32 = 6;
+// This value means there is 1 node per processor.
+// See also the documentation for leaf_0x8000001e::ecx::NODES_PER_PROCESSOR_BITRANGE.
+const NODES_PER_PROCESSOR: u32 = 0;
 
 pub fn update_structured_extended_entry(
     entry: &mut kvm_cpuid_entry2,
@@ -84,11 +87,52 @@ pub fn update_extended_cache_topology_entry(
     common::update_cache_parameters_entry(entry, vm_spec)
 }
 
+pub fn update_extended_apic_id_entry(
+    entry: &mut kvm_cpuid_entry2,
+    vm_spec: &VmSpec,
+) -> Result<(), Error> {
+    use cpu_leaf::leaf_0x8000001e::*;
+
+    let mut core_id = u32::from(vm_spec.cpu_id);
+    // When hyper-threading is enabled each pair of 2 consecutive logical CPUs
+    // will have the same core id since they represent 2 threads in the same core.
+    // For Example:
+    // logical CPU 0 -> core id: 0
+    // logical CPU 1 -> core id: 0
+    // logical CPU 2 -> core id: 1
+    // logical CPU 3 -> core id: 1
+    if vm_spec.ht_enabled {
+        core_id /= 2;
+    }
+
+    entry
+        .eax
+        // the Extended APIC ID is the id of the current logical CPU
+        .write_bits_in_range(&eax::EXTENDED_APIC_ID_BITRANGE, u32::from(vm_spec.cpu_id));
+
+    entry
+        .ebx
+        .write_bits_in_range(&ebx::CORE_ID_BITRANGE, core_id)
+        .write_bits_in_range(
+            &ebx::THREADS_PER_CORE_BITRANGE,
+            u32::from(vm_spec.ht_enabled),
+        );
+
+    entry
+        .ecx
+        .write_bits_in_range(&ecx::NODES_PER_PROCESSOR_BITRANGE, NODES_PER_PROCESSOR)
+        // Put all the cpus in the same node.
+        .write_bits_in_range(&ecx::NODE_ID_BITRANGE, 0);
+
+    Ok(())
+}
+
 pub struct AmdCpuidTransformer {}
 
 impl CpuidTransformer for AmdCpuidTransformer {
     fn preprocess_cpuid(&self, cpuid: &mut CpuId) -> Result<(), Error> {
-        use_host_cpuid_function(cpuid, leaf_0x8000001d::LEAF_NUM)
+        use_host_cpuid_function(cpuid, leaf_0x8000001e::LEAF_NUM, false)?;
+        use_host_cpuid_function(cpuid, leaf_0x8000001d::LEAF_NUM, true)
     }
 
     fn transform_entry(&self, entry: &mut kvm_cpuid_entry2, vm_spec: &VmSpec) -> Result<(), Error> {
@@ -99,6 +143,7 @@ impl CpuidTransformer for AmdCpuidTransformer {
             leaf_0x80000001::LEAF_NUM => Some(amd::update_extended_feature_info_entry),
             leaf_0x80000008::LEAF_NUM => Some(amd::update_amd_features_entry),
             leaf_0x8000001d::LEAF_NUM => Some(amd::update_extended_cache_topology_entry),
+            leaf_0x8000001e::LEAF_NUM => Some(amd::update_extended_apic_id_entry),
             0x8000_0002..=0x8000_0004 => Some(common::update_brand_string_entry),
             _ => None,
         };
@@ -216,6 +261,56 @@ mod test {
         );
     }
 
+    fn check_update_extended_apic_id_entry(
+        cpu_id: u8,
+        cpu_count: u8,
+        ht_enabled: bool,
+        expected_core_id: u32,
+        expected_threads_per_core: u32,
+    ) {
+        use cpu_leaf::leaf_0x8000001e::*;
+
+        let vm_spec = VmSpec::new(VENDOR_ID_AMD, cpu_id, cpu_count, ht_enabled);
+        let mut entry = &mut kvm_cpuid_entry2 {
+            function: LEAF_NUM,
+            index: 0,
+            flags: 0,
+            eax: 0,
+            ebx: 0,
+            ecx: 0,
+            edx: 0,
+            padding: [0, 0, 0],
+        };
+
+        assert!(update_extended_apic_id_entry(&mut entry, &vm_spec).is_ok());
+
+        assert_eq!(
+            entry
+                .eax
+                .read_bits_in_range(&eax::EXTENDED_APIC_ID_BITRANGE),
+            u32::from(cpu_id)
+        );
+
+        assert_eq!(
+            entry.ebx.read_bits_in_range(&ebx::CORE_ID_BITRANGE),
+            expected_core_id
+        );
+        assert_eq!(
+            entry
+                .ebx
+                .read_bits_in_range(&ebx::THREADS_PER_CORE_BITRANGE),
+            expected_threads_per_core
+        );
+
+        assert_eq!(
+            entry
+                .ecx
+                .read_bits_in_range(&ecx::NODES_PER_PROCESSOR_BITRANGE),
+            NODES_PER_PROCESSOR
+        );
+        assert_eq!(entry.ecx.read_bits_in_range(&ecx::NODE_ID_BITRANGE), 0);
+    }
+
     #[test]
     fn test_update_extended_cache_topology_entry() {
         let vm_spec = VmSpec::new(VENDOR_ID_AMD, 0, 1, false);
@@ -238,20 +333,30 @@ mod test {
     #[test]
     fn test_1vcpu_ht_off() {
         check_update_amd_features_entry(1, false);
+
+        check_update_extended_apic_id_entry(0, 1, false, 0, 0);
     }
 
     #[test]
     fn test_1vcpu_ht_on() {
         check_update_amd_features_entry(1, true);
+
+        check_update_extended_apic_id_entry(0, 1, true, 0, 1);
     }
 
     #[test]
     fn test_2vcpu_ht_off() {
         check_update_amd_features_entry(2, false);
+
+        check_update_extended_apic_id_entry(0, 2, false, 0, 0);
+        check_update_extended_apic_id_entry(1, 2, false, 1, 0);
     }
 
     #[test]
     fn test_2vcpu_ht_on() {
         check_update_amd_features_entry(2, true);
+
+        check_update_extended_apic_id_entry(0, 2, true, 0, 1);
+        check_update_extended_apic_id_entry(1, 2, true, 0, 1);
     }
 }

cpuid/src/transformer/common.rs

@@ -96,7 +96,11 @@ pub fn update_cache_parameters_entry(
 
 /// Replaces the `cpuid` entries corresponding to `function` with the entries from the host's cpuid.
 ///
-pub fn use_host_cpuid_function(cpuid: &mut CpuId, function: u32) -> Result<(), Error> {
+pub fn use_host_cpuid_function(
+    cpuid: &mut CpuId,
+    function: u32,
+    use_count: bool,
+) -> Result<(), Error> {
     // copy all the CpuId entries, except for the ones with the provided function
     let mut entries: Vec<kvm_cpuid_entry2> = Vec::new();
     for entry in cpuid.mut_entries_slice().iter() {
@@ -108,6 +112,9 @@ pub fn use_host_cpuid_function(cpuid: &mut CpuId, function: u32) -> Result<(), E
     // add all the host leaves with the provided function
     let mut count: u32 = 0;
     while let Ok(entry) = get_cpuid(function, count) {
+        if count > 0 && !use_count {
+            break;
+        }
         // check if there's enough space to add a new entry to the cpuid
         if entries.len() == MAX_KVM_CPUID_ENTRIES {
             return Err(Error::SizeLimitExceeded);
@@ -254,14 +261,14 @@ mod test {
 
     #[test]
     #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    fn use_host_cpuid_function_test() {
+    fn test_use_host_cpuid_function_with_count() {
         // try to emulate the extended cache topology leaves
         let topoext_fn = get_topoext_fn();
 
         // check that it behaves correctly for TOPOEXT function
         let mut cpuid = CpuId::new(1);
         cpuid.mut_entries_slice()[0].function = topoext_fn;
-        assert!(use_host_cpuid_function(&mut cpuid, topoext_fn).is_ok());
+        assert!(use_host_cpuid_function(&mut cpuid, topoext_fn, true).is_ok());
         let entries = cpuid.mut_entries_slice();
         assert!(entries.len() > 1);
         let mut count = 0;
@@ -271,10 +278,35 @@ mod test {
             assert!(entry.eax != 0);
             count = count + 1;
         }
+    }
 
+    #[test]
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    fn test_use_host_cpuid_function_without_count() {
+        use cpu_leaf::leaf_0x1::*;
+        // try to emulate the extended cache topology leaves
+        let feature_info_fn = LEAF_NUM;
+
+        // check that it behaves correctly for TOPOEXT function
+        let mut cpuid = CpuId::new(1);
+        cpuid.mut_entries_slice()[0].function = feature_info_fn;
+        assert!(use_host_cpuid_function(&mut cpuid, feature_info_fn, false).is_ok());
+        let entries = cpuid.mut_entries_slice();
+        assert!(entries.len() == 1);
+        let entry = entries[0];
+
+        assert!(entry.function == feature_info_fn);
+        assert!(entry.index == 0);
+        assert!(entry.eax != 0);
+    }
+
+    #[test]
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    fn test_use_host_cpuid_function_err() {
+        let topoext_fn = get_topoext_fn();
         // check that it returns Err when there are too many entriesentry.function == topoext_fn
         let mut cpuid = CpuId::new(MAX_KVM_CPUID_ENTRIES);
-        match use_host_cpuid_function(&mut cpuid, topoext_fn) {
+        match use_host_cpuid_function(&mut cpuid, topoext_fn, true) {
             Err(Error::SizeLimitExceeded) => {}
             _ => panic!("Wrong behavior"),
         }