add cpuid integration tests

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

Author: Serban Iorga

tests/integration_tests/build/test_coverage.py

@@ -18,7 +18,7 @@
 
 import host_tools.cargo_build as host  # pylint: disable=import-error
 
-COVERAGE_TARGET_PCT = 83.9
+COVERAGE_TARGET_PCT = 84.1
 COVERAGE_MAX_DELTA = 0.01
 
 CARGO_KCOV_REL_PATH = os.path.join(host.CARGO_BUILD_REL_PATH, 'kcov')

tests/integration_tests/functional/test_cpu_features.py

@@ -4,78 +4,216 @@
 
 import re
 
+from enum import Enum, auto
+
 import host_tools.network as net_tools  # pylint: disable=import-error
 
 
-def test_1vcpu(test_microvm_with_ssh, network_config):
-    """Test CPU feature emulation with 1 vCPU."""
-    test_microvm = test_microvm_with_ssh
-    test_microvm.spawn()
+class CpuVendor(Enum):
+    """CPU vendors enum."""
 
-    # Set up the microVM with 1 vCPUs, 256 MiB of RAM, no network ifaces, and
-    # a root file system with the rw permission. The network interfaces is
-    # added after we get a unique MAC and IP.
-    test_microvm.basic_config(vcpu_count=1)
+    AMD = auto()
+    INTEL = auto()
 
-    _tap, _, _ = test_microvm.ssh_network_config(network_config, '1')
-    test_microvm.start()
+
+def _get_cpu_vendor():
+    cif = open('/proc/cpuinfo', 'r')
+    host_vendor_id = None
+    while True:
+        line = cif.readline()
+        if line == '':
+            break
+        mo = re.search("^vendor_id\\s+:\\s+(.+)$", line)
+        if mo:
+            host_vendor_id = mo.group(1)
+    cif.close()
+    assert host_vendor_id is not None
+
+    if host_vendor_id == "AuthenticAMD":
+        return CpuVendor.AMD
+    return CpuVendor.INTEL
+
+
+def _check_guest_cmd_output(test_microvm, guest_cmd, expected_header,
+                            expected_separator,
+                            expected_key_value_store):
+    ssh_connection = net_tools.SSHConnection(test_microvm.ssh_config)
+    _, stdout, stderr = ssh_connection.execute_command(guest_cmd)
+
+    assert stderr.read().decode("utf-8") == ''
+    while True:
+        line = stdout.readline().decode('utf-8')
+        if line != '':
+            # All the keys have been matched. Stop.
+            if not expected_key_value_store:
+                break
+
+            # Try to match the header if needed.
+            if expected_header not in (None, ''):
+                if line.strip() == expected_header:
+                    expected_header = None
+                    continue
+                else:
+                    continue
+
+            # See if any key matches.
+            # We Use a try-catch block here since line.split() may fail.
+            try:
+                [key, value] = list(
+                    map(lambda x: x.strip(), line.split(expected_separator)))
+            except ValueError:
+                continue
+
+            if key in expected_key_value_store.keys():
+                assert value == expected_key_value_store[key], \
+                    "%s does not have the expected value" % key
+                del expected_key_value_store[key]
+
+        else:
+            break
+
+    assert not expected_key_value_store, \
+        "some keys in dictionary have not been found in the output: %s" \
+        % expected_key_value_store
+
+
+def _check_cpu_topology(test_microvm, expected_cpu_count,
+                        expected_threads_per_core,
+                        expected_cpus_list):
     expected_cpu_topology = {
-        "CPU(s)": "1",
-        "On-line CPU(s) list": "0",
-        "Thread(s) per core": "1",
-        "Core(s) per socket": "1",
+        "CPU(s)": str(expected_cpu_count),
+        "On-line CPU(s) list": expected_cpus_list,
+        "Thread(s) per core": str(expected_threads_per_core),
+        "Core(s) per socket": str(
+            int(expected_cpu_count / expected_threads_per_core)),
         "Socket(s)": "1",
         "NUMA node(s)": "1"
     }
