mirror of
https://github.com/torvalds/linux.git
synced 2026-07-27 09:36:22 +02:00
selftests/bpf: Add basic tests for resizable hash map
Test basic map operations (lookup, update, delete) for BPF_MAP_TYPE_RHASH including boundary conditions like duplicate key insertion and deletion of nonexistent keys. Signed-off-by: Mykyta Yatsenko <yatsenko@meta.com> Link: https://lore.kernel.org/r/20260605-rhash-v7-9-5b8e05f8630d@meta.com Signed-off-by: Alexei Starovoitov <ast@kernel.org>
This commit is contained in:
Mykyta Yatsenko
Alexei Starovoitov
parent
6e46ff0abe
commit
249996365b
120
tools/testing/selftests/bpf/prog_tests/rhash.c
Normal file
120
tools/testing/selftests/bpf/prog_tests/rhash.c
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
|
||||
#include <test_progs.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "rhash.skel.h"
|
||||
#include <linux/bpf.h>
|
||||
#include <linux/perf_event.h>
|
||||
#include <sys/syscall.h>
|
||||
|
||||
static void rhash_run(const char *prog_name)
|
||||
{
|
||||
struct rhash *skel;
|
||||
struct bpf_program *prog;
|
||||
LIBBPF_OPTS(bpf_test_run_opts, opts);
|
||||
int err;
|
||||
|
||||
skel = rhash__open();
|
||||
if (!ASSERT_OK_PTR(skel, "rhash__open"))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_name(skel->obj, prog_name);
|
||||
if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))
|
||||
goto cleanup;
|
||||
bpf_program__set_autoload(prog, true);
|
||||
|
||||
err = rhash__load(skel);
|
||||
if (!ASSERT_OK(err, "skel_load"))
|
||||
goto cleanup;
|
||||
|
||||
err = bpf_prog_test_run_opts(bpf_program__fd(prog), &opts);
|
||||
if (!ASSERT_OK(err, "prog run"))
|
||||
goto cleanup;
|
||||
|
||||
if (!ASSERT_OK(opts.retval, "prog retval"))
|
||||
goto cleanup;
|
||||
|
||||
if (!ASSERT_OK(skel->bss->err, "bss->err"))
|
||||
goto cleanup;
|
||||
|
||||
cleanup:
|
||||
rhash__destroy(skel);
|
||||
}
|
||||
|
||||
static int rhash_map_create(__u32 max_entries, __u64 map_extra)
|
||||
{
|
||||
LIBBPF_OPTS(bpf_map_create_opts, opts,
|
||||
.map_flags = BPF_F_NO_PREALLOC,
|
||||
.map_extra = map_extra);
|
||||
|
||||
return bpf_map_create(BPF_MAP_TYPE_RHASH, "rhash_extra",
|
||||
sizeof(__u32), sizeof(__u64), max_entries, &opts);
|
||||
}
|
||||
|
||||
static void rhash_map_extra_presize(void)
|
||||
{
|
||||
const __u32 max_entries = 1024;
|
||||
const __u32 nelem_hint = 256;
|
||||
struct bpf_map_info info = {};
|
||||
__u32 info_len = sizeof(info);
|
||||
__u64 val = 0;
|
||||
__u32 key;
|
||||
int fd, i;
|
||||
|
||||
fd = rhash_map_create(max_entries, nelem_hint);
|
||||
if (!ASSERT_GE(fd, 0, "rhash_map_create presize"))
|
||||
return;
|
||||
|
||||
if (!ASSERT_OK(bpf_map_get_info_by_fd(fd, &info, &info_len), "info"))
|
||||
goto close;
|
||||
ASSERT_EQ(info.map_extra, nelem_hint, "info.map_extra");
|
||||
|
||||
for (i = 0; i < (int)nelem_hint; i++) {
|
||||
key = i;
|
||||
if (!ASSERT_OK(bpf_map_update_elem(fd, &key, &val, BPF_NOEXIST),
|
||||
"update"))
|
||||
goto close;
|
||||
}
|
||||
close:
|
||||
close(fd);
|
||||
}
|
||||
|
||||
static void rhash_map_extra_too_big(void)
|
||||
{
|
||||
int fd;
|
||||
|
||||
fd = rhash_map_create(1U << 20, 0x10000);
|
||||
if (!ASSERT_LT(fd, 0, "rhash_map_create hint > U16_MAX"))
|
||||
close(fd);
|
||||
}
|
||||
|
||||
void test_rhash(void)
|
||||
{
|
||||
if (test__start_subtest("test_rhash_lookup_update"))
|
||||
rhash_run("test_rhash_lookup_update");
|
||||
|
||||
if (test__start_subtest("test_rhash_update_delete"))
|
||||
rhash_run("test_rhash_update_delete");
|
||||
|
||||
if (test__start_subtest("test_rhash_update_elements"))
|
||||
rhash_run("test_rhash_update_elements");
|
||||
|
||||
if (test__start_subtest("test_rhash_update_exist"))
|
||||
rhash_run("test_rhash_update_exist");
|
||||
|
||||
if (test__start_subtest("test_rhash_update_any"))
|
||||
rhash_run("test_rhash_update_any");
|
||||
|
||||
if (test__start_subtest("test_rhash_noexist_duplicate"))
|
||||
rhash_run("test_rhash_noexist_duplicate");
|
||||
|
||||
if (test__start_subtest("test_rhash_delete_nonexistent"))
|
||||
rhash_run("test_rhash_delete_nonexistent");
|
||||
|
||||
if (test__start_subtest("test_rhash_map_extra_presize"))
|
||||
rhash_map_extra_presize();
|
||||
|
||||
if (test__start_subtest("test_rhash_map_extra_too_big"))
|
||||
rhash_map_extra_too_big();
|
||||
}
|
||||
248
tools/testing/selftests/bpf/progs/rhash.c
Normal file
248
tools/testing/selftests/bpf/progs/rhash.c
Normal file
|
|
@ -0,0 +1,248 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
|
||||
|
||||
#include <vmlinux.h>
|
||||
#include <stdbool.h>
|
||||
#include <bpf/bpf_helpers.h>
|
||||
#include <bpf/bpf_tracing.h>
|
||||
#include "bpf_misc.h"
|
||||
|
||||
#define ENOENT 2
|
||||
#define EEXIST 17
|
||||
|
||||
char _license[] SEC("license") = "GPL";
|
||||
|
||||
int err;
|
||||
|
||||
struct elem {
|
||||
char arr[128];
|
||||
int val;
|
||||
};
|
||||
|
||||
struct {
|
||||
__uint(type, BPF_MAP_TYPE_RHASH);
|
||||
__uint(map_flags, BPF_F_NO_PREALLOC);
|
||||
__uint(max_entries, 128);
|
||||
__type(key, int);
|
||||
__type(value, struct elem);
|
||||
} rhmap SEC(".maps");
|
||||
|
||||
SEC("syscall")
|
||||
int test_rhash_lookup_update(void *ctx)
|
||||
{
|
||||
int key = 5;
|
||||
struct elem empty = {.val = 3, .arr = {0}};
|
||||
struct elem *e;
|
||||
|
||||
err = 1;
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (e)
|
||||
return 1;
|
||||
|
||||
err = bpf_map_update_elem(&rhmap, &key, &empty, BPF_NOEXIST);
|
||||
if (err)
|
||||
return 1;
|
||||
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (!e || e->val != empty.val) {
|
||||
err = 2;
|
||||
return 2;
|
||||
}
|
||||
|
||||
err = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
int test_rhash_update_delete(void *ctx)
|
||||
{
|
||||
int key = 6;
|
||||
struct elem empty = {.val = 4, .arr = {0}};
|
||||
struct elem *e;
|
||||
|
||||
err = 1;
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (e)
|
||||
return 1;
|
||||
|
||||
err = bpf_map_update_elem(&rhmap, &key, &empty, BPF_NOEXIST);
|
||||
if (err)
|
||||
return 2;
|
||||
|
||||
err = bpf_map_delete_elem(&rhmap, &key);
|
||||
if (err)
|
||||
return 3;
|
||||
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (e) {
|
||||
err = 4;
|
||||
return 4;
|
||||
}
|
||||
|
||||
err = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
int test_rhash_update_elements(void *ctx)
|
||||
{
|
||||
int key = 0;
|
||||
struct elem empty = {.val = 4, .arr = {0}};
|
||||
struct elem *e;
|
||||
int i;
|
||||
|
||||
err = 1;
|
||||
|
||||
for (i = 0; i < 128; ++i) {
|
||||
key = i;
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (e)
|
||||
return 1;
|
||||
|
||||
empty.val = key;
|
||||
err = bpf_map_update_elem(&rhmap, &key, &empty, BPF_NOEXIST);
|
||||
if (err)
|
||||
return 2;
|
||||
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (!e || e->val != key) {
|
||||
err = 4;
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < 128; ++i) {
|
||||
key = i;
|
||||
err = bpf_map_delete_elem(&rhmap, &key);
|
||||
if (err)
|
||||
return 3;
|
||||
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (e) {
|
||||
err = 5;
|
||||
return 5;
|
||||
}
|
||||
}
|
||||
|
||||
err = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
int test_rhash_update_exist(void *ctx)
|
||||
{
|
||||
int key = 10;
|
||||
struct elem val1 = {.val = 100, .arr = {0}};
|
||||
struct elem val2 = {.val = 200, .arr = {0}};
|
||||
struct elem *e;
|
||||
int ret;
|
||||
|
||||
err = 1;
|
||||
|
||||
/* BPF_EXIST on non-existent key should fail with -ENOENT */
|
||||
ret = bpf_map_update_elem(&rhmap, &key, &val1, BPF_EXIST);
|
||||
if (ret != -ENOENT)
|
||||
return 1;
|
||||
|
||||
/* Insert element first */
|
||||
ret = bpf_map_update_elem(&rhmap, &key, &val1, BPF_NOEXIST);
|
||||
if (ret)
|
||||
return 2;
|
||||
|
||||
/* Verify initial value */
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (!e || e->val != 100)
|
||||
return 3;
|
||||
|
||||
/* BPF_EXIST on existing key should succeed and update value */
|
||||
ret = bpf_map_update_elem(&rhmap, &key, &val2, BPF_EXIST);
|
||||
if (ret)
|
||||
return 4;
|
||||
|
||||
/* Verify value was updated */
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (!e || e->val != 200)
|
||||
return 5;
|
||||
|
||||
/* Cleanup */
|
||||
bpf_map_delete_elem(&rhmap, &key);
|
||||
err = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
int test_rhash_update_any(void *ctx)
|
||||
{
|
||||
int key = 11;
|
||||
struct elem val1 = {.val = 111, .arr = {0}};
|
||||
struct elem val2 = {.val = 222, .arr = {0}};
|
||||
struct elem *e;
|
||||
int ret;
|
||||
|
||||
err = 1;
|
||||
|
||||
/* BPF_ANY on non-existent key should insert */
|
||||
ret = bpf_map_update_elem(&rhmap, &key, &val1, BPF_ANY);
|
||||
if (ret)
|
||||
return 1;
|
||||
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (!e || e->val != 111)
|
||||
return 2;
|
||||
|
||||
/* BPF_ANY on existing key should update */
|
||||
ret = bpf_map_update_elem(&rhmap, &key, &val2, BPF_ANY);
|
||||
if (ret)
|
||||
return 3;
|
||||
|
||||
e = bpf_map_lookup_elem(&rhmap, &key);
|
||||
if (!e || e->val != 222)
|
||||
return 4;
|
||||
|
||||
/* Cleanup */
|
||||
bpf_map_delete_elem(&rhmap, &key);
|
||||
err = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
int test_rhash_noexist_duplicate(void *ctx)
|
||||
{
|
||||
int key = 12;
|
||||
struct elem val = {.val = 600, .arr = {0}};
|
||||
int ret;
|
||||
|
||||
err = 1;
|
||||
|
||||
/* Insert element */
|
||||
ret = bpf_map_update_elem(&rhmap, &key, &val, BPF_NOEXIST);
|
||||
if (ret)
|
||||
return 1;
|
||||
|
||||
/* Try to insert again with BPF_NOEXIST - should fail with -EEXIST */
|
||||
ret = bpf_map_update_elem(&rhmap, &key, &val, BPF_NOEXIST);
|
||||
if (ret != -EEXIST)
|
||||
return 2;
|
||||
|
||||
/* Cleanup */
|
||||
bpf_map_delete_elem(&rhmap, &key);
|
||||
err = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
int test_rhash_delete_nonexistent(void *ctx)
|
||||
{
|
||||
int key = 99999;
|
||||
int ret;
|
||||
|
||||
err = 1;
|
||||
|
||||
/* Delete non-existent key should return -ENOENT */
|
||||
ret = bpf_map_delete_elem(&rhmap, &key);
|
||||
if (ret != -ENOENT)
|
||||
return 1;
|
||||
|
||||
err = 0;
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user