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 "config.h" 18 #include "hist.h" 19 #include "intlist.h" 20 #include "tests.h" 21 #include "debug.h" 22 #include "color.h" 23 #include <subcmd/parse-options.h> 24 #include "string2.h" 25 #include "symbol.h" 26 #include "util/rlimit.h" 27 #include <linux/kernel.h> 28 #include <linux/string.h> 29 #include <subcmd/exec-cmd.h> 30 #include <linux/zalloc.h> 31 32 #include "builtin-test-list.h" 33 34 static bool dont_fork; 35 const char *dso_to_test; 36 const char *test_objdump_path = "objdump"; 37 38 /* 39 * List of architecture specific tests. Not a weak symbol as the array length is 40 * dependent on the initialization, as such GCC with LTO complains of 41 * conflicting definitions with a weak symbol. 42 */ 43 #if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__) || defined(__powerpc64__) 44 extern struct test_suite *arch_tests[]; 45 #else 46 static struct test_suite *arch_tests[] = { 47 NULL, 48 }; 49 #endif 50 51 static struct test_suite *generic_tests[] = { 52 &suite__vmlinux_matches_kallsyms, 53 #ifdef HAVE_LIBTRACEEVENT 54 &suite__openat_syscall_event, 55 &suite__openat_syscall_event_on_all_cpus, 56 &suite__basic_mmap, 57 #endif 58 &suite__mem, 59 &suite__parse_events, 60 &suite__expr, 61 &suite__PERF_RECORD, 62 &suite__pmu, 63 &suite__pmu_events, 64 &suite__dso_data, 65 &suite__perf_evsel__roundtrip_name_test, 66 #ifdef HAVE_LIBTRACEEVENT 67 &suite__perf_evsel__tp_sched_test, 68 &suite__syscall_openat_tp_fields, 69 #endif 70 &suite__attr, 71 &suite__hists_link, 72 &suite__python_use, 73 &suite__bp_signal, 74 &suite__bp_signal_overflow, 75 &suite__bp_accounting, 76 &suite__wp, 77 &suite__task_exit, 78 &suite__sw_clock_freq, 79 &suite__code_reading, 80 &suite__sample_parsing, 81 &suite__keep_tracking, 82 &suite__parse_no_sample_id_all, 83 &suite__hists_filter, 84 &suite__mmap_thread_lookup, 85 &suite__thread_maps_share, 86 &suite__hists_output, 87 &suite__hists_cumulate, 88 #ifdef HAVE_LIBTRACEEVENT 89 &suite__switch_tracking, 90 #endif 91 &suite__fdarray__filter, 92 &suite__fdarray__add, 93 &suite__kmod_path__parse, 94 &suite__thread_map, 95 &suite__session_topology, 96 &suite__thread_map_synthesize, 97 &suite__thread_map_remove, 98 &suite__cpu_map, 99 &suite__synthesize_stat_config, 100 &suite__synthesize_stat, 101 &suite__synthesize_stat_round, 102 &suite__event_update, 103 &suite__event_times, 104 &suite__backward_ring_buffer, 105 &suite__sdt_event, 106 &suite__is_printable_array, 107 &suite__bitmap_print, 108 &suite__perf_hooks, 109 &suite__unit_number__scnprint, 110 &suite__mem2node, 111 &suite__time_utils, 112 &suite__jit_write_elf, 113 &suite__pfm, 114 &suite__api_io, 115 &suite__maps__merge_in, 116 &suite__demangle_java, 117 &suite__demangle_ocaml, 118 &suite__parse_metric, 119 &suite__pe_file_parsing, 120 &suite__expand_cgroup_events, 121 &suite__perf_time_to_tsc, 122 &suite__dlfilter, 123 &suite__sigtrap, 124 &suite__event_groups, 125 &suite__symbols, 126 &suite__util, 127 NULL, 128 }; 129 130 static struct test_suite **tests[] = { 131 generic_tests, 132 arch_tests, 133 }; 134 135 static struct test_workload *workloads[] = { 136 &workload__noploop, 137 &workload__thloop, 138 &workload__leafloop, 139 &workload__sqrtloop, 140 &workload__brstack, 141 &workload__datasym, 142 }; 143 144 static int num_subtests(const struct test_suite *t) 145 { 146 int num; 147 148 if (!t->test_cases) 149 return 0; 150 151 num = 0; 152 while (t->test_cases[num].name) 153 num++; 154 155 return num; 156 } 157 158 static bool has_subtests(const struct test_suite *t) 159 { 160 return num_subtests(t) > 1; 161 } 162 163 static const char *skip_reason(const struct test_suite *t, int subtest) 164 { 165 if (!t->test_cases) 166 return NULL; 167 168 return t->test_cases[subtest >= 0 ? subtest : 0].skip_reason; 169 } 170 171 static const char *test_description(const struct test_suite *t, int subtest) 172 { 173 if (t->test_cases && subtest >= 0) 174 return t->test_cases[subtest].desc; 175 176 return t->desc; 177 } 178 179 static test_fnptr test_function(const struct test_suite *t, int subtest) 180 { 181 if (subtest <= 0) 182 return t->test_cases[0].run_case; 183 184 return t->test_cases[subtest].run_case; 185 } 186 187 static bool perf_test__matches(const char *desc, int curr, int argc, const char *argv[]) 188 { 189 int i; 190 191 if (argc == 0) 192 return true; 193 194 for (i = 0; i < argc; ++i) { 195 char *end; 196 long nr = strtoul(argv[i], &end, 10); 197 198 if (*end == '\0') { 199 if (nr == curr + 1) 200 return true; 201 continue; 202 } 203 204 if (strcasestr(desc, argv[i])) 205 return true; 206 } 207 208 return false; 209 } 210 211 static int run_test(struct test_suite *test, int subtest) 212 { 213 int status, err = -1, child = dont_fork ? 0 : fork(); 214 char sbuf[STRERR_BUFSIZE]; 215 216 if (child < 0) { 217 pr_err("failed to fork test: %s\n", 218 str_error_r(errno, sbuf, sizeof(sbuf))); 219 return -1; 220 } 221 222 if (!child) { 223 if (!dont_fork) { 224 pr_debug("test child forked, pid %d\n", getpid()); 225 226 if (verbose <= 0) { 227 int nullfd = open("/dev/null", O_WRONLY); 228 229 if (nullfd >= 0) { 230 close(STDERR_FILENO); 231 close(STDOUT_FILENO); 232 233 dup2(nullfd, STDOUT_FILENO); 234 dup2(STDOUT_FILENO, STDERR_FILENO); 235 close(nullfd); 236 } 237 } else { 238 signal(SIGSEGV, sighandler_dump_stack); 239 signal(SIGFPE, sighandler_dump_stack); 240 } 241 } 242 243 err = test_function(test, subtest)(test, subtest); 244 if (!dont_fork) 245 exit(err); 246 } 247 248 if (!dont_fork) { 249 wait(&status); 250 251 if (WIFEXITED(status)) { 252 err = (signed char)WEXITSTATUS(status); 253 pr_debug("test child finished with %d\n", err); 254 } else if (WIFSIGNALED(status)) { 255 err = -1; 256 pr_debug("test child interrupted\n"); 257 } 258 } 259 260 return err; 261 } 262 263 #define for_each_test(j, k, t) \ 264 for (j = 0, k = 0; j < ARRAY_SIZE(tests); j++, k = 0) \ 265 while ((t = tests[j][k++]) != NULL) 266 267 static int test_and_print(struct test_suite *t, int subtest) 268 { 269 int err; 270 271 pr_debug("\n--- start ---\n"); 272 err = run_test(t, subtest); 273 pr_debug("---- end ----\n"); 274 275 if (!has_subtests(t)) 276 pr_debug("%s:", t->desc); 277 else 278 pr_debug("%s subtest %d:", t->desc, subtest + 1); 279 280 switch (err) { 281 case TEST_OK: 282 pr_info(" Ok\n"); 283 break; 284 case TEST_SKIP: { 285 const char *reason = skip_reason(t, subtest); 286 287 if (reason) 288 color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (%s)\n", reason); 289 else 290 color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip\n"); 291 } 292 break; 293 case TEST_FAIL: 294 default: 295 color_fprintf(stderr, PERF_COLOR_RED, " FAILED!\n"); 296 break; 297 } 298 299 return err; 300 } 301 302 struct shell_test { 303 const char *dir; 304 const char *file; 305 }; 306 307 static int shell_test__run(struct test_suite *test, int subdir __maybe_unused) 308 { 309 int err; 310 char script[PATH_MAX]; 311 struct shell_test *st = test->priv; 312 313 path__join(script, sizeof(script) - 3, st->dir, st->file); 314 315 if (verbose > 0) 316 strncat(script, " -v", sizeof(script) - strlen(script) - 1); 317 318 err = system(script); 319 if (!err) 320 return TEST_OK; 321 322 return WEXITSTATUS(err) == 2 ? TEST_SKIP : TEST_FAIL; 323 } 324 325 static int run_shell_tests(int argc, const char *argv[], int i, int width, 326 struct intlist *skiplist) 327 { 328 struct shell_test st; 329 const struct script_file *files, *file; 330 331 files = list_script_files(); 332 if (!files) 333 return 0; 334 for (file = files; file->dir; file++) { 335 int curr = i++; 336 struct test_case test_cases[] = { 337 { 338 .desc = file->desc, 339 .run_case = shell_test__run, 340 }, 341 { .name = NULL, } 342 }; 343 struct test_suite test_suite = { 344 .desc = test_cases[0].desc, 345 .test_cases = test_cases, 346 .priv = &st, 347 }; 348 st.dir = file->dir; 349 350 if (test_suite.desc == NULL || 351 !perf_test__matches(test_suite.desc, curr, argc, argv)) 352 continue; 353 354 st.file = file->file; 355 pr_info("%3d: %-*s:", i, width, test_suite.desc); 356 357 if (intlist__find(skiplist, i)) { 358 color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (user override)\n"); 359 continue; 360 } 361 362 test_and_print(&test_suite, 0); 363 } 364 return 0; 365 } 366 367 static int __cmd_test(int argc, const char *argv[], struct intlist *skiplist) 368 { 369 struct test_suite *t; 370 unsigned int j, k; 371 int i = 0; 372 int width = list_script_max_width(); 373 374 for_each_test(j, k, t) { 375 int len = strlen(test_description(t, -1)); 376 377 if (width < len) 378 width = len; 379 } 380 381 for_each_test(j, k, t) { 382 int curr = i++; 383 int subi; 384 385 if (!perf_test__matches(test_description(t, -1), curr, argc, argv)) { 386 bool skip = true; 387 int subn; 388 389 subn = num_subtests(t); 390 391 for (subi = 0; subi < subn; subi++) { 392 if (perf_test__matches(test_description(t, subi), 393 curr, argc, argv)) 394 skip = false; 395 } 396 397 if (skip) 398 continue; 399 } 400 401 pr_info("%3d: %-*s:", i, width, test_description(t, -1)); 402 403 if (intlist__find(skiplist, i)) { 404 color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (user override)\n"); 405 continue; 406 } 407 408 if (!has_subtests(t)) { 409 test_and_print(t, -1); 410 } else { 411 int subn = num_subtests(t); 412 /* 413 * minus 2 to align with normal testcases. 414 * For subtest we print additional '.x' in number. 415 * for example: 416 * 417 * 35: Test LLVM searching and compiling : 418 * 35.1: Basic BPF llvm compiling test : Ok 419 */ 420 int subw = width > 2 ? width - 2 : width; 421 422 if (subn <= 0) { 423 color_fprintf(stderr, PERF_COLOR_YELLOW, 424 " Skip (not compiled in)\n"); 425 continue; 426 } 427 pr_info("\n"); 428 429 for (subi = 0; subi < subn; subi++) { 430 int len = strlen(test_description(t, subi)); 431 432 if (subw < len) 433 subw = len; 434 } 435 436 for (subi = 0; subi < subn; subi++) { 437 if (!perf_test__matches(test_description(t, subi), 438 curr, argc, argv)) 439 continue; 440 441 pr_info("%3d.%1d: %-*s:", i, subi + 1, subw, 442 test_description(t, subi)); 443 test_and_print(t, subi); 444 } 445 } 446 } 447 448 return run_shell_tests(argc, argv, i, width, skiplist); 449 } 450 451 static int perf_test__list_shell(int argc, const char **argv, int i) 452 { 453 const struct script_file *files, *file; 454 455 files = list_script_files(); 456 if (!files) 457 return 0; 458 for (file = files; file->dir; file++) { 459 int curr = i++; 460 struct test_suite t = { 461 .desc = file->desc 462 }; 463 464 if (!perf_test__matches(t.desc, curr, argc, argv)) 465 continue; 466 467 pr_info("%3d: %s\n", i, t.desc); 468 } 469 return 0; 470 } 471 472 static int perf_test__list(int argc, const char **argv) 473 { 474 unsigned int j, k; 475 struct test_suite *t; 476 int i = 0; 477 478 for_each_test(j, k, t) { 479 int curr = i++; 480 481 if (!perf_test__matches(test_description(t, -1), curr, argc, argv)) 482 continue; 483 484 pr_info("%3d: %s\n", i, test_description(t, -1)); 485 486 if (has_subtests(t)) { 487 int subn = num_subtests(t); 488 int subi; 489 490 for (subi = 0; subi < subn; subi++) 491 pr_info("%3d:%1d: %s\n", i, subi + 1, 492 test_description(t, subi)); 493 } 494 } 495 496 perf_test__list_shell(argc, argv, i); 497 498 return 0; 499 } 500 501 static int run_workload(const char *work, int argc, const char **argv) 502 { 503 unsigned int i = 0; 504 struct test_workload *twl; 505 506 for (i = 0; i < ARRAY_SIZE(workloads); i++) { 507 twl = workloads[i]; 508 if (!strcmp(twl->name, work)) 509 return twl->func(argc, argv); 510 } 511 512 pr_info("No workload found: %s\n", work); 513 return -1; 514 } 515 516 static int perf_test__config(const char *var, const char *value, 517 void *data __maybe_unused) 518 { 519 if (!strcmp(var, "annotate.objdump")) 520 test_objdump_path = value; 521 522 return 0; 523 } 524 525 int cmd_test(int argc, const char **argv) 526 { 527 const char *test_usage[] = { 528 "perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]", 529 NULL, 530 }; 531 const char *skip = NULL; 532 const char *workload = NULL; 533 const struct option test_options[] = { 534 OPT_STRING('s', "skip", &skip, "tests", "tests to skip"), 535 OPT_INCR('v', "verbose", &verbose, 536 "be more verbose (show symbol address, etc)"), 537 OPT_BOOLEAN('F', "dont-fork", &dont_fork, 538 "Do not fork for testcase"), 539 OPT_STRING('w', "workload", &workload, "work", "workload to run for testing"), 540 OPT_STRING(0, "dso", &dso_to_test, "dso", "dso to test"), 541 OPT_STRING(0, "objdump", &test_objdump_path, "path", 542 "objdump binary to use for disassembly and annotations"), 543 OPT_END() 544 }; 545 const char * const test_subcommands[] = { "list", NULL }; 546 struct intlist *skiplist = NULL; 547 int ret = hists__init(); 548 549 if (ret < 0) 550 return ret; 551 552 perf_config(perf_test__config, NULL); 553 554 /* Unbuffered output */ 555 setvbuf(stdout, NULL, _IONBF, 0); 556 557 argc = parse_options_subcommand(argc, argv, test_options, test_subcommands, test_usage, 0); 558 if (argc >= 1 && !strcmp(argv[0], "list")) 559 return perf_test__list(argc - 1, argv + 1); 560 561 if (workload) 562 return run_workload(workload, argc, argv); 563 564 symbol_conf.priv_size = sizeof(int); 565 symbol_conf.try_vmlinux_path = true; 566 567 if (symbol__init(NULL) < 0) 568 return -1; 569 570 if (skip != NULL) 571 skiplist = intlist__new(skip); 572 /* 573 * Tests that create BPF maps, for instance, need more than the 64K 574 * default: 575 */ 576 rlimit__bump_memlock(); 577 578 return __cmd_test(argc, argv, skiplist); 579 } 580