Commit 2a7c2fff authored by Yonghong Song's avatar Yonghong Song Committed by Alexei Starovoitov
Browse files

selftests/bpf: Add test for bpf hash map iterators 



Two subtests are added.
  $ ./test_progs -n 4
  ...
  #4/18 bpf_hash_map:OK
  #4/19 bpf_percpu_hash_map:OK
  ...

Signed-off-by: default avatarYonghong Song <yhs@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20200723184120.590916-1-yhs@fb.com
parent d8793aca

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

+187 −0
Original line number Diff line number Diff line
@@ -15,6 +15,8 @@ 
#include "bpf_iter_test_kern2.skel.h"

#include "bpf_iter_test_kern3.skel.h"

#include "bpf_iter_test_kern4.skel.h"

#include "bpf_iter_bpf_hash_map.skel.h"

#include "bpf_iter_bpf_percpu_hash_map.skel.h"



static int duration;
@@ -455,6 +457,187 @@ static void test_overflow(bool test_e2big_overflow, bool ret1) 
	bpf_iter_test_kern4__destroy(skel);

}



static void test_bpf_hash_map(void)

{

	__u32 expected_key_a = 0, expected_key_b = 0, expected_key_c = 0;

	DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);

	struct bpf_iter_bpf_hash_map *skel;

	int err, i, len, map_fd, iter_fd;

	__u64 val, expected_val = 0;

	struct bpf_link *link;

	struct key_t {

		int a;

		int b;

		int c;

	} key;

	char buf[64];



	skel = bpf_iter_bpf_hash_map__open();

	if (CHECK(!skel, "bpf_iter_bpf_hash_map__open",

		  "skeleton open failed\n"))

		return;



	skel->bss->in_test_mode = true;



	err = bpf_iter_bpf_hash_map__load(skel);

	if (CHECK(!skel, "bpf_iter_bpf_hash_map__load",

		  "skeleton load failed\n"))

		goto out;



	/* iterator with hashmap2 and hashmap3 should fail */

	opts.map_fd = bpf_map__fd(skel->maps.hashmap2);

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

	if (CHECK(!IS_ERR(link), "attach_iter",

		  "attach_iter for hashmap2 unexpected succeeded\n"))

		goto out;



	opts.map_fd = bpf_map__fd(skel->maps.hashmap3);

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

	if (CHECK(!IS_ERR(link), "attach_iter",

		  "attach_iter for hashmap3 unexpected succeeded\n"))

		goto out;



	/* hashmap1 should be good, update map values here */

	map_fd = bpf_map__fd(skel->maps.hashmap1);

	for (i = 0; i < bpf_map__max_entries(skel->maps.hashmap1); i++) {

		key.a = i + 1;

		key.b = i + 2;

		key.c = i + 3;

		val = i + 4;

		expected_key_a += key.a;

		expected_key_b += key.b;

		expected_key_c += key.c;

		expected_val += val;



		err = bpf_map_update_elem(map_fd, &key, &val, BPF_ANY);

		if (CHECK(err, "map_update", "map_update failed\n"))

			goto out;

	}



	opts.map_fd = map_fd;

	link = bpf_program__attach_iter(skel->progs.dump_bpf_hash_map, &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", "read failed: %s\n", strerror(errno)))

		goto close_iter;



	/* test results */

	if (CHECK(skel->bss->key_sum_a != expected_key_a,

		  "key_sum_a", "got %u expected %u\n",

		  skel->bss->key_sum_a, expected_key_a))

		goto close_iter;

	if (CHECK(skel->bss->key_sum_b != expected_key_b,

		  "key_sum_b", "got %u expected %u\n",

		  skel->bss->key_sum_b, expected_key_b))

		goto close_iter;

	if (CHECK(skel->bss->val_sum != expected_val,

		  "val_sum", "got %llu expected %llu\n",

		  skel->bss->val_sum, expected_val))

		goto close_iter;



close_iter:

	close(iter_fd);

free_link:

	bpf_link__destroy(link);

out:

	bpf_iter_bpf_hash_map__destroy(skel);

}



