Commit 91134d84 authored by Martin KaFai Lau's avatar Martin KaFai Lau Committed by Daniel Borkmann
Browse files

bpf: Test BPF_PROG_TYPE_SK_REUSEPORT 



This patch add tests for the new BPF_PROG_TYPE_SK_REUSEPORT.

The tests cover:
- IPv4/IPv6 + TCP/UDP
- TCP syncookie
- TCP fastopen
- Cases when the bpf_sk_select_reuseport() returning errors
- Cases when the bpf prog returns SK_DROP
- Values from sk_reuseport_md
- outer_map => reuseport_array

The test depends on
commit 3eee1f75 ("bpf: fix bpf_skb_load_bytes_relative pkt length check")

Signed-off-by: default avatarMartin KaFai Lau <kafai@fb.com>
Acked-by: default avatarAlexei Starovoitov <ast@kernel.org>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
parent 6bc8529c

tools/lib/bpf/bpf.c

+1 −0
Original line number Diff line number Diff line
@@ -92,6 +92,7 @@ int bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr) 
	attr.btf_key_type_id = create_attr->btf_key_type_id;

	attr.btf_value_type_id = create_attr->btf_value_type_id;

	attr.map_ifindex = create_attr->map_ifindex;

	attr.inner_map_fd = create_attr->inner_map_fd;



	return sys_bpf(BPF_MAP_CREATE, &attr, sizeof(attr));

}

tools/lib/bpf/bpf.h

+1 −0
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ struct bpf_create_map_attr { 
	__u32 btf_key_type_id;

	__u32 btf_value_type_id;

	__u32 map_ifindex;

	__u32 inner_map_fd;

};



int bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr);

tools/testing/selftests/bpf/Makefile

+2 −2
Original line number Diff line number Diff line
@@ -23,7 +23,7 @@ $(TEST_CUSTOM_PROGS): $(OUTPUT)/%: %.c 
TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test_progs \

	test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \

	test_sock test_btf test_sockmap test_lirc_mode2_user get_cgroup_id_user \

	test_socket_cookie test_cgroup_storage

	test_socket_cookie test_cgroup_storage test_select_reuseport



TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test_obj_id.o \

	test_pkt_md_access.o test_xdp_redirect.o test_xdp_meta.o sockmap_parse_prog.o     \
@@ -34,7 +34,7 @@ TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test 
	test_btf_haskv.o test_btf_nokv.o test_sockmap_kern.o test_tunnel_kern.o \

	test_get_stack_rawtp.o test_sockmap_kern.o test_sockhash_kern.o \

	test_lwt_seg6local.o sendmsg4_prog.o sendmsg6_prog.o test_lirc_mode2_kern.o \

	get_cgroup_id_kern.o socket_cookie_prog.o

	get_cgroup_id_kern.o socket_cookie_prog.o test_select_reuseport_kern.o



# Order correspond to 'make run_tests' order

TEST_PROGS := test_kmod.sh \

tools/testing/selftests/bpf/bpf_helpers.h

+4 −0
Original line number Diff line number Diff line
@@ -111,6 +111,8 @@ static int (*bpf_xdp_adjust_tail)(void *ctx, int offset) = 
static int (*bpf_skb_get_xfrm_state)(void *ctx, int index, void *state,

				     int size, int flags) =

	(void *) BPF_FUNC_skb_get_xfrm_state;

static int (*bpf_sk_select_reuseport)(void *ctx, void *map, void *key, __u32 flags) =

	(void *) BPF_FUNC_sk_select_reuseport;

static int (*bpf_get_stack)(void *ctx, void *buf, int size, int flags) =

	(void *) BPF_FUNC_get_stack;

