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 15 static 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) 21 static __u64 kmulti_addrs[KMULTI_CNT]; 22 static __u64 kmulti_cookies[] = { 3, 1, 2 }; 23 24 #define KPROBE_FUNC "bpf_fentry_test1" 25 static __u64 kprobe_addr; 26 27 #define UPROBE_FILE "/proc/self/exe" 28 static ssize_t uprobe_offset; 29 /* uprobe attach point */ 30 static noinline void uprobe_func(void) 31 { 32 asm volatile (""); 33 } 34 35 #define PERF_EVENT_COOKIE 0xdeadbeef 36 37 static 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 48 again: 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 124 static 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 149 static 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 179 static 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 197 static 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 226 error: 227 close(pfd); 228 } 229 230 static 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 253 static 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 262 again: 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 290 static 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 344 static 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 352 static 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 380 static short uprobe_link_info_sema_1 SEC(".probes"); 381 static short uprobe_link_info_sema_2 SEC(".probes"); 382 static short uprobe_link_info_sema_3 SEC(".probes"); 383 384 noinline void uprobe_link_info_func_1(void) 385 { 386 asm volatile (""); 387 uprobe_link_info_sema_1++; 388 } 389 390 noinline void uprobe_link_info_func_2(void) 391 { 392 asm volatile (""); 393 uprobe_link_info_sema_2++; 394 } 395 396 noinline void uprobe_link_info_func_3(void) 397 { 398 asm volatile (""); 399 uprobe_link_info_sema_3++; 400 } 401 402 static int 403 verify_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 463 static 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 511 static 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); 563 out: 564 free(ref_ctr_offsets); 565 free(offsets); 566 } 567 568 void 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 620 cleanup: 621 test_fill_link_info__destroy(skel); 622 } 623