static void test_bpf_percpu_hash_map(void)

{

	__u32 expected_key_a = 0, expected_key_b = 0, expected_key_c = 0;

	DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);

	struct bpf_iter_bpf_percpu_hash_map *skel;

	int err, i, j, len, map_fd, iter_fd;

	__u32 expected_val = 0;

	struct bpf_link *link;

	struct key_t {

		int a;

		int b;

		int c;

	} key;

	char buf[64];

	void *val;



	val = malloc(8 * bpf_num_possible_cpus());



	skel = bpf_iter_bpf_percpu_hash_map__open();

	if (CHECK(!skel, "bpf_iter_bpf_percpu_hash_map__open",

		  "skeleton open failed\n"))

		return;



	skel->rodata->num_cpus = bpf_num_possible_cpus();



	err = bpf_iter_bpf_percpu_hash_map__load(skel);

	if (CHECK(!skel, "bpf_iter_bpf_percpu_hash_map__load",

		  "skeleton load failed\n"))

		goto out;



	/* update map values here */

	map_fd = bpf_map__fd(skel->maps.hashmap1);

	for (i = 0; i < bpf_map__max_entries(skel->maps.hashmap1); i++) {

		key.a = i + 1;

		key.b = i + 2;

		key.c = i + 3;

		expected_key_a += key.a;

		expected_key_b += key.b;

		expected_key_c += key.c;



		for (j = 0; j < bpf_num_possible_cpus(); j++) {

			*(__u32 *)(val + j * 8) = i + j;

			expected_val += i + j;

		}



		err = bpf_map_update_elem(map_fd, &key, val, BPF_ANY);

		if (CHECK(err, "map_update", "map_update failed\n"))

			goto out;

	}



	opts.map_fd = map_fd;

	link = bpf_program__attach_iter(skel->progs.dump_bpf_percpu_hash_map, &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", "read failed: %s\n", strerror(errno)))

		goto close_iter;



	/* test results */

	if (CHECK(skel->bss->key_sum_a != expected_key_a,

		  "key_sum_a", "got %u expected %u\n",

		  skel->bss->key_sum_a, expected_key_a))

		goto close_iter;

	if (CHECK(skel->bss->key_sum_b != expected_key_b,

		  "key_sum_b", "got %u expected %u\n",

		  skel->bss->key_sum_b, expected_key_b))

		goto close_iter;

	if (CHECK(skel->bss->val_sum != expected_val,

		  "val_sum", "got %u expected %u\n",

		  skel->bss->val_sum, expected_val))

		goto close_iter;



close_iter:

	close(iter_fd);

free_link:

	bpf_link__destroy(link);

out:

	bpf_iter_bpf_percpu_hash_map__destroy(skel);

}



void test_bpf_iter(void)

{

	if (test__start_subtest("btf_id_or_null"))
@@ -491,4 +674,8 @@ void test_bpf_iter(void) 
		test_overflow(true, false);

	if (test__start_subtest("prog-ret-1"))

		test_overflow(false, true);

	if (test__start_subtest("bpf_hash_map"))

		test_bpf_hash_map();

	if (test__start_subtest("bpf_percpu_hash_map"))

		test_bpf_percpu_hash_map();

}

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

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

/* Copyright (c) 2020 Facebook */

#include "bpf_iter.h"

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_tracing.h>



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



struct key_t {

	int a;

	int b;

	int c;

};



struct {

	__uint(type, BPF_MAP_TYPE_HASH);

	__uint(max_entries, 3);

	__type(key, struct key_t);

	__type(value, __u64);

} hashmap1 SEC(".maps");



struct {

	__uint(type, BPF_MAP_TYPE_HASH);

	__uint(max_entries, 3);

	__type(key, __u64);

