AMD: fix the value of the largest extended fn

KVM sets the largest extended function to 0x80000000.
We have to change it to 0x8000001f since we also use the leaf 0x8000001d.

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

Author: Serban Iorga

cpuid/src/cpu_leaf.rs

@@ -173,10 +173,6 @@ pub mod leaf_0x7 {
     }
 }
 
-pub mod leaf_0x80000000 {
-    pub const LEAF_NUM: u32 = 0x8000_0000;
-}
-
 pub mod leaf_0x80000001 {
     pub const LEAF_NUM: u32 = 0x8000_0001;
 
@@ -225,3 +221,13 @@ pub mod leaf_0xb {
         pub const LEVEL_NUMBER_BITRANGE: BitRange = bit_range!(7, 0);
     }
 }
+
+pub mod leaf_0x80000000 {
+    pub const LEAF_NUM: u32 = 0x8000_0000;
+
+    pub mod eax {
+        use bit_helper::BitRange;
+
+        pub const LARGEST_EXTENDED_FN_BITRANGE: BitRange = bit_range!(31, 0);
+    }
+}

cpuid/src/transformer/amd.rs

@@ -10,6 +10,9 @@ use bit_helper::BitHelper;
 use cpu_leaf::*;
 use transformer::common::use_host_cpuid_function;
 
+// Largest extended function. It has to be larger then 0x8000001d (Extended Cache Topology).
+const LARGEST_EXTENDED_FN: u32 = 0x8000_001f;
+
 pub fn update_structured_extended_entry(
     entry: &mut kvm_cpuid_entry2,
     _vm_spec: &VmSpec,
@@ -26,6 +29,21 @@ pub fn update_structured_extended_entry(
     Ok(())
 }
 
+pub fn update_largest_extended_fn_entry(
+    entry: &mut kvm_cpuid_entry2,
+    _vm_spec: &VmSpec,
+) -> Result<(), Error> {
+    use cpu_leaf::leaf_0x80000000::*;
+
+    // KVM sets the largest extended function to 0x80000000. Change it to 0x8000001f
+    // Since we also use the leaf 0x8000001d (Extended Cache Topology).
+    entry
+        .eax
+        .write_bits_in_range(&eax::LARGEST_EXTENDED_FN_BITRANGE, LARGEST_EXTENDED_FN);
+
+    Ok(())
+}
+
 pub fn update_extended_cache_topology_entry(
     entry: &mut kvm_cpuid_entry2,
     vm_spec: &VmSpec,
@@ -46,6 +64,7 @@ impl CpuidTransformer for AmdCpuidTransformer {
         let maybe_transformer_fn: Option<EntryTransformerFn> = match entry.function {
             leaf_0x1::LEAF_NUM => Some(common::update_feature_info_entry),
             leaf_0x7::LEAF_NUM => Some(amd::update_structured_extended_entry),
+            leaf_0x80000000::LEAF_NUM => Some(amd::update_largest_extended_fn_entry),
             leaf_0x8000001d::LEAF_NUM => Some(amd::update_extended_cache_topology_entry),
             0x8000_0002..=0x8000_0004 => Some(common::update_brand_string_entry),
             _ => None,
@@ -65,10 +84,38 @@ mod test {
     use common::VENDOR_ID_AMD;
 
     #[test]
-    fn test_update_extended_cache_topology_entry() {
+    fn test_update_structured_extended_entry() {
+        use cpu_leaf::leaf_0x7::index0::*;
+
+        // Check that if index == 0 the entry is processed
         let vm_spec = VmSpec::new(VENDOR_ID_AMD, 0, 1, false);
         let mut entry = &mut kvm_cpuid_entry2 {
-            function: leaf_0x8000001d::LEAF_NUM,
+            function: leaf_0x7::LEAF_NUM,
+            index: 0,
+            flags: 0,
+            eax: 0,
+            ebx: 0,
+            ecx: 0,
+            edx: *(0 as u32).write_bit(edx::ARCH_CAPABILITIES_BITINDEX, true),
+            padding: [0, 0, 0],
+        };
+        assert!(update_structured_extended_entry(&mut entry, &vm_spec).is_ok());
+        assert_eq!(entry.edx.read_bit(edx::ARCH_CAPABILITIES_BITINDEX), false);
+
+        // Check that if index != 0 the entry is not processed
+        entry.index = 1;
+        entry.edx.write_bit(edx::ARCH_CAPABILITIES_BITINDEX, true);
+        assert!(update_structured_extended_entry(&mut entry, &vm_spec).is_ok());
+        assert_eq!(entry.edx.read_bit(edx::ARCH_CAPABILITIES_BITINDEX), true);
+    }
+
+    #[test]
+    fn test_update_largest_extended_fn_entry() {
+        use cpu_leaf::leaf_0x80000000::*;
+
+        let vm_spec = VmSpec::new(VENDOR_ID_AMD, 0, 1, false);
+        let mut entry = &mut kvm_cpuid_entry2 {
+            function: LEAF_NUM,
             index: 0,
             flags: 0,
             eax: 0,
@@ -78,34 +125,32 @@ mod test {
             padding: [0, 0, 0],
         };
 
-        assert!(update_extended_cache_topology_entry(&mut entry, &vm_spec).is_ok());
+        assert!(update_largest_extended_fn_entry(&mut entry, &vm_spec).is_ok());
 
-        assert_eq!(entry.flags & KVM_CPUID_FLAG_SIGNIFCANT_INDEX, 1);
+        assert_eq!(
+            entry
+                .eax
+                .read_bits_in_range(&eax::LARGEST_EXTENDED_FN_BITRANGE),
+            LARGEST_EXTENDED_FN
+        );
     }
 
     #[test]
-    fn test_update_structured_extended_entry() {
-        use cpu_leaf::leaf_0x7::index0::*;
-
-        // Check that if index == 0 the entry is processed
+    fn test_update_extended_cache_topology_entry() {
         let vm_spec = VmSpec::new(VENDOR_ID_AMD, 0, 1, false);
         let mut entry = &mut kvm_cpuid_entry2 {
-            function: leaf_0x7::LEAF_NUM,
+            function: leaf_0x8000001d::LEAF_NUM,
             index: 0,
             flags: 0,
             eax: 0,
             ebx: 0,
             ecx: 0,
-            edx: *(0 as u32).write_bit(edx::ARCH_CAPABILITIES_BITINDEX, true),
+            edx: 0,
             padding: [0, 0, 0],
         };
-        assert!(update_structured_extended_entry(&mut entry, &vm_spec).is_ok());
-        assert_eq!(entry.edx.read_bit(edx::ARCH_CAPABILITIES_BITINDEX), false);
 
-        // Check that if index != 0 the entry is not processed
-        entry.index = 1;
-        entry.edx.write_bit(edx::ARCH_CAPABILITIES_BITINDEX, true);
-        assert!(update_structured_extended_entry(&mut entry, &vm_spec).is_ok());
-        assert_eq!(entry.edx.read_bit(edx::ARCH_CAPABILITIES_BITINDEX), true);
+        assert!(update_extended_cache_topology_entry(&mut entry, &vm_spec).is_ok());
+
+        assert_eq!(entry.flags & KVM_CPUID_FLAG_SIGNIFCANT_INDEX, 1);
     }
 }