Merge branch 'selftests-drv-net-fix-issues-in-devlink_rate_tc_bw-py'

+1

tools/testing/selftests/drivers/net/hw/Makefile

··· 20 20 TEST_PROGS = \ 21 21 csum.py \ 22 22 devlink_port_split.py \ 23 + devlink_rate_tc_bw.py \ 23 24 devmem.py \ 24 25 ethtool.sh \ 25 26 ethtool_extended_state.sh \

+74 -100

tools/testing/selftests/drivers/net/hw/devlink_rate_tc_bw.py

··· 21 21 ---------- 22 22 1. test_no_tc_mapping_bandwidth: 23 23 - Verifies that without TC mapping, bandwidth is NOT distributed according to 24 - the configured 80/20 split between TC4 and TC3 25 - - This test should fail if bandwidth matches the 80/20 split without TC 24 + the configured 20/80 split between TC3 and TC4 25 + - This test should fail if bandwidth matches the 20/80 split without TC 26 26 mapping 27 - - Expected: Bandwidth should NOT be distributed as 80/20 27 + - Expected: Bandwidth should NOT be distributed as 20/80 28 28 29 29 2. test_tc_mapping_bandwidth: 30 30 - Configures TC mapping using mqprio qdisc 31 31 - Verifies that with TC mapping, bandwidth IS distributed according to the 32 - configured 80/20 split between TC3 and TC4 33 - - Expected: Bandwidth should be distributed as 80/20 32 + configured 20/80 split between TC3 and TC4 33 + - Expected: Bandwidth should be distributed as 20/80 34 34 35 35 Bandwidth Distribution: 36 36 ---------------------- 37 - - TC3 (VLAN 101): Configured for 80% of total bandwidth 38 - - TC4 (VLAN 102): Configured for 20% of total bandwidth 37 + - TC3 (VLAN 101): Configured for 20% of total bandwidth 38 + - TC4 (VLAN 102): Configured for 80% of total bandwidth 39 39 - Total bandwidth: 1Gbps 40 40 - Tolerance: +-12% 41 41 ··· 64 64 from lib.py import NetDrvEpEnv, DevlinkFamily 65 65 from lib.py import NlError 66 66 from lib.py import cmd, defer, ethtool, ip 67 + from lib.py import Iperf3Runner 67 68 68 69 69 70 class BandwidthValidator: 70 71 """ 71 - Validates bandwidth totals and per-TC shares against expected values 72 - with a tolerance. 72 + Validates total bandwidth and individual shares with tolerance 73 + relative to the overall total. 73 74 """ 74 75 75 - def __init__(self): 76 + def __init__(self, shares): 76 77 self.tolerance_percent = 12 77 - self.expected_total_gbps = 1.0 78 - self.total_min_expected = self.min_expected(self.expected_total_gbps) 79 - self.total_max_expected = self.max_expected(self.expected_total_gbps) 80 - self.tc_expected_percent = { 81 - 3: 20.0, 82 - 4: 80.0, 83 - } 78 + self.expected_total = sum(shares.values()) 79 + self.bounds = {} 80 + 81 + for name, exp in shares.items(): 82 + self.bounds[name] = (self.min_expected(exp), self.max_expected(exp)) 84 83 85 84 def min_expected(self, value): 86 85 """Calculates the minimum acceptable value based on tolerance.""" 87 - return value - (value * self.tolerance_percent / 100) 86 + return value - (self.expected_total * self.tolerance_percent / 100) 88 87 89 88 def max_expected(self, value): 90 89 """Calculates the maximum acceptable value based on tolerance.""" 91 - return value + (value * self.tolerance_percent / 100) 90 + return value + (self.expected_total * self.tolerance_percent / 100) 92 91 93 - def bound(self, expected, value): 94 - """Returns True if value is within expected tolerance.""" 95 - return self.min_expected(expected) <= value <= self.max_expected(expected) 96 - 97 - def tc_bandwidth_bound(self, value, tc_ix): 92 + def bound(self, values): 98 93 """ 99 - Returns True if the given bandwidth value is within tolerance 100 - for the TC's expected bandwidth. 94 + Return True if all given values fall within tolerance. 101 95 """ 102 - expected = self.tc_expected_percent[tc_ix] 103 - return self.bound(expected, value) 96 + for name, value in values.items(): 97 + low, high = self.bounds[name] 98 + if not low <= value <= high: 99 + return False 100 + return True 104 101 105 102 106 103 def setup_vf(cfg, set_tc_mapping=True): ··· 113 116 except Exception as exc: 114 117 raise KsftSkipEx(f"Failed to enable switchdev mode on {cfg.pci}") from exc 115 118 try: 116 - cmd(f"echo 1 > /sys/class/net/{cfg.ifname}/device/sriov_numvfs") 117 - defer(cmd, f"echo 0 > /sys/class/net/{cfg.ifname}/device/sriov_numvfs") 119 + cmd(f"echo 1 > /sys/class/net/{cfg.ifname}/device/sriov_numvfs", shell=True) 120 + defer(cmd, f"echo 0 > /sys/class/net/{cfg.ifname}/device/sriov_numvfs", shell=True) 118 121 except Exception as exc: 119 122 raise KsftSkipEx(f"Failed to enable SR-IOV on {cfg.ifname}") from exc 120 123 ··· 136 139 Sets up two VLAN interfaces on the given VF, each mapped to a different TC. 137 140 """ 138 141 vlan_configs = [ 139 - {"vlan_id": 101, "tc": 3, "ip": "198.51.100.2"}, 140 - {"vlan_id": 102, "tc": 4, "ip": "198.51.100.10"}, 142 + {"vlan_id": 101, "tc": 3, "ip": "198.51.100.1"}, 143 + {"vlan_id": 102, "tc": 4, "ip": "198.51.100.9"}, 141 144 ] 142 145 143 146 for config in vlan_configs: ··· 221 224 raise KsftFailEx(f"rate_set failed on VF port {port_index}") from exc 222 225 223 226 224 - def setup_remote_server(cfg): 227 + def setup_remote_vlans(cfg): 225 228 """ 226 - Sets up VLAN interfaces and starts iperf3 servers on the remote side. 229 + Sets up VLAN interfaces on the remote side. 227 230 """ 228 231 remote_dev = cfg.remote_ifname 229 232 vlan_ids = [101, 102] 230 - remote_ips = ["198.51.100.1", "198.51.100.9"] 233 + remote_ips = ["198.51.100.2", "198.51.100.10"] 231 234 232 235 for vlan_id, ip_addr in zip(vlan_ids, remote_ips): 233 236 vlan_dev = f"{remote_dev}.{vlan_id}" ··· 235 238 f"type vlan id {vlan_id}", host=cfg.remote) 236 239 cmd(f"ip addr add {ip_addr}/29 dev {vlan_dev}", host=cfg.remote) 237 240 cmd(f"ip link set dev {vlan_dev} up", host=cfg.remote) 238 - cmd(f"iperf3 -s -1 -B {ip_addr}",background=True, host=cfg.remote) 239 241 defer(cmd, f"ip link del {vlan_dev}", host=cfg.remote) 240 242 241 243 242 244 def setup_test_environment(cfg, set_tc_mapping=True): 243 245 """ 244 246 Sets up the complete test environment including VF creation, VLANs, 245 - bridge configuration, devlink rate setup, and the remote server. 247 + bridge configuration and devlink rate setup. 246 248 """ 247 249 vf_ifc = setup_vf(cfg, set_tc_mapping) 248 250 ksft_pr(f"Created VF interface: {vf_ifc}") ··· 252 256 setup_bridge(cfg) 253 257 254 258 setup_devlink_rate(cfg) 255 - setup_remote_server(cfg) 256 - time.sleep(2) 259 + setup_remote_vlans(cfg) 257 260 258 261 259 - def run_iperf_client(server_ip, local_ip, barrier, min_expected_gbps=0.1): 262 + def measure_bandwidth(cfg, server_ip, client_ip, barrier): 260 263 """ 261 - Runs a single iperf3 client instance, binding to the given local IP. 262 - Waits on a barrier to synchronize with other threads. 264 + Synchronizes with peers and runs an iperf3-based bandwidth measurement 265 + between the given endpoints. Returns average Gbps. 263 266 """ 267 + runner = Iperf3Runner(cfg, server_ip=server_ip, client_ip=client_ip) 264 268 try: 265 269 barrier.wait(timeout=10) 266 270 except Exception as exc: 267 271 raise KsftFailEx("iperf3 barrier wait timed") from exc 268 272 269 - iperf_cmd = ["iperf3", "-c", server_ip, "-B", local_ip, "-J"] 270 - result = subprocess.run(iperf_cmd, capture_output=True, text=True, 271 - check=True) 272 - 273 273 try: 274 - output = json.loads(result.stdout) 275 - bits_per_second = output["end"]["sum_received"]["bits_per_second"] 276 - gbps = bits_per_second / 1e9 277 - if gbps < min_expected_gbps: 278 - ksft_pr( 279 - f"iperf3 bandwidth too low: {gbps:.2f} Gbps " 280 - f"(expected ≥ {min_expected_gbps} Gbps)" 281 - ) 282 - return None 283 - return gbps 284 - except json.JSONDecodeError as exc: 285 - ksft_pr(f"Failed to parse iperf3 JSON output: {exc}") 286 - return None 274 + bw_gbps = runner.measure_bandwidth(reverse=True) 275 + except Exception as exc: 276 + raise KsftFailEx("iperf3 bandwidth measurement failed") from exc 277 + 278 + return bw_gbps 287 279 288 280 289 - def run_bandwidth_test(): 281 + def run_bandwidth_test(cfg): 290 282 """ 291 - Launches iperf3 client threads for each VLAN/TC pair and collects results. 283 + Runs parallel bandwidth measurements for each VLAN/TC pair and collects results. 292 284 """ 293 - def _run_iperf_client_thread(server_ip, local_ip, results, barrier, tc_ix): 294 - results[tc_ix] = run_iperf_client(server_ip, local_ip, barrier) 285 + def _run_measure_bandwidth_thread(local_ip, remote_ip, results, barrier, tc_ix): 286 + results[tc_ix] = measure_bandwidth(cfg, local_ip, remote_ip, barrier) 295 287 296 288 vf_vlan_data = [ 297 289 # (local_ip, remote_ip, TC) 298 - ("198.51.100.2", "198.51.100.1", 3), 299 - ("198.51.100.10", "198.51.100.9", 4), 290 + ("198.51.100.1", "198.51.100.2", 3), 291 + ("198.51.100.9", "198.51.100.10", 4), 300 292 ] 301 293 302 294 results = {} ··· 293 309 294 310 for local_ip, remote_ip, tc_ix in vf_vlan_data: 295 311 thread = threading.Thread( 296 - target=_run_iperf_client_thread, 297 - args=(remote_ip, local_ip, results, start_barrier, tc_ix) 312 + target=_run_measure_bandwidth_thread, 313 + args=(local_ip, remote_ip, results, start_barrier, tc_ix) 298 314 ) 299 315 thread.start() 300 316 threads.append(thread) ··· 304 320 305 321 for tc_ix, tc_bw in results.items(): 306 322 if tc_bw is None: 307 - raise KsftFailEx("iperf3 client failed; cannot evaluate bandwidth") 323 + raise KsftFailEx("iperf3 failed; cannot evaluate bandwidth") 308 324 309 325 return results 326 + 310 327 311 328 def calculate_bandwidth_percentages(results): 312 329 """ ··· 349 364 """ 350 365 total = bw_data['total_bw'] 351 366 352 - if validator.bound(validator.expected_total_gbps, total): 367 + if validator.bound({"total": total}): 353 368 return 354 369 355 - if total < validator.total_min_expected: 370 + low, high = validator.bounds["total"] 371 + 372 + if total < low: 356 373 raise KsftSkipEx( 357 374 f"Total bandwidth {total:.2f} Gbps < minimum " 358 - f"{validator.total_min_expected:.2f} Gbps; " 359 - f"parent tx_max ({validator.expected_total_gbps:.1f} G) " 375 + f"{low:.2f} Gbps; " 376 + f"parent tx_max ({validator.expected_total:.1f} G) " 360 377 f"not reached, cannot validate share" 361 378 ) 362 379 363 380 raise KsftFailEx( 364 381 f"Total bandwidth {total:.2f} Gbps exceeds allowed ceiling " 365 - f"{validator.total_max_expected:.2f} Gbps " 366 - f"(VF tx_max set to {validator.expected_total_gbps:.1f} G)" 382 + f"{high:.2f} Gbps " 383 + f"(VF tx_max set to {validator.expected_total:.1f} G)" 367 384 ) 368 - 369 - 370 - def check_bandwidth_distribution(bw_data, validator): 371 - """ 372 - Checks whether the measured TC3 and TC4 bandwidth percentages 373 - fall within their expected tolerance ranges. 374 - 375 - Returns: 376 - bool: True if both TC3 and TC4 percentages are within bounds. 377 - """ 378 - tc3_valid = validator.tc_bandwidth_bound(bw_data['tc3_percentage'], 3) 379 - tc4_valid = validator.tc_bandwidth_bound(bw_data['tc4_percentage'], 4) 380 - 381 - return tc3_valid and tc4_valid 382 385 383 386 384 387 def run_bandwidth_distribution_test(cfg, set_tc_mapping): 385 388 """ 386 - Runs parallel iperf3 tests for both TCs and collects results. 389 + Runs parallel bandwidth measurements for both TCs and collects results. 387 390 """ 388 391 setup_test_environment(cfg, set_tc_mapping) 389 - bandwidths = run_bandwidth_test() 392 + bandwidths = run_bandwidth_test(cfg) 390 393 bw_data = calculate_bandwidth_percentages(bandwidths) 391 394 test_name = "with TC mapping" if set_tc_mapping else "without TC mapping" 392 395 print_bandwidth_results(bw_data, test_name) 393 396 394 - verify_total_bandwidth(bw_data, cfg.bw_validator) 397 + verify_total_bandwidth(bw_data, cfg.traffic_bw_validator) 395 398 396 - return check_bandwidth_distribution(bw_data, cfg.bw_validator) 399 + return cfg.tc_bw_validator.bound({"tc3": bw_data['tc3_percentage'], 400 + "tc4": bw_data['tc4_percentage']}) 397 401 398 402 399 403 def test_no_tc_mapping_bandwidth(cfg): 400 404 """ 401 - Verifies that bandwidth is not split 80/20 without traffic class mapping. 405 + Verifies that bandwidth is not split 20/80 without traffic class mapping. 402 406 """ 403 - pass_bw_msg = "Bandwidth is NOT distributed as 80/20 without TC mapping" 404 - fail_bw_msg = "Bandwidth matched 80/20 split without TC mapping" 407 + pass_bw_msg = "Bandwidth is NOT distributed as 20/80 without TC mapping" 408 + fail_bw_msg = "Bandwidth matched 20/80 split without TC mapping" 405 409 is_mlx5 = "driver: mlx5" in ethtool(f"-i {cfg.ifname}").stdout 406 410 407 411 if run_bandwidth_distribution_test(cfg, set_tc_mapping=False): ··· 404 430 405 431 def test_tc_mapping_bandwidth(cfg): 406 432 """ 407 - Verifies that bandwidth is correctly split 80/20 between TC3 and TC4 433 + Verifies that bandwidth is correctly split 20/80 between TC3 and TC4 408 434 when traffic class mapping is set. 409 435 """ 410 436 if run_bandwidth_distribution_test(cfg, set_tc_mapping=True): 411 - ksft_pr("Bandwidth is distributed as 80/20 with TC mapping") 437 + ksft_pr("Bandwidth is distributed as 20/80 with TC mapping") 412 438 else: 413 - raise KsftFailEx("Bandwidth did not match 80/20 split with TC mapping") 439 + raise KsftFailEx("Bandwidth did not match 20/80 split with TC mapping") 414 440 415 441 416 442 def main() -> None: ··· 425 451 ) 426 452 if not cfg.pci: 427 453 raise KsftSkipEx("Could not get PCI address of the interface") 428 - cfg.require_cmd("iperf3", local=True, remote=True) 429 454 430 - cfg.bw_validator = BandwidthValidator() 455 + cfg.traffic_bw_validator = BandwidthValidator({"total": 1}) 456 + cfg.tc_bw_validator = BandwidthValidator({"tc3": 20, "tc4": 80}) 431 457 432 458 cases = [test_no_tc_mapping_bandwidth, test_tc_mapping_bandwidth] 433 459

+3 -2

tools/testing/selftests/drivers/net/hw/lib/py/__init__.py

··· 28 28 ksft_setup, ksft_variants, KsftNamedVariant 29 29 from net.lib.py import ksft_eq, ksft_ge, ksft_in, ksft_is, ksft_lt, \ 30 30 ksft_ne, ksft_not_in, ksft_raises, ksft_true, ksft_gt, ksft_not_none 31 - from drivers.net.lib.py import GenerateTraffic, Remote 31 + from drivers.net.lib.py import GenerateTraffic, Remote, Iperf3Runner 32 32 from drivers.net.lib.py import NetDrvEnv, NetDrvEpEnv 33 33 34 34 __all__ = ["NetNS", "NetNSEnter", "NetdevSimDev", ··· 44 44 "ksft_eq", "ksft_ge", "ksft_in", "ksft_is", "ksft_lt", 45 45 "ksft_ne", "ksft_not_in", "ksft_raises", "ksft_true", "ksft_gt", 46 46 "ksft_not_none", "ksft_not_none", 47 - "NetDrvEnv", "NetDrvEpEnv", "GenerateTraffic", "Remote"] 47 + "NetDrvEnv", "NetDrvEpEnv", "GenerateTraffic", "Remote", 48 + "Iperf3Runner"] 48 49 except ModuleNotFoundError as e: 49 50 print("Failed importing `net` library from kernel sources") 50 51 print(str(e))

+3 -2

tools/testing/selftests/drivers/net/lib/py/__init__.py

··· 44 44 "ksft_not_none", "ksft_not_none"] 45 45 46 46 from .env import NetDrvEnv, NetDrvEpEnv 47 - from .load import GenerateTraffic 47 + from .load import GenerateTraffic, Iperf3Runner 48 48 from .remote import Remote 49 49 50 - __all__ += ["NetDrvEnv", "NetDrvEpEnv", "GenerateTraffic", "Remote"] 50 + __all__ += ["NetDrvEnv", "NetDrvEpEnv", "GenerateTraffic", "Remote", 51 + "Iperf3Runner"] 51 52 except ModuleNotFoundError as e: 52 53 print("Failed importing `net` library from kernel sources") 53 54 print(str(e))

+76 -8

tools/testing/selftests/drivers/net/lib/py/load.py

··· 2 2 3 3 import re 4 4 import time 5 + import json 5 6 6 7 from lib.py import ksft_pr, cmd, ip, rand_port, wait_port_listen 7 8 8 - class GenerateTraffic: 9 - def __init__(self, env, port=None): 9 + 10 + class Iperf3Runner: 11 + """ 12 + Sets up and runs iperf3 traffic. 13 + """ 14 + def __init__(self, env, port=None, server_ip=None, client_ip=None): 10 15 env.require_cmd("iperf3", local=True, remote=True) 11 - 12 16 self.env = env 13 - 14 17 self.port = rand_port() if port is None else port 15 - self._iperf_server = cmd(f"iperf3 -s -1 -p {self.port}", background=True) 18 + self.server_ip = server_ip 19 + self.client_ip = client_ip 20 + 21 + def _build_server(self): 22 + cmdline = f"iperf3 -s -1 -p {self.port}" 23 + if self.server_ip: 24 + cmdline += f" -B {self.server_ip}" 25 + return cmdline 26 + 27 + def _build_client(self, streams, duration, reverse): 28 + host = self.env.addr if self.server_ip is None else self.server_ip 29 + cmdline = f"iperf3 -c {host} -p {self.port} -P {streams} -t {duration} -J" 30 + if self.client_ip: 31 + cmdline += f" -B {self.client_ip}" 32 + if reverse: 33 + cmdline += " --reverse" 34 + return cmdline 35 + 36 + def start_server(self): 37 + """ 38 + Starts an iperf3 server with optional bind IP. 39 + """ 40 + cmdline = self._build_server() 41 + proc = cmd(cmdline, background=True) 16 42 wait_port_listen(self.port) 17 43 time.sleep(0.1) 18 - self._iperf_client = cmd(f"iperf3 -c {env.addr} -P 16 -p {self.port} -t 86400", 19 - background=True, host=env.remote) 44 + return proc 45 + 46 + def start_client(self, background=False, streams=1, duration=10, reverse=False): 47 + """ 48 + Starts the iperf3 client with the configured options. 49 + """ 50 + cmdline = self._build_client(streams, duration, reverse) 51 + return cmd(cmdline, background=background, host=self.env.remote) 52 + 53 + def measure_bandwidth(self, reverse=False): 54 + """ 55 + Runs an iperf3 measurement and returns the average bandwidth (Gbps). 56 + Discards the first and last few reporting intervals and uses only the 57 + middle part of the run where throughput is typically stable. 58 + """ 59 + self.start_server() 60 + result = self.start_client(duration=10, reverse=reverse) 61 + 62 + if result.ret != 0: 63 + raise RuntimeError("iperf3 failed to run successfully") 64 + try: 65 + out = json.loads(result.stdout) 66 + except json.JSONDecodeError as exc: 67 + raise ValueError("Failed to parse iperf3 JSON output") from exc 68 + 69 + intervals = out.get("intervals", []) 70 + samples = [i["sum"]["bits_per_second"] / 1e9 for i in intervals] 71 + if len(samples) < 10: 72 + raise ValueError(f"iperf3 returned too few intervals: {len(samples)}") 73 + # Discard potentially unstable first and last 3 seconds. 74 + stable = samples[3:-3] 75 + 76 + avg = sum(stable) / len(stable) 77 + 78 + return avg 79 + 80 + 81 + class GenerateTraffic: 82 + def __init__(self, env, port=None): 83 + self.env = env 84 + self.runner = Iperf3Runner(env, port) 85 + 86 + self._iperf_server = self.runner.start_server() 87 + self._iperf_client = self.runner.start_client(background=True, streams=16, duration=86400) 20 88 21 89 # Wait for traffic to ramp up 22 90 if not self._wait_pkts(pps=1000): ··· 129 61 def _wait_client_stopped(self, sleep=0.005, timeout=5): 130 62 end = time.monotonic() + timeout 131 63 132 - live_port_pattern = re.compile(fr":{self.port:04X} 0[^6] ") 64 + live_port_pattern = re.compile(fr":{self.runner.port:04X} 0[^6] ") 133 65 134 66 while time.monotonic() < end: 135 67 data = cmd("cat /proc/net/tcp*", host=self.env.remote).stdout

Configure Feed

Configure Feed