static int (*bpf_fib_lookup)(void *ctx, struct bpf_fib_lookup *params,
@@ -173,6 +175,8 @@ struct bpf_map_def { 


static int (*bpf_skb_load_bytes)(void *ctx, int off, void *to, int len) =

	(void *) BPF_FUNC_skb_load_bytes;

static int (*bpf_skb_load_bytes_relative)(void *ctx, int off, void *to, int len, __u32 start_header) =

	(void *) BPF_FUNC_skb_load_bytes_relative;

static int (*bpf_skb_store_bytes)(void *ctx, int off, void *from, int len, int flags) =

	(void *) BPF_FUNC_skb_store_bytes;

static int (*bpf_l3_csum_replace)(void *ctx, int off, int from, int to, int flags) =

tools/testing/selftests/bpf/test_select_reuseport.c

0 → 100644
+688 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2018 Facebook */



#include <stdlib.h>

#include <unistd.h>

#include <stdbool.h>

#include <string.h>

#include <errno.h>

#include <assert.h>

#include <fcntl.h>

#include <linux/bpf.h>

#include <linux/err.h>

#include <linux/types.h>

#include <linux/if_ether.h>

#include <sys/types.h>

#include <sys/epoll.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <bpf/bpf.h>

#include <bpf/libbpf.h>

#include "bpf_rlimit.h"

#include "bpf_util.h"

#include "test_select_reuseport_common.h"



#define MIN_TCPHDR_LEN 20

#define UDPHDR_LEN 8



#define TCP_SYNCOOKIE_SYSCTL "/proc/sys/net/ipv4/tcp_syncookies"

#define TCP_FO_SYSCTL "/proc/sys/net/ipv4/tcp_fastopen"

#define REUSEPORT_ARRAY_SIZE 32



static int result_map, tmp_index_ovr_map, linum_map, data_check_map;

static enum result expected_results[NR_RESULTS];

static int sk_fds[REUSEPORT_ARRAY_SIZE];

static int reuseport_array, outer_map;

static int select_by_skb_data_prog;

static int saved_tcp_syncookie;

static struct bpf_object *obj;

static int saved_tcp_fo;

static __u32 index_zero;

static int epfd;



static union sa46 {

	struct sockaddr_in6 v6;

	struct sockaddr_in v4;

	sa_family_t family;

} srv_sa;



#define CHECK(condition, tag, format...) ({				\

	int __ret = !!(condition);					\

	if (__ret) {							\

		printf("%s(%d):FAIL:%s ", __func__, __LINE__, tag);	\

		printf(format);						\

		exit(-1);						\

	}								\

})



static void create_maps(void)

{

	struct bpf_create_map_attr attr = {};



	/* Creating reuseport_array */

	attr.name = "reuseport_array";

	attr.map_type = BPF_MAP_TYPE_REUSEPORT_SOCKARRAY;

	attr.key_size = sizeof(__u32);

	attr.value_size = sizeof(__u32);

	attr.max_entries = REUSEPORT_ARRAY_SIZE;



	reuseport_array = bpf_create_map_xattr(&attr);

	CHECK(reuseport_array == -1, "creating reuseport_array",

	      "reuseport_array:%d errno:%d\n", reuseport_array, errno);



	/* Creating outer_map */

	attr.name = "outer_map";

	attr.map_type = BPF_MAP_TYPE_ARRAY_OF_MAPS;

	attr.key_size = sizeof(__u32);

	attr.value_size = sizeof(__u32);

	attr.max_entries = 1;

	attr.inner_map_fd = reuseport_array;

	outer_map = bpf_create_map_xattr(&attr);

	CHECK(outer_map == -1, "creating outer_map",

	      "outer_map:%d errno:%d\n", outer_map, errno);

}



static void prepare_bpf_obj(void)

