Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1#!/usr/bin/env python3
2# SPDX-License-Identifier: GPL-2.0
3
4"""
5GRO (Generic Receive Offload) conformance tests.
6
7Validates that GRO coalescing works correctly by running the gro
8binary in different configurations and checking for correct packet
9coalescing behavior.
10
11Test cases:
12 - data: Data packets with same size/headers and correct seq numbers coalesce
13 - ack: Pure ACK packets do not coalesce
14 - flags: Packets with PSH, SYN, URG, RST flags do not coalesce
15 - tcp: Packets with incorrect checksum, non-consecutive seqno don't coalesce
16 - ip: Packets with different ECN, TTL, TOS, or IP options don't coalesce
17 - large: Packets larger than GRO_MAX_SIZE don't coalesce
18"""
19
20import os
21from lib.py import ksft_run, ksft_exit, ksft_pr
22from lib.py import NetDrvEpEnv, KsftXfailEx
23from lib.py import cmd, defer, bkg, ip
24from lib.py import ksft_variants
25
26
27def _resolve_dmac(cfg, ipver):
28 """
29 Find the destination MAC address remote host should use to send packets
30 towards the local host. It may be a router / gateway address.
31 """
32
33 attr = "dmac" + ipver
34 # Cache the response across test cases
35 if hasattr(cfg, attr):
36 return getattr(cfg, attr)
37
38 route = ip(f"-{ipver} route get {cfg.addr_v[ipver]}",
39 json=True, host=cfg.remote)[0]
40 gw = route.get("gateway")
41 # Local L2 segment, address directly
42 if not gw:
43 setattr(cfg, attr, cfg.dev['address'])
44 return getattr(cfg, attr)
45
46 # ping to make sure neighbor is resolved,
47 # bind to an interface, for v6 the GW is likely link local
48 cmd(f"ping -c1 -W0 -I{cfg.remote_ifname} {gw}", host=cfg.remote)
49
50 neigh = ip(f"neigh get {gw} dev {cfg.remote_ifname}",
51 json=True, host=cfg.remote)[0]
52 setattr(cfg, attr, neigh['lladdr'])
53 return getattr(cfg, attr)
54
55
56def _write_defer_restore(cfg, path, val, defer_undo=False):
57 with open(path, "r", encoding="utf-8") as fp:
58 orig_val = fp.read().strip()
59 if str(val) == orig_val:
60 return
61 with open(path, "w", encoding="utf-8") as fp:
62 fp.write(val)
63 if defer_undo:
64 defer(_write_defer_restore, cfg, path, orig_val)
65
66
67def _set_mtu_restore(dev, mtu, host):
68 if dev['mtu'] < mtu:
69 ip(f"link set dev {dev['ifname']} mtu {mtu}", host=host)
70 defer(ip, f"link set dev {dev['ifname']} mtu {dev['mtu']}", host=host)
71
72
73def _setup(cfg, test_name):
74 """ Setup hardware loopback mode for GRO testing. """
75
76 if not hasattr(cfg, "bin_remote"):
77 cfg.bin_local = cfg.test_dir / "gro"
78 cfg.bin_remote = cfg.remote.deploy(cfg.bin_local)
79
80 # "large" test needs at least 4k MTU
81 if test_name == "large":
82 _set_mtu_restore(cfg.dev, 4096, None)
83 _set_mtu_restore(cfg.remote_dev, 4096, cfg.remote)
84
85 flush_path = f"/sys/class/net/{cfg.ifname}/gro_flush_timeout"
86 irq_path = f"/sys/class/net/{cfg.ifname}/napi_defer_hard_irqs"
87
88 _write_defer_restore(cfg, flush_path, "200000", defer_undo=True)
89 _write_defer_restore(cfg, irq_path, "10", defer_undo=True)
90
91 try:
92 # Disable TSO for local tests
93 cfg.require_nsim() # will raise KsftXfailEx if not running on nsim
94
95 cmd(f"ethtool -K {cfg.ifname} gro on tso off")
96 cmd(f"ethtool -K {cfg.remote_ifname} gro on tso off", host=cfg.remote)
97 except KsftXfailEx:
98 pass
99
100def _gro_variants():
101 """Generator that yields all combinations of protocol and test types."""
102
103 for protocol in ["ipv4", "ipv6", "ipip"]:
104 for test_name in ["data", "ack", "flags", "tcp", "ip", "large"]:
105 yield protocol, test_name
106
107
108@ksft_variants(_gro_variants())
109def test(cfg, protocol, test_name):
110 """Run a single GRO test with retries."""
111
112 ipver = "6" if protocol[-1] == "6" else "4"
113 cfg.require_ipver(ipver)
114
115 _setup(cfg, test_name)
116
117 base_cmd_args = [
118 f"--{protocol}",
119 f"--dmac {_resolve_dmac(cfg, ipver)}",
120 f"--smac {cfg.remote_dev['address']}",
121 f"--daddr {cfg.addr_v[ipver]}",
122 f"--saddr {cfg.remote_addr_v[ipver]}",
123 f"--test {test_name}",
124 "--verbose"
125 ]
126 base_args = " ".join(base_cmd_args)
127
128 # Each test is run 6 times to deflake, because given the receive timing,
129 # not all packets that should coalesce will be considered in the same flow
130 # on every try.
131 max_retries = 6
132 for attempt in range(max_retries):
133 rx_cmd = f"{cfg.bin_local} {base_args} --rx --iface {cfg.ifname}"
134 tx_cmd = f"{cfg.bin_remote} {base_args} --iface {cfg.remote_ifname}"
135
136 fail_now = attempt >= max_retries - 1
137
138 with bkg(rx_cmd, ksft_ready=True, exit_wait=True,
139 fail=fail_now) as rx_proc:
140 cmd(tx_cmd, host=cfg.remote)
141
142 if rx_proc.ret == 0:
143 return
144
145 ksft_pr(rx_proc.stdout.strip().replace('\n', '\n# '))
146 ksft_pr(rx_proc.stderr.strip().replace('\n', '\n# '))
147
148 if test_name == "large" and os.environ.get("KSFT_MACHINE_SLOW"):
149 ksft_pr(f"Ignoring {protocol}/{test_name} failure due to slow environment")
150 return
151
152 ksft_pr(f"Attempt {attempt + 1}/{max_retries} failed, retrying...")
153
154
155def main() -> None:
156 """ Ksft boiler plate main """
157
158 with NetDrvEpEnv(__file__) as cfg:
159 ksft_run(cases=[test], args=(cfg,))
160 ksft_exit()
161
162
163if __name__ == "__main__":
164 main()