Add selftests exercising BPF_MAP_TYPE_STRUCT_OPS support in light skeletons across both vmlinux and kernel module BTF targets: - struct_ops_vmlinux.c defines a SEC(".struct_ops.link") tcp_congestion_ops map in vmlinux BTF, testing open/load, link attachment, callback invocation over a loopback TCP connection, and unregistration upon detach. - struct_ops_mod.c defines two SEC(".struct_ops.link") maps targeting bpf_testmod_ops in module BTF (including a reordered subset struct bpf_testmod_ops___v2 sharing a callback), testing module BTF FD resolution, runtime member offset/index lookup via bpf_btf_get_struct_member_info(), scalar member copying, detach, and per-map re-attachment. Signed-off-by: Siddharth Nayyar --- tools/testing/selftests/bpf/Makefile.skel | 3 +- .../selftests/bpf/prog_tests/struct_ops_lskel.c | 122 +++++++++++++++++++++ tools/testing/selftests/bpf/progs/struct_ops_mod.c | 51 +++++++++ .../selftests/bpf/progs/struct_ops_vmlinux.c | 42 +++++++ 4 files changed, 217 insertions(+), 1 deletion(-) diff --git a/tools/testing/selftests/bpf/Makefile.skel b/tools/testing/selftests/bpf/Makefile.skel index b8eaecc7f429..2726f9081e35 100644 --- a/tools/testing/selftests/bpf/Makefile.skel +++ b/tools/testing/selftests/bpf/Makefile.skel @@ -34,7 +34,8 @@ LINKED_SKELS := test_static_linked.skel.h linked_funcs.skel.h \ LSKELS := fexit_sleep.c trace_printk.c trace_vprintk.c map_ptr_kern.c \ core_kern.c core_kern_overflow.c test_ringbuf.c \ test_ringbuf_n.c test_ringbuf_map_key.c test_ringbuf_write.c \ - test_ringbuf_overwrite.c callx_rodata.c + test_ringbuf_overwrite.c callx_rodata.c struct_ops_vmlinux.c \ + struct_ops_mod.c LSKELS_SIGNED := fentry_test.c fexit_test.c atomics.c diff --git a/tools/testing/selftests/bpf/prog_tests/struct_ops_lskel.c b/tools/testing/selftests/bpf/prog_tests/struct_ops_lskel.c new file mode 100644 index 000000000000..4e9bac460953 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/struct_ops_lskel.c @@ -0,0 +1,122 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include "network_helpers.h" +#include "struct_ops_vmlinux.lskel.h" +#include "struct_ops_mod.lskel.h" + +static int set_tcp_ca_cb(int fd, void *opts) +{ + const char *tcp_ca = opts; + + if (!ASSERT_OK(setsockopt(fd, IPPROTO_TCP, TCP_CONGESTION, + tcp_ca, strlen(tcp_ca)), "setsockopt")) + return -1; + return 0; +} + +static void test_vmlinux(void) +{ + char tcp_ca[] = "bpf_lskel_ca"; + struct network_helper_opts opts = { + .post_socket_cb = set_tcp_ca_cb, + .cb_opts = tcp_ca, + }; + struct struct_ops_vmlinux_lskel *skel; + int srv_fd = -1, cli_fd = -1, sock_fd = -1; + int err; + + skel = struct_ops_vmlinux_lskel__open_and_load(); + if (!ASSERT_OK_PTR(skel, "open_and_load")) + return; + + err = struct_ops_vmlinux_lskel__attach(skel); + if (!ASSERT_OK(err, "attach")) + goto cleanup; + + srv_fd = start_server_str(AF_INET6, SOCK_STREAM, NULL, 0, &opts); + if (!ASSERT_NEQ(srv_fd, -1, "start_server_str")) + goto cleanup; + + cli_fd = connect_to_fd_opts(srv_fd, &opts); + if (!ASSERT_NEQ(cli_fd, -1, "connect_to_fd_opts")) + goto cleanup; + + ASSERT_GT(skel->bss->ca_init_cnt, 0, "ca_init_cnt"); + + close(cli_fd); + cli_fd = -1; + close(srv_fd); + srv_fd = -1; + + struct_ops_vmlinux_lskel__detach(skel); + skel->links.lskel_ca_fd = 0; + + /* Verify congestion control was unregistered on detach */ + sock_fd = socket(AF_INET6, SOCK_STREAM, 0); + if (!ASSERT_GE(sock_fd, 0, "socket")) + goto cleanup; + + err = setsockopt(sock_fd, IPPROTO_TCP, TCP_CONGESTION, + tcp_ca, strlen(tcp_ca)); + ASSERT_EQ(err, -1, "setsockopt_after_detach"); + ASSERT_EQ(errno, ENOENT, "errno_after_detach"); + +cleanup: + if (sock_fd != -1) + close(sock_fd); + if (cli_fd != -1) + close(cli_fd); + if (srv_fd != -1) + close(srv_fd); + struct_ops_vmlinux_lskel__destroy(skel); +} + +static void test_module(void) +{ + struct struct_ops_mod_lskel *skel; + int err, link_fd; + + if (!env.has_testmod) { + test__skip(); + return; + } + + skel = struct_ops_mod_lskel__open_and_load(); + if (!ASSERT_OK_PTR(skel, "open_and_load")) + return; + + err = struct_ops_mod_lskel__attach(skel); + if (!ASSERT_OK(err, "attach")) + goto cleanup; + + ASSERT_GT(skel->links.testmod_1_fd, 0, "testmod_1_fd"); + ASSERT_GT(skel->links.testmod_2_fd, 0, "testmod_2_fd"); + ASSERT_EQ(skel->bss->test_1_cnt, 2, "test_1_cnt"); + ASSERT_EQ(skel->bss->testmod_1_result, 17, "testmod_1_result"); + ASSERT_EQ(skel->bss->testmod_2_result, 28, "testmod_2_result"); + + struct_ops_mod_lskel__detach(skel); + skel->links.testmod_1_fd = 0; + skel->links.testmod_2_fd = 0; + memset(skel->bss, 0, sizeof(*skel->bss)); + + link_fd = struct_ops_mod_lskel__testmod_1__attach(skel); + if (!ASSERT_GT(link_fd, 0, "testmod_1_attach")) + goto cleanup; + + ASSERT_EQ(skel->bss->test_1_cnt, 1, "reattach_test_1_cnt"); + ASSERT_EQ(skel->bss->testmod_1_result, 17, "reattach_testmod_1_result"); + ASSERT_EQ(skel->bss->testmod_2_result, 0, "reattach_testmod_2_result"); + +cleanup: + struct_ops_mod_lskel__destroy(skel); +} + +void test_struct_ops_lskel(void) +{ + if (test__start_subtest("vmlinux")) + test_vmlinux(); + if (test__start_subtest("module")) + test_module(); +} diff --git a/tools/testing/selftests/bpf/progs/struct_ops_mod.c b/tools/testing/selftests/bpf/progs/struct_ops_mod.c new file mode 100644 index 000000000000..b1bd7429149d --- /dev/null +++ b/tools/testing/selftests/bpf/progs/struct_ops_mod.c @@ -0,0 +1,51 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include +#include +#include "../test_kmods/bpf_testmod.h" + +char _license[] SEC("license") = "GPL"; + +int test_1_cnt = 0; +int testmod_1_result = 0; +int testmod_2_result = 0; + +SEC("struct_ops/test_1") +int BPF_PROG(test_1) +{ + test_1_cnt++; + return 0; +} + +SEC("struct_ops/test_2") +void BPF_PROG(test_2, int a, int b) +{ + testmod_1_result = a + b; +} + +SEC("struct_ops/test_2_v2") +void BPF_PROG(test_2_v2, int a, int b) +{ + testmod_2_result = a * b; +} + +SEC(".struct_ops.link") +struct bpf_testmod_ops testmod_1 = { + .test_1 = (void *)test_1, + .test_2 = (void *)test_2, + .data = 13, +}; + +struct bpf_testmod_ops___v2 { + int data; + void (*test_2)(int a, int b); + int (*test_1)(void); +}; + +SEC(".struct_ops.link") +struct bpf_testmod_ops___v2 testmod_2 = { + .data = 7, + .test_2 = (void *)test_2_v2, + .test_1 = (void *)test_1, +}; diff --git a/tools/testing/selftests/bpf/progs/struct_ops_vmlinux.c b/tools/testing/selftests/bpf/progs/struct_ops_vmlinux.c new file mode 100644 index 000000000000..1d8b573ad799 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/struct_ops_vmlinux.c @@ -0,0 +1,42 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "bpf_tracing_net.h" +#include +#include + +char _license[] SEC("license") = "GPL"; + +int ca_init_cnt = 0; + +SEC("struct_ops/ca_lskel_init") +void BPF_PROG(ca_lskel_init, struct sock *sk) +{ + ca_init_cnt++; +} + +SEC("struct_ops/ca_lskel_cong_control") +void BPF_PROG(ca_lskel_cong_control, struct sock *sk, __u32 ack, int flag, + const struct rate_sample *rs) +{ +} + +SEC("struct_ops/ca_lskel_ssthresh") +__u32 BPF_PROG(ca_lskel_ssthresh, struct sock *sk) +{ + return tcp_sk(sk)->snd_ssthresh; +} + +SEC("struct_ops/ca_lskel_undo_cwnd") +__u32 BPF_PROG(ca_lskel_undo_cwnd, struct sock *sk) +{ + return tcp_sk(sk)->snd_cwnd; +} + +SEC(".struct_ops.link") +struct tcp_congestion_ops lskel_ca = { + .init = (void *)ca_lskel_init, + .cong_control = (void *)ca_lskel_cong_control, + .ssthresh = (void *)ca_lskel_ssthresh, + .undo_cwnd = (void *)ca_lskel_undo_cwnd, + .name = "bpf_lskel_ca", +}; -- 2.56.0.455.g6c5a503b38-goog