-    _check_cpu_topology(test_microvm, expected_cpu_topology)
+
+    _check_guest_cmd_output(test_microvm, "lscpu", None, ':',
+                            expected_cpu_topology)
+
+
+def _check_cpu_features(test_microvm, expected_cpu_count, expected_htt):
+    expected_cpu_features = {
+        "cpu count": '{} ({})'.format(hex(expected_cpu_count),
+                                      expected_cpu_count),
+        "CLFLUSH line size": "0x8 (8)",
+        "hypervisor guest status": "true",
+        "hyper-threading / multi-core supported": expected_htt
+    }
+
+    _check_guest_cmd_output(test_microvm, "cpuid -1", None, '=',
+                            expected_cpu_features)
+
+
+def _check_cache_topology(test_microvm, num_vcpus_on_lvl_1_cache,
+                          num_vcpus_on_lvl_3_cache):
+    expected_lvl_1_str = '{} ({})'.format(hex(num_vcpus_on_lvl_1_cache),
+                                          num_vcpus_on_lvl_1_cache)
+    expected_lvl_3_str = '{} ({})'.format(hex(num_vcpus_on_lvl_3_cache),
+                                          num_vcpus_on_lvl_3_cache)
+
+    cpu_vendor = _get_cpu_vendor()
+    if cpu_vendor == CpuVendor.AMD:
+        expected_level_1_topology = {
+            "level": '0x1 (1)',
+            "extra cores sharing this cache": expected_lvl_1_str
+        }
+        expected_level_3_topology = {
+            "level": '0x3 (3)',
+            "extra cores sharing this cache": expected_lvl_3_str
+        }
+    elif cpu_vendor == CpuVendor.INTEL:
+        expected_level_1_topology = {
+            "cache level": '0x1 (1)',
+            "extra threads sharing this cache": expected_lvl_1_str,
+        }
+        expected_level_3_topology = {
+            "cache level": '0x3 (3)',
+            "extra threads sharing this cache": expected_lvl_3_str,
+        }
+
+    _check_guest_cmd_output(test_microvm, "cpuid -1", "--- cache 0 ---", '=',
+                            expected_level_1_topology)
+    _check_guest_cmd_output(test_microvm, "cpuid -1", "--- cache 1 ---", '=',
+                            expected_level_1_topology)
+    _check_guest_cmd_output(test_microvm, "cpuid -1", "--- cache 2 ---", '=',
+                            expected_level_1_topology)
+    _check_guest_cmd_output(test_microvm, "cpuid -1", "--- cache 3 ---", '=',
+                            expected_level_3_topology)
+
+
+def test_1vcpu_ht_disabled(test_microvm_with_ssh, network_config):
+    """Check the CPUID for a microvm with the specified config."""
+    test_microvm_with_ssh.spawn()
+    test_microvm_with_ssh.basic_config(vcpu_count=1, ht_enabled=False)
+    _tap, _, _ = test_microvm_with_ssh.ssh_network_config(network_config, '1')
+    test_microvm_with_ssh.start()
+
+    _check_cpu_topology(test_microvm_with_ssh, 1, 1, "0")
+    _check_cpu_features(test_microvm_with_ssh, 1, "false")
+    _check_cache_topology(test_microvm_with_ssh, 0, 0)
+
+
+def test_1vcpu_ht_enabled(test_microvm_with_ssh, network_config):
+    """Check the CPUID for a microvm with the specified config."""
+    test_microvm_with_ssh.spawn()
+    test_microvm_with_ssh.basic_config(vcpu_count=1, ht_enabled=True)
+    _tap, _, _ = test_microvm_with_ssh.ssh_network_config(network_config, '1')
+    test_microvm_with_ssh.start()
+
+    _check_cpu_topology(test_microvm_with_ssh, 1, 1, "0")
+    _check_cpu_features(test_microvm_with_ssh, 1, "false")
+    _check_cache_topology(test_microvm_with_ssh, 0, 0)
 
 
 def test_2vcpu_ht_disabled(test_microvm_with_ssh, network_config):
-    """Test CPU feature emulation with 2 vCPUs, and no hyperthreading."""
-    test_microvm = test_microvm_with_ssh
-    test_microvm.spawn()
+    """Check the CPUID for a microvm with the specified config."""
+    test_microvm_with_ssh.spawn()
+    test_microvm_with_ssh.basic_config(vcpu_count=2, ht_enabled=False)
+    _tap, _, _ = test_microvm_with_ssh.ssh_network_config(network_config, '1')
+    test_microvm_with_ssh.start()
 
-    # Set up the microVM with 2 vCPUs, 256 MiB of RAM, 0 network ifaces, and
-    # a root file system with the rw permission. The network interfaces is
-    # added after we get a unique MAC and IP.
-    test_microvm.basic_config(vcpu_count=2, ht_enabled=False)
+    _check_cpu_topology(test_microvm_with_ssh, 2, 1, "0,1")
+    _check_cpu_features(test_microvm_with_ssh, 2, "true")
+    _check_cache_topology(test_microvm_with_ssh, 0, 1)
 
-    _tap, _, _ = test_microvm.ssh_network_config(network_config, '1')
 
-    test_microvm.start()
+def test_2vcpu_ht_enabled(test_microvm_with_ssh, network_config):
+    """Check the CPUID for a microvm with the specified config."""
+    test_microvm_with_ssh.spawn()
+    test_microvm_with_ssh.basic_config(vcpu_count=2, ht_enabled=True)
+    _tap, _, _ = test_microvm_with_ssh.ssh_network_config(network_config, '1')
+    test_microvm_with_ssh.start()
 
