147 lines
4.7 KiB
Python
147 lines
4.7 KiB
Python
#!/usr/bin/env python3
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
|
|
"""
|
|
Tests for XDP metadata kfuncs (e.g. bpf_xdp_metadata_rx_hash).
|
|
|
|
These tests load device-bound XDP programs from xdp_metadata.bpf.o
|
|
that call metadata kfuncs, send traffic, and verify the extracted
|
|
metadata via BPF maps.
|
|
"""
|
|
from lib.py import ksft_run, ksft_eq, ksft_exit, ksft_ge, ksft_ne, ksft_pr
|
|
from lib.py import KsftNamedVariant, ksft_variants
|
|
from lib.py import CmdExitFailure, KsftSkipEx, NetDrvEpEnv
|
|
from lib.py import NetdevFamily
|
|
from lib.py import bkg, cmd, rand_port, wait_port_listen
|
|
from lib.py import ip, bpftool, defer
|
|
from lib.py import bpf_map_set, bpf_map_dump, bpf_prog_map_ids
|
|
|
|
|
|
def _load_xdp_metadata_prog(cfg, prog_name, bpf_file="xdp_metadata.bpf.o"):
|
|
"""Load a device-bound XDP metadata program and return prog/map info.
|
|
|
|
Returns:
|
|
dict with 'id', 'name', and 'maps' (name -> map_id).
|
|
"""
|
|
abs_path = cfg.net_lib_dir / bpf_file
|
|
pin_dir = "/sys/fs/bpf/xdp_metadata_test"
|
|
|
|
cmd(f"rm -rf {pin_dir}", shell=True, fail=False)
|
|
cmd(f"mkdir -p {pin_dir}", shell=True)
|
|
|
|
try:
|
|
bpftool(f"prog loadall {abs_path} {pin_dir} type xdp "
|
|
f"xdpmeta_dev {cfg.ifname}")
|
|
except CmdExitFailure as e:
|
|
cmd(f"rm -rf {pin_dir}", shell=True, fail=False)
|
|
raise KsftSkipEx(
|
|
f"Failed to load device-bound XDP program '{prog_name}'"
|
|
) from e
|
|
defer(cmd, f"rm -rf {pin_dir}", shell=True, fail=False)
|
|
|
|
pin_path = f"{pin_dir}/{prog_name}"
|
|
ip(f"link set dev {cfg.ifname} xdpdrv pinned {pin_path}")
|
|
defer(ip, f"link set dev {cfg.ifname} xdpdrv off")
|
|
|
|
xdp_info = ip(f"-d link show dev {cfg.ifname}", json=True)[0]
|
|
prog_id = xdp_info["xdp"]["prog"]["id"]
|
|
|
|
return {"id": prog_id,
|
|
"name": xdp_info["xdp"]["prog"]["name"],
|
|
"maps": bpf_prog_map_ids(prog_id)}
|
|
|
|
|
|
def _send_probe(cfg, port, proto="tcp"):
|
|
"""Send a single payload from the remote end using socat.
|
|
|
|
Args:
|
|
cfg: Configuration object containing network settings.
|
|
port: Port number for the exchange.
|
|
proto: Protocol to use, either "tcp" or "udp".
|
|
"""
|
|
cfg.require_cmd("socat", remote=True)
|
|
|
|
if proto == "tcp":
|
|
rx_cmd = f"socat -{cfg.addr_ipver} -T 2 TCP-LISTEN:{port},reuseport STDOUT"
|
|
tx_cmd = f"echo -n rss_hash_test | socat -t 2 -u STDIN TCP:{cfg.baddr}:{port}"
|
|
else:
|
|
rx_cmd = f"socat -{cfg.addr_ipver} -T 2 -u UDP-RECV:{port},reuseport STDOUT"
|
|
tx_cmd = f"echo -n rss_hash_test | socat -t 2 -u STDIN UDP:{cfg.baddr}:{port}"
|
|
|
|
with bkg(rx_cmd, exit_wait=True):
|
|
wait_port_listen(port, proto=proto)
|
|
cmd(tx_cmd, host=cfg.remote, shell=True)
|
|
|
|
|
|
# BPF map keys matching the enums in xdp_metadata.bpf.c
|
|
_SETUP_KEY_PORT = 1
|
|
|
|
_RSS_KEY_HASH = 0
|
|
_RSS_KEY_TYPE = 1
|
|
_RSS_KEY_PKT_CNT = 2
|
|
_RSS_KEY_ERR_CNT = 3
|
|
|
|
XDP_RSS_L4 = 0x8 # BIT(3) from enum xdp_rss_hash_type
|
|
|
|
|
|
@ksft_variants([
|
|
KsftNamedVariant("tcp", "tcp"),
|
|
KsftNamedVariant("udp", "udp"),
|
|
])
|
|
def test_xdp_rss_hash(cfg, proto):
|
|
"""Test RSS hash metadata extraction via bpf_xdp_metadata_rx_hash().
|
|
|
|
This test will only run on devices that support xdp-rx-metadata-features.
|
|
|
|
Loads the xdp_rss_hash program from xdp_metadata, sends a packet using
|
|
the specified protocol, and verifies that the program extracted a non-zero
|
|
hash with an L4 hash type.
|
|
"""
|
|
dev_info = cfg.netnl.dev_get({"ifindex": cfg.ifindex})
|
|
rx_meta = dev_info.get("xdp-rx-metadata-features", [])
|
|
if "hash" not in rx_meta:
|
|
raise KsftSkipEx("device does not support XDP rx hash metadata")
|
|
|
|
prog_info = _load_xdp_metadata_prog(cfg, "xdp_rss_hash")
|
|
|
|
port = rand_port()
|
|
bpf_map_set("map_xdp_setup", _SETUP_KEY_PORT, port)
|
|
|
|
rss_map_id = prog_info["maps"]["map_rss"]
|
|
|
|
_send_probe(cfg, port, proto=proto)
|
|
|
|
rss = bpf_map_dump(rss_map_id)
|
|
|
|
pkt_cnt = rss.get(_RSS_KEY_PKT_CNT, 0)
|
|
err_cnt = rss.get(_RSS_KEY_ERR_CNT, 0)
|
|
hash_val = rss.get(_RSS_KEY_HASH, 0)
|
|
hash_type = rss.get(_RSS_KEY_TYPE, 0)
|
|
|
|
ksft_ge(pkt_cnt, 1, comment="should have received at least one packet")
|
|
ksft_eq(err_cnt, 0, comment=f"RSS hash error count: {err_cnt}")
|
|
|
|
ksft_ne(hash_val, 0,
|
|
f"RSS hash should be non-zero for {proto.upper()} traffic")
|
|
ksft_pr(f" RSS hash: {hash_val:#010x}")
|
|
|
|
ksft_pr(f" RSS hash type: {hash_type:#06x}")
|
|
ksft_ne(hash_type & XDP_RSS_L4, 0,
|
|
f"RSS hash type should include L4 for {proto.upper()} traffic")
|
|
|
|
|
|
def main():
|
|
"""Run XDP metadata kfunc tests against a real device."""
|
|
with NetDrvEpEnv(__file__) as cfg:
|
|
cfg.netnl = NetdevFamily()
|
|
ksft_run(
|
|
[
|
|
test_xdp_rss_hash,
|
|
],
|
|
args=(cfg,))
|
|
ksft_exit()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|