Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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}