{

	struct bpf_program *prog;

	struct bpf_map *map;

	int err;

	struct bpf_object_open_attr attr = {

		.file = "test_select_reuseport_kern.o",

		.prog_type = BPF_PROG_TYPE_SK_REUSEPORT,

	};



	obj = bpf_object__open_xattr(&attr);

	CHECK(IS_ERR_OR_NULL(obj), "open test_select_reuseport_kern.o",

	      "obj:%p PTR_ERR(obj):%ld\n", obj, PTR_ERR(obj));



	prog = bpf_program__next(NULL, obj);

	CHECK(!prog, "get first bpf_program", "!prog\n");

	bpf_program__set_type(prog, attr.prog_type);



	map = bpf_object__find_map_by_name(obj, "outer_map");

	CHECK(!map, "find outer_map", "!map\n");

	err = bpf_map__reuse_fd(map, outer_map);

	CHECK(err, "reuse outer_map", "err:%d\n", err);



	err = bpf_object__load(obj);

	CHECK(err, "load bpf_object", "err:%d\n", err);



	select_by_skb_data_prog = bpf_program__fd(prog);

	CHECK(select_by_skb_data_prog == -1, "get prog fd",

	      "select_by_skb_data_prog:%d\n", select_by_skb_data_prog);



	map = bpf_object__find_map_by_name(obj, "result_map");

	CHECK(!map, "find result_map", "!map\n");

	result_map = bpf_map__fd(map);

	CHECK(result_map == -1, "get result_map fd",

	      "result_map:%d\n", result_map);



	map = bpf_object__find_map_by_name(obj, "tmp_index_ovr_map");

	CHECK(!map, "find tmp_index_ovr_map", "!map\n");

	tmp_index_ovr_map = bpf_map__fd(map);

	CHECK(tmp_index_ovr_map == -1, "get tmp_index_ovr_map fd",

	      "tmp_index_ovr_map:%d\n", tmp_index_ovr_map);



	map = bpf_object__find_map_by_name(obj, "linum_map");

	CHECK(!map, "find linum_map", "!map\n");

	linum_map = bpf_map__fd(map);

	CHECK(linum_map == -1, "get linum_map fd",

	      "linum_map:%d\n", linum_map);



	map = bpf_object__find_map_by_name(obj, "data_check_map");

	CHECK(!map, "find data_check_map", "!map\n");

	data_check_map = bpf_map__fd(map);

	CHECK(data_check_map == -1, "get data_check_map fd",

	      "data_check_map:%d\n", data_check_map);

}



static void sa46_init_loopback(union sa46 *sa, sa_family_t family)

{

	memset(sa, 0, sizeof(*sa));

	sa->family = family;

	if (sa->family == AF_INET6)

		sa->v6.sin6_addr = in6addr_loopback;

	else

		sa->v4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

}



static void sa46_init_inany(union sa46 *sa, sa_family_t family)

{

	memset(sa, 0, sizeof(*sa));

	sa->family = family;

	if (sa->family == AF_INET6)

		sa->v6.sin6_addr = in6addr_any;

	else

		sa->v4.sin_addr.s_addr = INADDR_ANY;

}



static int read_int_sysctl(const char *sysctl)

{

	char buf[16];

	int fd, ret;



	fd = open(sysctl, 0);

	CHECK(fd == -1, "open(sysctl)", "sysctl:%s fd:%d errno:%d\n",

	      sysctl, fd, errno);



	ret = read(fd, buf, sizeof(buf));

	CHECK(ret <= 0, "read(sysctl)", "sysctl:%s ret:%d errno:%d\n",

	      sysctl, ret, errno);

	close(fd);



	return atoi(buf);

}



static void write_int_sysctl(const char *sysctl, int v)

{

	int fd, ret, size;

	char buf[16];



	fd = open(sysctl, O_RDWR);

	CHECK(fd == -1, "open(sysctl)", "sysctl:%s fd:%d errno:%d\n",

	      sysctl, fd, errno);



	size = snprintf(buf, sizeof(buf), "%d", v);

	ret = write(fd, buf, size);

	CHECK(ret != size, "write(sysctl)",

	      "sysctl:%s ret:%d size:%d errno:%d\n", sysctl, ret, size, errno);

	close(fd);

}



static void restore_sysctls(void)

{

	write_int_sysctl(TCP_FO_SYSCTL, saved_tcp_fo);

	write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, saved_tcp_syncookie);

}



static void enable_fastopen(void)

{

	int fo;



	fo = read_int_sysctl(TCP_FO_SYSCTL);

	write_int_sysctl(TCP_FO_SYSCTL, fo | 7);

}



static void enable_syncookie(void)

{

	write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, 2);

}



static void disable_syncookie(void)

{

	write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, 0);

}



static __u32 get_linum(void)

{

	__u32 linum;

	int err;



	err = bpf_map_lookup_elem(linum_map, &index_zero, &linum);

	CHECK(err == -1, "lookup_elem(linum_map)", "err:%d errno:%d\n",

	      err, errno);



	return linum;

}



static void check_data(int type, sa_family_t family, const struct cmd *cmd,

		       int cli_fd)

