Commit 147c6930 authored by Jiri Olsa's avatar Jiri Olsa Committed by Andrii Nakryiko
Browse files

selftests/bpf: Add link_info test for uprobe_multi link 



Adding fill_link_info test for uprobe_multi link.

Setting up uprobes with bogus ref_ctr_offsets and cookie values
to test all the bpf_link_info::uprobe_multi fields.

Signed-off-by: default avatarJiri Olsa <jolsa@kernel.org>
Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
Acked-by: default avatarSong Liu <song@kernel.org>
Acked-by: default avatarYonghong Song <yonghong.song@linux.dev>
Link: https://lore.kernel.org/bpf/20231125193130.834322-6-jolsa@kernel.org
parent 17036128

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

+198 −0
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ 
#include <test_progs.h>

#include "trace_helpers.h"

#include "test_fill_link_info.skel.h"

#include "bpf/libbpf_internal.h"



#define TP_CAT "sched"

#define TP_NAME "sched_switch"
@@ -300,6 +301,196 @@ static void test_kprobe_multi_fill_link_info(struct test_fill_link_info *skel, 
	bpf_link__destroy(link);

}



#define SEC(name) __attribute__((section(name), used))



static short uprobe_link_info_sema_1 SEC(".probes");

static short uprobe_link_info_sema_2 SEC(".probes");

static short uprobe_link_info_sema_3 SEC(".probes");



noinline void uprobe_link_info_func_1(void)

{

	asm volatile ("");

	uprobe_link_info_sema_1++;

}



noinline void uprobe_link_info_func_2(void)

{

	asm volatile ("");

	uprobe_link_info_sema_2++;

}



noinline void uprobe_link_info_func_3(void)

{

	asm volatile ("");

	uprobe_link_info_sema_3++;

}



static int

verify_umulti_link_info(int fd, bool retprobe, __u64 *offsets,

			__u64 *cookies, __u64 *ref_ctr_offsets)

{

	char path[PATH_MAX], path_buf[PATH_MAX];

	struct bpf_link_info info;

	__u32 len = sizeof(info);

	__u64 ref_ctr_offsets_buf[3];

	__u64 offsets_buf[3];

	__u64 cookies_buf[3];

	int i, err, bit;

	__u32 count = 0;



	memset(path, 0, sizeof(path));

	err = readlink("/proc/self/exe", path, sizeof(path));

	if (!ASSERT_NEQ(err, -1, "readlink"))

		return -1;



	for (bit = 0; bit < 8; bit++) {

		memset(&info, 0, sizeof(info));

		info.uprobe_multi.path = ptr_to_u64(path_buf);

		info.uprobe_multi.path_size = sizeof(path_buf);

		info.uprobe_multi.count = count;



		if (bit & 0x1)

			info.uprobe_multi.offsets = ptr_to_u64(offsets_buf);

		if (bit & 0x2)

			info.uprobe_multi.cookies = ptr_to_u64(cookies_buf);

		if (bit & 0x4)

			info.uprobe_multi.ref_ctr_offsets = ptr_to_u64(ref_ctr_offsets_buf);



		err = bpf_link_get_info_by_fd(fd, &info, &len);

		if (!ASSERT_OK(err, "bpf_link_get_info_by_fd"))

			return -1;



		if (!ASSERT_EQ(info.type, BPF_LINK_TYPE_UPROBE_MULTI, "info.type"))

			return -1;



		ASSERT_EQ(info.uprobe_multi.pid, getpid(), "info.uprobe_multi.pid");

		ASSERT_EQ(info.uprobe_multi.count, 3, "info.uprobe_multi.count");

		ASSERT_EQ(info.uprobe_multi.flags & BPF_F_KPROBE_MULTI_RETURN,

			  retprobe, "info.uprobe_multi.flags.retprobe");

		ASSERT_EQ(info.uprobe_multi.path_size, strlen(path) + 1, "info.uprobe_multi.path_size");

		ASSERT_STREQ(path_buf, path, "info.uprobe_multi.path");



		for (i = 0; i < info.uprobe_multi.count; i++) {

			if (info.uprobe_multi.offsets)

				ASSERT_EQ(offsets_buf[i], offsets[i], "info.uprobe_multi.offsets");

			if (info.uprobe_multi.cookies)

				ASSERT_EQ(cookies_buf[i], cookies[i], "info.uprobe_multi.cookies");

			if (info.uprobe_multi.ref_ctr_offsets) {

				ASSERT_EQ(ref_ctr_offsets_buf[i], ref_ctr_offsets[i],

					  "info.uprobe_multi.ref_ctr_offsets");

			}

		}

		count = count ?: info.uprobe_multi.count;

	}



	return 0;

}



static void verify_umulti_invalid_user_buffer(int fd)

