github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-28 01:55:51 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

selftests/bpf: Add BPF iterator tests for resizable hash map

Browse Source 
Test basic BPF iterator functionality for BPF_MAP_TYPE_RHASH,
verifying all elements are visited.

Signed-off-by: Mykyta Yatsenko <yatsenko@meta.com>
Link: https://lore.kernel.org/r/20260605-rhash-v7-10-5b8e05f8630d@meta.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
This commit is contained in:
Mykyta Yatsenko 2026-06-05 04:41:27 -07:00 committed by Alexei Starovoitov
parent 249996365b
commit a996794fda
2 changed files with 97 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
tools/testing/selftests/bpf/prog_tests/rhash.c
View File

@ -4,6 +4,7 @@
#include <string.h>
#include <stdio.h>
#include "rhash.skel.h"
#include "bpf_iter_bpf_rhash_map.skel.h"
#include <linux/bpf.h>
#include <linux/perf_event.h>
#include <sys/syscall.h>
@ -89,6 +90,65 @@ static void rhash_map_extra_too_big(void)
close(fd);
}
static void rhash_iter_test(void)
{
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
struct bpf_iter_bpf_rhash_map *skel;
int err, i, len, map_fd, iter_fd;
union bpf_iter_link_info linfo;
u32 expected_key_sum = 0, key;
struct bpf_link *link;
u64 val = 0;
char buf[64];
skel = bpf_iter_bpf_rhash_map__open();
if (!ASSERT_OK_PTR(skel, "bpf_iter_bpf_rhash_map__open"))
return;
err = bpf_iter_bpf_rhash_map__load(skel);
if (!ASSERT_OK(err, "bpf_iter_bpf_rhash_map__load"))
goto out;
map_fd = bpf_map__fd(skel->maps.rhashmap);
/* Populate map with test data */
for (i = 0; i < 64; i++) {
key = i + 1;
expected_key_sum += key;
err = bpf_map_update_elem(map_fd, &key, &val, BPF_NOEXIST);
if (!ASSERT_OK(err, "map_update"))
goto out;
}
memset(&linfo, 0, sizeof(linfo));
linfo.map.map_fd = map_fd;
opts.link_info = &linfo;
opts.link_info_len = sizeof(linfo);
link = bpf_program__attach_iter(skel->progs.dump_bpf_rhash_map, &opts);
if (!ASSERT_OK_PTR(link, "attach_iter"))
goto out;
iter_fd = bpf_iter_create(bpf_link__fd(link));
if (!ASSERT_GE(iter_fd, 0, "create_iter"))
goto free_link;
do {
len = read(iter_fd, buf, sizeof(buf));
} while (len > 0);
ASSERT_EQ(skel->bss->key_sum, expected_key_sum, "key_sum");
ASSERT_EQ(skel->bss->elem_count, 64, "elem_count");
close(iter_fd);
free_link:
bpf_link__destroy(link);
out:
bpf_iter_bpf_rhash_map__destroy(skel);
}
void test_rhash(void)
{
if (test__start_subtest("test_rhash_lookup_update"))
@ -117,4 +177,7 @@ void test_rhash(void)
if (test__start_subtest("test_rhash_map_extra_too_big"))
rhash_map_extra_too_big();
if (test__start_subtest("test_rhash_iter"))
rhash_iter_test();
}

34
tools/testing/selftests/bpf/progs/bpf_iter_bpf_rhash_map.c Normal file
View File

@ -0,0 +1,34 @@
// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
#include <vmlinux.h>
#include <bpf/bpf_helpers.h>
char _license[] SEC("license") = "GPL";
struct {
__uint(type, BPF_MAP_TYPE_RHASH);
__uint(map_flags, BPF_F_NO_PREALLOC);
__uint(max_entries, 64);
__type(key, __u32);
__type(value, __u64);
} rhashmap SEC(".maps");
__u32 key_sum = 0;
__u64 val_sum = 0;
__u32 elem_count = 0;
__u32 err = 0;
SEC("iter/bpf_map_elem")
int dump_bpf_rhash_map(struct bpf_iter__bpf_map_elem *ctx)
{
__u32 *key = ctx->key;
__u64 *val = ctx->value;
if (!key || !val)
return 0;
key_sum += *key;
val_sum += *val;
elem_count++;
return 0;
}