mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2026-08-29 18:38:52 -04:00
c301658dfe
Certain devices which support ntuple-filters do not enable the feature by default. The existing tests will skip (if they check for the feature), or fail if they blindly attempt to install rules. Therefore, attempt to turn on ntuple-filters if the device supports them. Signed-off-by: Dimitri Daskalakis <daskald@meta.com> Reviewed-by: Joe Damato <joe@dama.to> Link: https://patch.msgid.link/20260430165217.3700469-1-dimitri.daskalakis1@gmail.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
305 lines
9.9 KiB
Python
Executable File
305 lines
9.9 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
|
|
"""
|
|
HW GRO tests focusing on device machinery like stats, rather than protocol
|
|
processing.
|
|
"""
|
|
|
|
import glob
|
|
import re
|
|
|
|
from lib.py import ksft_run, ksft_exit, ksft_pr
|
|
from lib.py import ksft_eq, ksft_ge, ksft_variants
|
|
from lib.py import NetDrvEpEnv, NetdevFamily
|
|
from lib.py import KsftSkipEx
|
|
from lib.py import bkg, cmd, defer, ethtool, ip
|
|
|
|
|
|
# gro.c uses hardcoded DPORT=8000
|
|
GRO_DPORT = 8000
|
|
|
|
|
|
def _get_queue_stats(cfg, queue_id):
|
|
"""Get stats for a specific Rx queue."""
|
|
cfg.wait_hw_stats_settle()
|
|
data = cfg.netnl.qstats_get({"ifindex": cfg.ifindex, "scope": ["queue"]},
|
|
dump=True)
|
|
for q in data:
|
|
if q.get('queue-type') == 'rx' and q.get('queue-id') == queue_id:
|
|
return q
|
|
return {}
|
|
|
|
|
|
def _resolve_dmac(cfg, ipver):
|
|
"""Find the destination MAC address for sending packets."""
|
|
attr = "dmac" + ipver
|
|
if hasattr(cfg, attr):
|
|
return getattr(cfg, attr)
|
|
|
|
route = ip(f"-{ipver} route get {cfg.addr_v[ipver]}",
|
|
json=True, host=cfg.remote)[0]
|
|
gw = route.get("gateway")
|
|
if not gw:
|
|
setattr(cfg, attr, cfg.dev['address'])
|
|
return getattr(cfg, attr)
|
|
|
|
cmd(f"ping -c1 -W0 -I{cfg.remote_ifname} {gw}", host=cfg.remote)
|
|
neigh = ip(f"neigh get {gw} dev {cfg.remote_ifname}",
|
|
json=True, host=cfg.remote)[0]
|
|
setattr(cfg, attr, neigh['lladdr'])
|
|
return getattr(cfg, attr)
|
|
|
|
|
|
def _require_ntuple(cfg):
|
|
features = ethtool(f"-k {cfg.ifname}", json=True)[0]
|
|
if not features["ntuple-filters"]["active"]:
|
|
if features["ntuple-filters"]["fixed"]:
|
|
raise KsftSkipEx("Device does not support ntuple-filters")
|
|
ethtool(f"-K {cfg.ifname} ntuple-filters on")
|
|
defer(ethtool, f"-K {cfg.ifname} ntuple-filters off")
|
|
|
|
|
|
def _setup_isolated_queue(cfg):
|
|
"""Set up an isolated queue for testing using ntuple filter.
|
|
|
|
Remove queue 1 from the default RSS context and steer test traffic to it.
|
|
"""
|
|
_require_ntuple(cfg)
|
|
test_queue = 1
|
|
|
|
qcnt = len(glob.glob(f"/sys/class/net/{cfg.ifname}/queues/rx-*"))
|
|
if qcnt < 2:
|
|
raise KsftSkipEx(f"Need at least 2 queues, have {qcnt}")
|
|
|
|
# Remove queue 1 from default RSS context by setting its weight to 0
|
|
weights = ["1"] * qcnt
|
|
weights[test_queue] = "0"
|
|
ethtool(f"-X {cfg.ifname} weight " + " ".join(weights))
|
|
defer(ethtool, f"-X {cfg.ifname} default")
|
|
|
|
# Set up ntuple filter to steer our test traffic to the isolated queue
|
|
flow = f"flow-type tcp{cfg.addr_ipver} "
|
|
flow += f"dst-ip {cfg.addr} dst-port {GRO_DPORT} action {test_queue}"
|
|
output = ethtool(f"-N {cfg.ifname} {flow}").stdout
|
|
ntuple_id = int(output.split()[-1])
|
|
defer(ethtool, f"-N {cfg.ifname} delete {ntuple_id}")
|
|
|
|
return test_queue
|
|
|
|
|
|
def _run_gro_test(cfg, test_name, num_flows=None, ignore_fail=False,
|
|
order_check=False):
|
|
"""Run gro binary with given test and return output."""
|
|
if not hasattr(cfg, "bin_remote"):
|
|
cfg.bin_local = cfg.net_lib_dir / "gro"
|
|
cfg.bin_remote = cfg.remote.deploy(cfg.bin_local)
|
|
|
|
ipver = cfg.addr_ipver
|
|
protocol = f"--ipv{ipver}"
|
|
dmac = _resolve_dmac(cfg, ipver)
|
|
|
|
base_args = [
|
|
protocol,
|
|
f"--dmac {dmac}",
|
|
f"--smac {cfg.remote_dev['address']}",
|
|
f"--daddr {cfg.addr}",
|
|
f"--saddr {cfg.remote_addr_v[ipver]}",
|
|
f"--test {test_name}",
|
|
]
|
|
if num_flows:
|
|
base_args.append(f"--num-flows {num_flows}")
|
|
if order_check:
|
|
base_args.append("--order-check")
|
|
|
|
args = " ".join(base_args)
|
|
|
|
rx_cmd = f"{cfg.bin_local} {args} --rx --iface {cfg.ifname}"
|
|
tx_cmd = f"{cfg.bin_remote} {args} --iface {cfg.remote_ifname}"
|
|
|
|
with bkg(rx_cmd, ksft_ready=True, exit_wait=True, fail=False) as rx_proc:
|
|
cmd(tx_cmd, host=cfg.remote)
|
|
|
|
if not ignore_fail:
|
|
ksft_eq(rx_proc.ret, 0)
|
|
if rx_proc.ret != 0:
|
|
ksft_pr(rx_proc)
|
|
|
|
return rx_proc.stdout
|
|
|
|
|
|
def _require_hw_gro_stats(cfg, queue_id):
|
|
"""Check if device reports HW GRO stats for the queue."""
|
|
stats = _get_queue_stats(cfg, queue_id)
|
|
required = ['rx-packets', 'rx-hw-gro-packets', 'rx-hw-gro-wire-packets']
|
|
for stat in required:
|
|
if stat not in stats:
|
|
raise KsftSkipEx(f"Driver does not report '{stat}' via qstats")
|
|
|
|
|
|
def _set_ethtool_feat(cfg, current, feats):
|
|
"""Set ethtool features with defer to restore original state."""
|
|
s2n = {True: "on", False: "off"}
|
|
|
|
new = ["-K", cfg.ifname]
|
|
old = ["-K", cfg.ifname]
|
|
no_change = True
|
|
for name, state in feats.items():
|
|
new += [name, s2n[state]]
|
|
old += [name, s2n[current[name]["active"]]]
|
|
|
|
if current[name]["active"] != state:
|
|
no_change = False
|
|
if current[name]["fixed"]:
|
|
raise KsftSkipEx(f"Device does not support {name}")
|
|
if no_change:
|
|
return
|
|
|
|
eth_cmd = ethtool(" ".join(new))
|
|
defer(ethtool, " ".join(old))
|
|
|
|
# If ethtool printed something kernel must have modified some features
|
|
if eth_cmd.stdout:
|
|
ksft_pr(eth_cmd)
|
|
|
|
|
|
def _setup_hw_gro(cfg):
|
|
"""Enable HW GRO on the device, disabling SW GRO."""
|
|
feat = ethtool(f"-k {cfg.ifname}", json=True)[0]
|
|
|
|
# Try to disable SW GRO and enable HW GRO
|
|
_set_ethtool_feat(cfg, feat,
|
|
{"generic-receive-offload": False,
|
|
"rx-gro-hw": True,
|
|
"large-receive-offload": False})
|
|
|
|
# Some NICs treat HW GRO as a GRO sub-feature so disabling GRO
|
|
# will also clear HW GRO. Use a hack of installing XDP generic
|
|
# to skip SW GRO, even when enabled.
|
|
feat = ethtool(f"-k {cfg.ifname}", json=True)[0]
|
|
if not feat["rx-gro-hw"]["active"]:
|
|
ksft_pr("Driver clears HW GRO when SW GRO is cleared, using generic XDP workaround")
|
|
prog = cfg.net_lib_dir / "xdp_dummy.bpf.o"
|
|
ip(f"link set dev {cfg.ifname} xdpgeneric obj {prog} sec xdp")
|
|
defer(ip, f"link set dev {cfg.ifname} xdpgeneric off")
|
|
|
|
# Attaching XDP may change features, fetch the latest state
|
|
feat = ethtool(f"-k {cfg.ifname}", json=True)[0]
|
|
|
|
_set_ethtool_feat(cfg, feat,
|
|
{"generic-receive-offload": True,
|
|
"rx-gro-hw": True,
|
|
"large-receive-offload": False})
|
|
|
|
|
|
def _check_gro_stats(cfg, test_queue, stats_before,
|
|
expect_rx, expect_gro, expect_wire):
|
|
"""Validate GRO stats against expected values."""
|
|
stats_after = _get_queue_stats(cfg, test_queue)
|
|
|
|
rx_delta = (stats_after.get('rx-packets', 0) -
|
|
stats_before.get('rx-packets', 0))
|
|
gro_delta = (stats_after.get('rx-hw-gro-packets', 0) -
|
|
stats_before.get('rx-hw-gro-packets', 0))
|
|
wire_delta = (stats_after.get('rx-hw-gro-wire-packets', 0) -
|
|
stats_before.get('rx-hw-gro-wire-packets', 0))
|
|
|
|
ksft_eq(rx_delta, expect_rx, comment="rx-packets")
|
|
ksft_eq(gro_delta, expect_gro, comment="rx-hw-gro-packets")
|
|
ksft_eq(wire_delta, expect_wire, comment="rx-hw-gro-wire-packets")
|
|
|
|
|
|
def test_gro_stats_single(cfg):
|
|
"""
|
|
Test that a single packet doesn't affect GRO stats.
|
|
|
|
Send a single packet that cannot be coalesced (nothing to coalesce with).
|
|
GRO stats should not increase since no coalescing occurred.
|
|
rx-packets should increase by 2 (1 data + 1 FIN).
|
|
"""
|
|
_setup_hw_gro(cfg)
|
|
|
|
test_queue = _setup_isolated_queue(cfg)
|
|
_require_hw_gro_stats(cfg, test_queue)
|
|
|
|
stats_before = _get_queue_stats(cfg, test_queue)
|
|
|
|
_run_gro_test(cfg, "single")
|
|
|
|
# 1 data + 1 FIN = 2 rx-packets, no coalescing
|
|
_check_gro_stats(cfg, test_queue, stats_before,
|
|
expect_rx=2, expect_gro=0, expect_wire=0)
|
|
|
|
|
|
def test_gro_stats_full(cfg):
|
|
"""
|
|
Test GRO stats when overwhelming HW GRO capacity.
|
|
|
|
Send 500 flows to exceed HW GRO flow capacity on a single queue.
|
|
This should result in some packets not being coalesced.
|
|
Validate that qstats match what gro.c observed.
|
|
"""
|
|
_setup_hw_gro(cfg)
|
|
|
|
test_queue = _setup_isolated_queue(cfg)
|
|
_require_hw_gro_stats(cfg, test_queue)
|
|
|
|
num_flows = 500
|
|
stats_before = _get_queue_stats(cfg, test_queue)
|
|
|
|
# Run capacity test - will likely fail because not all packets coalesce
|
|
output = _run_gro_test(cfg, "capacity", num_flows=num_flows,
|
|
ignore_fail=True)
|
|
|
|
# Parse gro.c output: "STATS: received=X wire=Y coalesced=Z"
|
|
match = re.search(r'STATS: received=(\d+) wire=(\d+) coalesced=(\d+)',
|
|
output)
|
|
if not match:
|
|
raise KsftSkipEx(f"Could not parse gro.c output: {output}")
|
|
|
|
rx_frames = int(match.group(2))
|
|
gro_coalesced = int(match.group(3))
|
|
|
|
ksft_ge(gro_coalesced, 1,
|
|
comment="At least some packets should coalesce")
|
|
|
|
# received + 1 FIN, coalesced super-packets, coalesced * 2 wire packets
|
|
_check_gro_stats(cfg, test_queue, stats_before,
|
|
expect_rx=rx_frames + 1,
|
|
expect_gro=gro_coalesced,
|
|
expect_wire=gro_coalesced * 2)
|
|
|
|
|
|
@ksft_variants([4, 32, 512])
|
|
def test_gro_order(cfg, num_flows):
|
|
"""
|
|
Test that HW GRO preserves packet ordering between flows.
|
|
|
|
Packets may get delayed until the aggregate is released,
|
|
but reordering between aggregates and packet terminating
|
|
the aggregate and normal packets should not happen.
|
|
|
|
Note that this test is stricter than truly required.
|
|
Reordering packets between flows should not cause issues.
|
|
This test will also fail if traffic is run over an ECMP fabric.
|
|
"""
|
|
_setup_hw_gro(cfg)
|
|
_setup_isolated_queue(cfg)
|
|
|
|
_run_gro_test(cfg, "capacity", num_flows=num_flows, order_check=True)
|
|
|
|
|
|
def main() -> None:
|
|
""" Ksft boiler plate main """
|
|
|
|
with NetDrvEpEnv(__file__, nsim_test=False) as cfg:
|
|
cfg.netnl = NetdevFamily()
|
|
ksft_run([test_gro_stats_single,
|
|
test_gro_stats_full,
|
|
test_gro_order], args=(cfg,))
|
|
ksft_exit()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|