Commit 7708bd43 authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'reuseport_to_test_progs' 

Jakub Sitnicki says:

====================
This change has been suggested by Martin Lau [0] during a review of a
related patch set that extends reuseport tests [1].

Patches 1 & 2 address a warning due to unrecognized section name from
libbpf when running reuseport tests. We don't want to carry this warning
into test_progs.

Patches 3-8 massage the reuseport tests to ease the switch to test_progs
framework. The intention here is to show the work. Happy to squash these,
if needed.

Patches 9-10 do the actual move and conversion to test_progs.

Output from a test_progs run after changes pasted below.

Thanks,
Jakub

[0] https://lore.kernel.org/bpf/20191123110751.6729-1-jakub@cloudflare.com/T/#m607d822caeb1eb5db101172821a78cc3896ff1c3
[1] https://lore.kernel.org/bpf/20191123110751.6729-1-jakub@cloudflare.com/T/#m55881bae9fb6e34837d07a0c0a7ffbc138f8d06f


====================

Acked-by: default avatarMartin KaFai Lau <kafai@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents 679152d3 7ee0d4e9

tools/lib/bpf/libbpf.c

+1 −0
Original line number Diff line number Diff line
@@ -4983,6 +4983,7 @@ static const struct { 
	enum bpf_attach_type attach_type;

} section_names[] = {

	BPF_PROG_SEC("socket",			BPF_PROG_TYPE_SOCKET_FILTER),

	BPF_PROG_SEC("sk_reuseport",		BPF_PROG_TYPE_SK_REUSEPORT),

	BPF_PROG_SEC("kprobe/",			BPF_PROG_TYPE_KPROBE),

	BPF_PROG_SEC("uprobe/",			BPF_PROG_TYPE_KPROBE),

	BPF_PROG_SEC("kretprobe/",		BPF_PROG_TYPE_KPROBE),

tools/testing/selftests/bpf/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ LDLIBS += -lcap -lelf -lrt -lpthread 
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 get_cgroup_id_user test_socket_cookie \

	test_cgroup_storage test_select_reuseport \

	test_cgroup_storage \

	test_netcnt test_tcpnotify_user test_sock_fields test_sysctl test_hashmap \

	test_cgroup_attach test_progs-no_alu32

tools/testing/selftests/bpf/test_select_reuseport.c→tools/testing/selftests/bpf/prog_tests/select_reuseport.c

+289 −225
Original line number Diff line number Diff line
@@ -20,8 +20,11 @@ 
#include <bpf/libbpf.h>

#include "bpf_rlimit.h"

#include "bpf_util.h"



#include "test_progs.h"

#include "test_select_reuseport_common.h"



#define MAX_TEST_NAME 80

#define MIN_TCPHDR_LEN 20

#define UDPHDR_LEN 8
@@ -32,11 +35,11 @@ 
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 reuseport_array = -1, outer_map = -1;

static int select_by_skb_data_prog;

static int saved_tcp_syncookie;

static int saved_tcp_syncookie = -1;

static struct bpf_object *obj;

static int saved_tcp_fo;

static int saved_tcp_fo = -1;

static __u32 index_zero;

static int epfd;
@@ -46,16 +49,21 @@ static union sa46 { 
	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);						\

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

	if (CHECK_FAIL(condition)) {					\

		printf(tag " " format);					\

		return;							\

	}								\

})



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

	if (CHECK_FAIL(condition)) {					\

		printf(tag " " format);					\

		return -1;						\

	}								\

})



static void create_maps(void)

static int create_maps(void)

{

	struct bpf_create_map_attr attr = {};
@@ -67,7 +75,7 @@ static void create_maps(void) 
	attr.max_entries = REUSEPORT_ARRAY_SIZE;



	reuseport_array = bpf_create_map_xattr(&attr);

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

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

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



	/* Creating outer_map */
@@ -78,63 +86,61 @@ static void create_maps(void) 
	attr.max_entries = 1;

	attr.inner_map_fd = reuseport_array;

	outer_map = bpf_create_map_xattr(&attr);

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

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

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



	return 0;

}



static void prepare_bpf_obj(void)

