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 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 127 static 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 152 static 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 186 static 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 204 static 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 233 error: 234 close(pfd); 235 } 236 237 static 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 260 static 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 269 again: 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 297 static 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 351 static 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 359 static 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 387 static short uprobe_link_info_sema_1 SEC(".probes"); 388 static short uprobe_link_info_sema_2 SEC(".probes"); 389 static short uprobe_link_info_sema_3 SEC(".probes"); 390 391 noinline void uprobe_link_info_func_1(void) 392 { 393 asm volatile (""); 394 uprobe_link_info_sema_1++; 395 } 396 397 noinline void uprobe_link_info_func_2(void) 398 { 399 asm volatile (""); 400 uprobe_link_info_sema_2++; 401 } 402 403 noinline void uprobe_link_info_func_3(void) 404 { 405 asm volatile (""); 406 uprobe_link_info_sema_3++; 407 } 408 409 static int 410 verify_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 479 static 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 527 static 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); 579 out: 580 free(ref_ctr_offsets); 581 free(offsets); 582 } 583 584 void 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 636 cleanup: 637 test_fill_link_info__destroy(skel); 638 } 639