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 "testing_helpers.h" 7#include "cgroup_helpers.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#include <sys/sysinfo.h> /* get_nprocs */ 15#include <netinet/in.h> 16#include <sys/select.h> 17#include <sys/socket.h> 18#include <sys/un.h> 19#include <bpf/btf.h> 20#include "json_writer.h" 21 22static bool verbose(void) 23{ 24 return env.verbosity > VERBOSE_NONE; 25} 26 27static void stdio_hijack_init(char **log_buf, size_t *log_cnt) 28{ 29#ifdef __GLIBC__ 30 if (verbose() && env.worker_id == -1) { 31 /* nothing to do, output to stdout by default */ 32 return; 33 } 34 35 fflush(stdout); 36 fflush(stderr); 37 38 stdout = open_memstream(log_buf, log_cnt); 39 if (!stdout) { 40 stdout = env.stdout; 41 perror("open_memstream"); 42 return; 43 } 44 45 if (env.subtest_state) 46 env.subtest_state->stdout = stdout; 47 else 48 env.test_state->stdout = stdout; 49 50 stderr = stdout; 51#endif 52} 53 54static void stdio_hijack(char **log_buf, size_t *log_cnt) 55{ 56#ifdef __GLIBC__ 57 if (verbose() && env.worker_id == -1) { 58 /* nothing to do, output to stdout by default */ 59 return; 60 } 61 62 env.stdout = stdout; 63 env.stderr = stderr; 64 65 stdio_hijack_init(log_buf, log_cnt); 66#endif 67} 68 69static void stdio_restore_cleanup(void) 70{ 71#ifdef __GLIBC__ 72 if (verbose() && env.worker_id == -1) { 73 /* nothing to do, output to stdout by default */ 74 return; 75 } 76 77 fflush(stdout); 78 79 if (env.subtest_state) { 80 fclose(env.subtest_state->stdout); 81 env.subtest_state->stdout = NULL; 82 stdout = env.test_state->stdout; 83 stderr = env.test_state->stdout; 84 } else { 85 fclose(env.test_state->stdout); 86 env.test_state->stdout = NULL; 87 } 88#endif 89} 90 91static void stdio_restore(void) 92{ 93#ifdef __GLIBC__ 94 if (verbose() && env.worker_id == -1) { 95 /* nothing to do, output to stdout by default */ 96 return; 97 } 98 99 if (stdout == env.stdout) 100 return; 101 102 stdio_restore_cleanup(); 103 104 stdout = env.stdout; 105 stderr = env.stderr; 106#endif 107} 108 109/* Adapted from perf/util/string.c */ 110static bool glob_match(const char *str, const char *pat) 111{ 112 while (*str && *pat && *pat != '*') { 113 if (*str != *pat) 114 return false; 115 str++; 116 pat++; 117 } 118 /* Check wild card */ 119 if (*pat == '*') { 120 while (*pat == '*') 121 pat++; 122 if (!*pat) /* Tail wild card matches all */ 123 return true; 124 while (*str) 125 if (glob_match(str++, pat)) 126 return true; 127 } 128 return !*str && !*pat; 129} 130 131#define EXIT_NO_TEST 2 132#define EXIT_ERR_SETUP_INFRA 3 133 134/* defined in test_progs.h */ 135struct test_env env = {}; 136 137struct prog_test_def { 138 const char *test_name; 139 int test_num; 140 void (*run_test)(void); 141 void (*run_serial_test)(void); 142 bool should_run; 143 bool need_cgroup_cleanup; 144}; 145 146/* Override C runtime library's usleep() implementation to ensure nanosleep() 147 * is always called. Usleep is frequently used in selftests as a way to 148 * trigger kprobe and tracepoints. 149 */ 150int usleep(useconds_t usec) 151{ 152 struct timespec ts = { 153 .tv_sec = usec / 1000000, 154 .tv_nsec = (usec % 1000000) * 1000, 155 }; 156 157 return syscall(__NR_nanosleep, &ts, NULL); 158} 159 160static bool should_run(struct test_selector *sel, int num, const char *name) 161{ 162 int i; 163 164 for (i = 0; i < sel->blacklist.cnt; i++) { 165 if (glob_match(name, sel->blacklist.tests[i].name) && 166 !sel->blacklist.tests[i].subtest_cnt) 167 return false; 168 } 169 170 for (i = 0; i < sel->whitelist.cnt; i++) { 171 if (glob_match(name, sel->whitelist.tests[i].name)) 172 return true; 173 } 174 175 if (!sel->whitelist.cnt && !sel->num_set) 176 return true; 177 178 return num < sel->num_set_len && sel->num_set[num]; 179} 180 181static bool should_run_subtest(struct test_selector *sel, 182 struct test_selector *subtest_sel, 183 int subtest_num, 184 const char *test_name, 185 const char *subtest_name) 186{ 187 int i, j; 188 189 for (i = 0; i < sel->blacklist.cnt; i++) { 190 if (glob_match(test_name, sel->blacklist.tests[i].name)) { 191 if (!sel->blacklist.tests[i].subtest_cnt) 192 return false; 193 194 for (j = 0; j < sel->blacklist.tests[i].subtest_cnt; j++) { 195 if (glob_match(subtest_name, 196 sel->blacklist.tests[i].subtests[j])) 197 return false; 198 } 199 } 200 } 201 202 for (i = 0; i < sel->whitelist.cnt; i++) { 203 if (glob_match(test_name, sel->whitelist.tests[i].name)) { 204 if (!sel->whitelist.tests[i].subtest_cnt) 205 return true; 206 207 for (j = 0; j < sel->whitelist.tests[i].subtest_cnt; j++) { 208 if (glob_match(subtest_name, 209 sel->whitelist.tests[i].subtests[j])) 210 return true; 211 } 212 } 213 } 214 215 if (!sel->whitelist.cnt && !subtest_sel->num_set) 216 return true; 217 218 return subtest_num < subtest_sel->num_set_len && subtest_sel->num_set[subtest_num]; 219} 220 221static char *test_result(bool failed, bool skipped) 222{ 223 return failed ? "FAIL" : (skipped ? "SKIP" : "OK"); 224} 225 226#define TEST_NUM_WIDTH 7 227 228static void print_test_result(const struct prog_test_def *test, const struct test_state *test_state) 229{ 230 int skipped_cnt = test_state->skip_cnt; 231 int subtests_cnt = test_state->subtest_num; 232 233 fprintf(env.stdout, "#%-*d %s:", TEST_NUM_WIDTH, test->test_num, test->test_name); 234 if (test_state->error_cnt) 235 fprintf(env.stdout, "FAIL"); 236 else if (!skipped_cnt) 237 fprintf(env.stdout, "OK"); 238 else if (skipped_cnt == subtests_cnt || !subtests_cnt) 239 fprintf(env.stdout, "SKIP"); 240 else 241 fprintf(env.stdout, "OK (SKIP: %d/%d)", skipped_cnt, subtests_cnt); 242 243 fprintf(env.stdout, "\n"); 244} 245 246static void print_test_log(char *log_buf, size_t log_cnt) 247{ 248 log_buf[log_cnt] = '\0'; 249 fprintf(env.stdout, "%s", log_buf); 250 if (log_buf[log_cnt - 1] != '\n') 251 fprintf(env.stdout, "\n"); 252} 253 254static void print_subtest_name(int test_num, int subtest_num, 255 const char *test_name, char *subtest_name, 256 char *result) 257{ 258 char test_num_str[TEST_NUM_WIDTH + 1]; 259 260 snprintf(test_num_str, sizeof(test_num_str), "%d/%d", test_num, subtest_num); 261 262 fprintf(env.stdout, "#%-*s %s/%s", 263 TEST_NUM_WIDTH, test_num_str, 264 test_name, subtest_name); 265 266 if (result) 267 fprintf(env.stdout, ":%s", result); 268 269 fprintf(env.stdout, "\n"); 270} 271 272static void jsonw_write_log_message(json_writer_t *w, char *log_buf, size_t log_cnt) 273{ 274 /* open_memstream (from stdio_hijack_init) ensures that log_bug is terminated by a 275 * null byte. Yet in parallel mode, log_buf will be NULL if there is no message. 276 */ 277 if (log_cnt) { 278 jsonw_string_field(w, "message", log_buf); 279 } else { 280 jsonw_string_field(w, "message", ""); 281 } 282} 283 284static void dump_test_log(const struct prog_test_def *test, 285 const struct test_state *test_state, 286 bool skip_ok_subtests, 287 bool par_exec_result, 288 json_writer_t *w) 289{ 290 bool test_failed = test_state->error_cnt > 0; 291 bool force_log = test_state->force_log; 292 bool print_test = verbose() || force_log || test_failed; 293 int i; 294 struct subtest_state *subtest_state; 295 bool subtest_failed; 296 bool subtest_filtered; 297 bool print_subtest; 298 299 /* we do not print anything in the worker thread */ 300 if (env.worker_id != -1) 301 return; 302 303 /* there is nothing to print when verbose log is used and execution 304 * is not in parallel mode 305 */ 306 if (verbose() && !par_exec_result) 307 return; 308 309 if (test_state->log_cnt && print_test) 310 print_test_log(test_state->log_buf, test_state->log_cnt); 311 312 if (w && print_test) { 313 jsonw_start_object(w); 314 jsonw_string_field(w, "name", test->test_name); 315 jsonw_uint_field(w, "number", test->test_num); 316 jsonw_write_log_message(w, test_state->log_buf, test_state->log_cnt); 317 jsonw_bool_field(w, "failed", test_failed); 318 jsonw_name(w, "subtests"); 319 jsonw_start_array(w); 320 } 321 322 for (i = 0; i < test_state->subtest_num; i++) { 323 subtest_state = &test_state->subtest_states[i]; 324 subtest_failed = subtest_state->error_cnt; 325 subtest_filtered = subtest_state->filtered; 326 print_subtest = verbose() || force_log || subtest_failed; 327 328 if ((skip_ok_subtests && !subtest_failed) || subtest_filtered) 329 continue; 330 331 if (subtest_state->log_cnt && print_subtest) { 332 print_test_log(subtest_state->log_buf, 333 subtest_state->log_cnt); 334 } 335 336 print_subtest_name(test->test_num, i + 1, 337 test->test_name, subtest_state->name, 338 test_result(subtest_state->error_cnt, 339 subtest_state->skipped)); 340 341 if (w && print_subtest) { 342 jsonw_start_object(w); 343 jsonw_string_field(w, "name", subtest_state->name); 344 jsonw_uint_field(w, "number", i+1); 345 jsonw_write_log_message(w, subtest_state->log_buf, subtest_state->log_cnt); 346 jsonw_bool_field(w, "failed", subtest_failed); 347 jsonw_end_object(w); 348 } 349 } 350 351 if (w && print_test) { 352 jsonw_end_array(w); 353 jsonw_end_object(w); 354 } 355 356 print_test_result(test, test_state); 357} 358 359static void stdio_restore(void); 360 361/* A bunch of tests set custom affinity per-thread and/or per-process. Reset 362 * it after each test/sub-test. 363 */ 364static void reset_affinity(void) 365{ 366 cpu_set_t cpuset; 367 int i, err; 368 369 CPU_ZERO(&cpuset); 370 for (i = 0; i < env.nr_cpus; i++) 371 CPU_SET(i, &cpuset); 372 373 err = sched_setaffinity(0, sizeof(cpuset), &cpuset); 374 if (err < 0) { 375 stdio_restore(); 376 fprintf(stderr, "Failed to reset process affinity: %d!\n", err); 377 exit(EXIT_ERR_SETUP_INFRA); 378 } 379 err = pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset); 380 if (err < 0) { 381 stdio_restore(); 382 fprintf(stderr, "Failed to reset thread affinity: %d!\n", err); 383 exit(EXIT_ERR_SETUP_INFRA); 384 } 385} 386 387static void save_netns(void) 388{ 389 env.saved_netns_fd = open("/proc/self/ns/net", O_RDONLY); 390 if (env.saved_netns_fd == -1) { 391 perror("open(/proc/self/ns/net)"); 392 exit(EXIT_ERR_SETUP_INFRA); 393 } 394} 395 396static void restore_netns(void) 397{ 398 if (setns(env.saved_netns_fd, CLONE_NEWNET) == -1) { 399 stdio_restore(); 400 perror("setns(CLONE_NEWNS)"); 401 exit(EXIT_ERR_SETUP_INFRA); 402 } 403} 404 405void test__end_subtest(void) 406{ 407 struct prog_test_def *test = env.test; 408 struct test_state *test_state = env.test_state; 409 struct subtest_state *subtest_state = env.subtest_state; 410 411 if (subtest_state->error_cnt) { 412 test_state->error_cnt++; 413 } else { 414 if (!subtest_state->skipped) 415 test_state->sub_succ_cnt++; 416 else 417 test_state->skip_cnt++; 418 } 419 420 if (verbose() && !env.workers) 421 print_subtest_name(test->test_num, test_state->subtest_num, 422 test->test_name, subtest_state->name, 423 test_result(subtest_state->error_cnt, 424 subtest_state->skipped)); 425 426 stdio_restore_cleanup(); 427 env.subtest_state = NULL; 428} 429 430bool test__start_subtest(const char *subtest_name) 431{ 432 struct prog_test_def *test = env.test; 433 struct test_state *state = env.test_state; 434 struct subtest_state *subtest_state; 435 size_t sub_state_size = sizeof(*subtest_state); 436 437 if (env.subtest_state) 438 test__end_subtest(); 439 440 state->subtest_num++; 441 state->subtest_states = 442 realloc(state->subtest_states, 443 state->subtest_num * sub_state_size); 444 if (!state->subtest_states) { 445 fprintf(stderr, "Not enough memory to allocate subtest result\n"); 446 return false; 447 } 448 449 subtest_state = &state->subtest_states[state->subtest_num - 1]; 450 451 memset(subtest_state, 0, sub_state_size); 452 453 if (!subtest_name || !subtest_name[0]) { 454 fprintf(env.stderr, 455 "Subtest #%d didn't provide sub-test name!\n", 456 state->subtest_num); 457 return false; 458 } 459 460 subtest_state->name = strdup(subtest_name); 461 if (!subtest_state->name) { 462 fprintf(env.stderr, 463 "Subtest #%d: failed to copy subtest name!\n", 464 state->subtest_num); 465 return false; 466 } 467 468 if (!should_run_subtest(&env.test_selector, 469 &env.subtest_selector, 470 state->subtest_num, 471 test->test_name, 472 subtest_name)) { 473 subtest_state->filtered = true; 474 return false; 475 } 476 477 env.subtest_state = subtest_state; 478 stdio_hijack_init(&subtest_state->log_buf, &subtest_state->log_cnt); 479 480 return true; 481} 482 483void test__force_log(void) 484{ 485 env.test_state->force_log = true; 486} 487 488void test__skip(void) 489{ 490 if (env.subtest_state) 491 env.subtest_state->skipped = true; 492 else 493 env.test_state->skip_cnt++; 494} 495 496void test__fail(void) 497{ 498 if (env.subtest_state) 499 env.subtest_state->error_cnt++; 500 else 501 env.test_state->error_cnt++; 502} 503 504int test__join_cgroup(const char *path) 505{ 506 int fd; 507 508 if (!env.test->need_cgroup_cleanup) { 509 if (setup_cgroup_environment()) { 510 fprintf(stderr, 511 "#%d %s: Failed to setup cgroup environment\n", 512 env.test->test_num, env.test->test_name); 513 return -1; 514 } 515 516 env.test->need_cgroup_cleanup = true; 517 } 518 519 fd = create_and_get_cgroup(path); 520 if (fd < 0) { 521 fprintf(stderr, 522 "#%d %s: Failed to create cgroup '%s' (errno=%d)\n", 523 env.test->test_num, env.test->test_name, path, errno); 524 return fd; 525 } 526 527 if (join_cgroup(path)) { 528 fprintf(stderr, 529 "#%d %s: Failed to join cgroup '%s' (errno=%d)\n", 530 env.test->test_num, env.test->test_name, path, errno); 531 return -1; 532 } 533 534 return fd; 535} 536 537int bpf_find_map(const char *test, struct bpf_object *obj, const char *name) 538{ 539 struct bpf_map *map; 540 541 map = bpf_object__find_map_by_name(obj, name); 542 if (!map) { 543 fprintf(stdout, "%s:FAIL:map '%s' not found\n", test, name); 544 test__fail(); 545 return -1; 546 } 547 return bpf_map__fd(map); 548} 549 550static bool is_jit_enabled(void) 551{ 552 const char *jit_sysctl = "/proc/sys/net/core/bpf_jit_enable"; 553 bool enabled = false; 554 int sysctl_fd; 555 556 sysctl_fd = open(jit_sysctl, 0, O_RDONLY); 557 if (sysctl_fd != -1) { 558 char tmpc; 559 560 if (read(sysctl_fd, &tmpc, sizeof(tmpc)) == 1) 561 enabled = (tmpc != '0'); 562 close(sysctl_fd); 563 } 564 565 return enabled; 566} 567 568int compare_map_keys(int map1_fd, int map2_fd) 569{ 570 __u32 key, next_key; 571 char val_buf[PERF_MAX_STACK_DEPTH * 572 sizeof(struct bpf_stack_build_id)]; 573 int err; 574 575 err = bpf_map_get_next_key(map1_fd, NULL, &key); 576 if (err) 577 return err; 578 err = bpf_map_lookup_elem(map2_fd, &key, val_buf); 579 if (err) 580 return err; 581 582 while (bpf_map_get_next_key(map1_fd, &key, &next_key) == 0) { 583 err = bpf_map_lookup_elem(map2_fd, &next_key, val_buf); 584 if (err) 585 return err; 586 587 key = next_key; 588 } 589 if (errno != ENOENT) 590 return -1; 591 592 return 0; 593} 594 595int compare_stack_ips(int smap_fd, int amap_fd, int stack_trace_len) 596{ 597 __u32 key, next_key, *cur_key_p, *next_key_p; 598 char *val_buf1, *val_buf2; 599 int i, err = 0; 600 601 val_buf1 = malloc(stack_trace_len); 602 val_buf2 = malloc(stack_trace_len); 603 cur_key_p = NULL; 604 next_key_p = &key; 605 while (bpf_map_get_next_key(smap_fd, cur_key_p, next_key_p) == 0) { 606 err = bpf_map_lookup_elem(smap_fd, next_key_p, val_buf1); 607 if (err) 608 goto out; 609 err = bpf_map_lookup_elem(amap_fd, next_key_p, val_buf2); 610 if (err) 611 goto out; 612 for (i = 0; i < stack_trace_len; i++) { 613 if (val_buf1[i] != val_buf2[i]) { 614 err = -1; 615 goto out; 616 } 617 } 618 key = *next_key_p; 619 cur_key_p = &key; 620 next_key_p = &next_key; 621 } 622 if (errno != ENOENT) 623 err = -1; 624 625out: 626 free(val_buf1); 627 free(val_buf2); 628 return err; 629} 630 631/* extern declarations for test funcs */ 632#define DEFINE_TEST(name) \ 633 extern void test_##name(void) __weak; \ 634 extern void serial_test_##name(void) __weak; 635#include <prog_tests/tests.h> 636#undef DEFINE_TEST 637 638static struct prog_test_def prog_test_defs[] = { 639#define DEFINE_TEST(name) { \ 640 .test_name = #name, \ 641 .run_test = &test_##name, \ 642 .run_serial_test = &serial_test_##name, \ 643}, 644#include <prog_tests/tests.h> 645#undef DEFINE_TEST 646}; 647 648static const int prog_test_cnt = ARRAY_SIZE(prog_test_defs); 649 650static struct test_state test_states[ARRAY_SIZE(prog_test_defs)]; 651 652const char *argp_program_version = "test_progs 0.1"; 653const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; 654static const char argp_program_doc[] = 655"BPF selftests test runner\v" 656"Options accepting the NAMES parameter take either a comma-separated list\n" 657"of test names, or a filename prefixed with @. The file contains one name\n" 658"(or wildcard pattern) per line, and comments beginning with # are ignored.\n" 659"\n" 660"These options can be passed repeatedly to read multiple files.\n"; 661 662enum ARG_KEYS { 663 ARG_TEST_NUM = 'n', 664 ARG_TEST_NAME = 't', 665 ARG_TEST_NAME_BLACKLIST = 'b', 666 ARG_VERIFIER_STATS = 's', 667 ARG_VERBOSE = 'v', 668 ARG_GET_TEST_CNT = 'c', 669 ARG_LIST_TEST_NAMES = 'l', 670 ARG_TEST_NAME_GLOB_ALLOWLIST = 'a', 671 ARG_TEST_NAME_GLOB_DENYLIST = 'd', 672 ARG_NUM_WORKERS = 'j', 673 ARG_DEBUG = -1, 674 ARG_JSON_SUMMARY = 'J' 675}; 676 677static const struct argp_option opts[] = { 678 { "num", ARG_TEST_NUM, "NUM", 0, 679 "Run test number NUM only " }, 680 { "name", ARG_TEST_NAME, "NAMES", 0, 681 "Run tests with names containing any string from NAMES list" }, 682 { "name-blacklist", ARG_TEST_NAME_BLACKLIST, "NAMES", 0, 683 "Don't run tests with names containing any string from NAMES list" }, 684 { "verifier-stats", ARG_VERIFIER_STATS, NULL, 0, 685 "Output verifier statistics", }, 686 { "verbose", ARG_VERBOSE, "LEVEL", OPTION_ARG_OPTIONAL, 687 "Verbose output (use -vv or -vvv for progressively verbose output)" }, 688 { "count", ARG_GET_TEST_CNT, NULL, 0, 689 "Get number of selected top-level tests " }, 690 { "list", ARG_LIST_TEST_NAMES, NULL, 0, 691 "List test names that would run (without running them) " }, 692 { "allow", ARG_TEST_NAME_GLOB_ALLOWLIST, "NAMES", 0, 693 "Run tests with name matching the pattern (supports '*' wildcard)." }, 694 { "deny", ARG_TEST_NAME_GLOB_DENYLIST, "NAMES", 0, 695 "Don't run tests with name matching the pattern (supports '*' wildcard)." }, 696 { "workers", ARG_NUM_WORKERS, "WORKERS", OPTION_ARG_OPTIONAL, 697 "Number of workers to run in parallel, default to number of cpus." }, 698 { "debug", ARG_DEBUG, NULL, 0, 699 "print extra debug information for test_progs." }, 700 { "json-summary", ARG_JSON_SUMMARY, "FILE", 0, "Write report in json format to this file."}, 701 {}, 702}; 703 704static int libbpf_print_fn(enum libbpf_print_level level, 705 const char *format, va_list args) 706{ 707 if (env.verbosity < VERBOSE_VERY && level == LIBBPF_DEBUG) 708 return 0; 709 vfprintf(stdout, format, args); 710 return 0; 711} 712 713static void free_test_filter_set(const struct test_filter_set *set) 714{ 715 int i, j; 716 717 if (!set) 718 return; 719 720 for (i = 0; i < set->cnt; i++) { 721 free((void *)set->tests[i].name); 722 for (j = 0; j < set->tests[i].subtest_cnt; j++) 723 free((void *)set->tests[i].subtests[j]); 724 725 free((void *)set->tests[i].subtests); 726 } 727 728 free((void *)set->tests); 729} 730 731static void free_test_selector(struct test_selector *test_selector) 732{ 733 free_test_filter_set(&test_selector->blacklist); 734 free_test_filter_set(&test_selector->whitelist); 735 free(test_selector->num_set); 736} 737 738extern int extra_prog_load_log_flags; 739 740static error_t parse_arg(int key, char *arg, struct argp_state *state) 741{ 742 struct test_env *env = state->input; 743 int err = 0; 744 745 switch (key) { 746 case ARG_TEST_NUM: { 747 char *subtest_str = strchr(arg, '/'); 748 749 if (subtest_str) { 750 *subtest_str = '\0'; 751 if (parse_num_list(subtest_str + 1, 752 &env->subtest_selector.num_set, 753 &env->subtest_selector.num_set_len)) { 754 fprintf(stderr, 755 "Failed to parse subtest numbers.\n"); 756 return -EINVAL; 757 } 758 } 759 if (parse_num_list(arg, &env->test_selector.num_set, 760 &env->test_selector.num_set_len)) { 761 fprintf(stderr, "Failed to parse test numbers.\n"); 762 return -EINVAL; 763 } 764 break; 765 } 766 case ARG_TEST_NAME_GLOB_ALLOWLIST: 767 case ARG_TEST_NAME: { 768 if (arg[0] == '@') 769 err = parse_test_list_file(arg + 1, 770 &env->test_selector.whitelist, 771 key == ARG_TEST_NAME_GLOB_ALLOWLIST); 772 else 773 err = parse_test_list(arg, 774 &env->test_selector.whitelist, 775 key == ARG_TEST_NAME_GLOB_ALLOWLIST); 776 777 break; 778 } 779 case ARG_TEST_NAME_GLOB_DENYLIST: 780 case ARG_TEST_NAME_BLACKLIST: { 781 if (arg[0] == '@') 782 err = parse_test_list_file(arg + 1, 783 &env->test_selector.blacklist, 784 key == ARG_TEST_NAME_GLOB_DENYLIST); 785 else 786 err = parse_test_list(arg, 787 &env->test_selector.blacklist, 788 key == ARG_TEST_NAME_GLOB_DENYLIST); 789 790 break; 791 } 792 case ARG_VERIFIER_STATS: 793 env->verifier_stats = true; 794 break; 795 case ARG_VERBOSE: 796 env->verbosity = VERBOSE_NORMAL; 797 if (arg) { 798 if (strcmp(arg, "v") == 0) { 799 env->verbosity = VERBOSE_VERY; 800 extra_prog_load_log_flags = 1; 801 } else if (strcmp(arg, "vv") == 0) { 802 env->verbosity = VERBOSE_SUPER; 803 extra_prog_load_log_flags = 2; 804 } else { 805 fprintf(stderr, 806 "Unrecognized verbosity setting ('%s'), only -v and -vv are supported\n", 807 arg); 808 return -EINVAL; 809 } 810 } 811 812 if (verbose()) { 813 if (setenv("SELFTESTS_VERBOSE", "1", 1) == -1) { 814 fprintf(stderr, 815 "Unable to setenv SELFTESTS_VERBOSE=1 (errno=%d)", 816 errno); 817 return -EINVAL; 818 } 819 } 820 821 break; 822 case ARG_GET_TEST_CNT: 823 env->get_test_cnt = true; 824 break; 825 case ARG_LIST_TEST_NAMES: 826 env->list_test_names = true; 827 break; 828 case ARG_NUM_WORKERS: 829 if (arg) { 830 env->workers = atoi(arg); 831 if (!env->workers) { 832 fprintf(stderr, "Invalid number of worker: %s.", arg); 833 return -EINVAL; 834 } 835 } else { 836 env->workers = get_nprocs(); 837 } 838 break; 839 case ARG_DEBUG: 840 env->debug = true; 841 break; 842 case ARG_JSON_SUMMARY: 843 env->json = fopen(arg, "w"); 844 if (env->json == NULL) { 845 perror("Failed to open json summary file"); 846 return -errno; 847 } 848 break; 849 case ARGP_KEY_ARG: 850 argp_usage(state); 851 break; 852 case ARGP_KEY_END: 853 break; 854 default: 855 return ARGP_ERR_UNKNOWN; 856 } 857 return err; 858} 859 860/* 861 * Determine if test_progs is running as a "flavored" test runner and switch 862 * into corresponding sub-directory to load correct BPF objects. 863 * 864 * This is done by looking at executable name. If it contains "-flavor" 865 * suffix, then we are running as a flavored test runner. 866 */ 867int cd_flavor_subdir(const char *exec_name) 868{ 869 /* General form of argv[0] passed here is: 870 * some/path/to/test_progs[-flavor], where -flavor part is optional. 871 * First cut out "test_progs[-flavor]" part, then extract "flavor" 872 * part, if it's there. 873 */ 874 const char *flavor = strrchr(exec_name, '/'); 875 876 if (!flavor) 877 flavor = exec_name; 878 else 879 flavor++; 880 881 flavor = strrchr(flavor, '-'); 882 if (!flavor) 883 return 0; 884 flavor++; 885 if (verbose()) 886 fprintf(stdout, "Switching to flavor '%s' subdirectory...\n", flavor); 887 888 return chdir(flavor); 889} 890 891int trigger_module_test_read(int read_sz) 892{ 893 int fd, err; 894 895 fd = open(BPF_TESTMOD_TEST_FILE, O_RDONLY); 896 err = -errno; 897 if (!ASSERT_GE(fd, 0, "testmod_file_open")) 898 return err; 899 900 read(fd, NULL, read_sz); 901 close(fd); 902 903 return 0; 904} 905 906int trigger_module_test_write(int write_sz) 907{ 908 int fd, err; 909 char *buf = malloc(write_sz); 910 911 if (!buf) 912 return -ENOMEM; 913 914 memset(buf, 'a', write_sz); 915 buf[write_sz-1] = '\0'; 916 917 fd = open(BPF_TESTMOD_TEST_FILE, O_WRONLY); 918 err = -errno; 919 if (!ASSERT_GE(fd, 0, "testmod_file_open")) { 920 free(buf); 921 return err; 922 } 923 924 write(fd, buf, write_sz); 925 close(fd); 926 free(buf); 927 return 0; 928} 929 930int write_sysctl(const char *sysctl, const char *value) 931{ 932 int fd, err, len; 933 934 fd = open(sysctl, O_WRONLY); 935 if (!ASSERT_NEQ(fd, -1, "open sysctl")) 936 return -1; 937 938 len = strlen(value); 939 err = write(fd, value, len); 940 close(fd); 941 if (!ASSERT_EQ(err, len, "write sysctl")) 942 return -1; 943 944 return 0; 945} 946 947int get_bpf_max_tramp_links_from(struct btf *btf) 948{ 949 const struct btf_enum *e; 950 const struct btf_type *t; 951 __u32 i, type_cnt; 952 const char *name; 953 __u16 j, vlen; 954 955 for (i = 1, type_cnt = btf__type_cnt(btf); i < type_cnt; i++) { 956 t = btf__type_by_id(btf, i); 957 if (!t || !btf_is_enum(t) || t->name_off) 958 continue; 959 e = btf_enum(t); 960 for (j = 0, vlen = btf_vlen(t); j < vlen; j++, e++) { 961 name = btf__str_by_offset(btf, e->name_off); 962 if (name && !strcmp(name, "BPF_MAX_TRAMP_LINKS")) 963 return e->val; 964 } 965 } 966 967 return -1; 968} 969 970int get_bpf_max_tramp_links(void) 971{ 972 struct btf *vmlinux_btf; 973 int ret; 974 975 vmlinux_btf = btf__load_vmlinux_btf(); 976 if (!ASSERT_OK_PTR(vmlinux_btf, "vmlinux btf")) 977 return -1; 978 ret = get_bpf_max_tramp_links_from(vmlinux_btf); 979 btf__free(vmlinux_btf); 980 981 return ret; 982} 983 984#define MAX_BACKTRACE_SZ 128 985void crash_handler(int signum) 986{ 987 void *bt[MAX_BACKTRACE_SZ]; 988 size_t sz; 989 990 sz = backtrace(bt, ARRAY_SIZE(bt)); 991 992 if (env.stdout) 993 stdio_restore(); 994 if (env.test) { 995 env.test_state->error_cnt++; 996 dump_test_log(env.test, env.test_state, true, false, NULL); 997 } 998 if (env.worker_id != -1) 999 fprintf(stderr, "[%d]: ", env.worker_id); 1000 fprintf(stderr, "Caught signal #%d!\nStack trace:\n", signum); 1001 backtrace_symbols_fd(bt, sz, STDERR_FILENO); 1002} 1003 1004static void sigint_handler(int signum) 1005{ 1006 int i; 1007 1008 for (i = 0; i < env.workers; i++) 1009 if (env.worker_socks[i] > 0) 1010 close(env.worker_socks[i]); 1011} 1012 1013static int current_test_idx; 1014static pthread_mutex_t current_test_lock; 1015static pthread_mutex_t stdout_output_lock; 1016 1017static inline const char *str_msg(const struct msg *msg, char *buf) 1018{ 1019 switch (msg->type) { 1020 case MSG_DO_TEST: 1021 sprintf(buf, "MSG_DO_TEST %d", msg->do_test.num); 1022 break; 1023 case MSG_TEST_DONE: 1024 sprintf(buf, "MSG_TEST_DONE %d (log: %d)", 1025 msg->test_done.num, 1026 msg->test_done.have_log); 1027 break; 1028 case MSG_SUBTEST_DONE: 1029 sprintf(buf, "MSG_SUBTEST_DONE %d (log: %d)", 1030 msg->subtest_done.num, 1031 msg->subtest_done.have_log); 1032 break; 1033 case MSG_TEST_LOG: 1034 sprintf(buf, "MSG_TEST_LOG (cnt: %zu, last: %d)", 1035 strlen(msg->test_log.log_buf), 1036 msg->test_log.is_last); 1037 break; 1038 case MSG_EXIT: 1039 sprintf(buf, "MSG_EXIT"); 1040 break; 1041 default: 1042 sprintf(buf, "UNKNOWN"); 1043 break; 1044 } 1045 1046 return buf; 1047} 1048 1049static int send_message(int sock, const struct msg *msg) 1050{ 1051 char buf[256]; 1052 1053 if (env.debug) 1054 fprintf(stderr, "Sending msg: %s\n", str_msg(msg, buf)); 1055 return send(sock, msg, sizeof(*msg), 0); 1056} 1057 1058static int recv_message(int sock, struct msg *msg) 1059{ 1060 int ret; 1061 char buf[256]; 1062 1063 memset(msg, 0, sizeof(*msg)); 1064 ret = recv(sock, msg, sizeof(*msg), 0); 1065 if (ret >= 0) { 1066 if (env.debug) 1067 fprintf(stderr, "Received msg: %s\n", str_msg(msg, buf)); 1068 } 1069 return ret; 1070} 1071 1072static void run_one_test(int test_num) 1073{ 1074 struct prog_test_def *test = &prog_test_defs[test_num]; 1075 struct test_state *state = &test_states[test_num]; 1076 1077 env.test = test; 1078 env.test_state = state; 1079 1080 stdio_hijack(&state->log_buf, &state->log_cnt); 1081 1082 if (test->run_test) 1083 test->run_test(); 1084 else if (test->run_serial_test) 1085 test->run_serial_test(); 1086 1087 /* ensure last sub-test is finalized properly */ 1088 if (env.subtest_state) 1089 test__end_subtest(); 1090 1091 state->tested = true; 1092 1093 if (verbose() && env.worker_id == -1) 1094 print_test_result(test, state); 1095 1096 reset_affinity(); 1097 restore_netns(); 1098 if (test->need_cgroup_cleanup) 1099 cleanup_cgroup_environment(); 1100 1101 stdio_restore(); 1102 1103 dump_test_log(test, state, false, false, NULL); 1104} 1105 1106struct dispatch_data { 1107 int worker_id; 1108 int sock_fd; 1109}; 1110 1111static int read_prog_test_msg(int sock_fd, struct msg *msg, enum msg_type type) 1112{ 1113 if (recv_message(sock_fd, msg) < 0) 1114 return 1; 1115 1116 if (msg->type != type) { 1117 printf("%s: unexpected message type %d. expected %d\n", __func__, msg->type, type); 1118 return 1; 1119 } 1120 1121 return 0; 1122} 1123 1124static int dispatch_thread_read_log(int sock_fd, char **log_buf, size_t *log_cnt) 1125{ 1126 FILE *log_fp = NULL; 1127 int result = 0; 1128 1129 log_fp = open_memstream(log_buf, log_cnt); 1130 if (!log_fp) 1131 return 1; 1132 1133 while (true) { 1134 struct msg msg; 1135 1136 if (read_prog_test_msg(sock_fd, &msg, MSG_TEST_LOG)) { 1137 result = 1; 1138 goto out; 1139 } 1140 1141 fprintf(log_fp, "%s", msg.test_log.log_buf); 1142 if (msg.test_log.is_last) 1143 break; 1144 } 1145 1146out: 1147 fclose(log_fp); 1148 log_fp = NULL; 1149 return result; 1150} 1151 1152static int dispatch_thread_send_subtests(int sock_fd, struct test_state *state) 1153{ 1154 struct msg msg; 1155 struct subtest_state *subtest_state; 1156 int subtest_num = state->subtest_num; 1157 1158 state->subtest_states = malloc(subtest_num * sizeof(*subtest_state)); 1159 1160 for (int i = 0; i < subtest_num; i++) { 1161 subtest_state = &state->subtest_states[i]; 1162 1163 memset(subtest_state, 0, sizeof(*subtest_state)); 1164 1165 if (read_prog_test_msg(sock_fd, &msg, MSG_SUBTEST_DONE)) 1166 return 1; 1167 1168 subtest_state->name = strdup(msg.subtest_done.name); 1169 subtest_state->error_cnt = msg.subtest_done.error_cnt; 1170 subtest_state->skipped = msg.subtest_done.skipped; 1171 subtest_state->filtered = msg.subtest_done.filtered; 1172 1173 /* collect all logs */ 1174 if (msg.subtest_done.have_log) 1175 if (dispatch_thread_read_log(sock_fd, 1176 &subtest_state->log_buf, 1177 &subtest_state->log_cnt)) 1178 return 1; 1179 } 1180 1181 return 0; 1182} 1183 1184static void *dispatch_thread(void *ctx) 1185{ 1186 struct dispatch_data *data = ctx; 1187 int sock_fd; 1188 1189 sock_fd = data->sock_fd; 1190 1191 while (true) { 1192 int test_to_run = -1; 1193 struct prog_test_def *test; 1194 struct test_state *state; 1195 1196 /* grab a test */ 1197 { 1198 pthread_mutex_lock(¤t_test_lock); 1199 1200 if (current_test_idx >= prog_test_cnt) { 1201 pthread_mutex_unlock(¤t_test_lock); 1202 goto done; 1203 } 1204 1205 test = &prog_test_defs[current_test_idx]; 1206 test_to_run = current_test_idx; 1207 current_test_idx++; 1208 1209 pthread_mutex_unlock(¤t_test_lock); 1210 } 1211 1212 if (!test->should_run || test->run_serial_test) 1213 continue; 1214 1215 /* run test through worker */ 1216 { 1217 struct msg msg_do_test; 1218 1219 memset(&msg_do_test, 0, sizeof(msg_do_test)); 1220 msg_do_test.type = MSG_DO_TEST; 1221 msg_do_test.do_test.num = test_to_run; 1222 if (send_message(sock_fd, &msg_do_test) < 0) { 1223 perror("Fail to send command"); 1224 goto done; 1225 } 1226 env.worker_current_test[data->worker_id] = test_to_run; 1227 } 1228 1229 /* wait for test done */ 1230 do { 1231 struct msg msg; 1232 1233 if (read_prog_test_msg(sock_fd, &msg, MSG_TEST_DONE)) 1234 goto error; 1235 if (test_to_run != msg.test_done.num) 1236 goto error; 1237 1238 state = &test_states[test_to_run]; 1239 state->tested = true; 1240 state->error_cnt = msg.test_done.error_cnt; 1241 state->skip_cnt = msg.test_done.skip_cnt; 1242 state->sub_succ_cnt = msg.test_done.sub_succ_cnt; 1243 state->subtest_num = msg.test_done.subtest_num; 1244 1245 /* collect all logs */ 1246 if (msg.test_done.have_log) { 1247 if (dispatch_thread_read_log(sock_fd, 1248 &state->log_buf, 1249 &state->log_cnt)) 1250 goto error; 1251 } 1252 1253 /* collect all subtests and subtest logs */ 1254 if (!state->subtest_num) 1255 break; 1256 1257 if (dispatch_thread_send_subtests(sock_fd, state)) 1258 goto error; 1259 } while (false); 1260 1261 pthread_mutex_lock(&stdout_output_lock); 1262 dump_test_log(test, state, false, true, NULL); 1263 pthread_mutex_unlock(&stdout_output_lock); 1264 } /* while (true) */ 1265error: 1266 if (env.debug) 1267 fprintf(stderr, "[%d]: Protocol/IO error: %s.\n", data->worker_id, strerror(errno)); 1268 1269done: 1270 { 1271 struct msg msg_exit; 1272 1273 msg_exit.type = MSG_EXIT; 1274 if (send_message(sock_fd, &msg_exit) < 0) { 1275 if (env.debug) 1276 fprintf(stderr, "[%d]: send_message msg_exit: %s.\n", 1277 data->worker_id, strerror(errno)); 1278 } 1279 } 1280 return NULL; 1281} 1282 1283static void calculate_summary_and_print_errors(struct test_env *env) 1284{ 1285 int i; 1286 int succ_cnt = 0, fail_cnt = 0, sub_succ_cnt = 0, skip_cnt = 0; 1287 json_writer_t *w = NULL; 1288 1289 for (i = 0; i < prog_test_cnt; i++) { 1290 struct test_state *state = &test_states[i]; 1291 1292 if (!state->tested) 1293 continue; 1294 1295 sub_succ_cnt += state->sub_succ_cnt; 1296 skip_cnt += state->skip_cnt; 1297 1298 if (state->error_cnt) 1299 fail_cnt++; 1300 else 1301 succ_cnt++; 1302 } 1303 1304 if (env->json) { 1305 w = jsonw_new(env->json); 1306 if (!w) 1307 fprintf(env->stderr, "Failed to create new JSON stream."); 1308 } 1309 1310 if (w) { 1311 jsonw_start_object(w); 1312 jsonw_uint_field(w, "success", succ_cnt); 1313 jsonw_uint_field(w, "success_subtest", sub_succ_cnt); 1314 jsonw_uint_field(w, "skipped", skip_cnt); 1315 jsonw_uint_field(w, "failed", fail_cnt); 1316 jsonw_name(w, "results"); 1317 jsonw_start_array(w); 1318 } 1319 1320 /* 1321 * We only print error logs summary when there are failed tests and 1322 * verbose mode is not enabled. Otherwise, results may be incosistent. 1323 * 1324 */ 1325 if (!verbose() && fail_cnt) { 1326 printf("\nAll error logs:\n"); 1327 1328 /* print error logs again */ 1329 for (i = 0; i < prog_test_cnt; i++) { 1330 struct prog_test_def *test = &prog_test_defs[i]; 1331 struct test_state *state = &test_states[i]; 1332 1333 if (!state->tested || !state->error_cnt) 1334 continue; 1335 1336 dump_test_log(test, state, true, true, w); 1337 } 1338 } 1339 1340 if (w) { 1341 jsonw_end_array(w); 1342 jsonw_end_object(w); 1343 jsonw_destroy(&w); 1344 } 1345 1346 if (env->json) 1347 fclose(env->json); 1348 1349 printf("Summary: %d/%d PASSED, %d SKIPPED, %d FAILED\n", 1350 succ_cnt, sub_succ_cnt, skip_cnt, fail_cnt); 1351 1352 env->succ_cnt = succ_cnt; 1353 env->sub_succ_cnt = sub_succ_cnt; 1354 env->fail_cnt = fail_cnt; 1355 env->skip_cnt = skip_cnt; 1356} 1357 1358static void server_main(void) 1359{ 1360 pthread_t *dispatcher_threads; 1361 struct dispatch_data *data; 1362 struct sigaction sigact_int = { 1363 .sa_handler = sigint_handler, 1364 .sa_flags = SA_RESETHAND, 1365 }; 1366 int i; 1367 1368 sigaction(SIGINT, &sigact_int, NULL); 1369 1370 dispatcher_threads = calloc(sizeof(pthread_t), env.workers); 1371 data = calloc(sizeof(struct dispatch_data), env.workers); 1372 1373 env.worker_current_test = calloc(sizeof(int), env.workers); 1374 for (i = 0; i < env.workers; i++) { 1375 int rc; 1376 1377 data[i].worker_id = i; 1378 data[i].sock_fd = env.worker_socks[i]; 1379 rc = pthread_create(&dispatcher_threads[i], NULL, dispatch_thread, &data[i]); 1380 if (rc < 0) { 1381 perror("Failed to launch dispatcher thread"); 1382 exit(EXIT_ERR_SETUP_INFRA); 1383 } 1384 } 1385 1386 /* wait for all dispatcher to finish */ 1387 for (i = 0; i < env.workers; i++) { 1388 while (true) { 1389 int ret = pthread_tryjoin_np(dispatcher_threads[i], NULL); 1390 1391 if (!ret) { 1392 break; 1393 } else if (ret == EBUSY) { 1394 if (env.debug) 1395 fprintf(stderr, "Still waiting for thread %d (test %d).\n", 1396 i, env.worker_current_test[i] + 1); 1397 usleep(1000 * 1000); 1398 continue; 1399 } else { 1400 fprintf(stderr, "Unexpected error joining dispatcher thread: %d", ret); 1401 break; 1402 } 1403 } 1404 } 1405 free(dispatcher_threads); 1406 free(env.worker_current_test); 1407 free(data); 1408 1409 /* run serial tests */ 1410 save_netns(); 1411 1412 for (int i = 0; i < prog_test_cnt; i++) { 1413 struct prog_test_def *test = &prog_test_defs[i]; 1414 1415 if (!test->should_run || !test->run_serial_test) 1416 continue; 1417 1418 run_one_test(i); 1419 } 1420 1421 /* generate summary */ 1422 fflush(stderr); 1423 fflush(stdout); 1424 1425 calculate_summary_and_print_errors(&env); 1426 1427 /* reap all workers */ 1428 for (i = 0; i < env.workers; i++) { 1429 int wstatus, pid; 1430 1431 pid = waitpid(env.worker_pids[i], &wstatus, 0); 1432 if (pid != env.worker_pids[i]) 1433 perror("Unable to reap worker"); 1434 } 1435} 1436 1437static void worker_main_send_log(int sock, char *log_buf, size_t log_cnt) 1438{ 1439 char *src; 1440 size_t slen; 1441 1442 src = log_buf; 1443 slen = log_cnt; 1444 while (slen) { 1445 struct msg msg_log; 1446 char *dest; 1447 size_t len; 1448 1449 memset(&msg_log, 0, sizeof(msg_log)); 1450 msg_log.type = MSG_TEST_LOG; 1451 dest = msg_log.test_log.log_buf; 1452 len = slen >= MAX_LOG_TRUNK_SIZE ? MAX_LOG_TRUNK_SIZE : slen; 1453 memcpy(dest, src, len); 1454 1455 src += len; 1456 slen -= len; 1457 if (!slen) 1458 msg_log.test_log.is_last = true; 1459 1460 assert(send_message(sock, &msg_log) >= 0); 1461 } 1462} 1463 1464static void free_subtest_state(struct subtest_state *state) 1465{ 1466 if (state->log_buf) { 1467 free(state->log_buf); 1468 state->log_buf = NULL; 1469 state->log_cnt = 0; 1470 } 1471 free(state->name); 1472 state->name = NULL; 1473} 1474 1475static int worker_main_send_subtests(int sock, struct test_state *state) 1476{ 1477 int i, result = 0; 1478 struct msg msg; 1479 struct subtest_state *subtest_state; 1480 1481 memset(&msg, 0, sizeof(msg)); 1482 msg.type = MSG_SUBTEST_DONE; 1483 1484 for (i = 0; i < state->subtest_num; i++) { 1485 subtest_state = &state->subtest_states[i]; 1486 1487 msg.subtest_done.num = i; 1488 1489 strncpy(msg.subtest_done.name, subtest_state->name, MAX_SUBTEST_NAME); 1490 1491 msg.subtest_done.error_cnt = subtest_state->error_cnt; 1492 msg.subtest_done.skipped = subtest_state->skipped; 1493 msg.subtest_done.filtered = subtest_state->filtered; 1494 msg.subtest_done.have_log = false; 1495 1496 if (verbose() || state->force_log || subtest_state->error_cnt) { 1497 if (subtest_state->log_cnt) 1498 msg.subtest_done.have_log = true; 1499 } 1500 1501 if (send_message(sock, &msg) < 0) { 1502 perror("Fail to send message done"); 1503 result = 1; 1504 goto out; 1505 } 1506 1507 /* send logs */ 1508 if (msg.subtest_done.have_log) 1509 worker_main_send_log(sock, subtest_state->log_buf, subtest_state->log_cnt); 1510 1511 free_subtest_state(subtest_state); 1512 free(subtest_state->name); 1513 } 1514 1515out: 1516 for (; i < state->subtest_num; i++) 1517 free_subtest_state(&state->subtest_states[i]); 1518 free(state->subtest_states); 1519 return result; 1520} 1521 1522static int worker_main(int sock) 1523{ 1524 save_netns(); 1525 1526 while (true) { 1527 /* receive command */ 1528 struct msg msg; 1529 1530 if (recv_message(sock, &msg) < 0) 1531 goto out; 1532 1533 switch (msg.type) { 1534 case MSG_EXIT: 1535 if (env.debug) 1536 fprintf(stderr, "[%d]: worker exit.\n", 1537 env.worker_id); 1538 goto out; 1539 case MSG_DO_TEST: { 1540 int test_to_run = msg.do_test.num; 1541 struct prog_test_def *test = &prog_test_defs[test_to_run]; 1542 struct test_state *state = &test_states[test_to_run]; 1543 struct msg msg; 1544 1545 if (env.debug) 1546 fprintf(stderr, "[%d]: #%d:%s running.\n", 1547 env.worker_id, 1548 test_to_run + 1, 1549 test->test_name); 1550 1551 run_one_test(test_to_run); 1552 1553 memset(&msg, 0, sizeof(msg)); 1554 msg.type = MSG_TEST_DONE; 1555 msg.test_done.num = test_to_run; 1556 msg.test_done.error_cnt = state->error_cnt; 1557 msg.test_done.skip_cnt = state->skip_cnt; 1558 msg.test_done.sub_succ_cnt = state->sub_succ_cnt; 1559 msg.test_done.subtest_num = state->subtest_num; 1560 msg.test_done.have_log = false; 1561 1562 if (verbose() || state->force_log || state->error_cnt) { 1563 if (state->log_cnt) 1564 msg.test_done.have_log = true; 1565 } 1566 if (send_message(sock, &msg) < 0) { 1567 perror("Fail to send message done"); 1568 goto out; 1569 } 1570 1571 /* send logs */ 1572 if (msg.test_done.have_log) 1573 worker_main_send_log(sock, state->log_buf, state->log_cnt); 1574 1575 if (state->log_buf) { 1576 free(state->log_buf); 1577 state->log_buf = NULL; 1578 state->log_cnt = 0; 1579 } 1580 1581 if (state->subtest_num) 1582 if (worker_main_send_subtests(sock, state)) 1583 goto out; 1584 1585 if (env.debug) 1586 fprintf(stderr, "[%d]: #%d:%s done.\n", 1587 env.worker_id, 1588 test_to_run + 1, 1589 test->test_name); 1590 break; 1591 } /* case MSG_DO_TEST */ 1592 default: 1593 if (env.debug) 1594 fprintf(stderr, "[%d]: unknown message.\n", env.worker_id); 1595 return -1; 1596 } 1597 } 1598out: 1599 return 0; 1600} 1601 1602static void free_test_states(void) 1603{ 1604 int i, j; 1605 1606 for (i = 0; i < ARRAY_SIZE(prog_test_defs); i++) { 1607 struct test_state *test_state = &test_states[i]; 1608 1609 for (j = 0; j < test_state->subtest_num; j++) 1610 free_subtest_state(&test_state->subtest_states[j]); 1611 1612 free(test_state->subtest_states); 1613 free(test_state->log_buf); 1614 test_state->subtest_states = NULL; 1615 test_state->log_buf = NULL; 1616 } 1617} 1618 1619int main(int argc, char **argv) 1620{ 1621 static const struct argp argp = { 1622 .options = opts, 1623 .parser = parse_arg, 1624 .doc = argp_program_doc, 1625 }; 1626 struct sigaction sigact = { 1627 .sa_handler = crash_handler, 1628 .sa_flags = SA_RESETHAND, 1629 }; 1630 int err, i; 1631 1632 sigaction(SIGSEGV, &sigact, NULL); 1633 1634 err = argp_parse(&argp, argc, argv, 0, NULL, &env); 1635 if (err) 1636 return err; 1637 1638 err = cd_flavor_subdir(argv[0]); 1639 if (err) 1640 return err; 1641 1642 /* Use libbpf 1.0 API mode */ 1643 libbpf_set_strict_mode(LIBBPF_STRICT_ALL); 1644 libbpf_set_print(libbpf_print_fn); 1645 1646 srand(time(NULL)); 1647 1648 env.jit_enabled = is_jit_enabled(); 1649 env.nr_cpus = libbpf_num_possible_cpus(); 1650 if (env.nr_cpus < 0) { 1651 fprintf(stderr, "Failed to get number of CPUs: %d!\n", 1652 env.nr_cpus); 1653 return -1; 1654 } 1655 1656 env.stdout = stdout; 1657 env.stderr = stderr; 1658 1659 env.has_testmod = true; 1660 if (!env.list_test_names) { 1661 /* ensure previous instance of the module is unloaded */ 1662 unload_bpf_testmod(verbose()); 1663 1664 if (load_bpf_testmod(verbose())) { 1665 fprintf(env.stderr, "WARNING! Selftests relying on bpf_testmod.ko will be skipped.\n"); 1666 env.has_testmod = false; 1667 } 1668 } 1669 1670 /* initializing tests */ 1671 for (i = 0; i < prog_test_cnt; i++) { 1672 struct prog_test_def *test = &prog_test_defs[i]; 1673 1674 test->test_num = i + 1; 1675 test->should_run = should_run(&env.test_selector, 1676 test->test_num, test->test_name); 1677 1678 if ((test->run_test == NULL && test->run_serial_test == NULL) || 1679 (test->run_test != NULL && test->run_serial_test != NULL)) { 1680 fprintf(stderr, "Test %d:%s must have either test_%s() or serial_test_%sl() defined.\n", 1681 test->test_num, test->test_name, test->test_name, test->test_name); 1682 exit(EXIT_ERR_SETUP_INFRA); 1683 } 1684 } 1685 1686 /* ignore workers if we are just listing */ 1687 if (env.get_test_cnt || env.list_test_names) 1688 env.workers = 0; 1689 1690 /* launch workers if requested */ 1691 env.worker_id = -1; /* main process */ 1692 if (env.workers) { 1693 env.worker_pids = calloc(sizeof(__pid_t), env.workers); 1694 env.worker_socks = calloc(sizeof(int), env.workers); 1695 if (env.debug) 1696 fprintf(stdout, "Launching %d workers.\n", env.workers); 1697 for (i = 0; i < env.workers; i++) { 1698 int sv[2]; 1699 pid_t pid; 1700 1701 if (socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, sv) < 0) { 1702 perror("Fail to create worker socket"); 1703 return -1; 1704 } 1705 pid = fork(); 1706 if (pid < 0) { 1707 perror("Failed to fork worker"); 1708 return -1; 1709 } else if (pid != 0) { /* main process */ 1710 close(sv[1]); 1711 env.worker_pids[i] = pid; 1712 env.worker_socks[i] = sv[0]; 1713 } else { /* inside each worker process */ 1714 close(sv[0]); 1715 env.worker_id = i; 1716 return worker_main(sv[1]); 1717 } 1718 } 1719 1720 if (env.worker_id == -1) { 1721 server_main(); 1722 goto out; 1723 } 1724 } 1725 1726 /* The rest of the main process */ 1727 1728 /* on single mode */ 1729 save_netns(); 1730 1731 for (i = 0; i < prog_test_cnt; i++) { 1732 struct prog_test_def *test = &prog_test_defs[i]; 1733 1734 if (!test->should_run) 1735 continue; 1736 1737 if (env.get_test_cnt) { 1738 env.succ_cnt++; 1739 continue; 1740 } 1741 1742 if (env.list_test_names) { 1743 fprintf(env.stdout, "%s\n", test->test_name); 1744 env.succ_cnt++; 1745 continue; 1746 } 1747 1748 run_one_test(i); 1749 } 1750 1751 if (env.get_test_cnt) { 1752 printf("%d\n", env.succ_cnt); 1753 goto out; 1754 } 1755 1756 if (env.list_test_names) 1757 goto out; 1758 1759 calculate_summary_and_print_errors(&env); 1760 1761 close(env.saved_netns_fd); 1762out: 1763 if (!env.list_test_names && env.has_testmod) 1764 unload_bpf_testmod(verbose()); 1765 1766 free_test_selector(&env.test_selector); 1767 free_test_selector(&env.subtest_selector); 1768 free_test_states(); 1769 1770 if (env.succ_cnt + env.fail_cnt + env.skip_cnt == 0) 1771 return EXIT_NO_TEST; 1772 1773 return env.fail_cnt ? EXIT_FAILURE : EXIT_SUCCESS; 1774} 1775