static int 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 = bpf_object__open("test_select_reuseport_kern.o");

	RET_ERR(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");

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

	err = bpf_map__reuse_fd(map, outer_map);

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

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



	err = bpf_object__load(obj);

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

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



	prog = bpf_program__next(NULL, obj);

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

	select_by_skb_data_prog = bpf_program__fd(prog);

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

	RET_ERR(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");

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

	result_map = bpf_map__fd(map);

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

	RET_ERR(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");

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

	tmp_index_ovr_map = bpf_map__fd(map);

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

	RET_ERR(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");

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

	linum_map = bpf_map__fd(map);

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

	RET_ERR(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");

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

	data_check_map = bpf_map__fd(map);

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

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

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



	return 0;

}



static void sa46_init_loopback(union sa46 *sa, sa_family_t family)
@@ -163,64 +169,72 @@ static int read_int_sysctl(const char *sysctl) 
	int fd, ret;



	fd = open(sysctl, 0);

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

	      sysctl, fd, errno);

	RET_ERR(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);

	RET_ERR(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)

static int 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);

	RET_ERR(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);

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

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

		sysctl, ret, size, errno);



	close(fd);

	return 0;

}



static void restore_sysctls(void)

{

	if (saved_tcp_fo != -1)

		write_int_sysctl(TCP_FO_SYSCTL, saved_tcp_fo);

	if (saved_tcp_syncookie != -1)

		write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, saved_tcp_syncookie);

}



static void enable_fastopen(void)

static int enable_fastopen(void)

{

	int fo;



	fo = read_int_sysctl(TCP_FO_SYSCTL);

	write_int_sysctl(TCP_FO_SYSCTL, fo | 7);

	if (fo < 0)

		return -1;



	return write_int_sysctl(TCP_FO_SYSCTL, fo | 7);

}



static void enable_syncookie(void)

static int enable_syncookie(void)

{

	write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, 2);

	return write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, 2);

}



static void disable_syncookie(void)

static int disable_syncookie(void)

{

	write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, 0);

	return write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, 0);

}



static __u32 get_linum(void)

static long 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",

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

		err, errno);



	return linum;
@@ -237,11 +251,11 @@ static void check_data(int type, sa_family_t family, const struct cmd *cmd, 
	addrlen = sizeof(cli_sa);

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

			  &addrlen);

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

	RET_IF(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",

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

	       err, errno);



	if (type == SOCK_STREAM) {
@@ -284,21 +298,21 @@ static void check_data(int type, sa_family_t family, const struct cmd *cmd, 
		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());

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

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

	}



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

	RET_IF(!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",

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

		       "expected.len:%u result.len:%u bpf_prog_linum:%ld\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",

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

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

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

}
@@ -310,7 +324,7 @@ static void check_results(void) 


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

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

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

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

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

	}
