test(pci): make test_net_change_mac_address pass with PCI devices

This patch makes 2 changes to make the test work on PCI:
 - simplify logic to find device address to be generic irrespective of
   ACPI/no-ACPI, PCI/no-PCI
 - move config offset from within the C program to the python test, as
   it's different between MMIO (0x100) and PCI (0x4000)

Signed-off-by: Riccardo Mancini <[email protected]>
Signed-off-by: Babis Chalios <[email protected]>

Author: Manciukic

tests/host_tools/change_net_config_space.c

@@ -14,7 +14,7 @@
 #include <unistd.h>
 
 int show_usage() {
-    printf("Usage: ./change_net_config_space.bin [dev_addr_start] [mac_addr]\n");
+    printf("Usage: ./change_net_config_space.bin [dev_addr] [mac_addr]\n");
     printf("Example:\n");
     printf("> ./change_net_config_space.bin 0xd00001000 0x060504030201\n");
     return 0;
@@ -25,18 +25,17 @@ int main(int argc, char *argv[]) {
     uint8_t *map_base;
     volatile uint8_t *virt_addr;
 
-    uint64_t mapped_size, page_size, offset_in_page, target;
+    uint64_t mapped_size, page_size, page_addr, offset_in_page;
     uint64_t width = 6;
 
-    uint64_t config_offset = 0x100;
-    uint64_t device_start_addr = 0x00000000;
+    uint64_t dev_addr = 0x00000000;
     uint64_t mac = 0;
 
     if (argc != 3) {
         return show_usage();
     }
 
-    device_start_addr = strtoull(argv[1], NULL, 0);
+    dev_addr = strtoull(argv[1], NULL, 0);
     mac = strtoull(argv[2], NULL, 0);
 
     fd = open("/dev/mem", O_RDWR | O_SYNC);
@@ -45,11 +44,11 @@ int main(int argc, char *argv[]) {
         return 1;
     }
 
-    target = device_start_addr + config_offset;
     // Get the page size.
     mapped_size = page_size = getpagesize();
     // Get the target address physical frame page offset.
-    offset_in_page = (unsigned) target & (page_size - 1);
+    offset_in_page = (unsigned) dev_addr & (page_size - 1);
+    page_addr = dev_addr & ~(page_size - 1);
     /* If the data length goes out of the current page,
      * double the needed map size. */
     if (offset_in_page + width > page_size) {
@@ -64,7 +63,8 @@ int main(int argc, char *argv[]) {
             PROT_READ | PROT_WRITE,
             MAP_SHARED,
             fd,
-            target & ~(off_t)(page_size - 1));
+            page_addr
+    );
     if (map_base == MAP_FAILED) {
             perror("Failed to mmap '/dev/mem'.");
             return 2;

tests/integration_tests/functional/test_net_config_space.py

@@ -2,9 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 """Tests on devices config space."""
 
-import platform
 import random
-import re
 import string
 import subprocess
 from threading import Thread
@@ -15,14 +13,16 @@
 PAYLOAD_DATA_SIZE = 20
 
 
-def test_net_change_mac_address(uvm_plain_any, change_net_config_space_bin):
+def test_net_change_mac_address(
+    uvm_plain_any, pci_enabled, change_net_config_space_bin
+):
     """
     Test changing the MAC address of the network device.
     """
 
     test_microvm = uvm_plain_any
     test_microvm.help.enable_console()
-    test_microvm.spawn()
+    test_microvm.spawn(pci=pci_enabled)
     test_microvm.basic_config(boot_args="ipv6.disable=1")
 
     # Data exchange interface ('eth0' in guest).
@@ -64,6 +64,8 @@ def test_net_change_mac_address(uvm_plain_any, change_net_config_space_bin):
 
     net_addr_base = _get_net_mem_addr_base(ssh_conn, guest_if1_name)
     assert net_addr_base is not None
+    config_offset = 0x4000 if test_microvm.pci_enabled else 0x100
+    dev_addr = net_addr_base + config_offset
 
     # Write into '/dev/mem' the same mac address, byte by byte.
     # This changes the MAC address physically, in the network device registers.
@@ -72,7 +74,7 @@ def test_net_change_mac_address(uvm_plain_any, change_net_config_space_bin):
     # `tx_spoofed_mac_count` metric shouldn't be incremented later on.
     rmt_path = "/tmp/change_net_config_space"
     test_microvm.ssh.scp_put(change_net_config_space_bin, rmt_path)
-    cmd = f"chmod u+x {rmt_path} && {rmt_path} {net_addr_base} {mac_hex}"
+    cmd = f"chmod u+x {rmt_path} && {rmt_path} {dev_addr} {mac_hex}"
 
     # This should be executed successfully.
     _, stdout, _ = ssh_conn.check_output(cmd)
@@ -219,8 +221,7 @@ def _find_iomem_range(ssh_connection, dev_name):
     # its contents and grep for the VirtIO device name, which
     # with ACPI is "LNRO0005:XY".
     cmd = f"cat /proc/iomem | grep -m 1 {dev_name}"
-    rc, stdout, stderr = ssh_connection.run(cmd)
-    assert rc == 0, stderr
+    _, stdout, _ = ssh_connection.check_output(cmd)
 
     # Take range in the form 'start-end' from line. The line looks like this:
     # d00002000-d0002fff : LNRO0005:02
@@ -231,89 +232,16 @@ def _find_iomem_range(ssh_connection, dev_name):
     return (int(tokens[0], 16), int(tokens[1], 16))
 
 
-def _get_net_mem_addr_base_x86_acpi(ssh_connection, if_name):
-    """Check for net device memory start address via ACPI info"""
-    # On x86 we define VirtIO devices through ACPI AML bytecode. VirtIO devices
-    # are identified as "LNRO0005" and appear under /sys/devices/platform
-    sys_virtio_mmio_cmdline = "/sys/devices/platform/"
-    cmd = "ls {}"
-    _, stdout, _ = ssh_connection.check_output(cmd.format(sys_virtio_mmio_cmdline))
-    virtio_devs = list(filter(lambda x: "LNRO0005" in x, stdout.strip().split()))
-
-    # For virtio-net LNRO0005 devices, we should have a path like:
-    # /sys/devices/platform/LNRO0005::XY/virtioXY/net which is a directory
-    # that includes a subdirectory `ethZ` which represents the network device
-    # that corresponds to the virtio-net device.
-    cmd = "ls {}/{}/virtio{}/net"
-    for idx, dev in enumerate(virtio_devs):
-        _, guest_if_name, _ = ssh_connection.run(
-            cmd.format(sys_virtio_mmio_cmdline, dev, idx)
-        )
-        if guest_if_name.strip() == if_name:
-            return _find_iomem_range(ssh_connection, dev)[0]
-
-    return None
-
-
-def _get_net_mem_addr_base_x86_cmdline(ssh_connection, if_name):
-    """Check for net device memory start address via command line arguments"""
-    sys_virtio_mmio_cmdline = "/sys/devices/virtio-mmio-cmdline/"
-    cmd = "ls {} | grep virtio-mmio. | sed 's/virtio-mmio.//'"
-    exit_code, stdout, stderr = ssh_connection.run(cmd.format(sys_virtio_mmio_cmdline))
-    assert exit_code == 0, stderr
-    virtio_devs_idx = stdout.strip().split()
-
-    cmd = "cat /proc/cmdline"
-    _, cmd_line, _ = ssh_connection.check_output(cmd)
-    pattern_dev = re.compile("(virtio_mmio.device=4K@0x[0-9a-f]+:[0-9]+)+")
-    pattern_addr = re.compile("virtio_mmio.device=4K@(0x[0-9a-f]+):[0-9]+")
-    devs_addr = []
-    for dev in re.findall(pattern_dev, cmd_line):
-        matched_addr = pattern_addr.search(dev)
-        # The 1st group which matches this pattern
-        # is the device start address. `0` group is
-        # full match
-        addr = matched_addr.group(1)
-        devs_addr.append(addr)
-
-    cmd = "ls {}/virtio-mmio.{}/virtio{}/net"
-    for idx in virtio_devs_idx:
-        _, guest_if_name, _ = ssh_connection.run(
-            cmd.format(sys_virtio_mmio_cmdline, idx, idx)
-        )
-        if guest_if_name.strip() == if_name:
-            return devs_addr[int(idx)]
-
-    return None
-
-
 def _get_net_mem_addr_base(ssh_connection, if_name):
     """Get the net device memory start address."""
-    if platform.machine() == "x86_64":
-        acpi_info = _get_net_mem_addr_base_x86_acpi(ssh_connection, if_name)
-        if acpi_info is not None:
-            return acpi_info
-
-        return _get_net_mem_addr_base_x86_cmdline(ssh_connection, if_name)
-
-    if platform.machine() == "aarch64":
-        sys_virtio_mmio_cmdline = "/sys/devices/platform"
-        cmd = "ls {} | grep .virtio_mmio".format(sys_virtio_mmio_cmdline)
-        rc, stdout, _ = ssh_connection.run(cmd)
-        assert rc == 0
-
-        virtio_devs = stdout.split()
-        devs_addr = list(map(lambda dev: dev.split(".")[0], virtio_devs))
-
-        cmd = "ls {}/{}/virtio{}/net"
-        # Device start addresses lack the hex prefix and are not interpreted
-        # accordingly when parsed inside `change_config_space.c`.
-        hex_prefix = "0x"
-        for idx, dev in enumerate(virtio_devs):
-            _, guest_if_name, _ = ssh_connection.run(
-                cmd.format(sys_virtio_mmio_cmdline, dev, idx)
-            )
-            if guest_if_name.strip() == if_name:
-                return hex_prefix + devs_addr[int(idx)]
-
-    return None
+    _, stdout, _ = ssh_connection.check_output(f"find /sys/devices -name {if_name}")
+    device_paths = stdout.strip().split("\n")
+    assert (
+        len(device_paths) == 1
+    ), f"No or multiple devices found for {if_name}:\n{stdout}"
+    device_path = device_paths[0]
+    parts = device_path.split("/")
+    assert len(parts) >= 6, f"Unexpected device path: {device_path}"
+    device = parts[-4]
+    start_addr, _ = _find_iomem_range(ssh_connection, device)
+    return start_addr