{

	struct data_check expected = {}, result;

	union sa46 cli_sa;

	socklen_t addrlen;

	int err;



	addrlen = sizeof(cli_sa);

	err = getsockname(cli_fd, (struct sockaddr *)&cli_sa,

			  &addrlen);

	CHECK(err == -1, "getsockname(cli_fd)", "err:%d errno:%d\n",

	      err, errno);



	err = bpf_map_lookup_elem(data_check_map, &index_zero, &result);

	CHECK(err == -1, "lookup_elem(data_check_map)", "err:%d errno:%d\n",

	      err, errno);



	if (type == SOCK_STREAM) {

		expected.len = MIN_TCPHDR_LEN;

		expected.ip_protocol = IPPROTO_TCP;

	} else {

		expected.len = UDPHDR_LEN;

		expected.ip_protocol = IPPROTO_UDP;

	}



	if (family == AF_INET6) {

		expected.eth_protocol = htons(ETH_P_IPV6);

		expected.bind_inany = !srv_sa.v6.sin6_addr.s6_addr32[3] &&

			!srv_sa.v6.sin6_addr.s6_addr32[2] &&

			!srv_sa.v6.sin6_addr.s6_addr32[1] &&

			!srv_sa.v6.sin6_addr.s6_addr32[0];



		memcpy(&expected.skb_addrs[0], cli_sa.v6.sin6_addr.s6_addr32,

		       sizeof(cli_sa.v6.sin6_addr));

		memcpy(&expected.skb_addrs[4], &in6addr_loopback,

		       sizeof(in6addr_loopback));

		expected.skb_ports[0] = cli_sa.v6.sin6_port;

		expected.skb_ports[1] = srv_sa.v6.sin6_port;

	} else {

		expected.eth_protocol = htons(ETH_P_IP);

		expected.bind_inany = !srv_sa.v4.sin_addr.s_addr;



		expected.skb_addrs[0] = cli_sa.v4.sin_addr.s_addr;

		expected.skb_addrs[1] = htonl(INADDR_LOOPBACK);

		expected.skb_ports[0] = cli_sa.v4.sin_port;

		expected.skb_ports[1] = srv_sa.v4.sin_port;

	}



	if (memcmp(&result, &expected, offsetof(struct data_check,

						equal_check_end))) {

		printf("unexpected data_check\n");

		printf("  result: (0x%x, %u, %u)\n",

		       result.eth_protocol, result.ip_protocol,

		       result.bind_inany);

		printf("expected: (0x%x, %u, %u)\n",

		       expected.eth_protocol, expected.ip_protocol,

		       expected.bind_inany);

		CHECK(1, "data_check result != expected",

		      "bpf_prog_linum:%u\n", get_linum());

	}



	CHECK(!result.hash, "data_check result.hash empty",

	      "result.hash:%u", result.hash);



	expected.len += cmd ? sizeof(*cmd) : 0;

	if (type == SOCK_STREAM)

		CHECK(expected.len > result.len, "expected.len > result.len",

		      "expected.len:%u result.len:%u bpf_prog_linum:%u\n",

		      expected.len, result.len, get_linum());

	else

		CHECK(expected.len != result.len, "expected.len != result.len",

		      "expected.len:%u result.len:%u bpf_prog_linum:%u\n",

		      expected.len, result.len, get_linum());

}



static void check_results(void)

{

	__u32 results[NR_RESULTS];

	__u32 i, broken = 0;

	int err;



	for (i = 0; i < NR_RESULTS; i++) {

		err = bpf_map_lookup_elem(result_map, &i, &results[i]);

		CHECK(err == -1, "lookup_elem(result_map)",

		      "i:%u err:%d errno:%d\n", i, err, errno);

	}



	for (i = 0; i < NR_RESULTS; i++) {

		if (results[i] != expected_results[i]) {

			broken = i;

			break;

		}

	}



	if (i == NR_RESULTS)

		return;



	printf("unexpected result\n");

	printf(" result: [");

	printf("%u", results[0]);

	for (i = 1; i < NR_RESULTS; i++)

		printf(", %u", results[i]);

	printf("]\n");



	printf("expected: [");

	printf("%u", expected_results[0]);

	for (i = 1; i < NR_RESULTS; i++)

		printf(", %u", expected_results[i]);

	printf("]\n");



	CHECK(expected_results[broken] != results[broken],

	      "unexpected result",

	      "expected_results[%u] != results[%u] bpf_prog_linum:%u\n",

	      broken, broken, get_linum());

}



