selftests/bpf: Add test for bpf hash map iterators (2a7c2fff) · Commits · 戴 / test

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 @@ out:
		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;
		}

Admin message