1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * builtin-test.c 4 * 5 * Builtin regression testing command: ever growing number of sanity tests 6 */ 7 #include <fcntl.h> 8 #include <errno.h> 9 #include <unistd.h> 10 #include <string.h> 11 #include <stdlib.h> 12 #include <sys/types.h> 13 #include <dirent.h> 14 #include <sys/wait.h> 15 #include <sys/stat.h> 16 #include "builtin.h" 17 #include "hist.h" 18 #include "intlist.h" 19 #include "tests.h" 20 #include "debug.h" 21 #include "color.h" 22 #include <subcmd/parse-options.h> 23 #include "string2.h" 24 #include "symbol.h" 25 #include "util/rlimit.h" 26 #include <linux/kernel.h> 27 #include <linux/string.h> 28 #include <subcmd/exec-cmd.h> 29 #include <linux/zalloc.h> 30 31 static bool dont_fork; 32 33 struct test __weak arch_tests[] = { 34 { 35 .func = NULL, 36 }, 37 }; 38 39 static struct test generic_tests[] = { 40 { 41 .desc = "vmlinux symtab matches kallsyms", 42 .func = test__vmlinux_matches_kallsyms, 43 }, 44 { 45 .desc = "Detect openat syscall event", 46 .func = test__openat_syscall_event, 47 }, 48 { 49 .desc = "Detect openat syscall event on all cpus", 50 .func = test__openat_syscall_event_on_all_cpus, 51 }, 52 { 53 .desc = "Read samples using the mmap interface", 54 .func = test__basic_mmap, 55 }, 56 { 57 .desc = "Test data source output", 58 .func = test__mem, 59 }, 60 { 61 .desc = "Parse event definition strings", 62 .func = test__parse_events, 63 }, 64 { 65 .desc = "Simple expression parser", 66 .func = test__expr, 67 }, 68 { 69 .desc = "PERF_RECORD_* events & perf_sample fields", 70 .func = test__PERF_RECORD, 71 }, 72 { 73 .desc = "Parse perf pmu format", 74 .func = test__pmu, 75 }, 76 { 77 .desc = "PMU events", 78 .func = test__pmu_events, 79 .subtest = { 80 .skip_if_fail = false, 81 .get_nr = test__pmu_events_subtest_get_nr, 82 .get_desc = test__pmu_events_subtest_get_desc, 83 .skip_reason = test__pmu_events_subtest_skip_reason, 84 }, 85 86 }, 87 { 88 .desc = "DSO data read", 89 .func = test__dso_data, 90 }, 91 { 92 .desc = "DSO data cache", 93 .func = test__dso_data_cache, 94 }, 95 { 96 .desc = "DSO data reopen", 97 .func = test__dso_data_reopen, 98 }, 99 { 100 .desc = "Roundtrip evsel->name", 101 .func = test__perf_evsel__roundtrip_name_test, 102 }, 103 { 104 .desc = "Parse sched tracepoints fields", 105 .func = test__perf_evsel__tp_sched_test, 106 }, 107 { 108 .desc = "syscalls:sys_enter_openat event fields", 109 .func = test__syscall_openat_tp_fields, 110 }, 111 { 112 .desc = "Setup struct perf_event_attr", 113 .func = test__attr, 114 }, 115 { 116 .desc = "Match and link multiple hists", 117 .func = test__hists_link, 118 }, 119 { 120 .desc = "'import perf' in python", 121 .func = test__python_use, 122 }, 123 { 124 .desc = "Breakpoint overflow signal handler", 125 .func = test__bp_signal, 126 .is_supported = test__bp_signal_is_supported, 127 }, 128 { 129 .desc = "Breakpoint overflow sampling", 130 .func = test__bp_signal_overflow, 131 .is_supported = test__bp_signal_is_supported, 132 }, 133 { 134 .desc = "Breakpoint accounting", 135 .func = test__bp_accounting, 136 .is_supported = test__bp_account_is_supported, 137 }, 138 { 139 .desc = "Watchpoint", 140 .func = test__wp, 141 .is_supported = test__wp_is_supported, 142 .subtest = { 143 .skip_if_fail = false, 144 .get_nr = test__wp_subtest_get_nr, 145 .get_desc = test__wp_subtest_get_desc, 146 .skip_reason = test__wp_subtest_skip_reason, 147 }, 148 }, 149 { 150 .desc = "Number of exit events of a simple workload", 151 .func = test__task_exit, 152 }, 153 { 154 .desc = "Software clock events period values", 155 .func = test__sw_clock_freq, 156 }, 157 { 158 .desc = "Object code reading", 159 .func = test__code_reading, 160 }, 161 { 162 .desc = "Sample parsing", 163 .func = test__sample_parsing, 164 }, 165 { 166 .desc = "Use a dummy software event to keep tracking", 167 .func = test__keep_tracking, 168 }, 169 { 170 .desc = "Parse with no sample_id_all bit set", 171 .func = test__parse_no_sample_id_all, 172 }, 173 { 174 .desc = "Filter hist entries", 175 .func = test__hists_filter, 176 }, 177 { 178 .desc = "Lookup mmap thread", 179 .func = test__mmap_thread_lookup, 180 }, 181 { 182 .desc = "Share thread maps", 183 .func = test__thread_maps_share, 184 }, 185 { 186 .desc = "Sort output of hist entries", 187 .func = test__hists_output, 188 }, 189 { 190 .desc = "Cumulate child hist entries", 191 .func = test__hists_cumulate, 192 }, 193 { 194 .desc = "Track with sched_switch", 195 .func = test__switch_tracking, 196 }, 197 { 198 .desc = "Filter fds with revents mask in a fdarray", 199 .func = test__fdarray__filter, 200 }, 201 { 202 .desc = "Add fd to a fdarray, making it autogrow", 203 .func = test__fdarray__add, 204 }, 205 { 206 .desc = "kmod_path__parse", 207 .func = test__kmod_path__parse, 208 }, 209 { 210 .desc = "Thread map", 211 .func = test__thread_map, 212 }, 213 { 214 .desc = "LLVM search and compile", 215 .func = test__llvm, 216 .subtest = { 217 .skip_if_fail = true, 218 .get_nr = test__llvm_subtest_get_nr, 219 .get_desc = test__llvm_subtest_get_desc, 220 }, 221 }, 222 { 223 .desc = "Session topology", 224 .func = test__session_topology, 225 }, 226 { 227 .desc = "BPF filter", 228 .func = test__bpf, 229 .subtest = { 230 .skip_if_fail = true, 231 .get_nr = test__bpf_subtest_get_nr, 232 .get_desc = test__bpf_subtest_get_desc, 233 }, 234 }, 235 { 236 .desc = "Synthesize thread map", 237 .func = test__thread_map_synthesize, 238 }, 239 { 240 .desc = "Remove thread map", 241 .func = test__thread_map_remove, 242 }, 243 { 244 .desc = "Synthesize cpu map", 245 .func = test__cpu_map_synthesize, 246 }, 247 { 248 .desc = "Synthesize stat config", 249 .func = test__synthesize_stat_config, 250 }, 251 { 252 .desc = "Synthesize stat", 253 .func = test__synthesize_stat, 254 }, 255 { 256 .desc = "Synthesize stat round", 257 .func = test__synthesize_stat_round, 258 }, 259 { 260 .desc = "Synthesize attr update", 261 .func = test__event_update, 262 }, 263 { 264 .desc = "Event times", 265 .func = test__event_times, 266 }, 267 { 268 .desc = "Read backward ring buffer", 269 .func = test__backward_ring_buffer, 270 }, 271 { 272 .desc = "Print cpu map", 273 .func = test__cpu_map_print, 274 }, 275 { 276 .desc = "Merge cpu map", 277 .func = test__cpu_map_merge, 278 }, 279 280 { 281 .desc = "Probe SDT events", 282 .func = test__sdt_event, 283 }, 284 { 285 .desc = "is_printable_array", 286 .func = test__is_printable_array, 287 }, 288 { 289 .desc = "Print bitmap", 290 .func = test__bitmap_print, 291 }, 292 { 293 .desc = "perf hooks", 294 .func = test__perf_hooks, 295 }, 296 { 297 .desc = "builtin clang support", 298 .func = test__clang, 299 .subtest = { 300 .skip_if_fail = true, 301 .get_nr = test__clang_subtest_get_nr, 302 .get_desc = test__clang_subtest_get_desc, 303 } 304 }, 305 { 306 .desc = "unit_number__scnprintf", 307 .func = test__unit_number__scnprint, 308 }, 309 { 310 .desc = "mem2node", 311 .func = test__mem2node, 312 }, 313 { 314 .desc = "time utils", 315 .func = test__time_utils, 316 }, 317 { 318 .desc = "Test jit_write_elf", 319 .func = test__jit_write_elf, 320 }, 321 { 322 .desc = "Test libpfm4 support", 323 .func = test__pfm, 324 .subtest = { 325 .skip_if_fail = true, 326 .get_nr = test__pfm_subtest_get_nr, 327 .get_desc = test__pfm_subtest_get_desc, 328 } 329 }, 330 { 331 .desc = "Test api io", 332 .func = test__api_io, 333 }, 334 { 335 .desc = "maps__merge_in", 336 .func = test__maps__merge_in, 337 }, 338 { 339 .desc = "Demangle Java", 340 .func = test__demangle_java, 341 }, 342 { 343 .desc = "Demangle OCaml", 344 .func = test__demangle_ocaml, 345 }, 346 { 347 .desc = "Parse and process metrics", 348 .func = test__parse_metric, 349 }, 350 { 351 .desc = "PE file support", 352 .func = test__pe_file_parsing, 353 }, 354 { 355 .desc = "Event expansion for cgroups", 356 .func = test__expand_cgroup_events, 357 }, 358 { 359 .desc = "Convert perf time to TSC", 360 .func = test__perf_time_to_tsc, 361 .is_supported = test__tsc_is_supported, 362 }, 363 { 364 .desc = "dlfilter C API", 365 .func = test__dlfilter, 366 }, 367 { 368 .func = NULL, 369 }, 370 }; 371 372 static struct test *tests[] = { 373 generic_tests, 374 arch_tests, 375 }; 376 377 static bool perf_test__matches(const char *desc, int curr, int argc, const char *argv[]) 378 { 379 int i; 380 381 if (argc == 0) 382 return true; 383 384 for (i = 0; i < argc; ++i) { 385 char *end; 386 long nr = strtoul(argv[i], &end, 10); 387 388 if (*end == '\0') { 389 if (nr == curr + 1) 390 return true; 391 continue; 392 } 393 394 if (strcasestr(desc, argv[i])) 395 return true; 396 } 397 398 return false; 399 } 400 401 static int run_test(struct test *test, int subtest) 402 { 403 int status, err = -1, child = dont_fork ? 0 : fork(); 404 char sbuf[STRERR_BUFSIZE]; 405 406 if (child < 0) { 407 pr_err("failed to fork test: %s\n", 408 str_error_r(errno, sbuf, sizeof(sbuf))); 409 return -1; 410 } 411 412 if (!child) { 413 if (!dont_fork) { 414 pr_debug("test child forked, pid %d\n", getpid()); 415 416 if (verbose <= 0) { 417 int nullfd = open("/dev/null", O_WRONLY); 418 419 if (nullfd >= 0) { 420 close(STDERR_FILENO); 421 close(STDOUT_FILENO); 422 423 dup2(nullfd, STDOUT_FILENO); 424 dup2(STDOUT_FILENO, STDERR_FILENO); 425 close(nullfd); 426 } 427 } else { 428 signal(SIGSEGV, sighandler_dump_stack); 429 signal(SIGFPE, sighandler_dump_stack); 430 } 431 } 432 433 err = test->func(test, subtest); 434 if (!dont_fork) 435 exit(err); 436 } 437 438 if (!dont_fork) { 439 wait(&status); 440 441 if (WIFEXITED(status)) { 442 err = (signed char)WEXITSTATUS(status); 443 pr_debug("test child finished with %d\n", err); 444 } else if (WIFSIGNALED(status)) { 445 err = -1; 446 pr_debug("test child interrupted\n"); 447 } 448 } 449 450 return err; 451 } 452 453 #define for_each_test(j, t) \ 454 for (j = 0; j < ARRAY_SIZE(tests); j++) \ 455 for (t = &tests[j][0]; t->func; t++) 456 457 static int test_and_print(struct test *t, bool force_skip, int subtest) 458 { 459 int err; 460 461 if (!force_skip) { 462 pr_debug("\n--- start ---\n"); 463 err = run_test(t, subtest); 464 pr_debug("---- end ----\n"); 465 } else { 466 pr_debug("\n--- force skipped ---\n"); 467 err = TEST_SKIP; 468 } 469 470 if (!t->subtest.get_nr) 471 pr_debug("%s:", t->desc); 472 else 473 pr_debug("%s subtest %d:", t->desc, subtest + 1); 474 475 switch (err) { 476 case TEST_OK: 477 pr_info(" Ok\n"); 478 break; 479 case TEST_SKIP: { 480 const char *skip_reason = NULL; 481 if (t->subtest.skip_reason) 482 skip_reason = t->subtest.skip_reason(subtest); 483 if (skip_reason) 484 color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (%s)\n", skip_reason); 485 else 486 color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip\n"); 487 } 488 break; 489 case TEST_FAIL: 490 default: 491 color_fprintf(stderr, PERF_COLOR_RED, " FAILED!\n"); 492 break; 493 } 494 495 return err; 496 } 497 498 static const char *shell_test__description(char *description, size_t size, 499 const char *path, const char *name) 500 { 501 FILE *fp; 502 char filename[PATH_MAX]; 503 504 path__join(filename, sizeof(filename), path, name); 505 fp = fopen(filename, "r"); 506 if (!fp) 507 return NULL; 508 509 /* Skip shebang */ 510 while (fgetc(fp) != '\n'); 511 512 description = fgets(description, size, fp); 513 fclose(fp); 514 515 return description ? strim(description + 1) : NULL; 516 } 517 518 #define for_each_shell_test(entlist, nr, base, ent) \ 519 for (int __i = 0; __i < nr && (ent = entlist[__i]); __i++) \ 520 if (!is_directory(base, ent) && ent->d_name[0] != '.') 521 522 static const char *shell_tests__dir(char *path, size_t size) 523 { 524 const char *devel_dirs[] = { "./tools/perf/tests", "./tests", }; 525 char *exec_path; 526 unsigned int i; 527 528 for (i = 0; i < ARRAY_SIZE(devel_dirs); ++i) { 529 struct stat st; 530 if (!lstat(devel_dirs[i], &st)) { 531 scnprintf(path, size, "%s/shell", devel_dirs[i]); 532 if (!lstat(devel_dirs[i], &st)) 533 return path; 534 } 535 } 536 537 /* Then installed path. */ 538 exec_path = get_argv_exec_path(); 539 scnprintf(path, size, "%s/tests/shell", exec_path); 540 free(exec_path); 541 return path; 542 } 543 544 static int shell_tests__max_desc_width(void) 545 { 546 struct dirent **entlist; 547 struct dirent *ent; 548 int n_dirs, e; 549 char path_dir[PATH_MAX]; 550 const char *path = shell_tests__dir(path_dir, sizeof(path_dir)); 551 int width = 0; 552 553 if (path == NULL) 554 return -1; 555 556 n_dirs = scandir(path, &entlist, NULL, alphasort); 557 if (n_dirs == -1) 558 return -1; 559 560 for_each_shell_test(entlist, n_dirs, path, ent) { 561 char bf[256]; 562 const char *desc = shell_test__description(bf, sizeof(bf), path, ent->d_name); 563 564 if (desc) { 565 int len = strlen(desc); 566 567 if (width < len) 568 width = len; 569 } 570 } 571 572 for (e = 0; e < n_dirs; e++) 573 zfree(&entlist[e]); 574 free(entlist); 575 return width; 576 } 577 578 struct shell_test { 579 const char *dir; 580 const char *file; 581 }; 582 583 static int shell_test__run(struct test *test, int subdir __maybe_unused) 584 { 585 int err; 586 char script[PATH_MAX]; 587 struct shell_test *st = test->priv; 588 589 path__join(script, sizeof(script) - 3, st->dir, st->file); 590 591 if (verbose) 592 strncat(script, " -v", sizeof(script) - strlen(script) - 1); 593 594 err = system(script); 595 if (!err) 596 return TEST_OK; 597 598 return WEXITSTATUS(err) == 2 ? TEST_SKIP : TEST_FAIL; 599 } 600 601 static int run_shell_tests(int argc, const char *argv[], int i, int width, 602 struct intlist *skiplist) 603 { 604 struct dirent **entlist; 605 struct dirent *ent; 606 int n_dirs, e; 607 char path_dir[PATH_MAX]; 608 struct shell_test st = { 609 .dir = shell_tests__dir(path_dir, sizeof(path_dir)), 610 }; 611 612 if (st.dir == NULL) 613 return -1; 614 615 n_dirs = scandir(st.dir, &entlist, NULL, alphasort); 616 if (n_dirs == -1) { 617 pr_err("failed to open shell test directory: %s\n", 618 st.dir); 619 return -1; 620 } 621 622 for_each_shell_test(entlist, n_dirs, st.dir, ent) { 623 int curr = i++; 624 char desc[256]; 625 struct test test = { 626 .desc = shell_test__description(desc, sizeof(desc), st.dir, ent->d_name), 627 .func = shell_test__run, 628 .priv = &st, 629 }; 630 631 if (!perf_test__matches(test.desc, curr, argc, argv)) 632 continue; 633 634 st.file = ent->d_name; 635 pr_info("%2d: %-*s:", i, width, test.desc); 636 637 if (intlist__find(skiplist, i)) { 638 color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (user override)\n"); 639 continue; 640 } 641 642 test_and_print(&test, false, -1); 643 } 644 645 for (e = 0; e < n_dirs; e++) 646 zfree(&entlist[e]); 647 free(entlist); 648 return 0; 649 } 650 651 static int __cmd_test(int argc, const char *argv[], struct intlist *skiplist) 652 { 653 struct test *t; 654 unsigned int j; 655 int i = 0; 656 int width = shell_tests__max_desc_width(); 657 658 for_each_test(j, t) { 659 int len = strlen(t->desc); 660 661 if (width < len) 662 width = len; 663 } 664 665 for_each_test(j, t) { 666 int curr = i++, err; 667 int subi; 668 669 if (!perf_test__matches(t->desc, curr, argc, argv)) { 670 bool skip = true; 671 int subn; 672 673 if (!t->subtest.get_nr) 674 continue; 675 676 subn = t->subtest.get_nr(); 677 678 for (subi = 0; subi < subn; subi++) { 679 if (perf_test__matches(t->subtest.get_desc(subi), curr, argc, argv)) 680 skip = false; 681 } 682 683 if (skip) 684 continue; 685 } 686 687 if (t->is_supported && !t->is_supported()) { 688 pr_debug("%2d: %-*s: Disabled\n", i, width, t->desc); 689 continue; 690 } 691 692 pr_info("%2d: %-*s:", i, width, t->desc); 693 694 if (intlist__find(skiplist, i)) { 695 color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (user override)\n"); 696 continue; 697 } 698 699 if (!t->subtest.get_nr) { 700 test_and_print(t, false, -1); 701 } else { 702 int subn = t->subtest.get_nr(); 703 /* 704 * minus 2 to align with normal testcases. 705 * For subtest we print additional '.x' in number. 706 * for example: 707 * 708 * 35: Test LLVM searching and compiling : 709 * 35.1: Basic BPF llvm compiling test : Ok 710 */ 711 int subw = width > 2 ? width - 2 : width; 712 bool skip = false; 713 714 if (subn <= 0) { 715 color_fprintf(stderr, PERF_COLOR_YELLOW, 716 " Skip (not compiled in)\n"); 717 continue; 718 } 719 pr_info("\n"); 720 721 for (subi = 0; subi < subn; subi++) { 722 int len = strlen(t->subtest.get_desc(subi)); 723 724 if (subw < len) 725 subw = len; 726 } 727 728 for (subi = 0; subi < subn; subi++) { 729 if (!perf_test__matches(t->subtest.get_desc(subi), curr, argc, argv)) 730 continue; 731 732 pr_info("%2d.%1d: %-*s:", i, subi + 1, subw, 733 t->subtest.get_desc(subi)); 734 err = test_and_print(t, skip, subi); 735 if (err != TEST_OK && t->subtest.skip_if_fail) 736 skip = true; 737 } 738 } 739 } 740 741 return run_shell_tests(argc, argv, i, width, skiplist); 742 } 743 744 static int perf_test__list_shell(int argc, const char **argv, int i) 745 { 746 struct dirent **entlist; 747 struct dirent *ent; 748 int n_dirs, e; 749 char path_dir[PATH_MAX]; 750 const char *path = shell_tests__dir(path_dir, sizeof(path_dir)); 751 752 if (path == NULL) 753 return -1; 754 755 n_dirs = scandir(path, &entlist, NULL, alphasort); 756 if (n_dirs == -1) 757 return -1; 758 759 for_each_shell_test(entlist, n_dirs, path, ent) { 760 int curr = i++; 761 char bf[256]; 762 struct test t = { 763 .desc = shell_test__description(bf, sizeof(bf), path, ent->d_name), 764 }; 765 766 if (!perf_test__matches(t.desc, curr, argc, argv)) 767 continue; 768 769 pr_info("%2d: %s\n", i, t.desc); 770 771 } 772 773 for (e = 0; e < n_dirs; e++) 774 zfree(&entlist[e]); 775 free(entlist); 776 return 0; 777 } 778 779 static int perf_test__list(int argc, const char **argv) 780 { 781 unsigned int j; 782 struct test *t; 783 int i = 0; 784 785 for_each_test(j, t) { 786 int curr = i++; 787 788 if (!perf_test__matches(t->desc, curr, argc, argv) || 789 (t->is_supported && !t->is_supported())) 790 continue; 791 792 pr_info("%2d: %s\n", i, t->desc); 793 794 if (t->subtest.get_nr) { 795 int subn = t->subtest.get_nr(); 796 int subi; 797 798 for (subi = 0; subi < subn; subi++) 799 pr_info("%2d:%1d: %s\n", i, subi + 1, 800 t->subtest.get_desc(subi)); 801 } 802 } 803 804 perf_test__list_shell(argc, argv, i); 805 806 return 0; 807 } 808 809 int cmd_test(int argc, const char **argv) 810 { 811 const char *test_usage[] = { 812 "perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]", 813 NULL, 814 }; 815 const char *skip = NULL; 816 const struct option test_options[] = { 817 OPT_STRING('s', "skip", &skip, "tests", "tests to skip"), 818 OPT_INCR('v', "verbose", &verbose, 819 "be more verbose (show symbol address, etc)"), 820 OPT_BOOLEAN('F', "dont-fork", &dont_fork, 821 "Do not fork for testcase"), 822 OPT_END() 823 }; 824 const char * const test_subcommands[] = { "list", NULL }; 825 struct intlist *skiplist = NULL; 826 int ret = hists__init(); 827 828 if (ret < 0) 829 return ret; 830 831 argc = parse_options_subcommand(argc, argv, test_options, test_subcommands, test_usage, 0); 832 if (argc >= 1 && !strcmp(argv[0], "list")) 833 return perf_test__list(argc - 1, argv + 1); 834 835 symbol_conf.priv_size = sizeof(int); 836 symbol_conf.sort_by_name = true; 837 symbol_conf.try_vmlinux_path = true; 838 839 if (symbol__init(NULL) < 0) 840 return -1; 841 842 if (skip != NULL) 843 skiplist = intlist__new(skip); 844 /* 845 * Tests that create BPF maps, for instance, need more than the 64K 846 * default: 847 */ 848 rlimit__bump_memlock(); 849 850 return __cmd_test(argc, argv, skiplist); 851 } 852