static int send_data(int type, sa_family_t family, void *data, size_t len,

		     enum result expected)

{

	union sa46 cli_sa;

	int fd, err;



	fd = socket(family, type, 0);

	CHECK(fd == -1, "socket()", "fd:%d errno:%d\n", fd, errno);



	sa46_init_loopback(&cli_sa, family);

	err = bind(fd, (struct sockaddr *)&cli_sa, sizeof(cli_sa));

	CHECK(fd == -1, "bind(cli_sa)", "err:%d errno:%d\n", err, errno);



	err = sendto(fd, data, len, MSG_FASTOPEN, (struct sockaddr *)&srv_sa,

		     sizeof(srv_sa));

	CHECK(err != len && expected >= PASS,

	      "sendto()", "family:%u err:%d errno:%d expected:%d\n",

	      family, err, errno, expected);



	return fd;

}



static void do_test(int type, sa_family_t family, struct cmd *cmd,

		    enum result expected)

{

	int nev, srv_fd, cli_fd;

	struct epoll_event ev;

	struct cmd rcv_cmd;

	ssize_t nread;



	cli_fd = send_data(type, family, cmd, cmd ? sizeof(*cmd) : 0,

			   expected);

	nev = epoll_wait(epfd, &ev, 1, expected >= PASS ? 5 : 0);

	CHECK((nev <= 0 && expected >= PASS) ||

	      (nev > 0 && expected < PASS),

	      "nev <> expected",

	      "nev:%d expected:%d type:%d family:%d data:(%d, %d)\n",

	      nev, expected, type, family,

	      cmd ? cmd->reuseport_index : -1,

	      cmd ? cmd->pass_on_failure : -1);

	check_results();

	check_data(type, family, cmd, cli_fd);



	if (expected < PASS)

		return;



	CHECK(expected != PASS_ERR_SK_SELECT_REUSEPORT &&

	      cmd->reuseport_index != ev.data.u32,

	      "check cmd->reuseport_index",

	      "cmd:(%u, %u) ev.data.u32:%u\n",

	      cmd->pass_on_failure, cmd->reuseport_index, ev.data.u32);



	srv_fd = sk_fds[ev.data.u32];

	if (type == SOCK_STREAM) {

		int new_fd = accept(srv_fd, NULL, 0);



		CHECK(new_fd == -1, "accept(srv_fd)",

		      "ev.data.u32:%u new_fd:%d errno:%d\n",

		      ev.data.u32, new_fd, errno);



		nread = recv(new_fd, &rcv_cmd, sizeof(rcv_cmd), MSG_DONTWAIT);

		CHECK(nread != sizeof(rcv_cmd),

		      "recv(new_fd)",

		      "ev.data.u32:%u nread:%zd sizeof(rcv_cmd):%zu errno:%d\n",

		      ev.data.u32, nread, sizeof(rcv_cmd), errno);



		close(new_fd);

	} else {

		nread = recv(srv_fd, &rcv_cmd, sizeof(rcv_cmd), MSG_DONTWAIT);

		CHECK(nread != sizeof(rcv_cmd),

		      "recv(sk_fds)",

		      "ev.data.u32:%u nread:%zd sizeof(rcv_cmd):%zu errno:%d\n",

		      ev.data.u32, nread, sizeof(rcv_cmd), errno);

	}



	close(cli_fd);

}



static void test_err_inner_map(int type, sa_family_t family)

{

	struct cmd cmd = {

		.reuseport_index = 0,

		.pass_on_failure = 0,

	};



	printf("%s: ", __func__);

	expected_results[DROP_ERR_INNER_MAP]++;

	do_test(type, family, &cmd, DROP_ERR_INNER_MAP);

	printf("OK\n");

}



static void test_err_skb_data(int type, sa_family_t family)

{

	printf("%s: ", __func__);

	expected_results[DROP_ERR_SKB_DATA]++;

	do_test(type, family, NULL, DROP_ERR_SKB_DATA);

	printf("OK\n");

}



static void test_err_sk_select_port(int type, sa_family_t family)

