selftests/bpf: Add test for xdp_md context in BPF_PROG_TEST_RUN

Add a test for using xdp_md as a context to BPF_PROG_TEST_RUN for XDP
programs.

The test uses a BPF program that takes in a return value from XDP
meta data, then reduces the size of the XDP meta data by 4 bytes.

Test cases validate the possible failure cases for passing in invalid
xdp_md contexts, that the return value is successfully passed
in, and that the adjusted meta data is successfully copied out.

Co-developed-by: Cody Haas <chaas@riotgames.com>
Co-developed-by: Lisa Watanabe <lwatanabe@riotgames.com>
Signed-off-by: Cody Haas <chaas@riotgames.com>
Signed-off-by: Lisa Watanabe <lwatanabe@riotgames.com>
Signed-off-by: Zvi Effron <zeffron@riotgames.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: Yonghong Song <yhs@fb.com>
Link: https://lore.kernel.org/bpf/20210707221657.3985075-5-zeffron@riotgames.com

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
new file mode 100644 (file)
index 0000000..ab4952b
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/xdp_context_test_run.c
@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <test_progs.h>
+#include <network_helpers.h>
+#include "test_xdp_context_test_run.skel.h"
+
+void test_xdp_context_error(int prog_fd, struct bpf_test_run_opts opts,
+                           __u32 data_meta, __u32 data, __u32 data_end,
+                           __u32 ingress_ifindex, __u32 rx_queue_index,
+                           __u32 egress_ifindex)
+{
+       struct xdp_md ctx = {
+               .data = data,
+               .data_end = data_end,
+               .data_meta = data_meta,
+               .ingress_ifindex = ingress_ifindex,
+               .rx_queue_index = rx_queue_index,
+               .egress_ifindex = egress_ifindex,
+       };
+       int err;
+
+       opts.ctx_in = &ctx;
+       opts.ctx_size_in = sizeof(ctx);
+       err = bpf_prog_test_run_opts(prog_fd, &opts);
+       ASSERT_EQ(errno, EINVAL, "errno-EINVAL");
+       ASSERT_ERR(err, "bpf_prog_test_run");
+}
+
+void test_xdp_context_test_run(void)
+{
+       struct test_xdp_context_test_run *skel = NULL;
+       char data[sizeof(pkt_v4) + sizeof(__u32)];
+       char bad_ctx[sizeof(struct xdp_md) + 1];
+       struct xdp_md ctx_in, ctx_out;
+       DECLARE_LIBBPF_OPTS(bpf_test_run_opts, opts,
+                           .data_in = &data,
+                           .data_size_in = sizeof(data),
+                           .ctx_out = &ctx_out,
+                           .ctx_size_out = sizeof(ctx_out),
+                           .repeat = 1,
+               );
+       int err, prog_fd;
+
+       skel = test_xdp_context_test_run__open_and_load();
+       if (!ASSERT_OK_PTR(skel, "skel"))
+               return;
+       prog_fd = bpf_program__fd(skel->progs.xdp_context);
+
+       /* Data past the end of the kernel's struct xdp_md must be 0 */
+       bad_ctx[sizeof(bad_ctx) - 1] = 1;
+       opts.ctx_in = bad_ctx;
+       opts.ctx_size_in = sizeof(bad_ctx);
+       err = bpf_prog_test_run_opts(prog_fd, &opts);
+       ASSERT_EQ(errno, E2BIG, "extradata-errno");
+       ASSERT_ERR(err, "bpf_prog_test_run(extradata)");
+
+       *(__u32 *)data = XDP_PASS;
+       *(struct ipv4_packet *)(data + sizeof(__u32)) = pkt_v4;
+       opts.ctx_in = &ctx_in;
+       opts.ctx_size_in = sizeof(ctx_in);
+       memset(&ctx_in, 0, sizeof(ctx_in));
+       ctx_in.data_meta = 0;
+       ctx_in.data = sizeof(__u32);
+       ctx_in.data_end = ctx_in.data + sizeof(pkt_v4);
+       err = bpf_prog_test_run_opts(prog_fd, &opts);
+       ASSERT_OK(err, "bpf_prog_test_run(valid)");
+       ASSERT_EQ(opts.retval, XDP_PASS, "valid-retval");
+       ASSERT_EQ(opts.data_size_out, sizeof(pkt_v4), "valid-datasize");
+       ASSERT_EQ(opts.ctx_size_out, opts.ctx_size_in, "valid-ctxsize");
+       ASSERT_EQ(ctx_out.data_meta, 0, "valid-datameta");
+       ASSERT_EQ(ctx_out.data, 0, "valid-data");
+       ASSERT_EQ(ctx_out.data_end, sizeof(pkt_v4), "valid-dataend");
+
+       /* Meta data's size must be a multiple of 4 */
+       test_xdp_context_error(prog_fd, opts, 0, 1, sizeof(data), 0, 0, 0);
+
+       /* data_meta must reference the start of data */
+       test_xdp_context_error(prog_fd, opts, 4, sizeof(__u32), sizeof(data),
+                              0, 0, 0);
+
+       /* Meta data must be 32 bytes or smaller */
+       test_xdp_context_error(prog_fd, opts, 0, 36, sizeof(data), 0, 0, 0);
+
+       /* Total size of data must match data_end - data_meta */
+       test_xdp_context_error(prog_fd, opts, 0, sizeof(__u32),
+                              sizeof(data) - 1, 0, 0, 0);
+       test_xdp_context_error(prog_fd, opts, 0, sizeof(__u32),
+                              sizeof(data) + 1, 0, 0, 0);
+
+       /* RX queue cannot be specified without specifying an ingress */
+       test_xdp_context_error(prog_fd, opts, 0, sizeof(__u32), sizeof(data),
+                              0, 1, 0);
+
+       /* Interface 1 is always the loopback interface which always has only
+        * one RX queue (index 0). This makes index 1 an invalid rx queue index
+        * for interface 1.
+        */
+       test_xdp_context_error(prog_fd, opts, 0, sizeof(__u32), sizeof(data),
+                              1, 1, 0);
+
+       /* The egress cannot be specified */
+       test_xdp_context_error(prog_fd, opts, 0, sizeof(__u32), sizeof(data),
+                              0, 0, 1);
+
+       test_xdp_context_test_run__destroy(skel);
+}

diff --git a/tools/testing/selftests/bpf/progs/test_xdp_context_test_run.c b/tools/testing/selftests/bpf/progs/test_xdp_context_test_run.c
new file mode 100644 (file)
index 0000000..d7b88cd
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/test_xdp_context_test_run.c
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+
+SEC("xdp")
+int xdp_context(struct xdp_md *xdp)
+{
+       void *data = (void *)(long)xdp->data;
+       __u32 *metadata = (void *)(long)xdp->data_meta;
+       __u32 ret;
+
+       if (metadata + 1 > data)
+               return XDP_ABORTED;
+       ret = *metadata;
+       if (bpf_xdp_adjust_meta(xdp, 4))
+               return XDP_ABORTED;
+       return ret;
+}
+
+char _license[] SEC("license") = "GPL";