{

	struct bpf_link_info info;

	__u32 len = sizeof(info);

	__u64 buf[3];

	int err;



	/* upath_size defined, not path */

	memset(&info, 0, sizeof(info));

	info.uprobe_multi.path_size = 3;

	err = bpf_link_get_info_by_fd(fd, &info, &len);

	ASSERT_EQ(err, -EINVAL, "failed_upath_size");



	/* path defined, but small */

	memset(&info, 0, sizeof(info));

	info.uprobe_multi.path = ptr_to_u64(buf);

	info.uprobe_multi.path_size = 3;

	err = bpf_link_get_info_by_fd(fd, &info, &len);

	ASSERT_LT(err, 0, "failed_upath_small");



	/* path has wrong pointer */

	memset(&info, 0, sizeof(info));

	info.uprobe_multi.path_size = PATH_MAX;

	info.uprobe_multi.path = 123;

	err = bpf_link_get_info_by_fd(fd, &info, &len);

	ASSERT_EQ(err, -EFAULT, "failed_bad_path_ptr");



	/* count zero, with offsets */

	memset(&info, 0, sizeof(info));

	info.uprobe_multi.offsets = ptr_to_u64(buf);

	err = bpf_link_get_info_by_fd(fd, &info, &len);

	ASSERT_EQ(err, -EINVAL, "failed_count");



	/* offsets not big enough */

	memset(&info, 0, sizeof(info));

	info.uprobe_multi.offsets = ptr_to_u64(buf);

	info.uprobe_multi.count = 2;

	err = bpf_link_get_info_by_fd(fd, &info, &len);

	ASSERT_EQ(err, -ENOSPC, "failed_small_count");



	/* offsets has wrong pointer */

	memset(&info, 0, sizeof(info));

	info.uprobe_multi.offsets = 123;

	info.uprobe_multi.count = 3;

	err = bpf_link_get_info_by_fd(fd, &info, &len);

	ASSERT_EQ(err, -EFAULT, "failed_wrong_offsets");

}



static void test_uprobe_multi_fill_link_info(struct test_fill_link_info *skel,

					     bool retprobe, bool invalid)

{

	LIBBPF_OPTS(bpf_uprobe_multi_opts, opts,

		.retprobe = retprobe,

	);

	const char *syms[3] = {

		"uprobe_link_info_func_1",

		"uprobe_link_info_func_2",

		"uprobe_link_info_func_3",

	};

	__u64 cookies[3] = {

		0xdead,

		0xbeef,

		0xcafe,

	};

	const char *sema[3] = {

		"uprobe_link_info_sema_1",

		"uprobe_link_info_sema_2",

		"uprobe_link_info_sema_3",

	};

	__u64 *offsets = NULL, *ref_ctr_offsets;

	struct bpf_link *link;

	int link_fd, err;



	err = elf_resolve_syms_offsets("/proc/self/exe", 3, sema,

				       (unsigned long **) &ref_ctr_offsets, STT_OBJECT);

	if (!ASSERT_OK(err, "elf_resolve_syms_offsets_object"))

		return;



	err = elf_resolve_syms_offsets("/proc/self/exe", 3, syms,

				       (unsigned long **) &offsets, STT_FUNC);

	if (!ASSERT_OK(err, "elf_resolve_syms_offsets_func"))

		goto out;



	opts.syms = syms;

	opts.cookies = &cookies[0];

	opts.ref_ctr_offsets = (unsigned long *) &ref_ctr_offsets[0];

	opts.cnt = ARRAY_SIZE(syms);



	link = bpf_program__attach_uprobe_multi(skel->progs.umulti_run, 0,

						"/proc/self/exe", NULL, &opts);

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

		goto out;



	link_fd = bpf_link__fd(link);

	if (invalid)

		verify_umulti_invalid_user_buffer(link_fd);

	else

		verify_umulti_link_info(link_fd, retprobe, offsets, cookies, ref_ctr_offsets);



	bpf_link__destroy(link);

out:

	free(ref_ctr_offsets);

	free(offsets);

}



void test_fill_link_info(void)

{

	struct test_fill_link_info *skel;
@@ -339,6 +530,13 @@ void test_fill_link_info(void) 
	if (test__start_subtest("kprobe_multi_invalid_ubuff"))

		test_kprobe_multi_fill_link_info(skel, true, true);



	if (test__start_subtest("uprobe_multi_link_info"))

		test_uprobe_multi_fill_link_info(skel, false, false);

	if (test__start_subtest("uretprobe_multi_link_info"))

		test_uprobe_multi_fill_link_info(skel, true, false);

	if (test__start_subtest("uprobe_multi_invalid"))

		test_uprobe_multi_fill_link_info(skel, false, true);



cleanup:

	test_fill_link_info__destroy(skel);

}

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

+6 −0
Original line number Diff line number Diff line
@@ -39,4 +39,10 @@ int BPF_PROG(kmulti_run) 
	return 0;

}



SEC("uprobe.multi")

int BPF_PROG(umulti_run)

{

	return 0;

}



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