-    expected_cpu_topology = {
-        "CPU(s)": "2",
-        "On-line CPU(s) list": "0,1",
-        "Thread(s) per core": "1",
-        "Core(s) per socket": "2",
-        "Socket(s)": "1",
-        "NUMA node(s)": "1"
-    }
-    _check_cpu_topology(test_microvm, expected_cpu_topology)
+    _check_cpu_topology(test_microvm_with_ssh, 2, 2, "0,1")
+    _check_cpu_features(test_microvm_with_ssh, 2, "true")
+    _check_cache_topology(test_microvm_with_ssh, 1, 1)
 
 
-def _check_cpu_topology(test_microvm, expected_cpu_topology):
-    """Perform common microvm setup for different CPU topology tests.
+def test_16vcpu_ht_disabled(test_microvm_with_ssh, network_config):
+    """Check the CPUID for a microvm with the specified config."""
+    test_microvm_with_ssh.spawn()
+    test_microvm_with_ssh.basic_config(vcpu_count=16, ht_enabled=False)
+    _tap, _, _ = test_microvm_with_ssh.ssh_network_config(network_config, '1')
+    test_microvm_with_ssh.start()
 
-    This is a wrapper function for calling lscpu and checking if the
-    command returns the expected cpu topology.
-    """
-    ssh_connection = net_tools.SSHConnection(test_microvm.ssh_config)
+    _check_cpu_topology(test_microvm_with_ssh, 16, 1, "0-15")
+    _check_cpu_features(test_microvm_with_ssh, 16, "true")
+    _check_cache_topology(test_microvm_with_ssh, 0, 15)
 
-    # Execute the lscpu command to check the guest topology
-    _, stdout, stderr = ssh_connection.execute_command("lscpu")
-    assert stderr.read().decode("utf-8") == ''
-    # Read the stdout of lscpu line by line to check the relevant information.
-    while True:
-        line = stdout.readline().decode('utf-8')
-        if line != '':
-            [key, value] = list(map(lambda x: x.strip(), line.split(':')))
-            if key in expected_cpu_topology.keys():
-                assert value == expected_cpu_topology[key],\
-                    "%s does not have the expected value" % key
-        else:
-            break
+
+def test_16vcpu_ht_enabled(test_microvm_with_ssh, network_config):
+    """Check the CPUID for a microvm with the specified config."""
+    test_microvm_with_ssh.spawn()
+    test_microvm_with_ssh.basic_config(vcpu_count=16, ht_enabled=True)
+    _tap, _, _ = test_microvm_with_ssh.ssh_network_config(network_config, '1')
+    test_microvm_with_ssh.start()
+
+    _check_cpu_topology(test_microvm_with_ssh, 16, 2, "0-15")
+    _check_cpu_features(test_microvm_with_ssh, 16, "true")
+    _check_cache_topology(test_microvm_with_ssh, 1, 15)
 
 
 def test_brand_string(test_microvm_with_ssh, network_config):
@@ -85,24 +223,21 @@ def test_brand_string(test_microvm_with_ssh, network_config):
         Intel(R) Xeon(R) Processor @ {host frequency}
     where {host frequency} is the frequency reported by the host CPUID
     (e.g. 4.01GHz)
-    * For non-Intel CPUs, the guest brand string should be:
-        Intel(R) Xeon(R) Processor
+    * For AMD CPUs, the guest brand string should be:
+        AMD EPYC
+    * For other CPUs, the guest brand string should be:
+        ""
     """
     cif = open('/proc/cpuinfo', 'r')
     host_brand_string = None
-    host_vendor_id = None
     while True:
         line = cif.readline()
         if line == '':
             break
-        mo = re.search("^vendor_id\\s+:\\s+(.+)$", line)
-        if mo:
-            host_vendor_id = mo.group(1)
         mo = re.search("^model name\\s+:\\s+(.+)$", line)
         if mo:
             host_brand_string = mo.group(1)
     cif.close()
-    assert host_vendor_id is not None
     assert host_brand_string is not None
 
     test_microvm = test_microvm_with_ssh
@@ -124,13 +259,14 @@ def test_brand_string(test_microvm_with_ssh, network_config):
     guest_brand_string = mo.group(1)
     assert guest_brand_string
 
+    cpu_vendor = _get_cpu_vendor()
     expected_guest_brand_string = ""
-    if host_vendor_id == "GenuineIntel":
+    if cpu_vendor == CpuVendor.AMD:
+        expected_guest_brand_string += "AMD EPYC"
+    elif cpu_vendor == CpuVendor.INTEL:
         expected_guest_brand_string = "Intel(R) Xeon(R) Processor"
         mo = re.search("[.0-9]+[MG]Hz", host_brand_string)
         if mo:
             expected_guest_brand_string += " @ " + mo.group(0)
-    elif host_vendor_id == "AuthenticAMD":
-        expected_guest_brand_string += "AMD EPYC"
 
     assert guest_brand_string == expected_guest_brand_string