Re: [PATCH bpf-next v3 15/15] selftests/bpf: Add test for bpf_tcp_ops header option hooks

["Emil Tsalapatis" <emil@etsalapatis.com>]

On Mon Jul 6, 2026 at 1:19 PM EDT, Amery Hung wrote:
> Add a test exercising the bpf_tcp_ops parse_hdr, hdr_opt_len and
> write_hdr_opt members together with the header option helpers.
>
> The struct_ops program (progs/bpf_tcp_ops_hdr.c) reserves space in
> hdr_opt_len via bpf_reserve_hdr_opt(), writes an experimental option in
> write_hdr_opt via bpf_store_hdr_opt(), and recovers it in parse_hdr via
> bpf_load_hdr_opt() on the incoming skb. Each hook bumps a counter and the
> parse hook records the option payload, so the three callbacks and all
> three overloaded helpers are covered.
>
> Signed-off-by: Amery Hung <ameryhung@gmail.com>
> ---

Reviewed-by: Emil Tsalapatis <emil@etsalapatis.com>

Since the struct_ops methods are wrapping the existing sockops code I
don't think we need more extensive tests (e.g., trying to exhaust 
all available space with reserve).

>  .../bpf/prog_tests/bpf_tcp_ops_hdr.c          | 77 +++++++++++++++++
>  .../selftests/bpf/progs/bpf_tcp_ops_hdr.c     | 83 +++++++++++++++++++
>  2 files changed, 160 insertions(+)
>  create mode 100644 tools/testing/selftests/bpf/prog_tests/bpf_tcp_ops_hdr.c
>  create mode 100644 tools/testing/selftests/bpf/progs/bpf_tcp_ops_hdr.c
>
> diff --git a/tools/testing/selftests/bpf/prog_tests/bpf_tcp_ops_hdr.c b/tools/testing/selftests/bpf/prog_tests/bpf_tcp_ops_hdr.c
> new file mode 100644
> index 000000000000..244605e69e40
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/prog_tests/bpf_tcp_ops_hdr.c
> @@ -0,0 +1,77 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
> +
> +#include <test_progs.h>
> +#include <network_helpers.h>
> +#include "cgroup_helpers.h"
> +#include "bpf_tcp_ops_hdr.skel.h"
> +
> +#define CGROUP_PATH	"/bpf_tcp_ops_hdr"
> +#define TEST_NETNS	"bpf_tcp_ops_hdr"
> +
> +#define TEST_OPT_D0	0xAB
> +#define TEST_OPT_D1	0xCD
> +
> +static void run_hdr_opt(void)
> +{
> +	struct bpf_tcp_ops_hdr *skel = NULL;
> +	struct bpf_link *link = NULL;
> +	struct netns_obj *ns = NULL;
> +	int cgroup_fd, lfd = -1, fd = -1;
> +
> +	cgroup_fd = test__join_cgroup(CGROUP_PATH);
> +	if (!ASSERT_GE(cgroup_fd, 0, "join_cgroup"))
> +		return;
> +
> +	ns = netns_new(TEST_NETNS, true);
> +	if (!ASSERT_OK_PTR(ns, "netns_new"))
> +		goto done;
> +
> +	skel = bpf_tcp_ops_hdr__open_and_load();
> +	if (!ASSERT_OK_PTR(skel, "open_and_load"))
> +		goto done;
> +
> +	link = bpf_map__attach_cgroup_opts(skel->maps.test_hdr_ops, cgroup_fd, NULL);
> +	if (!ASSERT_OK_PTR(link, "attach_cgroup"))
> +		goto done;
> +
> +	/*
> +	 * One direction of data is enough to exercise all hooks: both peers
> +	 * share the cgroup struct_ops, so the sender runs hdr_opt_len/write
> +	 * and the receiver runs parse.
> +	 */
> +	lfd = start_server(AF_INET6, SOCK_STREAM, "::1", 0, 0);
> +	if (!ASSERT_GE(lfd, 0, "start_server"))
> +		goto done;
> +
> +	fd = connect_to_fd(lfd, 0);
> +	if (!ASSERT_OK_FD(fd, "connect_to_fd"))
> +		goto done;
> +
> +	if (!ASSERT_OK(send_recv_data(lfd, fd, 64), "send_recv_data"))
> +		goto done;
> +
> +	/* Reserve + write hooks ran while sending. */
> +	ASSERT_GT(skel->bss->hdr_opt_len_cnt, 0, "hdr_opt_len_cnt");
> +	ASSERT_GT(skel->bss->write_cnt, 0, "write_cnt");
> +	/* Parse hook ran and recovered our option on the receive side. */
> +	ASSERT_GT(skel->bss->parse_cnt, 0, "parse_cnt");
> +	ASSERT_GT(skel->bss->found_cnt, 0, "found_cnt");
> +	ASSERT_EQ(skel->bss->found_d0, TEST_OPT_D0, "found_d0");
> +	ASSERT_EQ(skel->bss->found_d1, TEST_OPT_D1, "found_d1");
> +
> +done:
> +	if (fd >= 0)
> +		close(fd);
> +	if (lfd >= 0)
> +		close(lfd);
> +	bpf_link__destroy(link);
> +	bpf_tcp_ops_hdr__destroy(skel);
> +	netns_free(ns);
> +	close(cgroup_fd);
> +}
> +
> +void test_bpf_tcp_ops_hdr(void)
> +{
> +	run_hdr_opt();
> +}
> diff --git a/tools/testing/selftests/bpf/progs/bpf_tcp_ops_hdr.c b/tools/testing/selftests/bpf/progs/bpf_tcp_ops_hdr.c
> new file mode 100644
> index 000000000000..46618a604d96
> --- /dev/null
> +++ b/tools/testing/selftests/bpf/progs/bpf_tcp_ops_hdr.c
> @@ -0,0 +1,83 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
> +
> +#include "vmlinux.h"
> +#include <bpf/bpf_helpers.h>
> +#include <bpf/bpf_tracing.h>
> +
> +/* Experimental option kind and payload written/parsed by this test. */
> +#define TEST_OPT_KIND	0xFD
> +#define TEST_OPT_LEN	4
> +#define TEST_OPT_D0	0xAB
> +#define TEST_OPT_D1	0xCD
> +
> +int hdr_opt_len_cnt;
> +int write_cnt;
> +int parse_cnt;
> +int found_cnt;
> +__u8 found_d0;
> +__u8 found_d1;
> +
> +SEC("struct_ops")
> +void BPF_PROG(test_hdr_opt_len, struct sock *sk, struct sk_buff *skb,
> +	      struct request_sock *req, struct sk_buff *syn_skb,
> +	      enum tcp_synack_type synack_type, unsigned int *remaining)
> +{
> +	hdr_opt_len_cnt++;
> +
> +	/* Reserve TEST_OPT_LEN bytes; the helper decrements *remaining. Stacks
> +	 * with other progs in the cgroup hierarchy.
> +	 */
> +	bpf_reserve_hdr_opt(ctx, TEST_OPT_LEN, 0);
> +}
> +
> +SEC("struct_ops")
> +void BPF_PROG(test_write_hdr_opt, struct sock *sk, struct sk_buff *skb,
> +	      struct request_sock *req, struct sk_buff *syn_skb,
> +	      enum tcp_synack_type synack_type, __u32 opt_off)
> +{
> +	__u8 opt[TEST_OPT_LEN] = {
> +		TEST_OPT_KIND, TEST_OPT_LEN, TEST_OPT_D0, TEST_OPT_D1,
> +	};
> +
> +	/* bpf_store_hdr_opt() takes the program ctx (the kernel reads the
> +	 * outgoing skb from it); it appends after any options already written
> +	 * in the reserved window, rejects duplicates, and confines the write to
> +	 * the header option scratch. Stacks across progs in the cgroup hierarchy.
> +	 */
> +	if (bpf_store_hdr_opt(ctx, opt, sizeof(opt), 0))
> +		return;
> +
> +	write_cnt++;
> +}
> +
> +SEC("struct_ops")
> +void BPF_PROG(test_parse_hdr, struct sock *sk, struct sk_buff *skb)
> +{
> +	__u8 opt[TEST_OPT_LEN] = {
> +		TEST_OPT_KIND, TEST_OPT_LEN, TEST_OPT_D0, TEST_OPT_D1,
> +	};
> +
> +	parse_cnt++;
> +
> +	/* Look up the experimental option written by test_write_hdr_opt() in
> +	 * the incoming skb. For an experimental kind the search matches on the
> +	 * 2-byte magic in opt[2..3]; on a match the found option is copied back
> +	 * into opt[].
> +	 */
> +	if (bpf_load_hdr_opt(ctx, opt, sizeof(opt), 0) < 0)
> +		return;
> +
> +	found_d0 = opt[2];
> +	found_d1 = opt[3];
> +	found_cnt++;
> +}
> +
> +SEC(".struct_ops.link")
> +struct bpf_tcp_ops test_hdr_ops = {
> +	.hdr_opt_len	= (void *)test_hdr_opt_len,
> +	.write_hdr_opt	= (void *)test_write_hdr_opt,
> +	.parse_hdr	= (void *)test_parse_hdr,
> +};
> +
> +char _license[] SEC("license") = "GPL";