mirror of
https://github.com/raspberrypi/linux.git
synced 2025-12-14 13:59:51 +00:00
38d976c32d
The closing parentheses around the read syscall is misplaced, causing
single byte reads from the iterator instead of buf sized reads. While
the end result is the same, many more read calls than necessary are
performed.
$ tools/testing/selftests/bpf/vmtest.sh "./test_progs -t kmem_cache_iter"
145/1 kmem_cache_iter/check_task_struct:OK
145/2 kmem_cache_iter/check_slabinfo:OK
145/3 kmem_cache_iter/open_coded_iter:OK
145 kmem_cache_iter:OK
Summary: 1/3 PASSED, 0 SKIPPED, 0 FAILED
Fixes: a496d0cdc8 ("selftests/bpf: Add a test for kmem_cache_iter")
Signed-off-by: T.J. Mercier <tjmercier@google.com>
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
Acked-by: Song Liu <song@kernel.org>
Acked-by: Namhyung Kim <namhyung@kernel.org>
Link: https://patch.msgid.link/20250428180256.1482899-1-tjmercier@google.com
127 lines
3.3 KiB
C
127 lines
3.3 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* Copyright (c) 2024 Google */
|
|
|
|
#include <test_progs.h>
|
|
#include <bpf/libbpf.h>
|
|
#include <bpf/btf.h>
|
|
#include "kmem_cache_iter.skel.h"
|
|
|
|
#define SLAB_NAME_MAX 32
|
|
|
|
struct kmem_cache_result {
|
|
char name[SLAB_NAME_MAX];
|
|
long obj_size;
|
|
};
|
|
|
|
static void subtest_kmem_cache_iter_check_task_struct(struct kmem_cache_iter *skel)
|
|
{
|
|
LIBBPF_OPTS(bpf_test_run_opts, opts,
|
|
.flags = 0, /* Run it with the current task */
|
|
);
|
|
int prog_fd = bpf_program__fd(skel->progs.check_task_struct);
|
|
|
|
/* Get task_struct and check it if's from a slab cache */
|
|
ASSERT_OK(bpf_prog_test_run_opts(prog_fd, &opts), "prog_test_run");
|
|
|
|
/* The BPF program should set 'found' variable */
|
|
ASSERT_EQ(skel->bss->task_struct_found, 1, "task_struct_found");
|
|
}
|
|
|
|
static void subtest_kmem_cache_iter_check_slabinfo(struct kmem_cache_iter *skel)
|
|
{
|
|
FILE *fp;
|
|
int map_fd;
|
|
char name[SLAB_NAME_MAX];
|
|
unsigned long objsize;
|
|
char rest_of_line[1000];
|
|
struct kmem_cache_result r;
|
|
int seen = 0;
|
|
|
|
fp = fopen("/proc/slabinfo", "r");
|
|
if (fp == NULL) {
|
|
/* CONFIG_SLUB_DEBUG is not enabled */
|
|
return;
|
|
}
|
|
|
|
map_fd = bpf_map__fd(skel->maps.slab_result);
|
|
|
|
/* Ignore first two lines for header */
|
|
fscanf(fp, "slabinfo - version: %*d.%*d\n");
|
|
fscanf(fp, "# %*s %*s %*s %*s %*s %*s : %[^\n]\n", rest_of_line);
|
|
|
|
/* Compare name and objsize only - others can be changes frequently */
|
|
while (fscanf(fp, "%s %*u %*u %lu %*u %*u : %[^\n]\n",
|
|
name, &objsize, rest_of_line) == 3) {
|
|
int ret = bpf_map_lookup_elem(map_fd, &seen, &r);
|
|
|
|
if (!ASSERT_OK(ret, "kmem_cache_lookup"))
|
|
break;
|
|
|
|
ASSERT_STREQ(r.name, name, "kmem_cache_name");
|
|
ASSERT_EQ(r.obj_size, objsize, "kmem_cache_objsize");
|
|
|
|
seen++;
|
|
}
|
|
|
|
ASSERT_EQ(skel->bss->kmem_cache_seen, seen, "kmem_cache_seen_eq");
|
|
|
|
fclose(fp);
|
|
}
|
|
|
|
static void subtest_kmem_cache_iter_open_coded(struct kmem_cache_iter *skel)
|
|
{
|
|
LIBBPF_OPTS(bpf_test_run_opts, topts);
|
|
int err, fd;
|
|
|
|
/* No need to attach it, just run it directly */
|
|
fd = bpf_program__fd(skel->progs.open_coded_iter);
|
|
|
|
err = bpf_prog_test_run_opts(fd, &topts);
|
|
if (!ASSERT_OK(err, "test_run_opts err"))
|
|
return;
|
|
if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
|
|
return;
|
|
|
|
/* It should be same as we've seen from the explicit iterator */
|
|
ASSERT_EQ(skel->bss->open_coded_seen, skel->bss->kmem_cache_seen, "open_code_seen_eq");
|
|
}
|
|
|
|
void test_kmem_cache_iter(void)
|
|
{
|
|
struct kmem_cache_iter *skel = NULL;
|
|
char buf[256];
|
|
int iter_fd;
|
|
|
|
skel = kmem_cache_iter__open_and_load();
|
|
if (!ASSERT_OK_PTR(skel, "kmem_cache_iter__open_and_load"))
|
|
return;
|
|
|
|
if (!ASSERT_OK(kmem_cache_iter__attach(skel), "skel_attach"))
|
|
goto destroy;
|
|
|
|
iter_fd = bpf_iter_create(bpf_link__fd(skel->links.slab_info_collector));
|
|
if (!ASSERT_GE(iter_fd, 0, "iter_create"))
|
|
goto destroy;
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
while (read(iter_fd, buf, sizeof(buf)) > 0) {
|
|
/* Read out all contents */
|
|
printf("%s", buf);
|
|
}
|
|
|
|
/* Next reads should return 0 */
|
|
ASSERT_EQ(read(iter_fd, buf, sizeof(buf)), 0, "read");
|
|
|
|
if (test__start_subtest("check_task_struct"))
|
|
subtest_kmem_cache_iter_check_task_struct(skel);
|
|
if (test__start_subtest("check_slabinfo"))
|
|
subtest_kmem_cache_iter_check_slabinfo(skel);
|
|
if (test__start_subtest("open_coded_iter"))
|
|
subtest_kmem_cache_iter_open_coded(skel);
|
|
|
|
close(iter_fd);
|
|
|
|
destroy:
|
|
kmem_cache_iter__destroy(skel);
|
|
}
|