@@ -337,9 +351,9 @@ static void check_results(void) 
		printf(", %u", expected_results[i]);

	printf("]\n");



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

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

	       "unexpected result",

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

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

	       broken, broken, get_linum());

}
@@ -350,15 +364,15 @@ static int send_data(int type, sa_family_t family, void *data, size_t len, 
	int fd, err;



	fd = socket(family, type, 0);

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

	RET_ERR(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);

	RET_ERR(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,

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

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

		family, err, errno, expected);
@@ -375,8 +389,10 @@ static void do_test(int type, sa_family_t family, struct cmd *cmd, 


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

			   expected);

	if (cli_fd < 0)

		return;

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

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

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

	       (nev > 0 && expected < PASS),

	       "nev <> expected",

	       "nev:%d expected:%d type:%d family:%d data:(%d, %d)\n",
@@ -389,7 +405,7 @@ static void do_test(int type, sa_family_t family, struct cmd *cmd, 
	if (expected < PASS)

		return;



	CHECK(expected != PASS_ERR_SK_SELECT_REUSEPORT &&

	RET_IF(expected != PASS_ERR_SK_SELECT_REUSEPORT &&

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

	       "check cmd->reuseport_index",

	       "cmd:(%u, %u) ev.data.u32:%u\n",
@@ -399,12 +415,12 @@ static void do_test(int type, sa_family_t family, struct cmd *cmd, 
	if (type == SOCK_STREAM) {

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



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

		RET_IF(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),

		RET_IF(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);
@@ -412,7 +428,7 @@ static void do_test(int type, sa_family_t family, struct cmd *cmd, 
		close(new_fd);

	} else {

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

		CHECK(nread != sizeof(rcv_cmd),

		RET_IF(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);
@@ -428,18 +444,14 @@ static void test_err_inner_map(int type, sa_family_t family) 
		.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)
@@ -449,10 +461,8 @@ static void test_err_sk_select_port(int type, sa_family_t family) 
		.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)
@@ -460,14 +470,12 @@ 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)
@@ -481,7 +489,6 @@ static void test_syncookie(int type, sa_family_t family) 
	if (type != SOCK_STREAM)

		return;



	printf("%s: ", __func__);

	/*

	 * +1 for TCP-SYN and

	 * +1 for the TCP-ACK (ack the syncookie)
@@ -497,17 +504,16 @@ static void test_syncookie(int type, sa_family_t family) 
	 */

	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)",

	RET_IF(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,

	RET_IF(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)
@@ -517,10 +523,8 @@ static void test_pass_on_err(int type, sa_family_t family) 
		.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 test_detach_bpf(int type, sa_family_t family)
@@ -532,46 +536,47 @@ static void test_detach_bpf(int type, sa_family_t family) 
	struct cmd cmd = {};

	int optvalue = 0;



	printf("%s: ", __func__);

	err = setsockopt(sk_fds[0], SOL_SOCKET, SO_DETACH_REUSEPORT_BPF,

			 &optvalue, sizeof(optvalue));

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

	RET_IF(err == -1, "setsockopt(SO_DETACH_REUSEPORT_BPF)",

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



	err = setsockopt(sk_fds[1], SOL_SOCKET, SO_DETACH_REUSEPORT_BPF,

			 &optvalue, sizeof(optvalue));

	CHECK(err == 0 || errno != ENOENT, "setsockopt(SO_DETACH_REUSEPORT_BPF)",

	RET_IF(err == 0 || errno != ENOENT,

	       "setsockopt(SO_DETACH_REUSEPORT_BPF)",

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



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

		err = bpf_map_lookup_elem(result_map, &i, &tmp);

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

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

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

		nr_run_before += tmp;

	}



	cli_fd = send_data(type, family, &cmd, sizeof(cmd), PASS);

	if (cli_fd < 0)

		return;

	nev = epoll_wait(epfd, &ev, 1, 5);

	CHECK(nev <= 0, "nev <= 0",

	RET_IF(nev <= 0, "nev <= 0",

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

	       nev,  type, family);



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

		err = bpf_map_lookup_elem(result_map, &i, &tmp);

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

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

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

		nr_run_after += tmp;

	}



	CHECK(nr_run_before != nr_run_after,

	RET_IF(nr_run_before != nr_run_after,

	       "nr_run_before != nr_run_after",

	       "nr_run_before:%u nr_run_after:%u\n",

	       nr_run_before, nr_run_after);



	printf("OK\n");

	close(cli_fd);

#else

	printf("%s: SKIP\n", __func__);

	test__skip();

#endif

}
@@ -594,11 +599,11 @@ static void prepare_sk_fds(int type, sa_family_t family, bool inany) 
	 */

	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",

		RET_IF(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)",

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

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

		       i, err, errno);
@@ -607,24 +612,24 @@ static void prepare_sk_fds(int type, sa_family_t family, bool inany) 
					 SO_ATTACH_REUSEPORT_EBPF,

					 &select_by_skb_data_prog,

					 sizeof(select_by_skb_data_prog));

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

			RET_IF(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",

		RET_IF(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()",

			RET_IF(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)",

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

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



		if (i == first) {
@@ -632,35 +637,45 @@ static void prepare_sk_fds(int type, sa_family_t family, bool inany) 


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

					  &addrlen);

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

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

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

		}

	}



	epfd = epoll_create(1);

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

	RET_IF(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);

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

	}

}



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

static void setup_per_test(int type, sa_family_t family, bool inany,

			   bool no_inner_map)

{

	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)",

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

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



	/* Install reuseport_array to outer_map? */

	if (no_inner_map)

		return;



	err = bpf_map_update_elem(outer_map, &index_zero, &reuseport_array,

				  BPF_ANY);

	RET_IF(err == -1, "update_elem(outer_map, 0, reuseport_array)",

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

}



static void cleanup_per_test(void)

static void cleanup_per_test(bool no_inner_map)

{

	int i, err;
@@ -668,75 +683,124 @@ static void cleanup_per_test(void) 
		close(sk_fds[i]);

	close(epfd);



	/* Delete reuseport_array from outer_map? */

	if (no_inner_map)

		return;



	err = bpf_map_delete_elem(outer_map, &index_zero);

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

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

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

}



static void cleanup(void)

{

	if (outer_map != -1)

		close(outer_map);

	if (reuseport_array != -1)

		close(reuseport_array);

	if (obj)

		bpf_object__close(obj);

}



static void test_all(void)

static const char *family_str(sa_family_t family)

{

	/* 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];

	switch (family) {

	case AF_INET:

		return "IPv4";

	case AF_INET6:

		return "IPv6";

	default:

		return "unknown";

	}

}



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

			       family_strings[f], type_strings[t],

				inany ? " INANY  " : "LOOPBACK");

static const char *sotype_str(int sotype)

{

	switch (sotype) {

	case SOCK_STREAM:

		return "TCP";

	case SOCK_DGRAM:

		return "UDP";

	default:

		return "unknown";

	}

}



			setup_per_test(type, family, inany);

#define TEST_INIT(fn, ...) { fn, #fn, __VA_ARGS__ }



			test_err_inner_map(type, family);

static void test_config(int sotype, sa_family_t family, bool inany)

{

	const struct test {

		void (*fn)(int sotype, sa_family_t family);

		const char *name;

		bool no_inner_map;

	} tests[] = {

		TEST_INIT(test_err_inner_map, true /* no_inner_map */),

		TEST_INIT(test_err_skb_data),

		TEST_INIT(test_err_sk_select_port),

		TEST_INIT(test_pass),

		TEST_INIT(test_syncookie),

		TEST_INIT(test_pass_on_err),

		TEST_INIT(test_detach_bpf),

	};

	char s[MAX_TEST_NAME];

	const struct test *t;



			/* 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);

	for (t = tests; t < tests + ARRAY_SIZE(tests); t++) {

		snprintf(s, sizeof(s), "%s/%s %s %s",

			 family_str(family), sotype_str(sotype),

			 inany ? "INANY" : "LOOPBACK", t->name);



			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);

			/* Must be the last test */

			test_detach_bpf(type, family);

		if (!test__start_subtest(s))

			continue;



			cleanup_per_test();

			printf("\n");

		setup_per_test(sotype, family, inany, t->no_inner_map);

		t->fn(sotype, family);

		cleanup_per_test(t->no_inner_map);

	}

}