{

	struct cmd cmd = {

		.reuseport_index = REUSEPORT_ARRAY_SIZE,

		.pass_on_failure = 0,

	};



	printf("%s: ", __func__);

	expected_results[DROP_ERR_SK_SELECT_REUSEPORT]++;

	do_test(type, family, &cmd, DROP_ERR_SK_SELECT_REUSEPORT);

	printf("OK\n");

}



static void test_pass(int type, sa_family_t family)

{

	struct cmd cmd;

	int i;



	printf("%s: ", __func__);

	cmd.pass_on_failure = 0;

	for (i = 0; i < REUSEPORT_ARRAY_SIZE; i++) {

		expected_results[PASS]++;

		cmd.reuseport_index = i;

		do_test(type, family, &cmd, PASS);

	}

	printf("OK\n");

}



static void test_syncookie(int type, sa_family_t family)

{

	int err, tmp_index = 1;

	struct cmd cmd = {

		.reuseport_index = 0,

		.pass_on_failure = 0,

	};



	if (type != SOCK_STREAM)

		return;



	printf("%s: ", __func__);

	/*

	 * +1 for TCP-SYN and

	 * +1 for the TCP-ACK (ack the syncookie)

	 */

	expected_results[PASS] += 2;

	enable_syncookie();

	/*

	 * Simulate TCP-SYN and TCP-ACK are handled by two different sk:

	 * TCP-SYN: select sk_fds[tmp_index = 1] tmp_index is from the

	 *          tmp_index_ovr_map

	 * TCP-ACK: select sk_fds[reuseport_index = 0] reuseport_index

	 *          is from the cmd.reuseport_index

	 */

	err = bpf_map_update_elem(tmp_index_ovr_map, &index_zero,

				  &tmp_index, BPF_ANY);

	CHECK(err == -1, "update_elem(tmp_index_ovr_map, 0, 1)",

	      "err:%d errno:%d\n", err, errno);

	do_test(type, family, &cmd, PASS);

	err = bpf_map_lookup_elem(tmp_index_ovr_map, &index_zero,

				  &tmp_index);

	CHECK(err == -1 || tmp_index != -1,

	      "lookup_elem(tmp_index_ovr_map)",

	      "err:%d errno:%d tmp_index:%d\n",

	      err, errno, tmp_index);

	disable_syncookie();

	printf("OK\n");

}



static void test_pass_on_err(int type, sa_family_t family)

{

	struct cmd cmd = {

		.reuseport_index = REUSEPORT_ARRAY_SIZE,

		.pass_on_failure = 1,

	};



	printf("%s: ", __func__);

	expected_results[PASS_ERR_SK_SELECT_REUSEPORT] += 1;

	do_test(type, family, &cmd, PASS_ERR_SK_SELECT_REUSEPORT);

	printf("OK\n");

}



static void prepare_sk_fds(int type, sa_family_t family, bool inany)

