Add cross-hook tests for the metadata stash covering all generic LWT program types. For lwt_in, a TC ingress program tags the skb on loopback and the LWT program reads the stashed metadata. For lwt_out and lwt_xmit, the LWT programs tag the skb on the output path and a TC ingress program reads the metadata back after loopback. Signed-off-by: Jakub Sitnicki --- .../bpf/prog_tests/xdp_context_test_run.c | 121 +++++++++++++++++++++ tools/testing/selftests/bpf/progs/test_xdp_meta.c | 35 ++++++ 2 files changed, 156 insertions(+) diff --git a/tools/testing/selftests/bpf/prog_tests/xdp_context_test_run.c b/tools/testing/selftests/bpf/prog_tests/xdp_context_test_run.c index eb0d36e7a45d..aea7a1c8a755 100644 --- a/tools/testing/selftests/bpf/prog_tests/xdp_context_test_run.c +++ b/tools/testing/selftests/bpf/prog_tests/xdp_context_test_run.c @@ -1638,6 +1638,118 @@ static void test_skb_trace__nf(struct test_xdp_meta *skel, const char *name) netns_free(ns); } +#define LWT_EXT_PIN_PATH "/sys/fs/bpf/skb_trace_lwt" + +/* + * Test metadata passing across LWT hooks on loopback. + * + * @lwt_prog: BPF program to pin and attach via ip route encap + * @encap_dir: "in", "out", or "xmit" + * @writer: true if lwt_prog tags the skb (reader on TC ingress), + * false if lwt_prog reads the metadata (writer on TC ingress) + */ +static void test_skb_trace__lwt(struct test_xdp_meta *skel, const char *name, + struct bpf_program *lwt_prog, + const char *encap_dir, bool writer) +{ + LIBBPF_OPTS(bpf_tc_hook, tc_hook, + .ifindex = 1 /* IFINDEX_LO */, + .attach_point = BPF_TC_INGRESS); + LIBBPF_OPTS(bpf_tc_opts, tc_opts, .handle = 1, .priority = 1); + struct sockaddr_in addr = { + .sin_family = AF_INET, + }; + struct bpf_program *tc_prog; + struct bpf_link *put_link = NULL; + char buf[TEST_PAYLOAD_LEN]; + struct netns_obj *ns = NULL; + bool pinned = false; + int server_fd = -1; + int fd = -1; + int port; + int ret; + int i; + + put_link = bpf_program__attach(skel->progs.skb_free); + if (!ASSERT_OK_PTR(put_link, "put_attach")) + return; + + unlink(LWT_EXT_PIN_PATH); + ret = bpf_program__pin(lwt_prog, LWT_EXT_PIN_PATH); + if (!ASSERT_OK(ret, "pin lwt")) + goto cleanup; + pinned = true; + + ns = netns_new(name, true); + if (!ASSERT_OK_PTR(ns, "netns_new")) + goto cleanup_prehook; + + SYS(cleanup, "ip addr add 10.0.0.1/32 dev lo"); + SYS(cleanup, "ip route replace table local local 10.0.0.1 " + "encap bpf %s pinned " LWT_EXT_PIN_PATH " dev lo", + encap_dir); + + server_fd = start_server(AF_INET, SOCK_DGRAM, "10.0.0.1", 0, 0); + if (!ASSERT_GE(server_fd, 0, "start_server")) + goto cleanup_prehook; + + skel->bss->test_pass = false; + skel->bss->free_count = 0; + + ret = bpf_tc_hook_create(&tc_hook); + if (!ASSERT_OK(ret, "bpf_tc_hook_create")) + goto cleanup_prehook; + + /* When LWT writes, TC ingress reads; when LWT reads, TC ingress writes */ + tc_prog = writer ? skel->progs.tc_meta_read + : skel->progs.tc_meta_write; + tc_opts.prog_fd = bpf_program__fd(tc_prog); + ret = bpf_tc_attach(&tc_hook, &tc_opts); + if (!ASSERT_OK(ret, "bpf_tc_attach")) + goto cleanup; + + port = get_socket_local_port(server_fd); + if (!ASSERT_GE(port, 0, "get_port")) + goto cleanup; + + fd = socket(AF_INET, SOCK_DGRAM, 0); + if (!ASSERT_GE(fd, 0, "socket")) + goto cleanup; + + inet_pton(AF_INET, "10.0.0.1", &addr.sin_addr); + addr.sin_port = port; + ret = sendto(fd, test_payload, TEST_PAYLOAD_LEN, 0, + (void *)&addr, sizeof(addr)); + if (!ASSERT_EQ(ret, TEST_PAYLOAD_LEN, "sendto")) + goto cleanup; + ret = recvfrom(server_fd, buf, sizeof(buf), 0, NULL, NULL); + ASSERT_EQ(ret, TEST_PAYLOAD_LEN, "recvfrom"); + + /* Poll every 10 msec up to 1 sec */ + for (i = 0; i < 100 && !skel->bss->test_pass; i++) + usleep(10000); + ASSERT_TRUE(skel->bss->test_pass, "test_pass"); + + /* Skb is freed after RX delivery; wait for free tp */ + for (i = 0; i < 100 && !skel->bss->free_count; i++) + usleep(10000); + ASSERT_GE(skel->bss->free_count, 1, "free_count"); + + assert_meta_stash_empty(skel->maps.meta_map); + +cleanup: + if (fd >= 0) + close(fd); + bpf_tc_hook_destroy(&tc_hook); +cleanup_prehook: + bpf_link__destroy(put_link); + if (server_fd >= 0) + close(server_fd); + netns_free(ns); + if (pinned) + unlink(LWT_EXT_PIN_PATH); +} + void test_skb_trace_cross_hook(void) { struct test_xdp_meta *skel = NULL; @@ -1662,6 +1774,15 @@ void test_skb_trace_cross_hook(void) test_skb_trace__tcp_retrans(skel); if (test__start_subtest("tc_to_nf")) test_skb_trace__nf(skel, "tc_to_nf"); + if (test__start_subtest("tc_to_lwt_in")) + test_skb_trace__lwt(skel, "tc_to_lwt_in", + skel->progs.lwt_in_meta_read, "in", false); + if (test__start_subtest("lwt_out_to_tc")) + test_skb_trace__lwt(skel, "lwt_out_to_tc", + skel->progs.lwt_out_meta_write, "out", true); + if (test__start_subtest("lwt_xmit_to_tc")) + test_skb_trace__lwt(skel, "lwt_xmit_to_tc", + skel->progs.lwt_xmit_meta_write, "xmit", true); test_xdp_meta__destroy(skel); } diff --git a/tools/testing/selftests/bpf/progs/test_xdp_meta.c b/tools/testing/selftests/bpf/progs/test_xdp_meta.c index d85b60c24f73..adad5433fc19 100644 --- a/tools/testing/selftests/bpf/progs/test_xdp_meta.c +++ b/tools/testing/selftests/bpf/progs/test_xdp_meta.c @@ -1009,4 +1009,39 @@ int nf_meta_read(struct bpf_nf_ctx *ctx) return NF_ACCEPT; } +SEC("lwt_in") +int lwt_in_meta_read(struct __sk_buff *ctx) +{ + __u8 *meta_have; + + meta_have = bpf_map_lookup_elem(&meta_map, &ctx); + if (!meta_have) + return BPF_OK; + if (!check_metadata(meta_have)) + return BPF_OK; + + test_pass = true; + return BPF_OK; +} + +SEC("lwt_out") +int lwt_out_meta_write(struct __sk_buff *ctx) +{ + if (!is_test_packet_tc(ctx)) + return BPF_OK; + write_meta(ctx, &meta_map); + + return BPF_OK; +} + +SEC("lwt_xmit") +int lwt_xmit_meta_write(struct __sk_buff *ctx) +{ + if (!is_test_packet_tc(ctx)) + return BPF_OK; + write_meta(ctx, &meta_map); + + return BPF_OK; +} + char _license[] SEC("license") = "GPL"; -- 2.43.0