GitHub-Mirror/Star64_linux
2
0
Fork 0
mirror of https://github.com/Fishwaldo/Star64_linux.git synced 2025-07-10 08:33:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

bpf, selftests: Update array map tests for per-cpu batched ops

Browse source 
Follows the same logic as the hashtable tests.

Signed-off-by: Pedro Tammela <pctammela@mojatatu.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20210424214510.806627-3-pctammela@mojatatu.com
This commit is contained in:
Pedro Tammela 2021-04-24 18:45:10 -03:00 • committed by Daniel Borkmann
parent f008d732ab
commit 3733bfbbdd
1 changed files with 75 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

104
tools/testing/selftests/bpf/map_tests/array_map_batch_ops.c
View file

@ -9,10 +9,13 @@
#include <test_maps.h> #include <test_maps.h>
static int nr_cpus;
static void map_batch_update(int map_fd, __u32 max_entries, int *keys, static void map_batch_update(int map_fd, __u32 max_entries, int *keys,
int *values) __s64 *values, bool is_pcpu)
{ {
int i, err; int i, j, err;
int cpu_offset = 0;
DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts, DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts,
.elem_flags = 0, .elem_flags = 0,
.flags = 0, .flags = 0,
@ -20,22 +23,41 @@ static void map_batch_update(int map_fd, __u32 max_entries, int *keys,
for (i = 0; i < max_entries; i++) { for (i = 0; i < max_entries; i++) {
keys[i] = i; keys[i] = i;
values[i] = i + 1; if (is_pcpu) {
cpu_offset = i * nr_cpus;
for (j = 0; j < nr_cpus; j++)
(values + cpu_offset)[j] = i + 1 + j;
} else {
values[i] = i + 1;
}
} }
err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts); err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts);
CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno)); CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno));
} }
static void map_batch_verify(int *visited, __u32 max_entries, static void map_batch_verify(int *visited, __u32 max_entries, int *keys,
int *keys, int *values) __s64 *values, bool is_pcpu)
{ {
int i; int i, j;
int cpu_offset = 0;
memset(visited, 0, max_entries * sizeof(*visited)); memset(visited, 0, max_entries * sizeof(*visited));
for (i = 0; i < max_entries; i++) { for (i = 0; i < max_entries; i++) {
CHECK(keys[i] + 1 != values[i], "key/value checking", if (is_pcpu) {
"error: i %d key %d value %d\n", i, keys[i], values[i]); cpu_offset = i * nr_cpus;
for (j = 0; j < nr_cpus; j++) {
__s64 value = (values + cpu_offset)[j];
CHECK(keys[i] + j + 1 != value,
"key/value checking",
"error: i %d j %d key %d value %lld\n", i,
j, keys[i], value);
}
} else {
CHECK(keys[i] + 1 != values[i], "key/value checking",
"error: i %d key %d value %lld\n", i, keys[i],
values[i]);
}
visited[i] = 1; visited[i] = 1;
} }
for (i = 0; i < max_entries; i++) { for (i = 0; i < max_entries; i++) {
@ -44,19 +66,21 @@ static void map_batch_verify(int *visited, __u32 max_entries,
} }
} }
void test_array_map_batch_ops(void) static void __test_map_lookup_and_update_batch(bool is_pcpu)
{ {
struct bpf_create_map_attr xattr = { struct bpf_create_map_attr xattr = {
.name = "array_map", .name = "array_map",
.map_type = BPF_MAP_TYPE_ARRAY, .map_type = is_pcpu ? BPF_MAP_TYPE_PERCPU_ARRAY :
BPF_MAP_TYPE_ARRAY,
.key_size = sizeof(int), .key_size = sizeof(int),
.value_size = sizeof(int), .value_size = sizeof(__s64),
}; };
int map_fd, *keys, *values, *visited; int map_fd, *keys, *visited;
__u32 count, total, total_success; __u32 count, total, total_success;
const __u32 max_entries = 10; const __u32 max_entries = 10;
__u64 batch = 0; __u64 batch = 0;
int err, step; int err, step, value_size;
void *values;
DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts, DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts,
.elem_flags = 0, .elem_flags = 0,
.flags = 0, .flags = 0,
@ -67,22 +91,23 @@ void test_array_map_batch_ops(void)
CHECK(map_fd == -1, CHECK(map_fd == -1,
"bpf_create_map_xattr()", "error:%s\n", strerror(errno)); "bpf_create_map_xattr()", "error:%s\n", strerror(errno));
keys = malloc(max_entries * sizeof(int)); value_size = sizeof(__s64);
values = malloc(max_entries * sizeof(int)); if (is_pcpu)
visited = malloc(max_entries * sizeof(int)); value_size *= nr_cpus;
keys = calloc(max_entries, sizeof(*keys));
values = calloc(max_entries, value_size);
visited = calloc(max_entries, sizeof(*visited));
CHECK(!keys || !values || !visited, "malloc()", "error:%s\n", CHECK(!keys || !values || !visited, "malloc()", "error:%s\n",
strerror(errno)); strerror(errno));
/* populate elements to the map */
map_batch_update(map_fd, max_entries, keys, values);
/* test 1: lookup in a loop with various steps. */ /* test 1: lookup in a loop with various steps. */
total_success = 0; total_success = 0;
for (step = 1; step < max_entries; step++) { for (step = 1; step < max_entries; step++) {
map_batch_update(map_fd, max_entries, keys, values); map_batch_update(map_fd, max_entries, keys, values, is_pcpu);
map_batch_verify(visited, max_entries, keys, values); map_batch_verify(visited, max_entries, keys, values, is_pcpu);
memset(keys, 0, max_entries * sizeof(*keys)); memset(keys, 0, max_entries * sizeof(*keys));
memset(values, 0, max_entries * sizeof(*values)); memset(values, 0, max_entries * value_size);
batch = 0; batch = 0;
total = 0; total = 0;
/* iteratively lookup/delete elements with 'step' /* iteratively lookup/delete elements with 'step'
@ -91,10 +116,10 @@ void test_array_map_batch_ops(void)
count = step; count = step;
while (true) { while (true) {
err = bpf_map_lookup_batch(map_fd, err = bpf_map_lookup_batch(map_fd,
total ? &batch : NULL, &batch, total ? &batch : NULL,
keys + total, &batch, keys + total,
values + total, values + total * value_size,
&count, &opts); &count, &opts);
CHECK((err && errno != ENOENT), "lookup with steps", CHECK((err && errno != ENOENT), "lookup with steps",
"error: %s\n", strerror(errno)); "error: %s\n", strerror(errno));
@ -108,7 +133,7 @@ void test_array_map_batch_ops(void)
CHECK(total != max_entries, "lookup with steps", CHECK(total != max_entries, "lookup with steps",
"total = %u, max_entries = %u\n", total, max_entries); "total = %u, max_entries = %u\n", total, max_entries);
map_batch_verify(visited, max_entries, keys, values); map_batch_verify(visited, max_entries, keys, values, is_pcpu);
total_success++; total_success++;
} }
@ -116,9 +141,30 @@ void test_array_map_batch_ops(void)
CHECK(total_success == 0, "check total_success", CHECK(total_success == 0, "check total_success",
"unexpected failure\n"); "unexpected failure\n");
printf("%s:PASS\n", __func__);
free(keys); free(keys);
free(values); free(values);
free(visited); free(visited);
} }
static void array_map_batch_ops(void)
{
__test_map_lookup_and_update_batch(false);
printf("test_%s:PASS\n", __func__);
}
static void array_percpu_map_batch_ops(void)
{
__test_map_lookup_and_update_batch(true);
printf("test_%s:PASS\n", __func__);
}
void test_array_map_batch_ops(void)
{
nr_cpus = libbpf_num_possible_cpus();
CHECK(nr_cpus < 0, "nr_cpus checking",
"error: get possible cpus failed");
array_map_batch_ops();
array_percpu_map_batch_ops();
}