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 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 49 again: 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 129 static 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 154 static 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 188 static 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 206 static 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 235 error: 236 close(pfd); 237 } 238 239 static 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); 270 out: 271 free(ref_ctr_offset); 272 } 273 274 static 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 283 again: 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 311 static 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 365 static 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 373 static 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 401 static short uprobe_link_info_sema_1 SEC(".probes"); 402 static short uprobe_link_info_sema_2 SEC(".probes"); 403 static short uprobe_link_info_sema_3 SEC(".probes"); 404 405 noinline void uprobe_link_info_func_1(void) 406 { 407 asm volatile (""); 408 uprobe_link_info_sema_1++; 409 } 410 411 noinline void uprobe_link_info_func_2(void) 412 { 413 asm volatile (""); 414 uprobe_link_info_sema_2++; 415 } 416 417 noinline void uprobe_link_info_func_3(void) 418 { 419 asm volatile (""); 420 uprobe_link_info_sema_3++; 421 } 422 423 static int 424 verify_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 493 static 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 541 static 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); 593 out: 594 free(ref_ctr_offsets); 595 free(offsets); 596 } 597 598 void 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 650 cleanup: 651 test_fill_link_info__destroy(skel); 652 } 653