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