Commit d6378af6 authored by Cong Wang's avatar Cong Wang Committed by Alexei Starovoitov
Browse files

selftests/bpf: Add a test case for udp sockmap 



Add a test case to ensure redirection between two UDP sockets work.

Signed-off-by: default avatarCong Wang <cong.wang@bytedance.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20210331023237.41094-16-xiyou.wangcong@gmail.com
parent 122e6c79

tools/testing/selftests/bpf/prog_tests/sockmap_listen.c

+136 −0
Original line number Diff line number Diff line
@@ -1603,6 +1603,141 @@ static void test_reuseport(struct test_sockmap_listen *skel, 
	}

}



static void udp_redir_to_connected(int family, int sotype, int sock_mapfd,

				   int verd_mapfd, enum redir_mode mode)

{

	const char *log_prefix = redir_mode_str(mode);

	struct sockaddr_storage addr;

	int c0, c1, p0, p1;

	unsigned int pass;

	socklen_t len;

	int err, n;

	u64 value;

	u32 key;

	char b;



	zero_verdict_count(verd_mapfd);



	p0 = socket_loopback(family, sotype | SOCK_NONBLOCK);

	if (p0 < 0)

		return;

	len = sizeof(addr);

	err = xgetsockname(p0, sockaddr(&addr), &len);

	if (err)

		goto close_peer0;



	c0 = xsocket(family, sotype | SOCK_NONBLOCK, 0);

	if (c0 < 0)

		goto close_peer0;

	err = xconnect(c0, sockaddr(&addr), len);

	if (err)

		goto close_cli0;

	err = xgetsockname(c0, sockaddr(&addr), &len);

	if (err)

		goto close_cli0;

	err = xconnect(p0, sockaddr(&addr), len);

	if (err)

		goto close_cli0;



	p1 = socket_loopback(family, sotype | SOCK_NONBLOCK);

	if (p1 < 0)

		goto close_cli0;

	err = xgetsockname(p1, sockaddr(&addr), &len);

	if (err)

		goto close_cli0;



	c1 = xsocket(family, sotype | SOCK_NONBLOCK, 0);

	if (c1 < 0)

		goto close_peer1;

	err = xconnect(c1, sockaddr(&addr), len);

	if (err)

		goto close_cli1;

	err = xgetsockname(c1, sockaddr(&addr), &len);

	if (err)

		goto close_cli1;

	err = xconnect(p1, sockaddr(&addr), len);

	if (err)

		goto close_cli1;



	key = 0;

	value = p0;

	err = xbpf_map_update_elem(sock_mapfd, &key, &value, BPF_NOEXIST);

	if (err)

		goto close_cli1;



	key = 1;

	value = p1;

	err = xbpf_map_update_elem(sock_mapfd, &key, &value, BPF_NOEXIST);

	if (err)

		goto close_cli1;



	n = write(c1, "a", 1);

	if (n < 0)

		FAIL_ERRNO("%s: write", log_prefix);

	if (n == 0)

		FAIL("%s: incomplete write", log_prefix);

	if (n < 1)

		goto close_cli1;



	key = SK_PASS;

	err = xbpf_map_lookup_elem(verd_mapfd, &key, &pass);

	if (err)

		goto close_cli1;

	if (pass != 1)

		FAIL("%s: want pass count 1, have %d", log_prefix, pass);



	n = read(mode == REDIR_INGRESS ? p0 : c0, &b, 1);

	if (n < 0)

		FAIL_ERRNO("%s: read", log_prefix);

	if (n == 0)

		FAIL("%s: incomplete read", log_prefix);



close_cli1:

	xclose(c1);

close_peer1:

	xclose(p1);

close_cli0:

	xclose(c0);

close_peer0:

	xclose(p0);

}



static void udp_skb_redir_to_connected(struct test_sockmap_listen *skel,

				       struct bpf_map *inner_map, int family)

{

	int verdict = bpf_program__fd(skel->progs.prog_skb_verdict);

	int verdict_map = bpf_map__fd(skel->maps.verdict_map);

	int sock_map = bpf_map__fd(inner_map);

	int err;



	err = xbpf_prog_attach(verdict, sock_map, BPF_SK_SKB_VERDICT, 0);

	if (err)

		return;



	skel->bss->test_ingress = false;

	udp_redir_to_connected(family, SOCK_DGRAM, sock_map, verdict_map,

			       REDIR_EGRESS);

	skel->bss->test_ingress = true;

	udp_redir_to_connected(family, SOCK_DGRAM, sock_map, verdict_map,

			       REDIR_INGRESS);



	xbpf_prog_detach2(verdict, sock_map, BPF_SK_SKB_VERDICT);

}



static void test_udp_redir(struct test_sockmap_listen *skel, struct bpf_map *map,

			   int family)

{

	const char *family_name, *map_name;

	char s[MAX_TEST_NAME];



	family_name = family_str(family);

	map_name = map_type_str(map);

	snprintf(s, sizeof(s), "%s %s %s", map_name, family_name, __func__);

	if (!test__start_subtest(s))

		return;

	udp_skb_redir_to_connected(skel, map, family);

}



static void run_tests(struct test_sockmap_listen *skel, struct bpf_map *map,

		      int family)

{
@@ -1611,6 +1746,7 @@ static void run_tests(struct test_sockmap_listen *skel, struct bpf_map *map, 
	test_redir(skel, map, family, SOCK_STREAM);

	test_reuseport(skel, map, family, SOCK_STREAM);

	test_reuseport(skel, map, family, SOCK_DGRAM);

	test_udp_redir(skel, map, family);

}



void test_sockmap_listen(void)

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

+22 −0
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ struct { 
} verdict_map SEC(".maps");



static volatile bool test_sockmap; /* toggled by user-space */

static volatile bool test_ingress; /* toggled by user-space */



SEC("sk_skb/stream_parser")

int prog_stream_parser(struct __sk_buff *skb)
@@ -55,6 +56,27 @@ int prog_stream_verdict(struct __sk_buff *skb) 
	return verdict;

}



SEC("sk_skb/skb_verdict")

int prog_skb_verdict(struct __sk_buff *skb)

{

	unsigned int *count;

	__u32 zero = 0;

	int verdict;



	if (test_sockmap)

		verdict = bpf_sk_redirect_map(skb, &sock_map, zero,

					      test_ingress ? BPF_F_INGRESS : 0);

	else

		verdict = bpf_sk_redirect_hash(skb, &sock_hash, &zero,

					       test_ingress ? BPF_F_INGRESS : 0);



	count = bpf_map_lookup_elem(&verdict_map, &verdict);

	if (count)

		(*count)++;



	return verdict;

}



SEC("sk_msg")

int prog_msg_verdict(struct sk_msg_md *msg)

{