#define BIND_INANY true



static void test_all(void)

{

	const struct config {

		int sotype;

		sa_family_t family;

		bool inany;

	} configs[] = {

		{ SOCK_STREAM, AF_INET },

		{ SOCK_STREAM, AF_INET, BIND_INANY },

		{ SOCK_STREAM, AF_INET6 },

		{ SOCK_STREAM, AF_INET6, BIND_INANY },

		{ SOCK_DGRAM, AF_INET },

		{ SOCK_DGRAM, AF_INET6 },

	};

	const struct config *c;



	for (c = configs; c < configs + ARRAY_SIZE(configs); c++)

		test_config(c->sotype, c->family, c->inany);

}



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

void test_select_reuseport(void)

{

	create_maps();

	prepare_bpf_obj();

	if (create_maps())

		goto out;

	if (prepare_bpf_obj())

		goto out;



	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);

	if (saved_tcp_syncookie < 0 || saved_tcp_syncookie < 0)

		goto out;



	test_all();

	if (enable_fastopen())

		goto out;

	if (disable_syncookie())

		goto out;



	test_all();

out:

	cleanup();

	return 0;

	restore_sysctls();

}

tools/testing/selftests/bpf/progs/test_select_reuseport_kern.c

+1 −1
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ struct { 
	goto done;				\

})



SEC("select_by_skb_data")

SEC("sk_reuseport")

int _select_by_skb_data(struct sk_reuseport_md *reuse_md)

{

	__u32 linum, index = 0, flags = 0, index_zero = 0;