{

	const int first = REUSEPORT_ARRAY_SIZE - 1;

	int i, err, optval = 1;

	struct epoll_event ev;

	socklen_t addrlen;



	if (inany)

		sa46_init_inany(&srv_sa, family);

	else

		sa46_init_loopback(&srv_sa, family);

	addrlen = sizeof(srv_sa);



	/*

	 * The sk_fds[] is filled from the back such that the order

	 * is exactly opposite to the (struct sock_reuseport *)reuse->socks[].

	 */

	for (i = first; i >= 0; i--) {

		sk_fds[i] = socket(family, type, 0);

		CHECK(sk_fds[i] == -1, "socket()", "sk_fds[%d]:%d errno:%d\n",

		      i, sk_fds[i], errno);

		err = setsockopt(sk_fds[i], SOL_SOCKET, SO_REUSEPORT,

				 &optval, sizeof(optval));

		CHECK(err == -1, "setsockopt(SO_REUSEPORT)",

		      "sk_fds[%d] err:%d errno:%d\n",

		      i, err, errno);



		if (i == first) {

			err = setsockopt(sk_fds[i], SOL_SOCKET,

					 SO_ATTACH_REUSEPORT_EBPF,

					 &select_by_skb_data_prog,

					 sizeof(select_by_skb_data_prog));

			CHECK(err == -1, "setsockopt(SO_ATTACH_REUEPORT_EBPF)",

			      "err:%d errno:%d\n", err, errno);

		}



		err = bind(sk_fds[i], (struct sockaddr *)&srv_sa, addrlen);

		CHECK(err == -1, "bind()", "sk_fds[%d] err:%d errno:%d\n",

		      i, err, errno);



		if (type == SOCK_STREAM) {

			err = listen(sk_fds[i], 10);

			CHECK(err == -1, "listen()",

			      "sk_fds[%d] err:%d errno:%d\n",

			      i, err, errno);

		}



		err = bpf_map_update_elem(reuseport_array, &i, &sk_fds[i],

					  BPF_NOEXIST);

		CHECK(err == -1, "update_elem(reuseport_array)",

		      "sk_fds[%d] err:%d errno:%d\n", i, err, errno);



		if (i == first) {

			socklen_t addrlen = sizeof(srv_sa);



			err = getsockname(sk_fds[i], (struct sockaddr *)&srv_sa,

					  &addrlen);

			CHECK(err == -1, "getsockname()",

			      "sk_fds[%d] err:%d errno:%d\n", i, err, errno);

		}

	}



	epfd = epoll_create(1);

	CHECK(epfd == -1, "epoll_create(1)",

	      "epfd:%d errno:%d\n", epfd, errno);



	ev.events = EPOLLIN;

	for (i = 0; i < REUSEPORT_ARRAY_SIZE; i++) {

		ev.data.u32 = i;

		err = epoll_ctl(epfd, EPOLL_CTL_ADD, sk_fds[i], &ev);

		CHECK(err, "epoll_ctl(EPOLL_CTL_ADD)", "sk_fds[%d]\n", i);

	}

}



static void setup_per_test(int type, unsigned short family, bool inany)

{

	int ovr = -1, err;



	prepare_sk_fds(type, family, inany);

	err = bpf_map_update_elem(tmp_index_ovr_map, &index_zero, &ovr,

				  BPF_ANY);

	CHECK(err == -1, "update_elem(tmp_index_ovr_map, 0, -1)",

	      "err:%d errno:%d\n", err, errno);

}



static void cleanup_per_test(void)

{

	int i, err;



	for (i = 0; i < REUSEPORT_ARRAY_SIZE; i++)

		close(sk_fds[i]);

	close(epfd);



	err = bpf_map_delete_elem(outer_map, &index_zero);

	CHECK(err == -1, "delete_elem(outer_map)",

	      "err:%d errno:%d\n", err, errno);

}



static void cleanup(void)

{

	close(outer_map);

	close(reuseport_array);

	bpf_object__close(obj);

}



static void test_all(void)

{

	/* Extra SOCK_STREAM to test bind_inany==true */

	const int types[] = { SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM };

	const char * const type_strings[] = { "TCP", "UDP", "TCP" };

	const char * const family_strings[] = { "IPv6", "IPv4" };

	const unsigned short families[] = { AF_INET6, AF_INET };

	const bool bind_inany[] = { false, false, true };

	int t, f, err;



	for (f = 0; f < ARRAY_SIZE(families); f++) {

		unsigned short family = families[f];



		for (t = 0; t < ARRAY_SIZE(types); t++) {

			bool inany = bind_inany[t];

			int type = types[t];



			printf("######## %s/%s %s ########\n",

			       family_strings[f], type_strings[t],

				inany ? " INANY  " : "LOOPBACK");



			setup_per_test(type, family, inany);



			test_err_inner_map(type, family);



			/* Install reuseport_array to the outer_map */

			err = bpf_map_update_elem(outer_map, &index_zero,

						  &reuseport_array, BPF_ANY);

			CHECK(err == -1, "update_elem(outer_map)",

			      "err:%d errno:%d\n", err, errno);



			test_err_skb_data(type, family);

			test_err_sk_select_port(type, family);

			test_pass(type, family);

			test_syncookie(type, family);

			test_pass_on_err(type, family);



			cleanup_per_test();

			printf("\n");

		}

	}

}



int main(int argc, const char **argv)

{

	create_maps();

	prepare_bpf_obj();

	saved_tcp_fo = read_int_sysctl(TCP_FO_SYSCTL);

	saved_tcp_syncookie = read_int_sysctl(TCP_SYNCOOKIE_SYSCTL);

	enable_fastopen();

	disable_syncookie();

	atexit(restore_sysctls);



	test_all();



	cleanup();

	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE