fill_link_info.c

  1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright (C) 2023 Yafang Shao <laoar.shao@gmail.com> */
  3
  4#include <string.h>
  5#include <linux/bpf.h>
  6#include <linux/limits.h>
  7#include <test_progs.h>
  8#include "trace_helpers.h"
  9#include "test_fill_link_info.skel.h"
 10#include "bpf/libbpf_internal.h"
 11
 12#define TP_CAT "sched"
 13#define TP_NAME "sched_switch"
 14
 15static const char *kmulti_syms[] = {
 16	"bpf_fentry_test2",
 17	"bpf_fentry_test1",
 18	"bpf_fentry_test3",
 19};
 20#define KMULTI_CNT ARRAY_SIZE(kmulti_syms)
 21static __u64 kmulti_addrs[KMULTI_CNT];
 22static __u64 kmulti_cookies[] = { 3, 1, 2 };
 23
 24#define KPROBE_FUNC "bpf_fentry_test1"
 25static __u64 kprobe_addr;
 26
 27#define UPROBE_FILE "/proc/self/exe"
 28static ssize_t uprobe_offset;
 29/* uprobe attach point */
 30static noinline void uprobe_func(void)
 31{
 32	asm volatile ("");
 33}
 34
 35#define PERF_EVENT_COOKIE 0xdeadbeef
 36
 37static int verify_perf_link_info(int fd, enum bpf_perf_event_type type, long addr,
 38				 ssize_t offset, ssize_t entry_offset)
 39{
 40	ssize_t ref_ctr_offset = entry_offset /* ref_ctr_offset for uprobes */;
 41	struct bpf_link_info info;
 42	__u32 len = sizeof(info);
 43	char buf[PATH_MAX];
 44	int err;
 45
 46	memset(&info, 0, sizeof(info));
 47	buf[0] = '\0';
 48
 49again:
 50	err = bpf_link_get_info_by_fd(fd, &info, &len);
 51	if (!ASSERT_OK(err, "get_link_info"))
 52		return -1;
 53
 54	if (!ASSERT_EQ(info.type, BPF_LINK_TYPE_PERF_EVENT, "link_type"))
 55		return -1;
 56	if (!ASSERT_EQ(info.perf_event.type, type, "perf_type_match"))
 57		return -1;
 58
 59	switch (info.perf_event.type) {
 60	case BPF_PERF_EVENT_KPROBE:
 61	case BPF_PERF_EVENT_KRETPROBE:
 62		ASSERT_EQ(info.perf_event.kprobe.offset, offset, "kprobe_offset");
 63
 64		/* In case kernel.kptr_restrict is not permitted or MAX_SYMS is reached */
 65		if (addr)
 66			ASSERT_EQ(info.perf_event.kprobe.addr, addr + entry_offset,
 67				  "kprobe_addr");
 68
 69		ASSERT_EQ(info.perf_event.kprobe.cookie, PERF_EVENT_COOKIE, "kprobe_cookie");
 70
 71		ASSERT_EQ(info.perf_event.kprobe.name_len, strlen(KPROBE_FUNC) + 1,
 72				  "name_len");
 73		if (!info.perf_event.kprobe.func_name) {
 74			info.perf_event.kprobe.func_name = ptr_to_u64(&buf);
 75			info.perf_event.kprobe.name_len = sizeof(buf);
 76			goto again;
 77		}
 78
 79		err = strncmp(u64_to_ptr(info.perf_event.kprobe.func_name), KPROBE_FUNC,
 80			      strlen(KPROBE_FUNC));
 81		ASSERT_EQ(err, 0, "cmp_kprobe_func_name");
 82		break;
 83	case BPF_PERF_EVENT_TRACEPOINT:
 84		ASSERT_EQ(info.perf_event.tracepoint.name_len, strlen(TP_NAME) + 1,
 85				  "name_len");
 86		if (!info.perf_event.tracepoint.tp_name) {
 87			info.perf_event.tracepoint.tp_name = ptr_to_u64(&buf);
 88			info.perf_event.tracepoint.name_len = sizeof(buf);
 89			goto again;
 90		}
 91
 92		ASSERT_EQ(info.perf_event.tracepoint.cookie, PERF_EVENT_COOKIE, "tracepoint_cookie");
 93
 94		err = strncmp(u64_to_ptr(info.perf_event.tracepoint.tp_name), TP_NAME,
 95			      strlen(TP_NAME));
 96		ASSERT_EQ(err, 0, "cmp_tp_name");
 97		break;
 98	case BPF_PERF_EVENT_UPROBE:
 99	case BPF_PERF_EVENT_URETPROBE:
100		ASSERT_EQ(info.perf_event.uprobe.offset, offset, "uprobe_offset");
101		ASSERT_EQ(info.perf_event.uprobe.ref_ctr_offset, ref_ctr_offset, "uprobe_ref_ctr_offset");
102
103		ASSERT_EQ(info.perf_event.uprobe.name_len, strlen(UPROBE_FILE) + 1,
104				  "name_len");
105		if (!info.perf_event.uprobe.file_name) {
106			info.perf_event.uprobe.file_name = ptr_to_u64(&buf);
107			info.perf_event.uprobe.name_len = sizeof(buf);
108			goto again;
109		}
110
111		ASSERT_EQ(info.perf_event.uprobe.cookie, PERF_EVENT_COOKIE, "uprobe_cookie");
112
113		err = strncmp(u64_to_ptr(info.perf_event.uprobe.file_name), UPROBE_FILE,
114			      strlen(UPROBE_FILE));
115			ASSERT_EQ(err, 0, "cmp_file_name");
116		break;
117	case BPF_PERF_EVENT_EVENT:
118		ASSERT_EQ(info.perf_event.event.type, PERF_TYPE_SOFTWARE, "event_type");
119		ASSERT_EQ(info.perf_event.event.config, PERF_COUNT_SW_PAGE_FAULTS, "event_config");
120		ASSERT_EQ(info.perf_event.event.cookie, PERF_EVENT_COOKIE, "event_cookie");
121		break;
122	default:
123		err = -1;
124		break;
125	}
126	return err;
127}
128
129static void kprobe_fill_invalid_user_buffer(int fd)
130{
131	struct bpf_link_info info;
132	__u32 len = sizeof(info);
133	int err;
134
135	memset(&info, 0, sizeof(info));
136
137	info.perf_event.kprobe.func_name = 0x1; /* invalid address */
138	err = bpf_link_get_info_by_fd(fd, &info, &len);
139	ASSERT_EQ(err, -EINVAL, "invalid_buff_and_len");
140
141	info.perf_event.kprobe.name_len = 64;
142	err = bpf_link_get_info_by_fd(fd, &info, &len);
143	ASSERT_EQ(err, -EFAULT, "invalid_buff");
144
145	info.perf_event.kprobe.func_name = 0;
146	err = bpf_link_get_info_by_fd(fd, &info, &len);
147	ASSERT_EQ(err, -EINVAL, "invalid_len");
148
149	ASSERT_EQ(info.perf_event.kprobe.addr, 0, "func_addr");
150	ASSERT_EQ(info.perf_event.kprobe.offset, 0, "func_offset");
151	ASSERT_EQ(info.perf_event.type, 0, "type");
152}
153
154static void test_kprobe_fill_link_info(struct test_fill_link_info *skel,
155				       enum bpf_perf_event_type type,
156				       bool invalid)
157{
158	DECLARE_LIBBPF_OPTS(bpf_kprobe_opts, opts,
159		.attach_mode = PROBE_ATTACH_MODE_LINK,
160		.retprobe = type == BPF_PERF_EVENT_KRETPROBE,
161		.bpf_cookie = PERF_EVENT_COOKIE,
162	);
163	ssize_t entry_offset = 0;
164	struct bpf_link *link;
165	int link_fd, err;
166
167	link = bpf_program__attach_kprobe_opts(skel->progs.kprobe_run, KPROBE_FUNC, &opts);
168	if (!ASSERT_OK_PTR(link, "attach_kprobe"))
169		return;
170
171	link_fd = bpf_link__fd(link);
172	if (!invalid) {
173		/* See also arch_adjust_kprobe_addr(). */
174		if (skel->kconfig->CONFIG_X86_KERNEL_IBT)
175			entry_offset = 4;
176		if (skel->kconfig->CONFIG_PPC64 &&
177		    skel->kconfig->CONFIG_KPROBES_ON_FTRACE &&
178		    !skel->kconfig->CONFIG_PPC_FTRACE_OUT_OF_LINE)
179			entry_offset = 4;
180		err = verify_perf_link_info(link_fd, type, kprobe_addr, 0, entry_offset);
181		ASSERT_OK(err, "verify_perf_link_info");
182	} else {
183		kprobe_fill_invalid_user_buffer(link_fd);
184	}
185	bpf_link__destroy(link);
186}
187
188static void test_tp_fill_link_info(struct test_fill_link_info *skel)
189{
190	DECLARE_LIBBPF_OPTS(bpf_tracepoint_opts, opts,
191		.bpf_cookie = PERF_EVENT_COOKIE,
192	);
193	struct bpf_link *link;
194	int link_fd, err;
195
196	link = bpf_program__attach_tracepoint_opts(skel->progs.tp_run, TP_CAT, TP_NAME, &opts);
197	if (!ASSERT_OK_PTR(link, "attach_tp"))
198		return;
199
200	link_fd = bpf_link__fd(link);
201	err = verify_perf_link_info(link_fd, BPF_PERF_EVENT_TRACEPOINT, 0, 0, 0);
202	ASSERT_OK(err, "verify_perf_link_info");
203	bpf_link__destroy(link);
204}
205
206static void test_event_fill_link_info(struct test_fill_link_info *skel)
207{
208	DECLARE_LIBBPF_OPTS(bpf_perf_event_opts, opts,
209		.bpf_cookie = PERF_EVENT_COOKIE,
210	);
211	struct bpf_link *link;
212	int link_fd, err, pfd;
213	struct perf_event_attr attr = {
214		.type = PERF_TYPE_SOFTWARE,
215		.config = PERF_COUNT_SW_PAGE_FAULTS,
216		.freq = 1,
217		.sample_freq = 1,
218		.size = sizeof(struct perf_event_attr),
219	};
220
221	pfd = syscall(__NR_perf_event_open, &attr, -1 /* pid */, 0 /* cpu 0 */,
222		      -1 /* group id */, 0 /* flags */);
223	if (!ASSERT_GE(pfd, 0, "perf_event_open"))
224		return;
225
226	link = bpf_program__attach_perf_event_opts(skel->progs.event_run, pfd, &opts);
227	if (!ASSERT_OK_PTR(link, "attach_event"))
228		goto error;
229
230	link_fd = bpf_link__fd(link);
231	err = verify_perf_link_info(link_fd, BPF_PERF_EVENT_EVENT, 0, 0, 0);
232	ASSERT_OK(err, "verify_perf_link_info");
233	bpf_link__destroy(link);
234
235error:
236	close(pfd);
237}
238
239static void test_uprobe_fill_link_info(struct test_fill_link_info *skel,
240				       enum bpf_perf_event_type type)
241{
242	DECLARE_LIBBPF_OPTS(bpf_uprobe_opts, opts,
243		.retprobe = type == BPF_PERF_EVENT_URETPROBE,
244		.bpf_cookie = PERF_EVENT_COOKIE,
245	);
246	const char *sema[1] = {
247		"uprobe_link_info_sema_1",
248	};
249	__u64 *ref_ctr_offset;
250	struct bpf_link *link;
251	int link_fd, err;
252
253	err = elf_resolve_syms_offsets("/proc/self/exe", 1, sema,
254				       (unsigned long **) &ref_ctr_offset, STT_OBJECT);
255	if (!ASSERT_OK(err, "elf_resolve_syms_offsets_object"))
256		return;
257
258	opts.ref_ctr_offset = *ref_ctr_offset;
259	link = bpf_program__attach_uprobe_opts(skel->progs.uprobe_run,
260					       0, /* self pid */
261					       UPROBE_FILE, uprobe_offset,
262					       &opts);
263	if (!ASSERT_OK_PTR(link, "attach_uprobe"))
264		goto out;
265
266	link_fd = bpf_link__fd(link);
267	err = verify_perf_link_info(link_fd, type, 0, uprobe_offset, *ref_ctr_offset);
268	ASSERT_OK(err, "verify_perf_link_info");
269	bpf_link__destroy(link);
270out:
271	free(ref_ctr_offset);
272}
273
274static int verify_kmulti_link_info(int fd, bool retprobe, bool has_cookies)
275{
276	__u64 addrs[KMULTI_CNT], cookies[KMULTI_CNT];
277	struct bpf_link_info info;
278	__u32 len = sizeof(info);
279	int flags, i, err;
280
281	memset(&info, 0, sizeof(info));
282
283again:
284	err = bpf_link_get_info_by_fd(fd, &info, &len);
285	if (!ASSERT_OK(err, "get_link_info"))
286		return -1;
287
288	if (!ASSERT_EQ(info.type, BPF_LINK_TYPE_KPROBE_MULTI, "kmulti_type"))
289		return -1;
290
291	ASSERT_EQ(info.kprobe_multi.count, KMULTI_CNT, "func_cnt");
292	flags = info.kprobe_multi.flags & BPF_F_KPROBE_MULTI_RETURN;
293	if (!retprobe)
294		ASSERT_EQ(flags, 0, "kmulti_flags");
295	else
296		ASSERT_NEQ(flags, 0, "kretmulti_flags");
297
298	if (!info.kprobe_multi.addrs) {
299		info.kprobe_multi.addrs = ptr_to_u64(addrs);
300		info.kprobe_multi.cookies = ptr_to_u64(cookies);
301		goto again;
302	}
303	for (i = 0; i < KMULTI_CNT; i++) {
304		ASSERT_EQ(addrs[i], kmulti_addrs[i], "kmulti_addrs");
305		ASSERT_EQ(cookies[i], has_cookies ? kmulti_cookies[i] : 0,
306			  "kmulti_cookies_value");
307	}
308	return 0;
309}
310
311static void verify_kmulti_invalid_user_buffer(int fd)
312{
313	__u64 addrs[KMULTI_CNT], cookies[KMULTI_CNT];
314	struct bpf_link_info info;
315	__u32 len = sizeof(info);
316	int err, i;
317
318	memset(&info, 0, sizeof(info));
319
320	info.kprobe_multi.count = KMULTI_CNT;
321	err = bpf_link_get_info_by_fd(fd, &info, &len);
322	ASSERT_EQ(err, -EINVAL, "no_addr");
323
324	info.kprobe_multi.addrs = ptr_to_u64(addrs);
325	info.kprobe_multi.count = 0;
326	err = bpf_link_get_info_by_fd(fd, &info, &len);
327	ASSERT_EQ(err, -EINVAL, "no_cnt");
328
329	for (i = 0; i < KMULTI_CNT; i++)
330		addrs[i] = 0;
331	info.kprobe_multi.count = KMULTI_CNT - 1;
332	err = bpf_link_get_info_by_fd(fd, &info, &len);
333	ASSERT_EQ(err, -ENOSPC, "smaller_cnt");
334	for (i = 0; i < KMULTI_CNT - 1; i++)
335		ASSERT_EQ(addrs[i], kmulti_addrs[i], "kmulti_addrs");
336	ASSERT_EQ(addrs[i], 0, "kmulti_addrs");
337
338	for (i = 0; i < KMULTI_CNT; i++)
339		addrs[i] = 0;
340	info.kprobe_multi.count = KMULTI_CNT + 1;
341	err = bpf_link_get_info_by_fd(fd, &info, &len);
342	ASSERT_EQ(err, 0, "bigger_cnt");
343	for (i = 0; i < KMULTI_CNT; i++)
344		ASSERT_EQ(addrs[i], kmulti_addrs[i], "kmulti_addrs");
345
346	info.kprobe_multi.count = KMULTI_CNT;
347	info.kprobe_multi.addrs = 0x1; /* invalid addr */
348	err = bpf_link_get_info_by_fd(fd, &info, &len);
349	ASSERT_EQ(err, -EFAULT, "invalid_buff_addrs");
350
351	info.kprobe_multi.count = KMULTI_CNT;
352	info.kprobe_multi.addrs = ptr_to_u64(addrs);
353	info.kprobe_multi.cookies = 0x1; /* invalid addr */
354	err = bpf_link_get_info_by_fd(fd, &info, &len);
355	ASSERT_EQ(err, -EFAULT, "invalid_buff_cookies");
356
357	/* cookies && !count */
358	info.kprobe_multi.count = 0;
359	info.kprobe_multi.addrs = ptr_to_u64(NULL);
360	info.kprobe_multi.cookies = ptr_to_u64(cookies);
361	err = bpf_link_get_info_by_fd(fd, &info, &len);
362	ASSERT_EQ(err, -EINVAL, "invalid_cookies_count");
363}
364
365static int symbols_cmp_r(const void *a, const void *b)
366{
367	const char **str_a = (const char **) a;
368	const char **str_b = (const char **) b;
369
370	return strcmp(*str_a, *str_b);
371}
372
373static void test_kprobe_multi_fill_link_info(struct test_fill_link_info *skel,
374					     bool retprobe, bool cookies,
375					     bool invalid)
376{
377	LIBBPF_OPTS(bpf_kprobe_multi_opts, opts);
378	struct bpf_link *link;
379	int link_fd, err;
380
381	opts.syms = kmulti_syms;
382	opts.cookies = cookies ? kmulti_cookies : NULL;
383	opts.cnt = KMULTI_CNT;
384	opts.retprobe = retprobe;
385	link = bpf_program__attach_kprobe_multi_opts(skel->progs.kmulti_run, NULL, &opts);
386	if (!ASSERT_OK_PTR(link, "attach_kprobe_multi"))
387		return;
388
389	link_fd = bpf_link__fd(link);
390	if (!invalid) {
391		err = verify_kmulti_link_info(link_fd, retprobe, cookies);
392		ASSERT_OK(err, "verify_kmulti_link_info");
393	} else {
394		verify_kmulti_invalid_user_buffer(link_fd);
395	}
396	bpf_link__destroy(link);
397}
398
399#define SEC(name) __attribute__((section(name), used))
400
401static short uprobe_link_info_sema_1 SEC(".probes");
402static short uprobe_link_info_sema_2 SEC(".probes");
403static short uprobe_link_info_sema_3 SEC(".probes");
404
405noinline void uprobe_link_info_func_1(void)
406{
407	asm volatile ("");
408	uprobe_link_info_sema_1++;
409}
410
411noinline void uprobe_link_info_func_2(void)
412{
413	asm volatile ("");
414	uprobe_link_info_sema_2++;
415}
416
417noinline void uprobe_link_info_func_3(void)
418{
419	asm volatile ("");
420	uprobe_link_info_sema_3++;
421}
422
423static int
424verify_umulti_link_info(int fd, bool retprobe, __u64 *offsets,
425			__u64 *cookies, __u64 *ref_ctr_offsets)
426{
427	char path[PATH_MAX], path_buf[PATH_MAX];
428	struct bpf_link_info info;
429	__u32 len = sizeof(info);
430	__u64 ref_ctr_offsets_buf[3];
431	__u64 offsets_buf[3];
432	__u64 cookies_buf[3];
433	int i, err, bit;
434	__u32 count = 0;
435
436	memset(path, 0, sizeof(path));
437	err = readlink("/proc/self/exe", path, sizeof(path));
438	if (!ASSERT_NEQ(err, -1, "readlink"))
439		return -1;
440
441	memset(&info, 0, sizeof(info));
442	err = bpf_link_get_info_by_fd(fd, &info, &len);
443	if (!ASSERT_OK(err, "bpf_link_get_info_by_fd"))
444		return -1;
445
446	ASSERT_EQ(info.uprobe_multi.count, 3, "info.uprobe_multi.count");
447	ASSERT_EQ(info.uprobe_multi.path_size, strlen(path) + 1,
448		  "info.uprobe_multi.path_size");
449
450	for (bit = 0; bit < 8; bit++) {
451		memset(&info, 0, sizeof(info));
452		info.uprobe_multi.path = ptr_to_u64(path_buf);
453		info.uprobe_multi.path_size = sizeof(path_buf);
454		info.uprobe_multi.count = count;
455
456		if (bit & 0x1)
457			info.uprobe_multi.offsets = ptr_to_u64(offsets_buf);
458		if (bit & 0x2)
459			info.uprobe_multi.cookies = ptr_to_u64(cookies_buf);
460		if (bit & 0x4)
461			info.uprobe_multi.ref_ctr_offsets = ptr_to_u64(ref_ctr_offsets_buf);
462
463		err = bpf_link_get_info_by_fd(fd, &info, &len);
464		if (!ASSERT_OK(err, "bpf_link_get_info_by_fd"))
465			return -1;
466
467		if (!ASSERT_EQ(info.type, BPF_LINK_TYPE_UPROBE_MULTI, "info.type"))
468			return -1;
469
470		ASSERT_EQ(info.uprobe_multi.pid, getpid(), "info.uprobe_multi.pid");
471		ASSERT_EQ(info.uprobe_multi.count, 3, "info.uprobe_multi.count");
472		ASSERT_EQ(info.uprobe_multi.flags & BPF_F_KPROBE_MULTI_RETURN,
473			  retprobe, "info.uprobe_multi.flags.retprobe");
474		ASSERT_EQ(info.uprobe_multi.path_size, strlen(path) + 1, "info.uprobe_multi.path_size");
475		ASSERT_STREQ(path_buf, path, "info.uprobe_multi.path");
476
477		for (i = 0; i < info.uprobe_multi.count; i++) {
478			if (info.uprobe_multi.offsets)
479				ASSERT_EQ(offsets_buf[i], offsets[i], "info.uprobe_multi.offsets");
480			if (info.uprobe_multi.cookies)
481				ASSERT_EQ(cookies_buf[i], cookies[i], "info.uprobe_multi.cookies");
482			if (info.uprobe_multi.ref_ctr_offsets) {
483				ASSERT_EQ(ref_ctr_offsets_buf[i], ref_ctr_offsets[i],
484					  "info.uprobe_multi.ref_ctr_offsets");
485			}
486		}
487		count = count ?: info.uprobe_multi.count;
488	}
489
490	return 0;
491}
492
493static void verify_umulti_invalid_user_buffer(int fd)
494{
495	struct bpf_link_info info;
496	__u32 len = sizeof(info);
497	__u64 buf[3];
498	int err;
499
500	/* upath_size defined, not path */
501	memset(&info, 0, sizeof(info));
502	info.uprobe_multi.path_size = 3;
503	err = bpf_link_get_info_by_fd(fd, &info, &len);
504	ASSERT_EQ(err, -EINVAL, "failed_upath_size");
505
506	/* path defined, but small */
507	memset(&info, 0, sizeof(info));
508	info.uprobe_multi.path = ptr_to_u64(buf);
509	info.uprobe_multi.path_size = 3;
510	err = bpf_link_get_info_by_fd(fd, &info, &len);
511	ASSERT_LT(err, 0, "failed_upath_small");
512
513	/* path has wrong pointer */
514	memset(&info, 0, sizeof(info));
515	info.uprobe_multi.path_size = PATH_MAX;
516	info.uprobe_multi.path = 123;
517	err = bpf_link_get_info_by_fd(fd, &info, &len);
518	ASSERT_EQ(err, -EFAULT, "failed_bad_path_ptr");
519
520	/* count zero, with offsets */
521	memset(&info, 0, sizeof(info));
522	info.uprobe_multi.offsets = ptr_to_u64(buf);
523	err = bpf_link_get_info_by_fd(fd, &info, &len);
524	ASSERT_EQ(err, -EINVAL, "failed_count");
525
526	/* offsets not big enough */
527	memset(&info, 0, sizeof(info));
528	info.uprobe_multi.offsets = ptr_to_u64(buf);
529	info.uprobe_multi.count = 2;
530	err = bpf_link_get_info_by_fd(fd, &info, &len);
531	ASSERT_EQ(err, -ENOSPC, "failed_small_count");
532
533	/* offsets has wrong pointer */
534	memset(&info, 0, sizeof(info));
535	info.uprobe_multi.offsets = 123;
536	info.uprobe_multi.count = 3;
537	err = bpf_link_get_info_by_fd(fd, &info, &len);
538	ASSERT_EQ(err, -EFAULT, "failed_wrong_offsets");
539}
540
541static void test_uprobe_multi_fill_link_info(struct test_fill_link_info *skel,
542					     bool retprobe, bool invalid)
543{
544	LIBBPF_OPTS(bpf_uprobe_multi_opts, opts,
545		.retprobe = retprobe,
546	);
547	const char *syms[3] = {
548		"uprobe_link_info_func_1",
549		"uprobe_link_info_func_2",
550		"uprobe_link_info_func_3",
551	};
552	__u64 cookies[3] = {
553		0xdead,
554		0xbeef,
555		0xcafe,
556	};
557	const char *sema[3] = {
558		"uprobe_link_info_sema_1",
559		"uprobe_link_info_sema_2",
560		"uprobe_link_info_sema_3",
561	};
562	__u64 *offsets = NULL, *ref_ctr_offsets;
563	struct bpf_link *link;
564	int link_fd, err;
565
566	err = elf_resolve_syms_offsets("/proc/self/exe", 3, sema,
567				       (unsigned long **) &ref_ctr_offsets, STT_OBJECT);
568	if (!ASSERT_OK(err, "elf_resolve_syms_offsets_object"))
569		return;
570
571	err = elf_resolve_syms_offsets("/proc/self/exe", 3, syms,
572				       (unsigned long **) &offsets, STT_FUNC);
573	if (!ASSERT_OK(err, "elf_resolve_syms_offsets_func"))
574		goto out;
575
576	opts.syms = syms;
577	opts.cookies = &cookies[0];
578	opts.ref_ctr_offsets = (unsigned long *) &ref_ctr_offsets[0];
579	opts.cnt = ARRAY_SIZE(syms);
580
581	link = bpf_program__attach_uprobe_multi(skel->progs.umulti_run, 0,
582						"/proc/self/exe", NULL, &opts);
583	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_multi"))
584		goto out;
585
586	link_fd = bpf_link__fd(link);
587	if (invalid)
588		verify_umulti_invalid_user_buffer(link_fd);
589	else
590		verify_umulti_link_info(link_fd, retprobe, offsets, cookies, ref_ctr_offsets);
591
592	bpf_link__destroy(link);
593out:
594	free(ref_ctr_offsets);
595	free(offsets);
596}
597
598void test_fill_link_info(void)
599{
600	struct test_fill_link_info *skel;
601	int i;
602
603	skel = test_fill_link_info__open_and_load();
604	if (!ASSERT_OK_PTR(skel, "skel_open"))
605		return;
606
607	/* load kallsyms to compare the addr */
608	if (!ASSERT_OK(load_kallsyms(), "load_kallsyms"))
609		goto cleanup;
610
611	kprobe_addr = ksym_get_addr(KPROBE_FUNC);
612	if (test__start_subtest("kprobe_link_info"))
613		test_kprobe_fill_link_info(skel, BPF_PERF_EVENT_KPROBE, false);
614	if (test__start_subtest("kretprobe_link_info"))
615		test_kprobe_fill_link_info(skel, BPF_PERF_EVENT_KRETPROBE, false);
616	if (test__start_subtest("kprobe_invalid_ubuff"))
617		test_kprobe_fill_link_info(skel, BPF_PERF_EVENT_KPROBE, true);
618	if (test__start_subtest("tracepoint_link_info"))
619		test_tp_fill_link_info(skel);
620	if (test__start_subtest("event_link_info"))
621		test_event_fill_link_info(skel);
622
623	uprobe_offset = get_uprobe_offset(&uprobe_func);
624	if (test__start_subtest("uprobe_link_info"))
625		test_uprobe_fill_link_info(skel, BPF_PERF_EVENT_UPROBE);
626	if (test__start_subtest("uretprobe_link_info"))
627		test_uprobe_fill_link_info(skel, BPF_PERF_EVENT_URETPROBE);
628
629	qsort(kmulti_syms, KMULTI_CNT, sizeof(kmulti_syms[0]), symbols_cmp_r);
630	for (i = 0; i < KMULTI_CNT; i++)
631		kmulti_addrs[i] = ksym_get_addr(kmulti_syms[i]);
632	if (test__start_subtest("kprobe_multi_link_info")) {
633		test_kprobe_multi_fill_link_info(skel, false, false, false);
634		test_kprobe_multi_fill_link_info(skel, false, true, false);
635	}
636	if (test__start_subtest("kretprobe_multi_link_info")) {
637		test_kprobe_multi_fill_link_info(skel, true, false, false);
638		test_kprobe_multi_fill_link_info(skel, true, true, false);
639	}
640	if (test__start_subtest("kprobe_multi_invalid_ubuff"))
641		test_kprobe_multi_fill_link_info(skel, true, true, true);
642
643	if (test__start_subtest("uprobe_multi_link_info"))
644		test_uprobe_multi_fill_link_info(skel, false, false);
645	if (test__start_subtest("uretprobe_multi_link_info"))
646		test_uprobe_multi_fill_link_info(skel, true, false);
647	if (test__start_subtest("uprobe_multi_invalid"))
648		test_uprobe_multi_fill_link_info(skel, false, true);
649
650cleanup:
651	test_fill_link_info__destroy(skel);
652}