rss_input_xfrm.py \
toeplitz.py \
tso.py \
+ xdp_metadata.py \
xsk_reconfig.py \
#
from net.lib.py import bkg, cmd, bpftool, bpftrace, defer, ethtool, \
fd_read_timeout, ip, rand_port, rand_ports, wait_port_listen, \
wait_file, tool
+ from net.lib.py import bpf_map_set, bpf_map_dump, bpf_prog_map_ids
from net.lib.py import KsftSkipEx, KsftFailEx, KsftXfailEx
from net.lib.py import ksft_disruptive, ksft_exit, ksft_pr, ksft_run, \
ksft_setup, ksft_variants, KsftNamedVariant
"bkg", "cmd", "bpftool", "bpftrace", "defer", "ethtool",
"fd_read_timeout", "ip", "rand_port", "rand_ports",
"wait_port_listen", "wait_file", "tool",
+ "bpf_map_set", "bpf_map_dump", "bpf_prog_map_ids",
"KsftSkipEx", "KsftFailEx", "KsftXfailEx",
"ksft_disruptive", "ksft_exit", "ksft_pr", "ksft_run",
"ksft_setup", "ksft_variants", "KsftNamedVariant",
--- /dev/null
+#!/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()
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0
+
+#include <stddef.h>
+#include <linux/bpf.h>
+#include <linux/in.h>
+#include <linux/if_ether.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/udp.h>
+#include <linux/tcp.h>
+#include <bpf/bpf_endian.h>
+#include <bpf/bpf_helpers.h>
+
+enum {
+ XDP_PORT = 1,
+ XDP_PROTO = 4,
+} xdp_map_setup_keys;
+
+struct {
+ __uint(type, BPF_MAP_TYPE_ARRAY);
+ __uint(max_entries, 5);
+ __type(key, __u32);
+ __type(value, __s32);
+} map_xdp_setup SEC(".maps");
+
+/* RSS hash results: key 0 = hash, key 1 = hash type,
+ * key 2 = packet count, key 3 = error count.
+ */
+enum {
+ RSS_KEY_HASH = 0,
+ RSS_KEY_TYPE = 1,
+ RSS_KEY_PKT_CNT = 2,
+ RSS_KEY_ERR_CNT = 3,
+};
+
+struct {
+ __uint(type, BPF_MAP_TYPE_ARRAY);
+ __type(key, __u32);
+ __type(value, __u32);
+ __uint(max_entries, 4);
+} map_rss SEC(".maps");
+
+/* Mirror of enum xdp_rss_hash_type from include/net/xdp.h.
+ * Needed because the enum is not part of UAPI headers.
+ */
+enum xdp_rss_hash_type {
+ XDP_RSS_L3_IPV4 = 1U << 0,
+ XDP_RSS_L3_IPV6 = 1U << 1,
+ XDP_RSS_L3_DYNHDR = 1U << 2,
+ XDP_RSS_L4 = 1U << 3,
+ XDP_RSS_L4_TCP = 1U << 4,
+ XDP_RSS_L4_UDP = 1U << 5,
+ XDP_RSS_L4_SCTP = 1U << 6,
+ XDP_RSS_L4_IPSEC = 1U << 7,
+ XDP_RSS_L4_ICMP = 1U << 8,
+};
+
+extern int bpf_xdp_metadata_rx_hash(const struct xdp_md *ctx, __u32 *hash,
+ enum xdp_rss_hash_type *rss_type) __ksym;
+
+static __always_inline __u16 get_dest_port(void *l4, void *data_end,
+ __u8 protocol)
+{
+ if (protocol == IPPROTO_UDP) {
+ struct udphdr *udp = l4;
+
+ if ((void *)(udp + 1) > data_end)
+ return 0;
+ return udp->dest;
+ } else if (protocol == IPPROTO_TCP) {
+ struct tcphdr *tcp = l4;
+
+ if ((void *)(tcp + 1) > data_end)
+ return 0;
+ return tcp->dest;
+ }
+
+ return 0;
+}
+
+SEC("xdp")
+int xdp_rss_hash(struct xdp_md *ctx)
+{
+ void *data_end = (void *)(long)ctx->data_end;
+ void *data = (void *)(long)ctx->data;
+ enum xdp_rss_hash_type rss_type = 0;
+ struct ethhdr *eth = data;
+ __u8 l4_proto = 0;
+ __u32 hash = 0;
+ __u32 key, val;
+ void *l4 = NULL;
+ __u32 *cnt;
+ int ret;
+
+ if ((void *)(eth + 1) > data_end)
+ return XDP_PASS;
+
+ if (eth->h_proto == bpf_htons(ETH_P_IP)) {
+ struct iphdr *iph = (void *)(eth + 1);
+
+ if ((void *)(iph + 1) > data_end)
+ return XDP_PASS;
+ l4_proto = iph->protocol;
+ l4 = (void *)(iph + 1);
+ } else if (eth->h_proto == bpf_htons(ETH_P_IPV6)) {
+ struct ipv6hdr *ip6h = (void *)(eth + 1);
+
+ if ((void *)(ip6h + 1) > data_end)
+ return XDP_PASS;
+ l4_proto = ip6h->nexthdr;
+ l4 = (void *)(ip6h + 1);
+ }
+
+ if (!l4)
+ return XDP_PASS;
+
+ /* Filter on the configured protocol (map_xdp_setup key XDP_PROTO).
+ * When set, only process packets matching the requested L4 protocol.
+ */
+ key = XDP_PROTO;
+ __s32 *proto_cfg = bpf_map_lookup_elem(&map_xdp_setup, &key);
+
+ if (proto_cfg && *proto_cfg != 0 && l4_proto != (__u8)*proto_cfg)
+ return XDP_PASS;
+
+ /* Filter on the configured port (map_xdp_setup key XDP_PORT).
+ * Only applies to protocols with ports (UDP, TCP).
+ */
+ key = XDP_PORT;
+ __s32 *port_cfg = bpf_map_lookup_elem(&map_xdp_setup, &key);
+
+ if (port_cfg && *port_cfg != 0) {
+ __u16 dest = get_dest_port(l4, data_end, l4_proto);
+
+ if (!dest || bpf_ntohs(dest) != (__u16)*port_cfg)
+ return XDP_PASS;
+ }
+
+ ret = bpf_xdp_metadata_rx_hash(ctx, &hash, &rss_type);
+ if (ret < 0) {
+ key = RSS_KEY_ERR_CNT;
+ cnt = bpf_map_lookup_elem(&map_rss, &key);
+ if (cnt)
+ __sync_fetch_and_add(cnt, 1);
+ return XDP_PASS;
+ }
+
+ key = RSS_KEY_HASH;
+ bpf_map_update_elem(&map_rss, &key, &hash, BPF_ANY);
+
+ key = RSS_KEY_TYPE;
+ val = (__u32)rss_type;
+ bpf_map_update_elem(&map_rss, &key, &val, BPF_ANY);
+
+ key = RSS_KEY_PKT_CNT;
+ cnt = bpf_map_lookup_elem(&map_rss, &key);
+ if (cnt)
+ __sync_fetch_and_add(cnt, 1);
+
+ return XDP_PASS;
+}
+
+char _license[] SEC("license") = "GPL";
projects / thirdparty / linux.git / commitdiff
