1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (c) 2017 Facebook 3 */ 4 #define _GNU_SOURCE 5 #include "test_progs.h" 6 #include "cgroup_helpers.h" 7 #include "bpf_rlimit.h" 8 #include <argp.h> 9 #include <pthread.h> 10 #include <sched.h> 11 #include <signal.h> 12 #include <string.h> 13 #include <execinfo.h> /* backtrace */ 14 15 /* defined in test_progs.h */ 16 struct test_env env = {}; 17 18 struct prog_test_def { 19 const char *test_name; 20 int test_num; 21 void (*run_test)(void); 22 bool force_log; 23 int error_cnt; 24 int skip_cnt; 25 bool tested; 26 bool need_cgroup_cleanup; 27 28 char *subtest_name; 29 int subtest_num; 30 31 /* store counts before subtest started */ 32 int old_error_cnt; 33 }; 34 35 /* Override C runtime library's usleep() implementation to ensure nanosleep() 36 * is always called. Usleep is frequently used in selftests as a way to 37 * trigger kprobe and tracepoints. 38 */ 39 int usleep(useconds_t usec) 40 { 41 struct timespec ts = { 42 .tv_sec = usec / 1000000, 43 .tv_nsec = (usec % 1000000) * 1000, 44 }; 45 46 return syscall(__NR_nanosleep, &ts, NULL); 47 } 48 49 static bool should_run(struct test_selector *sel, int num, const char *name) 50 { 51 int i; 52 53 for (i = 0; i < sel->blacklist.cnt; i++) { 54 if (strstr(name, sel->blacklist.strs[i])) 55 return false; 56 } 57 58 for (i = 0; i < sel->whitelist.cnt; i++) { 59 if (strstr(name, sel->whitelist.strs[i])) 60 return true; 61 } 62 63 if (!sel->whitelist.cnt && !sel->num_set) 64 return true; 65 66 return num < sel->num_set_len && sel->num_set[num]; 67 } 68 69 static void dump_test_log(const struct prog_test_def *test, bool failed) 70 { 71 if (stdout == env.stdout) 72 return; 73 74 fflush(stdout); /* exports env.log_buf & env.log_cnt */ 75 76 if (env.verbosity > VERBOSE_NONE || test->force_log || failed) { 77 if (env.log_cnt) { 78 env.log_buf[env.log_cnt] = '\0'; 79 fprintf(env.stdout, "%s", env.log_buf); 80 if (env.log_buf[env.log_cnt - 1] != '\n') 81 fprintf(env.stdout, "\n"); 82 } 83 } 84 85 fseeko(stdout, 0, SEEK_SET); /* rewind */ 86 } 87 88 static void skip_account(void) 89 { 90 if (env.test->skip_cnt) { 91 env.skip_cnt++; 92 env.test->skip_cnt = 0; 93 } 94 } 95 96 static void stdio_restore(void); 97 98 /* A bunch of tests set custom affinity per-thread and/or per-process. Reset 99 * it after each test/sub-test. 100 */ 101 static void reset_affinity() { 102 103 cpu_set_t cpuset; 104 int i, err; 105 106 CPU_ZERO(&cpuset); 107 for (i = 0; i < env.nr_cpus; i++) 108 CPU_SET(i, &cpuset); 109 110 err = sched_setaffinity(0, sizeof(cpuset), &cpuset); 111 if (err < 0) { 112 stdio_restore(); 113 fprintf(stderr, "Failed to reset process affinity: %d!\n", err); 114 exit(-1); 115 } 116 err = pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset); 117 if (err < 0) { 118 stdio_restore(); 119 fprintf(stderr, "Failed to reset thread affinity: %d!\n", err); 120 exit(-1); 121 } 122 } 123 124 void test__end_subtest() 125 { 126 struct prog_test_def *test = env.test; 127 int sub_error_cnt = test->error_cnt - test->old_error_cnt; 128 129 if (sub_error_cnt) 130 env.fail_cnt++; 131 else 132 env.sub_succ_cnt++; 133 skip_account(); 134 135 dump_test_log(test, sub_error_cnt); 136 137 fprintf(env.stdout, "#%d/%d %s:%s\n", 138 test->test_num, test->subtest_num, 139 test->subtest_name, sub_error_cnt ? "FAIL" : "OK"); 140 141 reset_affinity(); 142 143 free(test->subtest_name); 144 test->subtest_name = NULL; 145 } 146 147 bool test__start_subtest(const char *name) 148 { 149 struct prog_test_def *test = env.test; 150 151 if (test->subtest_name) 152 test__end_subtest(); 153 154 test->subtest_num++; 155 156 if (!name || !name[0]) { 157 fprintf(env.stderr, 158 "Subtest #%d didn't provide sub-test name!\n", 159 test->subtest_num); 160 return false; 161 } 162 163 if (!should_run(&env.subtest_selector, test->subtest_num, name)) 164 return false; 165 166 test->subtest_name = strdup(name); 167 if (!test->subtest_name) { 168 fprintf(env.stderr, 169 "Subtest #%d: failed to copy subtest name!\n", 170 test->subtest_num); 171 return false; 172 } 173 env.test->old_error_cnt = env.test->error_cnt; 174 175 return true; 176 } 177 178 void test__force_log() { 179 env.test->force_log = true; 180 } 181 182 void test__skip(void) 183 { 184 env.test->skip_cnt++; 185 } 186 187 void test__fail(void) 188 { 189 env.test->error_cnt++; 190 } 191 192 int test__join_cgroup(const char *path) 193 { 194 int fd; 195 196 if (!env.test->need_cgroup_cleanup) { 197 if (setup_cgroup_environment()) { 198 fprintf(stderr, 199 "#%d %s: Failed to setup cgroup environment\n", 200 env.test->test_num, env.test->test_name); 201 return -1; 202 } 203 204 env.test->need_cgroup_cleanup = true; 205 } 206 207 fd = create_and_get_cgroup(path); 208 if (fd < 0) { 209 fprintf(stderr, 210 "#%d %s: Failed to create cgroup '%s' (errno=%d)\n", 211 env.test->test_num, env.test->test_name, path, errno); 212 return fd; 213 } 214 215 if (join_cgroup(path)) { 216 fprintf(stderr, 217 "#%d %s: Failed to join cgroup '%s' (errno=%d)\n", 218 env.test->test_num, env.test->test_name, path, errno); 219 return -1; 220 } 221 222 return fd; 223 } 224 225 struct ipv4_packet pkt_v4 = { 226 .eth.h_proto = __bpf_constant_htons(ETH_P_IP), 227 .iph.ihl = 5, 228 .iph.protocol = IPPROTO_TCP, 229 .iph.tot_len = __bpf_constant_htons(MAGIC_BYTES), 230 .tcp.urg_ptr = 123, 231 .tcp.doff = 5, 232 }; 233 234 struct ipv6_packet pkt_v6 = { 235 .eth.h_proto = __bpf_constant_htons(ETH_P_IPV6), 236 .iph.nexthdr = IPPROTO_TCP, 237 .iph.payload_len = __bpf_constant_htons(MAGIC_BYTES), 238 .tcp.urg_ptr = 123, 239 .tcp.doff = 5, 240 }; 241 242 int bpf_find_map(const char *test, struct bpf_object *obj, const char *name) 243 { 244 struct bpf_map *map; 245 246 map = bpf_object__find_map_by_name(obj, name); 247 if (!map) { 248 fprintf(stdout, "%s:FAIL:map '%s' not found\n", test, name); 249 test__fail(); 250 return -1; 251 } 252 return bpf_map__fd(map); 253 } 254 255 static bool is_jit_enabled(void) 256 { 257 const char *jit_sysctl = "/proc/sys/net/core/bpf_jit_enable"; 258 bool enabled = false; 259 int sysctl_fd; 260 261 sysctl_fd = open(jit_sysctl, 0, O_RDONLY); 262 if (sysctl_fd != -1) { 263 char tmpc; 264 265 if (read(sysctl_fd, &tmpc, sizeof(tmpc)) == 1) 266 enabled = (tmpc != '0'); 267 close(sysctl_fd); 268 } 269 270 return enabled; 271 } 272 273 int compare_map_keys(int map1_fd, int map2_fd) 274 { 275 __u32 key, next_key; 276 char val_buf[PERF_MAX_STACK_DEPTH * 277 sizeof(struct bpf_stack_build_id)]; 278 int err; 279 280 err = bpf_map_get_next_key(map1_fd, NULL, &key); 281 if (err) 282 return err; 283 err = bpf_map_lookup_elem(map2_fd, &key, val_buf); 284 if (err) 285 return err; 286 287 while (bpf_map_get_next_key(map1_fd, &key, &next_key) == 0) { 288 err = bpf_map_lookup_elem(map2_fd, &next_key, val_buf); 289 if (err) 290 return err; 291 292 key = next_key; 293 } 294 if (errno != ENOENT) 295 return -1; 296 297 return 0; 298 } 299 300 int compare_stack_ips(int smap_fd, int amap_fd, int stack_trace_len) 301 { 302 __u32 key, next_key, *cur_key_p, *next_key_p; 303 char *val_buf1, *val_buf2; 304 int i, err = 0; 305 306 val_buf1 = malloc(stack_trace_len); 307 val_buf2 = malloc(stack_trace_len); 308 cur_key_p = NULL; 309 next_key_p = &key; 310 while (bpf_map_get_next_key(smap_fd, cur_key_p, next_key_p) == 0) { 311 err = bpf_map_lookup_elem(smap_fd, next_key_p, val_buf1); 312 if (err) 313 goto out; 314 err = bpf_map_lookup_elem(amap_fd, next_key_p, val_buf2); 315 if (err) 316 goto out; 317 for (i = 0; i < stack_trace_len; i++) { 318 if (val_buf1[i] != val_buf2[i]) { 319 err = -1; 320 goto out; 321 } 322 } 323 key = *next_key_p; 324 cur_key_p = &key; 325 next_key_p = &next_key; 326 } 327 if (errno != ENOENT) 328 err = -1; 329 330 out: 331 free(val_buf1); 332 free(val_buf2); 333 return err; 334 } 335 336 int extract_build_id(char *build_id, size_t size) 337 { 338 FILE *fp; 339 char *line = NULL; 340 size_t len = 0; 341 342 fp = popen("readelf -n ./urandom_read | grep 'Build ID'", "r"); 343 if (fp == NULL) 344 return -1; 345 346 if (getline(&line, &len, fp) == -1) 347 goto err; 348 fclose(fp); 349 350 if (len > size) 351 len = size; 352 memcpy(build_id, line, len); 353 build_id[len] = '\0'; 354 free(line); 355 return 0; 356 err: 357 fclose(fp); 358 return -1; 359 } 360 361 void *spin_lock_thread(void *arg) 362 { 363 __u32 duration, retval; 364 int err, prog_fd = *(u32 *) arg; 365 366 err = bpf_prog_test_run(prog_fd, 10000, &pkt_v4, sizeof(pkt_v4), 367 NULL, NULL, &retval, &duration); 368 CHECK(err || retval, "", 369 "err %d errno %d retval %d duration %d\n", 370 err, errno, retval, duration); 371 pthread_exit(arg); 372 } 373 374 /* extern declarations for test funcs */ 375 #define DEFINE_TEST(name) extern void test_##name(void); 376 #include <prog_tests/tests.h> 377 #undef DEFINE_TEST 378 379 static struct prog_test_def prog_test_defs[] = { 380 #define DEFINE_TEST(name) { \ 381 .test_name = #name, \ 382 .run_test = &test_##name, \ 383 }, 384 #include <prog_tests/tests.h> 385 #undef DEFINE_TEST 386 }; 387 const int prog_test_cnt = ARRAY_SIZE(prog_test_defs); 388 389 const char *argp_program_version = "test_progs 0.1"; 390 const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; 391 const char argp_program_doc[] = "BPF selftests test runner"; 392 393 enum ARG_KEYS { 394 ARG_TEST_NUM = 'n', 395 ARG_TEST_NAME = 't', 396 ARG_TEST_NAME_BLACKLIST = 'b', 397 ARG_VERIFIER_STATS = 's', 398 ARG_VERBOSE = 'v', 399 }; 400 401 static const struct argp_option opts[] = { 402 { "num", ARG_TEST_NUM, "NUM", 0, 403 "Run test number NUM only " }, 404 { "name", ARG_TEST_NAME, "NAMES", 0, 405 "Run tests with names containing any string from NAMES list" }, 406 { "name-blacklist", ARG_TEST_NAME_BLACKLIST, "NAMES", 0, 407 "Don't run tests with names containing any string from NAMES list" }, 408 { "verifier-stats", ARG_VERIFIER_STATS, NULL, 0, 409 "Output verifier statistics", }, 410 { "verbose", ARG_VERBOSE, "LEVEL", OPTION_ARG_OPTIONAL, 411 "Verbose output (use -vv or -vvv for progressively verbose output)" }, 412 {}, 413 }; 414 415 static int libbpf_print_fn(enum libbpf_print_level level, 416 const char *format, va_list args) 417 { 418 if (env.verbosity < VERBOSE_VERY && level == LIBBPF_DEBUG) 419 return 0; 420 vfprintf(stdout, format, args); 421 return 0; 422 } 423 424 static void free_str_set(const struct str_set *set) 425 { 426 int i; 427 428 if (!set) 429 return; 430 431 for (i = 0; i < set->cnt; i++) 432 free((void *)set->strs[i]); 433 free(set->strs); 434 } 435 436 static int parse_str_list(const char *s, struct str_set *set) 437 { 438 char *input, *state = NULL, *next, **tmp, **strs = NULL; 439 int cnt = 0; 440 441 input = strdup(s); 442 if (!input) 443 return -ENOMEM; 444 445 set->cnt = 0; 446 set->strs = NULL; 447 448 while ((next = strtok_r(state ? NULL : input, ",", &state))) { 449 tmp = realloc(strs, sizeof(*strs) * (cnt + 1)); 450 if (!tmp) 451 goto err; 452 strs = tmp; 453 454 strs[cnt] = strdup(next); 455 if (!strs[cnt]) 456 goto err; 457 458 cnt++; 459 } 460 461 set->cnt = cnt; 462 set->strs = (const char **)strs; 463 free(input); 464 return 0; 465 err: 466 free(strs); 467 free(input); 468 return -ENOMEM; 469 } 470 471 int parse_num_list(const char *s, struct test_selector *sel) 472 { 473 int i, set_len = 0, new_len, num, start = 0, end = -1; 474 bool *set = NULL, *tmp, parsing_end = false; 475 char *next; 476 477 while (s[0]) { 478 errno = 0; 479 num = strtol(s, &next, 10); 480 if (errno) 481 return -errno; 482 483 if (parsing_end) 484 end = num; 485 else 486 start = num; 487 488 if (!parsing_end && *next == '-') { 489 s = next + 1; 490 parsing_end = true; 491 continue; 492 } else if (*next == ',') { 493 parsing_end = false; 494 s = next + 1; 495 end = num; 496 } else if (*next == '\0') { 497 parsing_end = false; 498 s = next; 499 end = num; 500 } else { 501 return -EINVAL; 502 } 503 504 if (start > end) 505 return -EINVAL; 506 507 if (end + 1 > set_len) { 508 new_len = end + 1; 509 tmp = realloc(set, new_len); 510 if (!tmp) { 511 free(set); 512 return -ENOMEM; 513 } 514 for (i = set_len; i < start; i++) 515 tmp[i] = false; 516 set = tmp; 517 set_len = new_len; 518 } 519 for (i = start; i <= end; i++) 520 set[i] = true; 521 } 522 523 if (!set) 524 return -EINVAL; 525 526 sel->num_set = set; 527 sel->num_set_len = set_len; 528 529 return 0; 530 } 531 532 extern int extra_prog_load_log_flags; 533 534 static error_t parse_arg(int key, char *arg, struct argp_state *state) 535 { 536 struct test_env *env = state->input; 537 538 switch (key) { 539 case ARG_TEST_NUM: { 540 char *subtest_str = strchr(arg, '/'); 541 542 if (subtest_str) { 543 *subtest_str = '\0'; 544 if (parse_num_list(subtest_str + 1, 545 &env->subtest_selector)) { 546 fprintf(stderr, 547 "Failed to parse subtest numbers.\n"); 548 return -EINVAL; 549 } 550 } 551 if (parse_num_list(arg, &env->test_selector)) { 552 fprintf(stderr, "Failed to parse test numbers.\n"); 553 return -EINVAL; 554 } 555 break; 556 } 557 case ARG_TEST_NAME: { 558 char *subtest_str = strchr(arg, '/'); 559 560 if (subtest_str) { 561 *subtest_str = '\0'; 562 if (parse_str_list(subtest_str + 1, 563 &env->subtest_selector.whitelist)) 564 return -ENOMEM; 565 } 566 if (parse_str_list(arg, &env->test_selector.whitelist)) 567 return -ENOMEM; 568 break; 569 } 570 case ARG_TEST_NAME_BLACKLIST: { 571 char *subtest_str = strchr(arg, '/'); 572 573 if (subtest_str) { 574 *subtest_str = '\0'; 575 if (parse_str_list(subtest_str + 1, 576 &env->subtest_selector.blacklist)) 577 return -ENOMEM; 578 } 579 if (parse_str_list(arg, &env->test_selector.blacklist)) 580 return -ENOMEM; 581 break; 582 } 583 case ARG_VERIFIER_STATS: 584 env->verifier_stats = true; 585 break; 586 case ARG_VERBOSE: 587 env->verbosity = VERBOSE_NORMAL; 588 if (arg) { 589 if (strcmp(arg, "v") == 0) { 590 env->verbosity = VERBOSE_VERY; 591 extra_prog_load_log_flags = 1; 592 } else if (strcmp(arg, "vv") == 0) { 593 env->verbosity = VERBOSE_SUPER; 594 extra_prog_load_log_flags = 2; 595 } else { 596 fprintf(stderr, 597 "Unrecognized verbosity setting ('%s'), only -v and -vv are supported\n", 598 arg); 599 return -EINVAL; 600 } 601 } 602 break; 603 case ARGP_KEY_ARG: 604 argp_usage(state); 605 break; 606 case ARGP_KEY_END: 607 break; 608 default: 609 return ARGP_ERR_UNKNOWN; 610 } 611 return 0; 612 } 613 614 static void stdio_hijack(void) 615 { 616 #ifdef __GLIBC__ 617 env.stdout = stdout; 618 env.stderr = stderr; 619 620 if (env.verbosity > VERBOSE_NONE) { 621 /* nothing to do, output to stdout by default */ 622 return; 623 } 624 625 /* stdout and stderr -> buffer */ 626 fflush(stdout); 627 628 stdout = open_memstream(&env.log_buf, &env.log_cnt); 629 if (!stdout) { 630 stdout = env.stdout; 631 perror("open_memstream"); 632 return; 633 } 634 635 stderr = stdout; 636 #endif 637 } 638 639 static void stdio_restore(void) 640 { 641 #ifdef __GLIBC__ 642 if (stdout == env.stdout) 643 return; 644 645 fclose(stdout); 646 free(env.log_buf); 647 648 env.log_buf = NULL; 649 env.log_cnt = 0; 650 651 stdout = env.stdout; 652 stderr = env.stderr; 653 #endif 654 } 655 656 /* 657 * Determine if test_progs is running as a "flavored" test runner and switch 658 * into corresponding sub-directory to load correct BPF objects. 659 * 660 * This is done by looking at executable name. If it contains "-flavor" 661 * suffix, then we are running as a flavored test runner. 662 */ 663 int cd_flavor_subdir(const char *exec_name) 664 { 665 /* General form of argv[0] passed here is: 666 * some/path/to/test_progs[-flavor], where -flavor part is optional. 667 * First cut out "test_progs[-flavor]" part, then extract "flavor" 668 * part, if it's there. 669 */ 670 const char *flavor = strrchr(exec_name, '/'); 671 672 if (!flavor) 673 return 0; 674 flavor++; 675 flavor = strrchr(flavor, '-'); 676 if (!flavor) 677 return 0; 678 flavor++; 679 fprintf(stdout, "Switching to flavor '%s' subdirectory...\n", flavor); 680 return chdir(flavor); 681 } 682 683 #define MAX_BACKTRACE_SZ 128 684 void crash_handler(int signum) 685 { 686 void *bt[MAX_BACKTRACE_SZ]; 687 size_t sz; 688 689 sz = backtrace(bt, ARRAY_SIZE(bt)); 690 691 if (env.test) 692 dump_test_log(env.test, true); 693 if (env.stdout) 694 stdio_restore(); 695 696 fprintf(stderr, "Caught signal #%d!\nStack trace:\n", signum); 697 backtrace_symbols_fd(bt, sz, STDERR_FILENO); 698 } 699 700 int main(int argc, char **argv) 701 { 702 static const struct argp argp = { 703 .options = opts, 704 .parser = parse_arg, 705 .doc = argp_program_doc, 706 }; 707 struct sigaction sigact = { 708 .sa_handler = crash_handler, 709 .sa_flags = SA_RESETHAND, 710 }; 711 int err, i; 712 713 sigaction(SIGSEGV, &sigact, NULL); 714 715 err = argp_parse(&argp, argc, argv, 0, NULL, &env); 716 if (err) 717 return err; 718 719 err = cd_flavor_subdir(argv[0]); 720 if (err) 721 return err; 722 723 libbpf_set_print(libbpf_print_fn); 724 725 srand(time(NULL)); 726 727 env.jit_enabled = is_jit_enabled(); 728 env.nr_cpus = libbpf_num_possible_cpus(); 729 if (env.nr_cpus < 0) { 730 fprintf(stderr, "Failed to get number of CPUs: %d!\n", 731 env.nr_cpus); 732 return -1; 733 } 734 735 stdio_hijack(); 736 for (i = 0; i < prog_test_cnt; i++) { 737 struct prog_test_def *test = &prog_test_defs[i]; 738 739 env.test = test; 740 test->test_num = i + 1; 741 742 if (!should_run(&env.test_selector, 743 test->test_num, test->test_name)) 744 continue; 745 746 test->run_test(); 747 /* ensure last sub-test is finalized properly */ 748 if (test->subtest_name) 749 test__end_subtest(); 750 751 test->tested = true; 752 if (test->error_cnt) 753 env.fail_cnt++; 754 else 755 env.succ_cnt++; 756 skip_account(); 757 758 dump_test_log(test, test->error_cnt); 759 760 fprintf(env.stdout, "#%d %s:%s\n", 761 test->test_num, test->test_name, 762 test->error_cnt ? "FAIL" : "OK"); 763 764 reset_affinity(); 765 if (test->need_cgroup_cleanup) 766 cleanup_cgroup_environment(); 767 } 768 stdio_restore(); 769 fprintf(stdout, "Summary: %d/%d PASSED, %d SKIPPED, %d FAILED\n", 770 env.succ_cnt, env.sub_succ_cnt, env.skip_cnt, env.fail_cnt); 771 772 free_str_set(&env.test_selector.blacklist); 773 free_str_set(&env.test_selector.whitelist); 774 free(env.test_selector.num_set); 775 free_str_set(&env.subtest_selector.blacklist); 776 free_str_set(&env.subtest_selector.whitelist); 777 free(env.subtest_selector.num_set); 778 779 return env.fail_cnt ? EXIT_FAILURE : EXIT_SUCCESS; 780 } 781