Commit 2f7de986 authored by Lorenz Bauer's avatar Lorenz Bauer Committed by Alexei Starovoitov
Browse files

selftests: bpf: Test iterating a sockmap 



Add a test that exercises a basic sockmap / sockhash iteration. For
now we simply count the number of elements seen. Once sockmap update
from iterators works we can extend this to perform a full copy.

Signed-off-by: default avatarLorenz Bauer <lmb@cloudflare.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20200909162712.221874-4-lmb@cloudflare.com
parent 03653515

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

+89 −0
Original line number Diff line number Diff line
@@ -6,6 +6,9 @@ 
#include "test_skmsg_load_helpers.skel.h"

#include "test_sockmap_update.skel.h"

#include "test_sockmap_invalid_update.skel.h"

#include "bpf_iter_sockmap.skel.h"



#include "progs/bpf_iter_sockmap.h"



#define TCP_REPAIR		19	/* TCP sock is under repair right now */
@@ -171,6 +174,88 @@ static void test_sockmap_invalid_update(void) 
		test_sockmap_invalid_update__destroy(skel);

}



static void test_sockmap_iter(enum bpf_map_type map_type)

{

	DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);

	int err, len, src_fd, iter_fd, duration = 0;

	union bpf_iter_link_info linfo = {0};

	__s64 sock_fd[SOCKMAP_MAX_ENTRIES];

	__u32 i, num_sockets, max_elems;

	struct bpf_iter_sockmap *skel;

	struct bpf_link *link;

	struct bpf_map *src;

	char buf[64];



	skel = bpf_iter_sockmap__open_and_load();

	if (CHECK(!skel, "bpf_iter_sockmap__open_and_load", "skeleton open_and_load failed\n"))

		return;



	for (i = 0; i < ARRAY_SIZE(sock_fd); i++)

		sock_fd[i] = -1;



	/* Make sure we have at least one "empty" entry to test iteration of

	 * an empty slot.

	 */

	num_sockets = ARRAY_SIZE(sock_fd) - 1;



	if (map_type == BPF_MAP_TYPE_SOCKMAP) {

		src = skel->maps.sockmap;

		max_elems = bpf_map__max_entries(src);

	} else {

		src = skel->maps.sockhash;

		max_elems = num_sockets;

	}



	src_fd = bpf_map__fd(src);



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

		sock_fd[i] = connected_socket_v4();

		if (CHECK(sock_fd[i] == -1, "connected_socket_v4", "cannot connect\n"))

			goto out;



		err = bpf_map_update_elem(src_fd, &i, &sock_fd[i], BPF_NOEXIST);

		if (CHECK(err, "map_update", "failed: %s\n", strerror(errno)))

			goto out;

	}



	linfo.map.map_fd = src_fd;

	opts.link_info = &linfo;

	opts.link_info_len = sizeof(linfo);

	link = bpf_program__attach_iter(skel->progs.count_elems, &opts);

	if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))

		goto out;



	iter_fd = bpf_iter_create(bpf_link__fd(link));

	if (CHECK(iter_fd < 0, "create_iter", "create_iter failed\n"))

		goto free_link;



	/* do some tests */

	while ((len = read(iter_fd, buf, sizeof(buf))) > 0)

		;

	if (CHECK(len < 0, "read", "failed: %s\n", strerror(errno)))

		goto close_iter;



	/* test results */

	if (CHECK(skel->bss->elems != max_elems, "elems", "got %u expected %u\n",

		  skel->bss->elems, max_elems))

		goto close_iter;



	if (CHECK(skel->bss->socks != num_sockets, "socks", "got %u expected %u\n",

		  skel->bss->socks, num_sockets))

		goto close_iter;



close_iter:

	close(iter_fd);

free_link:

	bpf_link__destroy(link);

out:

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

		if (sock_fd[i] >= 0)

			close(sock_fd[i]);

	}

	bpf_iter_sockmap__destroy(skel);

}



void test_sockmap_basic(void)

{

	if (test__start_subtest("sockmap create_update_free"))
@@ -187,4 +272,8 @@ void test_sockmap_basic(void) 
		test_sockmap_update(BPF_MAP_TYPE_SOCKHASH);

	if (test__start_subtest("sockmap update in unsafe context"))

		test_sockmap_invalid_update();

	if (test__start_subtest("sockmap iter"))

		test_sockmap_iter(BPF_MAP_TYPE_SOCKMAP);

	if (test__start_subtest("sockhash iter"))

		test_sockmap_iter(BPF_MAP_TYPE_SOCKHASH);

}

tools/testing/selftests/bpf/progs/bpf_iter.h

+9 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#define udp6_sock udp6_sock___not_used

#define bpf_iter__bpf_map_elem bpf_iter__bpf_map_elem___not_used

#define bpf_iter__bpf_sk_storage_map bpf_iter__bpf_sk_storage_map___not_used

#define bpf_iter__sockmap bpf_iter__sockmap___not_used

#include "vmlinux.h"

#undef bpf_iter_meta

#undef bpf_iter__bpf_map
@@ -26,6 +27,7 @@ 
#undef udp6_sock

#undef bpf_iter__bpf_map_elem

#undef bpf_iter__bpf_sk_storage_map

#undef bpf_iter__sockmap



struct bpf_iter_meta {

	struct seq_file *seq;
@@ -96,3 +98,10 @@ struct bpf_iter__bpf_sk_storage_map { 
	struct sock *sk;

	void *value;

};



struct bpf_iter__sockmap {

	struct bpf_iter_meta *meta;

	struct bpf_map *map;

	void *key;

	struct sock *sk;

};

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

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

/* Copyright (c) 2020 Cloudflare */

#include "bpf_iter.h"

#include "bpf_tracing_net.h"

#include "bpf_iter_sockmap.h"

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_tracing.h>

#include <errno.h>



char _license[] SEC("license") = "GPL";



struct {

	__uint(type, BPF_MAP_TYPE_SOCKMAP);

	__uint(max_entries, SOCKMAP_MAX_ENTRIES);

	__type(key, __u32);

	__type(value, __u64);

} sockmap SEC(".maps");



struct {

	__uint(type, BPF_MAP_TYPE_SOCKHASH);

	__uint(max_entries, SOCKMAP_MAX_ENTRIES);

	__type(key, __u32);

	__type(value, __u64);

} sockhash SEC(".maps");



__u32 elems = 0;

__u32 socks = 0;



SEC("iter/sockmap")

int count_elems(struct bpf_iter__sockmap *ctx)

{

	struct sock *sk = ctx->sk;

	__u32 tmp, *key = ctx->key;

	int ret;



	if (key)

		elems++;



	if (sk)

		socks++;



	return 0;

}

tools/testing/selftests/bpf/progs/bpf_iter_sockmap.h

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



#define SOCKMAP_MAX_ENTRIES (64)