Commit 5b6c7e5c authored by Jiri Olsa's avatar Jiri Olsa Committed by Alexei Starovoitov
Browse files

selftests/bpf: Add attach bench test 



Adding test that reads all functions from ftrace available_filter_functions
file and attach them all through kprobe_multi API.

It also prints stats info with -v option, like on my setup:

  test_bench_attach: found 48712 functions
  test_bench_attach: attached in   1.069s
  test_bench_attach: detached in   0.373s

Acked-by: default avatarAndrii Nakryiko <andrii@kernel.org>
Signed-off-by: default avatarJiri Olsa <jolsa@kernel.org>
Link: https://lore.kernel.org/r/20220510122616.2652285-6-jolsa@kernel.org


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent 0236fec5

tools/testing/selftests/bpf/prog_tests/kprobe_multi_test.c

+143 −0
Original line number Diff line number Diff line
@@ -2,6 +2,9 @@ 
#include <test_progs.h>

#include "kprobe_multi.skel.h"

#include "trace_helpers.h"

#include "kprobe_multi_empty.skel.h"

#include "bpf/libbpf_internal.h"

#include "bpf/hashmap.h"



static void kprobe_multi_test_run(struct kprobe_multi *skel, bool test_return)

{
@@ -301,6 +304,144 @@ static void test_attach_api_fails(void) 
	kprobe_multi__destroy(skel);

}



static inline __u64 get_time_ns(void)

{

	struct timespec t;



	clock_gettime(CLOCK_MONOTONIC, &t);

	return (__u64) t.tv_sec * 1000000000 + t.tv_nsec;

}



static size_t symbol_hash(const void *key, void *ctx __maybe_unused)

{

	return str_hash((const char *) key);

}



static bool symbol_equal(const void *key1, const void *key2, void *ctx __maybe_unused)

{

	return strcmp((const char *) key1, (const char *) key2) == 0;

}



static int get_syms(char ***symsp, size_t *cntp)

{

	size_t cap = 0, cnt = 0, i;

	char *name, **syms = NULL;

	struct hashmap *map;

	char buf[256];

	FILE *f;

	int err;



	/*

	 * The available_filter_functions contains many duplicates,

	 * but other than that all symbols are usable in kprobe multi

	 * interface.

	 * Filtering out duplicates by using hashmap__add, which won't

	 * add existing entry.

	 */

	f = fopen("/sys/kernel/debug/tracing/available_filter_functions", "r");

	if (!f)

		return -EINVAL;



	map = hashmap__new(symbol_hash, symbol_equal, NULL);

	if (IS_ERR(map))

		goto error;



	while (fgets(buf, sizeof(buf), f)) {

		/* skip modules */

		if (strchr(buf, '['))

			continue;

		if (sscanf(buf, "%ms$*[^\n]\n", &name) != 1)

			continue;

		/*

		 * We attach to almost all kernel functions and some of them

		 * will cause 'suspicious RCU usage' when fprobe is attached

		 * to them. Filter out the current culprits - arch_cpu_idle

		 * and rcu_* functions.

		 */

		if (!strcmp(name, "arch_cpu_idle"))

			continue;

		if (!strncmp(name, "rcu_", 4))

			continue;

		err = hashmap__add(map, name, NULL);

		if (err) {

			free(name);

			if (err == -EEXIST)

				continue;

			goto error;

		}

		err = libbpf_ensure_mem((void **) &syms, &cap,

					sizeof(*syms), cnt + 1);

		if (err) {

			free(name);

			goto error;

		}

		syms[cnt] = name;

		cnt++;

	}



	*symsp = syms;

	*cntp = cnt;



error:

	fclose(f);

	hashmap__free(map);

	if (err) {

		for (i = 0; i < cnt; i++)

			free(syms[cnt]);

		free(syms);

	}

	return err;

}



static void test_bench_attach(void)

{

	LIBBPF_OPTS(bpf_kprobe_multi_opts, opts);

	struct kprobe_multi_empty *skel = NULL;

	long attach_start_ns, attach_end_ns;

	long detach_start_ns, detach_end_ns;

	double attach_delta, detach_delta;

	struct bpf_link *link = NULL;

	char **syms = NULL;

	size_t cnt, i;



	if (!ASSERT_OK(get_syms(&syms, &cnt), "get_syms"))

		return;



	skel = kprobe_multi_empty__open_and_load();

	if (!ASSERT_OK_PTR(skel, "kprobe_multi_empty__open_and_load"))

		goto cleanup;



	opts.syms = (const char **) syms;

	opts.cnt = cnt;



	attach_start_ns = get_time_ns();

	link = bpf_program__attach_kprobe_multi_opts(skel->progs.test_kprobe_empty,

						     NULL, &opts);

	attach_end_ns = get_time_ns();



	if (!ASSERT_OK_PTR(link, "bpf_program__attach_kprobe_multi_opts"))

		goto cleanup;



	detach_start_ns = get_time_ns();

	bpf_link__destroy(link);

	detach_end_ns = get_time_ns();



	attach_delta = (attach_end_ns - attach_start_ns) / 1000000000.0;

	detach_delta = (detach_end_ns - detach_start_ns) / 1000000000.0;



	printf("%s: found %lu functions\n", __func__, cnt);

	printf("%s: attached in %7.3lfs\n", __func__, attach_delta);

	printf("%s: detached in %7.3lfs\n", __func__, detach_delta);



cleanup:

	kprobe_multi_empty__destroy(skel);

	if (syms) {

		for (i = 0; i < cnt; i++)

			free(syms[i]);

		free(syms);

	}

}



void test_kprobe_multi_test(void)

{

	if (!ASSERT_OK(load_kallsyms(), "load_kallsyms"))
@@ -320,4 +461,6 @@ void test_kprobe_multi_test(void) 
		test_attach_api_syms();

	if (test__start_subtest("attach_api_fails"))

		test_attach_api_fails();

	if (test__start_subtest("bench_attach"))

		test_bench_attach();

}

tools/testing/selftests/bpf/progs/kprobe_multi_empty.c

0 → 100644
+12 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <linux/bpf.h>

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_tracing.h>



char _license[] SEC("license") = "GPL";



SEC("kprobe.multi/")

int test_kprobe_empty(struct pt_regs *ctx)

{

	return 0;

}