	__type(value, __u64);

} hashmap2 SEC(".maps");



struct {

	__uint(type, BPF_MAP_TYPE_HASH);

	__uint(max_entries, 3);

	__type(key, struct key_t);

	__type(value, __u32);

} hashmap3 SEC(".maps");



/* will set before prog run */

bool in_test_mode = 0;



/* will collect results during prog run */

__u32 key_sum_a = 0, key_sum_b = 0, key_sum_c = 0;

__u64 val_sum = 0;



SEC("iter/bpf_map_elem")

int dump_bpf_hash_map(struct bpf_iter__bpf_map_elem *ctx)

{

	struct seq_file *seq = ctx->meta->seq;

	__u32 seq_num = ctx->meta->seq_num;

	struct bpf_map *map = ctx->map;

	struct key_t *key = ctx->key;

	__u64 *val = ctx->value;



	if (in_test_mode) {

		/* test mode is used by selftests to

		 * test functionality of bpf_hash_map iter.

		 *

		 * the above hashmap1 will have correct size

		 * and will be accepted, hashmap2 and hashmap3

		 * should be rejected due to smaller key/value

		 * size.

		 */

		if (key == (void *)0 || val == (void *)0)

			return 0;



		key_sum_a += key->a;

		key_sum_b += key->b;

		key_sum_c += key->c;

		val_sum += *val;

		return 0;

	}



	/* non-test mode, the map is prepared with the

	 * below bpftool command sequence:

	 *   bpftool map create /sys/fs/bpf/m1 type hash \

	 *   	key 12 value 8 entries 3 name map1

	 *   bpftool map update id 77 key 0 0 0 1 0 0 0 0 0 0 0 1 \

	 *   	value 0 0 0 1 0 0 0 1

	 *   bpftool map update id 77 key 0 0 0 1 0 0 0 0 0 0 0 2 \

	 *   	value 0 0 0 1 0 0 0 2

	 * The bpftool iter command line:

	 *   bpftool iter pin ./bpf_iter_bpf_hash_map.o /sys/fs/bpf/p1 \

	 *   	map id 77

	 * The below output will be:

	 *   map dump starts

	 *   77: (1000000 0 2000000) (200000001000000)

	 *   77: (1000000 0 1000000) (100000001000000)

	 *   map dump ends

	 */

	if (seq_num == 0)

		BPF_SEQ_PRINTF(seq, "map dump starts\n");



	if (key == (void *)0 || val == (void *)0) {

		BPF_SEQ_PRINTF(seq, "map dump ends\n");

		return 0;

	}



	BPF_SEQ_PRINTF(seq, "%d: (%x %d %x) (%llx)\n", map->id,

		       key->a, key->b, key->c, *val);



	return 0;

}

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

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

/* Copyright (c) 2020 Facebook */

#include "bpf_iter.h"

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_tracing.h>



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



struct key_t {

	int a;

	int b;

	int c;

};



struct {

	__uint(type, BPF_MAP_TYPE_PERCPU_HASH);

	__uint(max_entries, 3);

	__type(key, struct key_t);

	__type(value, __u32);

} hashmap1 SEC(".maps");



/* will set before prog run */

volatile const __u32 num_cpus = 0;



/* will collect results during prog run */

__u32 key_sum_a = 0, key_sum_b = 0, key_sum_c = 0;

__u32 val_sum = 0;



SEC("iter/bpf_map_elem")

int dump_bpf_percpu_hash_map(struct bpf_iter__bpf_map_elem *ctx)

{

	struct key_t *key = ctx->key;

	void *pptr = ctx->value;

	__u32 step;

	int i;



	if (key == (void *)0 || pptr == (void *)0)

		return 0;



	key_sum_a += key->a;

	key_sum_b += key->b;

	key_sum_c += key->c;



	step = 8;

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

		val_sum += *(__u32 *)pptr;

		pptr += step;

	}

	return 0;

}