1// SPDX-License-Identifier: GPL-2.0 2 3#include <unistd.h> 4#include <test_progs.h> 5#include "uprobe_multi.skel.h" 6#include "uprobe_multi_bench.skel.h" 7#include "uprobe_multi_usdt.skel.h" 8#include "bpf/libbpf_internal.h" 9#include "testing_helpers.h" 10 11static char test_data[] = "test_data"; 12 13noinline void uprobe_multi_func_1(void) 14{ 15 asm volatile (""); 16} 17 18noinline void uprobe_multi_func_2(void) 19{ 20 asm volatile (""); 21} 22 23noinline void uprobe_multi_func_3(void) 24{ 25 asm volatile (""); 26} 27 28struct child { 29 int go[2]; 30 int pid; 31}; 32 33static void release_child(struct child *child) 34{ 35 int child_status; 36 37 if (!child) 38 return; 39 close(child->go[1]); 40 close(child->go[0]); 41 if (child->pid > 0) 42 waitpid(child->pid, &child_status, 0); 43} 44 45static void kick_child(struct child *child) 46{ 47 char c = 1; 48 49 if (child) { 50 write(child->go[1], &c, 1); 51 release_child(child); 52 } 53 fflush(NULL); 54} 55 56static struct child *spawn_child(void) 57{ 58 static struct child child; 59 int err; 60 int c; 61 62 /* pipe to notify child to execute the trigger functions */ 63 if (pipe(child.go)) 64 return NULL; 65 66 child.pid = fork(); 67 if (child.pid < 0) { 68 release_child(&child); 69 errno = EINVAL; 70 return NULL; 71 } 72 73 /* child */ 74 if (child.pid == 0) { 75 close(child.go[1]); 76 77 /* wait for parent's kick */ 78 err = read(child.go[0], &c, 1); 79 if (err != 1) 80 exit(err); 81 82 uprobe_multi_func_1(); 83 uprobe_multi_func_2(); 84 uprobe_multi_func_3(); 85 86 exit(errno); 87 } 88 89 return &child; 90} 91 92static void uprobe_multi_test_run(struct uprobe_multi *skel, struct child *child) 93{ 94 skel->bss->uprobe_multi_func_1_addr = (__u64) uprobe_multi_func_1; 95 skel->bss->uprobe_multi_func_2_addr = (__u64) uprobe_multi_func_2; 96 skel->bss->uprobe_multi_func_3_addr = (__u64) uprobe_multi_func_3; 97 98 skel->bss->user_ptr = test_data; 99 100 /* 101 * Disable pid check in bpf program if we are pid filter test, 102 * because the probe should be executed only by child->pid 103 * passed at the probe attach. 104 */ 105 skel->bss->pid = child ? 0 : getpid(); 106 107 if (child) 108 kick_child(child); 109 110 /* trigger all probes */ 111 uprobe_multi_func_1(); 112 uprobe_multi_func_2(); 113 uprobe_multi_func_3(); 114 115 /* 116 * There are 2 entry and 2 exit probe called for each uprobe_multi_func_[123] 117 * function and each slepable probe (6) increments uprobe_multi_sleep_result. 118 */ 119 ASSERT_EQ(skel->bss->uprobe_multi_func_1_result, 2, "uprobe_multi_func_1_result"); 120 ASSERT_EQ(skel->bss->uprobe_multi_func_2_result, 2, "uprobe_multi_func_2_result"); 121 ASSERT_EQ(skel->bss->uprobe_multi_func_3_result, 2, "uprobe_multi_func_3_result"); 122 123 ASSERT_EQ(skel->bss->uretprobe_multi_func_1_result, 2, "uretprobe_multi_func_1_result"); 124 ASSERT_EQ(skel->bss->uretprobe_multi_func_2_result, 2, "uretprobe_multi_func_2_result"); 125 ASSERT_EQ(skel->bss->uretprobe_multi_func_3_result, 2, "uretprobe_multi_func_3_result"); 126 127 ASSERT_EQ(skel->bss->uprobe_multi_sleep_result, 6, "uprobe_multi_sleep_result"); 128 129 if (child) 130 ASSERT_EQ(skel->bss->child_pid, child->pid, "uprobe_multi_child_pid"); 131} 132 133static void test_skel_api(void) 134{ 135 struct uprobe_multi *skel = NULL; 136 int err; 137 138 skel = uprobe_multi__open_and_load(); 139 if (!ASSERT_OK_PTR(skel, "uprobe_multi__open_and_load")) 140 goto cleanup; 141 142 err = uprobe_multi__attach(skel); 143 if (!ASSERT_OK(err, "uprobe_multi__attach")) 144 goto cleanup; 145 146 uprobe_multi_test_run(skel, NULL); 147 148cleanup: 149 uprobe_multi__destroy(skel); 150} 151 152static void 153__test_attach_api(const char *binary, const char *pattern, struct bpf_uprobe_multi_opts *opts, 154 struct child *child) 155{ 156 pid_t pid = child ? child->pid : -1; 157 struct uprobe_multi *skel = NULL; 158 159 skel = uprobe_multi__open_and_load(); 160 if (!ASSERT_OK_PTR(skel, "uprobe_multi__open_and_load")) 161 goto cleanup; 162 163 opts->retprobe = false; 164 skel->links.uprobe = bpf_program__attach_uprobe_multi(skel->progs.uprobe, pid, 165 binary, pattern, opts); 166 if (!ASSERT_OK_PTR(skel->links.uprobe, "bpf_program__attach_uprobe_multi")) 167 goto cleanup; 168 169 opts->retprobe = true; 170 skel->links.uretprobe = bpf_program__attach_uprobe_multi(skel->progs.uretprobe, pid, 171 binary, pattern, opts); 172 if (!ASSERT_OK_PTR(skel->links.uretprobe, "bpf_program__attach_uprobe_multi")) 173 goto cleanup; 174 175 opts->retprobe = false; 176 skel->links.uprobe_sleep = bpf_program__attach_uprobe_multi(skel->progs.uprobe_sleep, pid, 177 binary, pattern, opts); 178 if (!ASSERT_OK_PTR(skel->links.uprobe_sleep, "bpf_program__attach_uprobe_multi")) 179 goto cleanup; 180 181 opts->retprobe = true; 182 skel->links.uretprobe_sleep = bpf_program__attach_uprobe_multi(skel->progs.uretprobe_sleep, 183 pid, binary, pattern, opts); 184 if (!ASSERT_OK_PTR(skel->links.uretprobe_sleep, "bpf_program__attach_uprobe_multi")) 185 goto cleanup; 186 187 opts->retprobe = false; 188 skel->links.uprobe_extra = bpf_program__attach_uprobe_multi(skel->progs.uprobe_extra, -1, 189 binary, pattern, opts); 190 if (!ASSERT_OK_PTR(skel->links.uprobe_extra, "bpf_program__attach_uprobe_multi")) 191 goto cleanup; 192 193 uprobe_multi_test_run(skel, child); 194 195cleanup: 196 uprobe_multi__destroy(skel); 197} 198 199static void 200test_attach_api(const char *binary, const char *pattern, struct bpf_uprobe_multi_opts *opts) 201{ 202 struct child *child; 203 204 /* no pid filter */ 205 __test_attach_api(binary, pattern, opts, NULL); 206 207 /* pid filter */ 208 child = spawn_child(); 209 if (!ASSERT_OK_PTR(child, "spawn_child")) 210 return; 211 212 __test_attach_api(binary, pattern, opts, child); 213} 214 215static void test_attach_api_pattern(void) 216{ 217 LIBBPF_OPTS(bpf_uprobe_multi_opts, opts); 218 219 test_attach_api("/proc/self/exe", "uprobe_multi_func_*", &opts); 220 test_attach_api("/proc/self/exe", "uprobe_multi_func_?", &opts); 221} 222 223static void test_attach_api_syms(void) 224{ 225 LIBBPF_OPTS(bpf_uprobe_multi_opts, opts); 226 const char *syms[3] = { 227 "uprobe_multi_func_1", 228 "uprobe_multi_func_2", 229 "uprobe_multi_func_3", 230 }; 231 232 opts.syms = syms; 233 opts.cnt = ARRAY_SIZE(syms); 234 test_attach_api("/proc/self/exe", NULL, &opts); 235} 236 237static void test_attach_api_fails(void) 238{ 239 LIBBPF_OPTS(bpf_link_create_opts, opts); 240 const char *path = "/proc/self/exe"; 241 struct uprobe_multi *skel = NULL; 242 int prog_fd, link_fd = -1; 243 unsigned long offset = 0; 244 245 skel = uprobe_multi__open_and_load(); 246 if (!ASSERT_OK_PTR(skel, "uprobe_multi__open_and_load")) 247 goto cleanup; 248 249 prog_fd = bpf_program__fd(skel->progs.uprobe_extra); 250 251 /* abnormal cnt */ 252 opts.uprobe_multi.path = path; 253 opts.uprobe_multi.offsets = &offset; 254 opts.uprobe_multi.cnt = INT_MAX; 255 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 256 if (!ASSERT_ERR(link_fd, "link_fd")) 257 goto cleanup; 258 if (!ASSERT_EQ(link_fd, -E2BIG, "big cnt")) 259 goto cleanup; 260 261 /* cnt is 0 */ 262 LIBBPF_OPTS_RESET(opts, 263 .uprobe_multi.path = path, 264 .uprobe_multi.offsets = (unsigned long *) &offset, 265 ); 266 267 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 268 if (!ASSERT_ERR(link_fd, "link_fd")) 269 goto cleanup; 270 if (!ASSERT_EQ(link_fd, -EINVAL, "cnt_is_zero")) 271 goto cleanup; 272 273 /* negative offset */ 274 offset = -1; 275 opts.uprobe_multi.path = path; 276 opts.uprobe_multi.offsets = (unsigned long *) &offset; 277 opts.uprobe_multi.cnt = 1; 278 279 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 280 if (!ASSERT_ERR(link_fd, "link_fd")) 281 goto cleanup; 282 if (!ASSERT_EQ(link_fd, -EINVAL, "offset_is_negative")) 283 goto cleanup; 284 285 /* offsets is NULL */ 286 LIBBPF_OPTS_RESET(opts, 287 .uprobe_multi.path = path, 288 .uprobe_multi.cnt = 1, 289 ); 290 291 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 292 if (!ASSERT_ERR(link_fd, "link_fd")) 293 goto cleanup; 294 if (!ASSERT_EQ(link_fd, -EINVAL, "offsets_is_null")) 295 goto cleanup; 296 297 /* wrong offsets pointer */ 298 LIBBPF_OPTS_RESET(opts, 299 .uprobe_multi.path = path, 300 .uprobe_multi.offsets = (unsigned long *) 1, 301 .uprobe_multi.cnt = 1, 302 ); 303 304 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 305 if (!ASSERT_ERR(link_fd, "link_fd")) 306 goto cleanup; 307 if (!ASSERT_EQ(link_fd, -EFAULT, "offsets_is_wrong")) 308 goto cleanup; 309 310 /* path is NULL */ 311 offset = 1; 312 LIBBPF_OPTS_RESET(opts, 313 .uprobe_multi.offsets = (unsigned long *) &offset, 314 .uprobe_multi.cnt = 1, 315 ); 316 317 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 318 if (!ASSERT_ERR(link_fd, "link_fd")) 319 goto cleanup; 320 if (!ASSERT_EQ(link_fd, -EINVAL, "path_is_null")) 321 goto cleanup; 322 323 /* wrong path pointer */ 324 LIBBPF_OPTS_RESET(opts, 325 .uprobe_multi.path = (const char *) 1, 326 .uprobe_multi.offsets = (unsigned long *) &offset, 327 .uprobe_multi.cnt = 1, 328 ); 329 330 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 331 if (!ASSERT_ERR(link_fd, "link_fd")) 332 goto cleanup; 333 if (!ASSERT_EQ(link_fd, -EFAULT, "path_is_wrong")) 334 goto cleanup; 335 336 /* wrong path type */ 337 LIBBPF_OPTS_RESET(opts, 338 .uprobe_multi.path = "/", 339 .uprobe_multi.offsets = (unsigned long *) &offset, 340 .uprobe_multi.cnt = 1, 341 ); 342 343 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 344 if (!ASSERT_ERR(link_fd, "link_fd")) 345 goto cleanup; 346 if (!ASSERT_EQ(link_fd, -EBADF, "path_is_wrong_type")) 347 goto cleanup; 348 349 /* wrong cookies pointer */ 350 LIBBPF_OPTS_RESET(opts, 351 .uprobe_multi.path = path, 352 .uprobe_multi.offsets = (unsigned long *) &offset, 353 .uprobe_multi.cookies = (__u64 *) 1ULL, 354 .uprobe_multi.cnt = 1, 355 ); 356 357 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 358 if (!ASSERT_ERR(link_fd, "link_fd")) 359 goto cleanup; 360 if (!ASSERT_EQ(link_fd, -EFAULT, "cookies_is_wrong")) 361 goto cleanup; 362 363 /* wrong ref_ctr_offsets pointer */ 364 LIBBPF_OPTS_RESET(opts, 365 .uprobe_multi.path = path, 366 .uprobe_multi.offsets = (unsigned long *) &offset, 367 .uprobe_multi.cookies = (__u64 *) &offset, 368 .uprobe_multi.ref_ctr_offsets = (unsigned long *) 1, 369 .uprobe_multi.cnt = 1, 370 ); 371 372 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 373 if (!ASSERT_ERR(link_fd, "link_fd")) 374 goto cleanup; 375 if (!ASSERT_EQ(link_fd, -EFAULT, "ref_ctr_offsets_is_wrong")) 376 goto cleanup; 377 378 /* wrong flags */ 379 LIBBPF_OPTS_RESET(opts, 380 .uprobe_multi.flags = 1 << 31, 381 ); 382 383 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 384 if (!ASSERT_ERR(link_fd, "link_fd")) 385 goto cleanup; 386 if (!ASSERT_EQ(link_fd, -EINVAL, "wrong_flags")) 387 goto cleanup; 388 389 /* wrong pid */ 390 LIBBPF_OPTS_RESET(opts, 391 .uprobe_multi.path = path, 392 .uprobe_multi.offsets = (unsigned long *) &offset, 393 .uprobe_multi.cnt = 1, 394 .uprobe_multi.pid = -2, 395 ); 396 397 link_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 398 if (!ASSERT_ERR(link_fd, "link_fd")) 399 goto cleanup; 400 ASSERT_EQ(link_fd, -ESRCH, "pid_is_wrong"); 401 402cleanup: 403 if (link_fd >= 0) 404 close(link_fd); 405 uprobe_multi__destroy(skel); 406} 407 408static void __test_link_api(struct child *child) 409{ 410 int prog_fd, link1_fd = -1, link2_fd = -1, link3_fd = -1, link4_fd = -1; 411 LIBBPF_OPTS(bpf_link_create_opts, opts); 412 const char *path = "/proc/self/exe"; 413 struct uprobe_multi *skel = NULL; 414 unsigned long *offsets = NULL; 415 const char *syms[3] = { 416 "uprobe_multi_func_1", 417 "uprobe_multi_func_2", 418 "uprobe_multi_func_3", 419 }; 420 int link_extra_fd = -1; 421 int err; 422 423 err = elf_resolve_syms_offsets(path, 3, syms, (unsigned long **) &offsets, STT_FUNC); 424 if (!ASSERT_OK(err, "elf_resolve_syms_offsets")) 425 return; 426 427 opts.uprobe_multi.path = path; 428 opts.uprobe_multi.offsets = offsets; 429 opts.uprobe_multi.cnt = ARRAY_SIZE(syms); 430 opts.uprobe_multi.pid = child ? child->pid : 0; 431 432 skel = uprobe_multi__open_and_load(); 433 if (!ASSERT_OK_PTR(skel, "uprobe_multi__open_and_load")) 434 goto cleanup; 435 436 opts.kprobe_multi.flags = 0; 437 prog_fd = bpf_program__fd(skel->progs.uprobe); 438 link1_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 439 if (!ASSERT_GE(link1_fd, 0, "link1_fd")) 440 goto cleanup; 441 442 opts.kprobe_multi.flags = BPF_F_UPROBE_MULTI_RETURN; 443 prog_fd = bpf_program__fd(skel->progs.uretprobe); 444 link2_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 445 if (!ASSERT_GE(link2_fd, 0, "link2_fd")) 446 goto cleanup; 447 448 opts.kprobe_multi.flags = 0; 449 prog_fd = bpf_program__fd(skel->progs.uprobe_sleep); 450 link3_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 451 if (!ASSERT_GE(link3_fd, 0, "link3_fd")) 452 goto cleanup; 453 454 opts.kprobe_multi.flags = BPF_F_UPROBE_MULTI_RETURN; 455 prog_fd = bpf_program__fd(skel->progs.uretprobe_sleep); 456 link4_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 457 if (!ASSERT_GE(link4_fd, 0, "link4_fd")) 458 goto cleanup; 459 460 opts.kprobe_multi.flags = 0; 461 opts.uprobe_multi.pid = 0; 462 prog_fd = bpf_program__fd(skel->progs.uprobe_extra); 463 link_extra_fd = bpf_link_create(prog_fd, 0, BPF_TRACE_UPROBE_MULTI, &opts); 464 if (!ASSERT_GE(link_extra_fd, 0, "link_extra_fd")) 465 goto cleanup; 466 467 uprobe_multi_test_run(skel, child); 468 469cleanup: 470 if (link1_fd >= 0) 471 close(link1_fd); 472 if (link2_fd >= 0) 473 close(link2_fd); 474 if (link3_fd >= 0) 475 close(link3_fd); 476 if (link4_fd >= 0) 477 close(link4_fd); 478 if (link_extra_fd >= 0) 479 close(link_extra_fd); 480 481 uprobe_multi__destroy(skel); 482 free(offsets); 483} 484 485static void test_link_api(void) 486{ 487 struct child *child; 488 489 /* no pid filter */ 490 __test_link_api(NULL); 491 492 /* pid filter */ 493 child = spawn_child(); 494 if (!ASSERT_OK_PTR(child, "spawn_child")) 495 return; 496 497 __test_link_api(child); 498} 499 500static void test_bench_attach_uprobe(void) 501{ 502 long attach_start_ns = 0, attach_end_ns = 0; 503 struct uprobe_multi_bench *skel = NULL; 504 long detach_start_ns, detach_end_ns; 505 double attach_delta, detach_delta; 506 int err; 507 508 skel = uprobe_multi_bench__open_and_load(); 509 if (!ASSERT_OK_PTR(skel, "uprobe_multi_bench__open_and_load")) 510 goto cleanup; 511 512 attach_start_ns = get_time_ns(); 513 514 err = uprobe_multi_bench__attach(skel); 515 if (!ASSERT_OK(err, "uprobe_multi_bench__attach")) 516 goto cleanup; 517 518 attach_end_ns = get_time_ns(); 519 520 system("./uprobe_multi bench"); 521 522 ASSERT_EQ(skel->bss->count, 50000, "uprobes_count"); 523 524cleanup: 525 detach_start_ns = get_time_ns(); 526 uprobe_multi_bench__destroy(skel); 527 detach_end_ns = get_time_ns(); 528 529 attach_delta = (attach_end_ns - attach_start_ns) / 1000000000.0; 530 detach_delta = (detach_end_ns - detach_start_ns) / 1000000000.0; 531 532 printf("%s: attached in %7.3lfs\n", __func__, attach_delta); 533 printf("%s: detached in %7.3lfs\n", __func__, detach_delta); 534} 535 536static void test_bench_attach_usdt(void) 537{ 538 long attach_start_ns = 0, attach_end_ns = 0; 539 struct uprobe_multi_usdt *skel = NULL; 540 long detach_start_ns, detach_end_ns; 541 double attach_delta, detach_delta; 542 543 skel = uprobe_multi_usdt__open_and_load(); 544 if (!ASSERT_OK_PTR(skel, "uprobe_multi__open")) 545 goto cleanup; 546 547 attach_start_ns = get_time_ns(); 548 549 skel->links.usdt0 = bpf_program__attach_usdt(skel->progs.usdt0, -1, "./uprobe_multi", 550 "test", "usdt", NULL); 551 if (!ASSERT_OK_PTR(skel->links.usdt0, "bpf_program__attach_usdt")) 552 goto cleanup; 553 554 attach_end_ns = get_time_ns(); 555 556 system("./uprobe_multi usdt"); 557 558 ASSERT_EQ(skel->bss->count, 50000, "usdt_count"); 559 560cleanup: 561 detach_start_ns = get_time_ns(); 562 uprobe_multi_usdt__destroy(skel); 563 detach_end_ns = get_time_ns(); 564 565 attach_delta = (attach_end_ns - attach_start_ns) / 1000000000.0; 566 detach_delta = (detach_end_ns - detach_start_ns) / 1000000000.0; 567 568 printf("%s: attached in %7.3lfs\n", __func__, attach_delta); 569 printf("%s: detached in %7.3lfs\n", __func__, detach_delta); 570} 571 572void test_uprobe_multi_test(void) 573{ 574 if (test__start_subtest("skel_api")) 575 test_skel_api(); 576 if (test__start_subtest("attach_api_pattern")) 577 test_attach_api_pattern(); 578 if (test__start_subtest("attach_api_syms")) 579 test_attach_api_syms(); 580 if (test__start_subtest("link_api")) 581 test_link_api(); 582 if (test__start_subtest("bench_uprobe")) 583 test_bench_attach_uprobe(); 584 if (test__start_subtest("bench_usdt")) 585 test_bench_attach_usdt(); 586 if (test__start_subtest("attach_api_fails")) 587 test_attach_api_fails(); 588} 589