Loading...
Note: File does not exist in v5.9.
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}