| #!/usr/bin/env python3 |
| # SPDX-License-Identifier: GPL-2.0 |
| |
| """ |
| Test channel and ring size configuration via ethtool (-L / -G). |
| """ |
| |
| import socket |
| import struct |
| import time |
| |
| from lib.py import ksft_run, ksft_exit, ksft_pr |
| from lib.py import ksft_eq |
| from lib.py import KsftSkipEx, KsftXfailEx |
| from lib.py import NetDrvEpEnv, EthtoolFamily, GenerateTraffic |
| from lib.py import cmd, defer, rand_port, tc, NlError |
| |
| # Added in Python 3.13; fallback to 61 for x86/ARM/MIPS |
| SO_TXTIME = getattr(socket, "SO_TXTIME", 61) |
| |
| # Not always exported by the socket module; asm-generic value (x86/ARM/MIPS). |
| SO_SNDBUFFORCE = getattr(socket, "SO_SNDBUFFORCE", 32) |
| |
| # TX ring size the test shrinks to so the ring fills quickly. |
| MIN_TX_RING = 32 |
| MAX_TX_RING = 1024 |
| |
| |
| def channels(cfg) -> None: |
| """ |
| Twiddle channel counts in various combinations of parameters. |
| We're only looking for driver adhering to the requested config |
| if the config is accepted and crashes. |
| """ |
| ehdr = {'header':{'dev-index': cfg.ifindex}} |
| chans = cfg.eth.channels_get(ehdr) |
| |
| all_keys = ["rx", "tx", "combined"] |
| mixes = [{"combined"}, {"rx", "tx"}, {"rx", "combined"}, {"tx", "combined"}, |
| {"rx", "tx", "combined"},] |
| |
| # Get the set of keys that device actually supports |
| restore = {} |
| supported = set() |
| for key in all_keys: |
| if key + "-max" in chans: |
| supported.add(key) |
| restore |= {key + "-count": chans[key + "-count"]} |
| |
| defer(cfg.eth.channels_set, ehdr | restore) |
| |
| def test_config(config): |
| try: |
| cfg.eth.channels_set(ehdr | config) |
| get = cfg.eth.channels_get(ehdr) |
| for k, v in config.items(): |
| ksft_eq(get.get(k, 0), v) |
| except NlError as e: |
| failed.append(mix) |
| ksft_pr("Can't set", config, e) |
| else: |
| ksft_pr("Okay", config) |
| |
| failed = [] |
| for mix in mixes: |
| if not mix.issubset(supported): |
| continue |
| |
| # Set all the values in the mix to 1, other supported to 0 |
| config = {} |
| for key in all_keys: |
| config[key + "-count"] = 1 if key in mix else 0 |
| test_config(config) |
| |
| for mix in mixes: |
| if not mix.issubset(supported): |
| continue |
| if mix in failed: |
| continue |
| |
| # Set all the values in the mix to max, other supported to 0 |
| config = {} |
| for key in all_keys: |
| config[key + "-count"] = chans[key + '-max'] if key in mix else 0 |
| test_config(config) |
| |
| |
| def _configure_min_ring_cnt(cfg) -> None: |
| """ Try to configure a single Rx/Tx ring. """ |
| ehdr = {'header':{'dev-index': cfg.ifindex}} |
| chans = cfg.eth.channels_get(ehdr) |
| |
| all_keys = ["rx-count", "tx-count", "combined-count"] |
| restore = {} |
| config = {} |
| for key in all_keys: |
| if key in chans: |
| restore[key] = chans[key] |
| config[key] = 0 |
| |
| if chans.get('combined-count', 0) > 1: |
| config['combined-count'] = 1 |
| elif chans.get('rx-count', 0) > 1 and chans.get('tx-count', 0) > 1: |
| config['tx-count'] = 1 |
| config['rx-count'] = 1 |
| else: |
| # looks like we're already on 1 channel |
| return |
| |
| cfg.eth.channels_set(ehdr | config) |
| defer(cfg.eth.channels_set, ehdr | restore) |
| |
| |
| def ringparam(cfg) -> None: |
| """ |
| Tweak the ringparam configuration. Try to run some traffic over min |
| ring size to make sure it actually functions. |
| """ |
| ehdr = {'header':{'dev-index': cfg.ifindex}} |
| rings = cfg.eth.rings_get(ehdr) |
| |
| restore = {} |
| maxes = {} |
| params = set() |
| for key in rings.keys(): |
| if 'max' in key: |
| param = key[:-4] |
| maxes[param] = rings[key] |
| params.add(param) |
| restore[param] = rings[param] |
| |
| defer(cfg.eth.rings_set, ehdr | restore) |
| |
| # Speed up the reconfig by configuring just one ring |
| _configure_min_ring_cnt(cfg) |
| |
| # Try to reach min on all settings |
| for param in params: |
| val = rings[param] |
| while True: |
| try: |
| cfg.eth.rings_set({'header':{'dev-index': cfg.ifindex}, |
| param: val // 2}) |
| if val == 0: |
| break |
| val //= 2 |
| except NlError: |
| break |
| |
| get = cfg.eth.rings_get(ehdr) |
| ksft_eq(get[param], val) |
| |
| ksft_pr(f"Reached min for '{param}' at {val} (max {rings[param]})") |
| |
| GenerateTraffic(cfg).wait_pkts_and_stop(10000) |
| |
| # Try max across all params, if the driver supports large rings |
| # this may OOM so we ignore errors |
| try: |
| ksft_pr("Applying max settings") |
| config = {p: maxes[p] for p in params} |
| cfg.eth.rings_set(ehdr | config) |
| except NlError as e: |
| ksft_pr("Can't set max params", config, e) |
| else: |
| GenerateTraffic(cfg).wait_pkts_and_stop(10000) |
| |
| |
| def _write_file(path, val): |
| """Write val to a file.""" |
| with open(path, "w", encoding="utf-8") as fp: |
| fp.write(str(val)) |
| |
| |
| def _write_sysfs(path, val): |
| """Write val to a sysfs file, restoring the original value on exit.""" |
| with open(path, "r", encoding="utf-8") as fp: |
| orig_val = fp.read().strip() |
| if str(val) == orig_val: |
| return |
| _write_file(path, val) |
| defer(_write_file, path, orig_val) |
| |
| |
| def _get_qdisc_backlog(cfg, mq_handle, queue): |
| """Return the qdisc backlog (bytes) for the given TX queue's leaf.""" |
| target_parent = f"{mq_handle}{queue + 1:x}" |
| for q in tc(f"-s qdisc show dev {cfg.ifname}", json=True): |
| if q.get("parent", "") == target_parent: |
| return q.get("backlog") or 0 |
| return 0 |
| |
| |
| def _setup_fq_qdisc(cfg, port, target_queue, other_queue, flow_limit): |
| """Put an fq qdisc on target_queue's leaf and return the mq handle in use. |
| |
| We must not disturb the device's existing TX/RX qdisc policy. On a real |
| NIC the root mq already has an addressable handle, so we leave the root |
| and every other queue alone and only swap this one leaf, restoring its |
| original qdisc afterwards. |
| |
| @flow_limit raises fq's per-flow packet limit (default 100) so a single |
| flow can back up more packets than the Tx ring holds and thus overflow it. |
| """ |
| qdiscs = tc(f"qdisc show dev {cfg.ifname}", json=True) |
| root = next((q for q in qdiscs if q.get("root")), None) |
| |
| if root and root["kind"] == "mq" and root["handle"] != "0:": |
| # Addressable mq (previously-configured): touch only the target queue's |
| # leaf and restore its original qdisc afterwards. |
| mq_handle = root["handle"] |
| parent = f"{mq_handle}{target_queue + 1:x}" |
| orig = next((q for q in qdiscs if q.get("parent") == parent), None) |
| orig_kind = orig["kind"] if orig else \ |
| cmd("sysctl -n net.core.default_qdisc").stdout.strip() |
| defer(tc, f"qdisc replace dev {cfg.ifname} parent {parent} {orig_kind}") |
| elif root is None or root["kind"] in ("mq", "noqueue"): |
| # The auto-attached root mq has handle 0: on any device (real or sim), |
| # which the kernel rejects as a qdisc parent. A 0: handle means the mq |
| # is the untouched kernel default - no custom child qdiscs can hang off |
| # an unaddressable parent - so installing a real handle and restoring |
| # the default mq on exit preserves the device's effective policy. |
| mq_handle = "1:" |
| tc(f"qdisc replace dev {cfg.ifname} root handle {mq_handle} mq") |
| defer(tc, f"qdisc replace dev {cfg.ifname} root mq") |
| parent = f"{mq_handle}{target_queue + 1:x}" |
| else: |
| raise KsftSkipEx(f"root qdisc '{root['kind']}' is not mq; " |
| "refusing to disturb existing qdisc policy") |
| |
| try: |
| tc(f"qdisc replace dev {cfg.ifname} parent {parent} fq " |
| f"flow_limit {flow_limit} limit {flow_limit * 2}") |
| except Exception as exc: |
| raise KsftSkipEx( |
| f"fq not available (CONFIG_NET_SCH_FQ): {exc}") from exc |
| |
| qdisc_j = tc(f"qdisc show dev {cfg.ifname}", json=True) |
| has_clsact = any(q['kind'] == 'clsact' for q in qdisc_j) |
| if not has_clsact: |
| tc(f"qdisc add dev {cfg.ifname} clsact") |
| defer(tc, f"qdisc del dev {cfg.ifname} clsact") |
| |
| proto = "ipv6" if int(cfg.addr_ipver) == 6 else "ip" |
| try: |
| tc(f"filter add dev {cfg.ifname} egress protocol {proto} " |
| f"pref 1 flower ip_proto udp dst_port {port} " |
| f"action skbedit queue_mapping {target_queue}") |
| except Exception as exc: |
| raise KsftSkipEx("tc flower/act_skbedit not available") from exc |
| defer(tc, f"filter del dev {cfg.ifname} egress pref 1") |
| |
| tc(f"filter add dev {cfg.ifname} egress pref 101 " |
| f"matchall action skbedit queue_mapping {other_queue}") |
| defer(tc, f"filter del dev {cfg.ifname} egress pref 101") |
| |
| return mq_handle |
| |
| |
| def _create_sotxtime_socket(cfg, sndbuf): |
| """Create a UDP socket with SO_TXTIME enabled, bound to the test device.""" |
| sock = socket.socket(socket.AF_INET6 if cfg.addr_ipver == "6" |
| else socket.AF_INET, socket.SOCK_DGRAM) |
| try: |
| sock.setsockopt(socket.SOL_SOCKET, SO_TXTIME, struct.pack("Ii", 1, 0)) |
| except OSError as exc: |
| sock.close() |
| raise KsftSkipEx("SO_TXTIME not supported") from exc |
| sock.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, |
| cfg.ifname.encode()) |
| # Deferred completions keep every in-flight skb charged to the socket, so |
| # size the send buffer to hold the whole burst. SO_SNDBUFFORCE bypasses |
| # net.core.wmem_max (the test runs as root). |
| try: |
| sock.setsockopt(socket.SOL_SOCKET, SO_SNDBUFFORCE, sndbuf) |
| except OSError: |
| sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, sndbuf) |
| return sock |
| |
| |
| def _send_sotxtime_burst(cfg, sock, port, count, delay_ns, pkt_size): |
| """Send count UDP packets scheduled delay_ns ahead using SO_TXTIME.""" |
| payload = b'\x00' * pkt_size |
| txtime_ns = time.clock_gettime_ns(time.CLOCK_MONOTONIC) + delay_ns |
| |
| ancdata = [(socket.SOL_SOCKET, SO_TXTIME, struct.pack("Q", txtime_ns))] |
| if int(cfg.addr_ipver) == 6: |
| dest = (cfg.remote_addr, port, 0, 0) |
| else: |
| dest = (cfg.remote_addr, port) |
| for _ in range(count): |
| sock.sendmsg([payload], ancdata, 0, dest) |
| |
| |
| def _set_small_tx_ring(cfg, ehdr): |
| """Set the Tx ring to the smallest size the driver accepts. |
| |
| Start at 32 so the ring fills quickly, then grow exponentially (64, |
| 128, 256, ...) up to 1024. Some drivers enforce a minimum well above 32 |
| (e.g. bnxt needs a large ring for software UDP segmentation), so raise |
| the lower bound until the driver accepts it, giving up past 1024. |
| """ |
| size = MIN_TX_RING |
| while size <= MAX_TX_RING: |
| try: |
| cfg.eth.rings_set(ehdr | {'tx': size}) |
| return size |
| except NlError: |
| size = size * 2 |
| continue |
| raise KsftSkipEx("driver rejects all tx ring sizes up to 1024") |
| |
| |
| def reconfig_tx_stall(cfg) -> None: |
| """Test that qdisc backlog drains after ring reconfiguration.""" |
| target_queue = 1 |
| other_queue = 0 |
| |
| ehdr = {'header': {'dev-index': cfg.ifindex}} |
| chans = cfg.eth.channels_get(ehdr) |
| |
| if "combined-max" not in chans: |
| raise KsftSkipEx("device does not support combined channels") |
| if chans.get("combined-max", 0) < 2: |
| raise KsftSkipEx("device does not support 2+ combined channels") |
| if chans["combined-count"] < 2: |
| defer(cfg.eth.channels_set, |
| ehdr | {"combined-count": chans["combined-count"]}) |
| cfg.eth.channels_set(ehdr | {"combined-count": 2}) |
| |
| rings = cfg.eth.rings_get(ehdr) |
| if 'rx' not in rings or 'tx' not in rings: |
| raise KsftSkipEx("device does not expose rx/tx ring params") |
| tx_cur = rings['tx'] |
| if tx_cur <= MIN_TX_RING: |
| raise KsftSkipEx("tx ring size already at minimum") |
| defer(cfg.eth.rings_set, ehdr | {'tx': tx_cur}) |
| |
| # Use the smallest Tx ring the driver accepts (32, growing to 1024). |
| tx_ring = _set_small_tx_ring(cfg, ehdr) |
| |
| # Slow completions so the ring stays full after FQ releases packets |
| napi_defer = f"/sys/class/net/{cfg.ifname}/napi_defer_hard_irqs" |
| gro_timeout = f"/sys/class/net/{cfg.ifname}/gro_flush_timeout" |
| _write_sysfs(napi_defer, 100) |
| _write_sysfs(gro_timeout, 1000000000) |
| |
| port = rand_port() |
| # A single flow must overflow the ring, so send twice the ring depth and |
| # let fq hold that many packets for the flow. |
| pkt_count = tx_ring * 2 |
| mq_handle = _setup_fq_qdisc(cfg, port, target_queue, other_queue, |
| tx_ring * 2) |
| |
| # Size each packet to one MTU (less L3/L4 headers to avoid fragmentation). |
| pkt_size = cfg.dev['mtu'] - (48 if int(cfg.addr_ipver) == 6 else 28) |
| |
| # Each queued skb charges the socket its truesize (~2x the payload), so |
| # budget the send buffer for the whole in-flight burst. |
| sock = _create_sotxtime_socket(cfg, pkt_count * pkt_size * 2) |
| defer(sock.close) |
| |
| for delay_ms in [100, 200, 500]: |
| _send_sotxtime_burst(cfg, sock, port, pkt_count, |
| delay_ms * 1_000_000, pkt_size) |
| ksft_pr(f"Sent {pkt_count} SO_TXTIME packets (+{delay_ms}ms)") |
| time.sleep(delay_ms / 1000 + 0.3) |
| |
| backlog = _get_qdisc_backlog(cfg, mq_handle, target_queue) |
| if backlog: |
| break |
| else: |
| # A device that completes Tx synchronously (e.g. a software/virtual |
| # driver like netdevsim) never keeps the ring full long enough for a |
| # backlog to form, so the wake-vs-start behavior can't be exercised. |
| # Treat that as an expected failure rather than a hard failure. |
| raise KsftXfailEx("could not build qdisc backlog") |
| |
| ksft_pr(f"Backlog before reconfig: {backlog} bytes") |
| |
| # Trigger ring reconfig — driver should call wake, not just start. |
| # Grow back to the original size so the driver actually switches channels |
| # (setting the current size is a no-op the driver short-circuits). |
| cfg.eth.rings_set(ehdr | {'tx': tx_cur}) |
| |
| # Let completions proceed normally |
| _write_sysfs(napi_defer, 0) |
| _write_sysfs(gro_timeout, 0) |
| |
| # Poll for backlog to drain |
| for _ in range(100): |
| backlog = _get_qdisc_backlog(cfg, mq_handle, target_queue) |
| if not backlog: |
| break |
| time.sleep(0.1) |
| |
| ksft_eq(0, backlog, |
| comment=f"qdisc backlog stuck on queue {target_queue} " |
| f"after ring reconfig") |
| |
| |
| def main() -> None: |
| """ Ksft boiler plate main """ |
| |
| with NetDrvEpEnv(__file__, queue_count=2) as cfg: |
| cfg.eth = EthtoolFamily() |
| |
| ksft_run([channels, |
| ringparam, |
| reconfig_tx_stall], |
| args=(cfg, )) |
| ksft_exit() |
| |
| |
| if __name__ == "__main__": |
| main() |
