mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2026-08-14 06:22:34 +02:00
Jakub Kicinski
2f7f2e3111
query_nic_features() detects which offloads depend on tx-gso-partial
by enabling everything, turning tx-gso-partial off, and seeing which
active features drop out. Enabling all hw features is dangerous:
we may end up enabling rx-fcs and loopback for example. For the
ice driver we end up getting into problems with feature dependencies
so the cleanup isn't successful either, and the test exits with
rx-fcs and loopback enabled.
Scope the feature probing just to segmentation bits.
Fixes: 266b835e5e ("selftests: drv-net: tso: enable test cases based on hw_features")
Reviewed-by: Pavan Chebbi <pavan.chebbi@broadcom.com>
Reviewed-by: Daniel Zahka <daniel.zahka@gmail.com>
Link: https://patch.msgid.link/20260629233923.2151144-1-kuba@kernel.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
264 lines
10 KiB
Python
Executable File
264 lines
10 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
|
|
"""Run the tools/testing/selftests/net/csum testsuite."""
|
|
|
|
import fcntl
|
|
import socket
|
|
import struct
|
|
import termios
|
|
import time
|
|
|
|
from lib.py import ksft_pr, ksft_run, ksft_exit, KsftSkipEx, KsftXfailEx
|
|
from lib.py import ksft_eq, ksft_ge, ksft_lt
|
|
from lib.py import EthtoolFamily, NetdevFamily, NetDrvEpEnv
|
|
from lib.py import bkg, cmd, defer, ethtool, ip, rand_port, wait_port_listen
|
|
|
|
|
|
def sock_wait_drain(sock, max_wait=1000):
|
|
"""Wait for all pending write data on the socket to get ACKed."""
|
|
for _ in range(max_wait):
|
|
one = b'\0' * 4
|
|
outq = fcntl.ioctl(sock.fileno(), termios.TIOCOUTQ, one)
|
|
outq = struct.unpack("I", outq)[0]
|
|
if outq == 0:
|
|
break
|
|
time.sleep(0.01)
|
|
ksft_eq(outq, 0)
|
|
|
|
|
|
def tcp_sock_get_retrans(sock):
|
|
"""Get the number of retransmissions for the TCP socket."""
|
|
info = sock.getsockopt(socket.SOL_TCP, socket.TCP_INFO, 512)
|
|
return struct.unpack("I", info[100:104])[0]
|
|
|
|
|
|
def run_one_stream(cfg, ipver, remote_v4, remote_v6, should_lso):
|
|
cfg.require_cmd("socat", local=False, remote=True)
|
|
|
|
# Set recv window clamp to avoid overwhelming receiver on debug kernels
|
|
# the 200k clamp should still let use reach > 15Gbps on real HW
|
|
port = rand_port()
|
|
listen_opts = f"{port},reuseport,tcp-window-clamp=200000"
|
|
listen_cmd = f"socat -{ipver} -t 2 -u TCP-LISTEN:{listen_opts} /dev/null,ignoreeof"
|
|
|
|
with bkg(listen_cmd, host=cfg.remote, exit_wait=True) as nc:
|
|
wait_port_listen(port, host=cfg.remote)
|
|
|
|
if ipver == "4":
|
|
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
sock.connect((remote_v4, port))
|
|
else:
|
|
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
|
|
sock.connect((remote_v6, port))
|
|
|
|
# Small send to make sure the connection is working.
|
|
sock.send("ping".encode())
|
|
sock_wait_drain(sock)
|
|
|
|
# Send 4MB of data, record the LSO packet count.
|
|
qstat_old = cfg.netnl.qstats_get({"ifindex": cfg.ifindex}, dump=True)[0]
|
|
buf = b"0" * 1024 * 1024 * 4
|
|
sock.send(buf)
|
|
sock_wait_drain(sock)
|
|
qstat_new = cfg.netnl.qstats_get({"ifindex": cfg.ifindex}, dump=True)[0]
|
|
|
|
# Check that at least 90% of the data was sent as LSO packets.
|
|
# System noise may cause false negatives. Also header overheads
|
|
# will add up to 5% of extra packes... The check is best effort.
|
|
total_lso_wire = len(buf) * 0.90 // cfg.dev["mtu"]
|
|
total_lso_super = len(buf) * 0.90 // cfg.dev["tso_max_size"]
|
|
|
|
# Make sure we have order of magnitude more LSO packets than
|
|
# retransmits, in case TCP retransmitted all the LSO packets.
|
|
ksft_lt(tcp_sock_get_retrans(sock), total_lso_wire / 16)
|
|
sock.close()
|
|
|
|
if should_lso:
|
|
if cfg.have_stat_super_count:
|
|
ksft_ge(qstat_new['tx-hw-gso-packets'] -
|
|
qstat_old['tx-hw-gso-packets'],
|
|
total_lso_super,
|
|
comment="Number of LSO super-packets with LSO enabled")
|
|
if cfg.have_stat_wire_count:
|
|
ksft_ge(qstat_new['tx-hw-gso-wire-packets'] -
|
|
qstat_old['tx-hw-gso-wire-packets'],
|
|
total_lso_wire,
|
|
comment="Number of LSO wire-packets with LSO enabled")
|
|
else:
|
|
if cfg.have_stat_super_count:
|
|
ksft_lt(qstat_new['tx-hw-gso-packets'] -
|
|
qstat_old['tx-hw-gso-packets'],
|
|
15, comment="Number of LSO super-packets with LSO disabled")
|
|
if cfg.have_stat_wire_count:
|
|
ksft_lt(qstat_new['tx-hw-gso-wire-packets'] -
|
|
qstat_old['tx-hw-gso-wire-packets'],
|
|
500, comment="Number of LSO wire-packets with LSO disabled")
|
|
|
|
|
|
def build_tunnel(cfg, outer_ipver, tun_info):
|
|
local_v4 = NetDrvEpEnv.nsim_v4_pfx + "1"
|
|
local_v6 = NetDrvEpEnv.nsim_v6_pfx + "1"
|
|
remote_v4 = NetDrvEpEnv.nsim_v4_pfx + "2"
|
|
remote_v6 = NetDrvEpEnv.nsim_v6_pfx + "2"
|
|
|
|
local_addr = cfg.addr_v[outer_ipver]
|
|
remote_addr = cfg.remote_addr_v[outer_ipver]
|
|
|
|
tun_type = tun_info[0]
|
|
tun_arg = tun_info[1]
|
|
ip(f"link add {tun_type}-ksft type {tun_type} {tun_arg} local {local_addr} remote {remote_addr} dev {cfg.ifname}")
|
|
defer(ip, f"link del {tun_type}-ksft")
|
|
ip(f"link set dev {tun_type}-ksft up")
|
|
ip(f"addr add {local_v4}/24 dev {tun_type}-ksft")
|
|
ip(f"addr add {local_v6}/64 dev {tun_type}-ksft")
|
|
|
|
ip(f"link add {tun_type}-ksft type {tun_type} {tun_arg} local {remote_addr} remote {local_addr} dev {cfg.remote_ifname}",
|
|
host=cfg.remote)
|
|
defer(ip, f"link del {tun_type}-ksft", host=cfg.remote)
|
|
ip(f"link set dev {tun_type}-ksft up", host=cfg.remote)
|
|
ip(f"addr add {remote_v4}/24 dev {tun_type}-ksft", host=cfg.remote)
|
|
ip(f"addr add {remote_v6}/64 dev {tun_type}-ksft", host=cfg.remote)
|
|
|
|
return remote_v4, remote_v6
|
|
|
|
|
|
def restore_wanted_features(cfg):
|
|
features_cmd = ""
|
|
for feature in cfg.hw_features:
|
|
setting = "on" if feature in cfg.wanted_features else "off"
|
|
features_cmd += f" {feature} {setting}"
|
|
try:
|
|
ethtool(f"-K {cfg.ifname} {features_cmd}")
|
|
except Exception as e:
|
|
ksft_pr(f"WARNING: failure restoring wanted features: {e}")
|
|
|
|
|
|
def test_builder(name, cfg, outer_ipver, feature, tun=None, inner_ipver=None):
|
|
"""Construct specific tests from the common template."""
|
|
def f(cfg):
|
|
cfg.require_ipver(outer_ipver)
|
|
defer(restore_wanted_features, cfg)
|
|
|
|
if not cfg.have_stat_super_count and \
|
|
not cfg.have_stat_wire_count:
|
|
raise KsftSkipEx(f"Device does not support LSO queue stats")
|
|
|
|
if feature not in cfg.hw_features:
|
|
raise KsftSkipEx(f"Device does not support {feature}")
|
|
|
|
ipver = outer_ipver
|
|
if tun:
|
|
remote_v4, remote_v6 = build_tunnel(cfg, ipver, tun)
|
|
ipver = inner_ipver
|
|
else:
|
|
remote_v4 = cfg.remote_addr_v["4"]
|
|
remote_v6 = cfg.remote_addr_v["6"]
|
|
|
|
# First test without the feature enabled.
|
|
ethtool(f"-K {cfg.ifname} {feature} off")
|
|
run_one_stream(cfg, ipver, remote_v4, remote_v6, should_lso=False)
|
|
|
|
ethtool(f"-K {cfg.ifname} tx-gso-partial off")
|
|
ethtool(f"-K {cfg.ifname} tx-tcp-mangleid-segmentation off")
|
|
if feature in cfg.partial_features:
|
|
ethtool(f"-K {cfg.ifname} tx-gso-partial on")
|
|
if ipver == "4":
|
|
ksft_pr("Testing with mangleid enabled")
|
|
ethtool(f"-K {cfg.ifname} tx-tcp-mangleid-segmentation on")
|
|
|
|
# Full feature enabled.
|
|
ethtool(f"-K {cfg.ifname} {feature} on")
|
|
run_one_stream(cfg, ipver, remote_v4, remote_v6, should_lso=True)
|
|
|
|
f.__name__ = name + ((outer_ipver + "_") if tun else "") + "ipv" + inner_ipver
|
|
return f
|
|
|
|
|
|
def query_nic_features(cfg) -> None:
|
|
"""Query and cache the NIC features."""
|
|
cfg.have_stat_super_count = False
|
|
cfg.have_stat_wire_count = False
|
|
|
|
features = cfg.ethnl.features_get({"header": {"dev-index": cfg.ifindex}})
|
|
|
|
cfg.wanted_features = set()
|
|
for f in features["wanted"]["bits"]["bit"]:
|
|
cfg.wanted_features.add(f["name"])
|
|
|
|
cfg.hw_features = set()
|
|
for f in features["hw"]["bits"]["bit"]:
|
|
if f.get("value", False):
|
|
cfg.hw_features.add(f["name"])
|
|
|
|
# Check which features are supported via GSO partial
|
|
cfg.partial_features = set()
|
|
if 'tx-gso-partial' in cfg.hw_features:
|
|
seg_features = {f for f in cfg.hw_features if "segmentation" in f}
|
|
ethtool(f"-K {cfg.ifname} " +
|
|
" ".join(f"{f} on" for f in seg_features))
|
|
|
|
ethtool(f"-K {cfg.ifname} tx-gso-partial off")
|
|
|
|
no_partial = set()
|
|
features = cfg.ethnl.features_get({"header": {"dev-index": cfg.ifindex}})
|
|
for f in features["active"]["bits"]["bit"]:
|
|
no_partial.add(f["name"])
|
|
cfg.partial_features = seg_features - no_partial
|
|
ethtool(f"-K {cfg.ifname} tx-gso-partial on")
|
|
|
|
restore_wanted_features(cfg)
|
|
|
|
stats = cfg.netnl.qstats_get({"ifindex": cfg.ifindex}, dump=True)
|
|
if stats:
|
|
if 'tx-hw-gso-packets' in stats[0]:
|
|
ksft_pr("Detected qstat for LSO super-packets")
|
|
cfg.have_stat_super_count = True
|
|
if 'tx-hw-gso-wire-packets' in stats[0]:
|
|
ksft_pr("Detected qstat for LSO wire-packets")
|
|
cfg.have_stat_wire_count = True
|
|
|
|
|
|
def main() -> None:
|
|
with NetDrvEpEnv(__file__, nsim_test=False) as cfg:
|
|
cfg.ethnl = EthtoolFamily()
|
|
cfg.netnl = NetdevFamily()
|
|
|
|
query_nic_features(cfg)
|
|
|
|
test_info = (
|
|
# name, v4/v6 ethtool_feature tun:(type, args, inner ip versions)
|
|
("", "4", "tx-tcp-segmentation", None),
|
|
("", "6", "tx-tcp6-segmentation", None),
|
|
("vxlan", "4", "tx-udp_tnl-segmentation", ("vxlan", "id 100 dstport 4789 noudpcsum", ("4", "6"))),
|
|
("vxlan", "6", "tx-udp_tnl-segmentation", ("vxlan", "id 100 dstport 4789 udp6zerocsumtx udp6zerocsumrx", ("4", "6"))),
|
|
("vxlan_csum", "", "tx-udp_tnl-csum-segmentation", ("vxlan", "id 100 dstport 4789 udpcsum", ("4", "6"))),
|
|
("gre", "4", "tx-gre-segmentation", ("gre", "", ("4", "6"))),
|
|
("gre", "6", "tx-gre-segmentation", ("ip6gre","", ("4", "6"))),
|
|
("ip", "6", "tx-ipxip6-segmentation", ("ip6tnl","mode any", ("4", "6"))),
|
|
("ip", "4", "tx-ipxip4-segmentation", ("sit","", ("6", ))),
|
|
("ip", "4", "tx-ipxip4-segmentation", ("ipip","", ("4", ))),
|
|
)
|
|
|
|
cases = []
|
|
for outer_ipver in ["4", "6"]:
|
|
for info in test_info:
|
|
# Skip if test which only works for a specific IP version
|
|
if info[1] and outer_ipver != info[1]:
|
|
continue
|
|
|
|
if info[3]:
|
|
cases += [
|
|
test_builder(info[0], cfg, outer_ipver, info[2], info[3], inner_ipver)
|
|
for inner_ipver in info[3][2]
|
|
]
|
|
else:
|
|
cases.append(test_builder(info[0], cfg, outer_ipver, info[2], None, outer_ipver))
|
|
|
|
ksft_run(cases=cases, args=(cfg, ))
|
|
ksft_exit()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|