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[32]; 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 550int compare_map_keys(int map1_fd, int map2_fd) 551{ 552 __u32 key, next_key; 553 char val_buf[PERF_MAX_STACK_DEPTH * 554 sizeof(struct bpf_stack_build_id)]; 555 int err; 556 557 err = bpf_map_get_next_key(map1_fd, NULL, &key); 558 if (err) 559 return err; 560 err = bpf_map_lookup_elem(map2_fd, &key, val_buf); 561 if (err) 562 return err; 563 564 while (bpf_map_get_next_key(map1_fd, &key, &next_key) == 0) { 565 err = bpf_map_lookup_elem(map2_fd, &next_key, val_buf); 566 if (err) 567 return err; 568 569 key = next_key; 570 } 571 if (errno != ENOENT) 572 return -1; 573 574 return 0; 575} 576 577int compare_stack_ips(int smap_fd, int amap_fd, int stack_trace_len) 578{ 579 __u32 key, next_key, *cur_key_p, *next_key_p; 580 char *val_buf1, *val_buf2; 581 int i, err = 0; 582 583 val_buf1 = malloc(stack_trace_len); 584 val_buf2 = malloc(stack_trace_len); 585 cur_key_p = NULL; 586 next_key_p = &key; 587 while (bpf_map_get_next_key(smap_fd, cur_key_p, next_key_p) == 0) { 588 err = bpf_map_lookup_elem(smap_fd, next_key_p, val_buf1); 589 if (err) 590 goto out; 591 err = bpf_map_lookup_elem(amap_fd, next_key_p, val_buf2); 592 if (err) 593 goto out; 594 for (i = 0; i < stack_trace_len; i++) { 595 if (val_buf1[i] != val_buf2[i]) { 596 err = -1; 597 goto out; 598 } 599 } 600 key = *next_key_p; 601 cur_key_p = &key; 602 next_key_p = &next_key; 603 } 604 if (errno != ENOENT) 605 err = -1; 606 607out: 608 free(val_buf1); 609 free(val_buf2); 610 return err; 611} 612 613/* extern declarations for test funcs */ 614#define DEFINE_TEST(name) \ 615 extern void test_##name(void) __weak; \ 616 extern void serial_test_##name(void) __weak; 617#include <prog_tests/tests.h> 618#undef DEFINE_TEST 619 620static struct prog_test_def prog_test_defs[] = { 621#define DEFINE_TEST(name) { \ 622 .test_name = #name, \ 623 .run_test = &test_##name, \ 624 .run_serial_test = &serial_test_##name, \ 625}, 626#include <prog_tests/tests.h> 627#undef DEFINE_TEST 628}; 629 630static const int prog_test_cnt = ARRAY_SIZE(prog_test_defs); 631 632static struct test_state test_states[ARRAY_SIZE(prog_test_defs)]; 633 634const char *argp_program_version = "test_progs 0.1"; 635const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; 636static const char argp_program_doc[] = 637"BPF selftests test runner\v" 638"Options accepting the NAMES parameter take either a comma-separated list\n" 639"of test names, or a filename prefixed with @. The file contains one name\n" 640"(or wildcard pattern) per line, and comments beginning with # are ignored.\n" 641"\n" 642"These options can be passed repeatedly to read multiple files.\n"; 643 644enum ARG_KEYS { 645 ARG_TEST_NUM = 'n', 646 ARG_TEST_NAME = 't', 647 ARG_TEST_NAME_BLACKLIST = 'b', 648 ARG_VERIFIER_STATS = 's', 649 ARG_VERBOSE = 'v', 650 ARG_GET_TEST_CNT = 'c', 651 ARG_LIST_TEST_NAMES = 'l', 652 ARG_TEST_NAME_GLOB_ALLOWLIST = 'a', 653 ARG_TEST_NAME_GLOB_DENYLIST = 'd', 654 ARG_NUM_WORKERS = 'j', 655 ARG_DEBUG = -1, 656 ARG_JSON_SUMMARY = 'J' 657}; 658 659static const struct argp_option opts[] = { 660 { "num", ARG_TEST_NUM, "NUM", 0, 661 "Run test number NUM only " }, 662 { "name", ARG_TEST_NAME, "NAMES", 0, 663 "Run tests with names containing any string from NAMES list" }, 664 { "name-blacklist", ARG_TEST_NAME_BLACKLIST, "NAMES", 0, 665 "Don't run tests with names containing any string from NAMES list" }, 666 { "verifier-stats", ARG_VERIFIER_STATS, NULL, 0, 667 "Output verifier statistics", }, 668 { "verbose", ARG_VERBOSE, "LEVEL", OPTION_ARG_OPTIONAL, 669 "Verbose output (use -vv or -vvv for progressively verbose output)" }, 670 { "count", ARG_GET_TEST_CNT, NULL, 0, 671 "Get number of selected top-level tests " }, 672 { "list", ARG_LIST_TEST_NAMES, NULL, 0, 673 "List test names that would run (without running them) " }, 674 { "allow", ARG_TEST_NAME_GLOB_ALLOWLIST, "NAMES", 0, 675 "Run tests with name matching the pattern (supports '*' wildcard)." }, 676 { "deny", ARG_TEST_NAME_GLOB_DENYLIST, "NAMES", 0, 677 "Don't run tests with name matching the pattern (supports '*' wildcard)." }, 678 { "workers", ARG_NUM_WORKERS, "WORKERS", OPTION_ARG_OPTIONAL, 679 "Number of workers to run in parallel, default to number of cpus." }, 680 { "debug", ARG_DEBUG, NULL, 0, 681 "print extra debug information for test_progs." }, 682 { "json-summary", ARG_JSON_SUMMARY, "FILE", 0, "Write report in json format to this file."}, 683 {}, 684}; 685 686static FILE *libbpf_capture_stream; 687 688static struct { 689 char *buf; 690 size_t buf_sz; 691} libbpf_output_capture; 692 693/* Creates a global memstream capturing INFO and WARN level output 694 * passed to libbpf_print_fn. 695 * Returns 0 on success, negative value on failure. 696 * On failure the description is printed using PRINT_FAIL and 697 * current test case is marked as fail. 698 */ 699int start_libbpf_log_capture(void) 700{ 701 if (libbpf_capture_stream) { 702 PRINT_FAIL("%s: libbpf_capture_stream != NULL\n", __func__); 703 return -EINVAL; 704 } 705 706 libbpf_capture_stream = open_memstream(&libbpf_output_capture.buf, 707 &libbpf_output_capture.buf_sz); 708 if (!libbpf_capture_stream) { 709 PRINT_FAIL("%s: open_memstream failed errno=%d\n", __func__, errno); 710 return -EINVAL; 711 } 712 713 return 0; 714} 715 716/* Destroys global memstream created by start_libbpf_log_capture(). 717 * Returns a pointer to captured data which has to be freed. 718 * Returned buffer is null terminated. 719 */ 720char *stop_libbpf_log_capture(void) 721{ 722 char *buf; 723 724 if (!libbpf_capture_stream) 725 return NULL; 726 727 fputc(0, libbpf_capture_stream); 728 fclose(libbpf_capture_stream); 729 libbpf_capture_stream = NULL; 730 /* get 'buf' after fclose(), see open_memstream() documentation */ 731 buf = libbpf_output_capture.buf; 732 memset(&libbpf_output_capture, 0, sizeof(libbpf_output_capture)); 733 return buf; 734} 735 736static int libbpf_print_fn(enum libbpf_print_level level, 737 const char *format, va_list args) 738{ 739 if (libbpf_capture_stream && level != LIBBPF_DEBUG) { 740 va_list args2; 741 742 va_copy(args2, args); 743 vfprintf(libbpf_capture_stream, format, args2); 744 } 745 746 if (env.verbosity < VERBOSE_VERY && level == LIBBPF_DEBUG) 747 return 0; 748 749 vfprintf(stdout, format, args); 750 return 0; 751} 752 753static void free_test_filter_set(const struct test_filter_set *set) 754{ 755 int i, j; 756 757 if (!set) 758 return; 759 760 for (i = 0; i < set->cnt; i++) { 761 free((void *)set->tests[i].name); 762 for (j = 0; j < set->tests[i].subtest_cnt; j++) 763 free((void *)set->tests[i].subtests[j]); 764 765 free((void *)set->tests[i].subtests); 766 } 767 768 free((void *)set->tests); 769} 770 771static void free_test_selector(struct test_selector *test_selector) 772{ 773 free_test_filter_set(&test_selector->blacklist); 774 free_test_filter_set(&test_selector->whitelist); 775 free(test_selector->num_set); 776} 777 778extern int extra_prog_load_log_flags; 779 780static error_t parse_arg(int key, char *arg, struct argp_state *state) 781{ 782 struct test_env *env = state->input; 783 int err = 0; 784 785 switch (key) { 786 case ARG_TEST_NUM: { 787 char *subtest_str = strchr(arg, '/'); 788 789 if (subtest_str) { 790 *subtest_str = '\0'; 791 if (parse_num_list(subtest_str + 1, 792 &env->subtest_selector.num_set, 793 &env->subtest_selector.num_set_len)) { 794 fprintf(stderr, 795 "Failed to parse subtest numbers.\n"); 796 return -EINVAL; 797 } 798 } 799 if (parse_num_list(arg, &env->test_selector.num_set, 800 &env->test_selector.num_set_len)) { 801 fprintf(stderr, "Failed to parse test numbers.\n"); 802 return -EINVAL; 803 } 804 break; 805 } 806 case ARG_TEST_NAME_GLOB_ALLOWLIST: 807 case ARG_TEST_NAME: { 808 if (arg[0] == '@') 809 err = parse_test_list_file(arg + 1, 810 &env->test_selector.whitelist, 811 key == ARG_TEST_NAME_GLOB_ALLOWLIST); 812 else 813 err = parse_test_list(arg, 814 &env->test_selector.whitelist, 815 key == ARG_TEST_NAME_GLOB_ALLOWLIST); 816 817 break; 818 } 819 case ARG_TEST_NAME_GLOB_DENYLIST: 820 case ARG_TEST_NAME_BLACKLIST: { 821 if (arg[0] == '@') 822 err = parse_test_list_file(arg + 1, 823 &env->test_selector.blacklist, 824 key == ARG_TEST_NAME_GLOB_DENYLIST); 825 else 826 err = parse_test_list(arg, 827 &env->test_selector.blacklist, 828 key == ARG_TEST_NAME_GLOB_DENYLIST); 829 830 break; 831 } 832 case ARG_VERIFIER_STATS: 833 env->verifier_stats = true; 834 break; 835 case ARG_VERBOSE: 836 env->verbosity = VERBOSE_NORMAL; 837 if (arg) { 838 if (strcmp(arg, "v") == 0) { 839 env->verbosity = VERBOSE_VERY; 840 extra_prog_load_log_flags = 1; 841 } else if (strcmp(arg, "vv") == 0) { 842 env->verbosity = VERBOSE_SUPER; 843 extra_prog_load_log_flags = 2; 844 } else { 845 fprintf(stderr, 846 "Unrecognized verbosity setting ('%s'), only -v and -vv are supported\n", 847 arg); 848 return -EINVAL; 849 } 850 } 851 852 if (verbose()) { 853 if (setenv("SELFTESTS_VERBOSE", "1", 1) == -1) { 854 fprintf(stderr, 855 "Unable to setenv SELFTESTS_VERBOSE=1 (errno=%d)", 856 errno); 857 return -EINVAL; 858 } 859 } 860 861 break; 862 case ARG_GET_TEST_CNT: 863 env->get_test_cnt = true; 864 break; 865 case ARG_LIST_TEST_NAMES: 866 env->list_test_names = true; 867 break; 868 case ARG_NUM_WORKERS: 869 if (arg) { 870 env->workers = atoi(arg); 871 if (!env->workers) { 872 fprintf(stderr, "Invalid number of worker: %s.", arg); 873 return -EINVAL; 874 } 875 } else { 876 env->workers = get_nprocs(); 877 } 878 break; 879 case ARG_DEBUG: 880 env->debug = true; 881 break; 882 case ARG_JSON_SUMMARY: 883 env->json = fopen(arg, "w"); 884 if (env->json == NULL) { 885 perror("Failed to open json summary file"); 886 return -errno; 887 } 888 break; 889 case ARGP_KEY_ARG: 890 argp_usage(state); 891 break; 892 case ARGP_KEY_END: 893 break; 894 default: 895 return ARGP_ERR_UNKNOWN; 896 } 897 return err; 898} 899 900/* 901 * Determine if test_progs is running as a "flavored" test runner and switch 902 * into corresponding sub-directory to load correct BPF objects. 903 * 904 * This is done by looking at executable name. If it contains "-flavor" 905 * suffix, then we are running as a flavored test runner. 906 */ 907int cd_flavor_subdir(const char *exec_name) 908{ 909 /* General form of argv[0] passed here is: 910 * some/path/to/test_progs[-flavor], where -flavor part is optional. 911 * First cut out "test_progs[-flavor]" part, then extract "flavor" 912 * part, if it's there. 913 */ 914 const char *flavor = strrchr(exec_name, '/'); 915 916 if (!flavor) 917 flavor = exec_name; 918 else 919 flavor++; 920 921 flavor = strrchr(flavor, '-'); 922 if (!flavor) 923 return 0; 924 flavor++; 925 if (verbose()) 926 fprintf(stdout, "Switching to flavor '%s' subdirectory...\n", flavor); 927 928 return chdir(flavor); 929} 930 931int trigger_module_test_read(int read_sz) 932{ 933 int fd, err; 934 935 fd = open(BPF_TESTMOD_TEST_FILE, O_RDONLY); 936 err = -errno; 937 if (!ASSERT_GE(fd, 0, "testmod_file_open")) 938 return err; 939 940 read(fd, NULL, read_sz); 941 close(fd); 942 943 return 0; 944} 945 946int trigger_module_test_write(int write_sz) 947{ 948 int fd, err; 949 char *buf = malloc(write_sz); 950 951 if (!buf) 952 return -ENOMEM; 953 954 memset(buf, 'a', write_sz); 955 buf[write_sz-1] = '\0'; 956 957 fd = open(BPF_TESTMOD_TEST_FILE, O_WRONLY); 958 err = -errno; 959 if (!ASSERT_GE(fd, 0, "testmod_file_open")) { 960 free(buf); 961 return err; 962 } 963 964 write(fd, buf, write_sz); 965 close(fd); 966 free(buf); 967 return 0; 968} 969 970int write_sysctl(const char *sysctl, const char *value) 971{ 972 int fd, err, len; 973 974 fd = open(sysctl, O_WRONLY); 975 if (!ASSERT_NEQ(fd, -1, "open sysctl")) 976 return -1; 977 978 len = strlen(value); 979 err = write(fd, value, len); 980 close(fd); 981 if (!ASSERT_EQ(err, len, "write sysctl")) 982 return -1; 983 984 return 0; 985} 986 987int get_bpf_max_tramp_links_from(struct btf *btf) 988{ 989 const struct btf_enum *e; 990 const struct btf_type *t; 991 __u32 i, type_cnt; 992 const char *name; 993 __u16 j, vlen; 994 995 for (i = 1, type_cnt = btf__type_cnt(btf); i < type_cnt; i++) { 996 t = btf__type_by_id(btf, i); 997 if (!t || !btf_is_enum(t) || t->name_off) 998 continue; 999 e = btf_enum(t); 1000 for (j = 0, vlen = btf_vlen(t); j < vlen; j++, e++) { 1001 name = btf__str_by_offset(btf, e->name_off); 1002 if (name && !strcmp(name, "BPF_MAX_TRAMP_LINKS")) 1003 return e->val; 1004 } 1005 } 1006 1007 return -1; 1008} 1009 1010int get_bpf_max_tramp_links(void) 1011{ 1012 struct btf *vmlinux_btf; 1013 int ret; 1014 1015 vmlinux_btf = btf__load_vmlinux_btf(); 1016 if (!ASSERT_OK_PTR(vmlinux_btf, "vmlinux btf")) 1017 return -1; 1018 ret = get_bpf_max_tramp_links_from(vmlinux_btf); 1019 btf__free(vmlinux_btf); 1020 1021 return ret; 1022} 1023 1024#define MAX_BACKTRACE_SZ 128 1025void crash_handler(int signum) 1026{ 1027 void *bt[MAX_BACKTRACE_SZ]; 1028 size_t sz; 1029 1030 sz = backtrace(bt, ARRAY_SIZE(bt)); 1031 1032 if (env.stdout) 1033 stdio_restore(); 1034 if (env.test) { 1035 env.test_state->error_cnt++; 1036 dump_test_log(env.test, env.test_state, true, false, NULL); 1037 } 1038 if (env.worker_id != -1) 1039 fprintf(stderr, "[%d]: ", env.worker_id); 1040 fprintf(stderr, "Caught signal #%d!\nStack trace:\n", signum); 1041 backtrace_symbols_fd(bt, sz, STDERR_FILENO); 1042} 1043 1044static void sigint_handler(int signum) 1045{ 1046 int i; 1047 1048 for (i = 0; i < env.workers; i++) 1049 if (env.worker_socks[i] > 0) 1050 close(env.worker_socks[i]); 1051} 1052 1053static int current_test_idx; 1054static pthread_mutex_t current_test_lock; 1055static pthread_mutex_t stdout_output_lock; 1056 1057static inline const char *str_msg(const struct msg *msg, char *buf) 1058{ 1059 switch (msg->type) { 1060 case MSG_DO_TEST: 1061 sprintf(buf, "MSG_DO_TEST %d", msg->do_test.num); 1062 break; 1063 case MSG_TEST_DONE: 1064 sprintf(buf, "MSG_TEST_DONE %d (log: %d)", 1065 msg->test_done.num, 1066 msg->test_done.have_log); 1067 break; 1068 case MSG_SUBTEST_DONE: 1069 sprintf(buf, "MSG_SUBTEST_DONE %d (log: %d)", 1070 msg->subtest_done.num, 1071 msg->subtest_done.have_log); 1072 break; 1073 case MSG_TEST_LOG: 1074 sprintf(buf, "MSG_TEST_LOG (cnt: %zu, last: %d)", 1075 strlen(msg->test_log.log_buf), 1076 msg->test_log.is_last); 1077 break; 1078 case MSG_EXIT: 1079 sprintf(buf, "MSG_EXIT"); 1080 break; 1081 default: 1082 sprintf(buf, "UNKNOWN"); 1083 break; 1084 } 1085 1086 return buf; 1087} 1088 1089static int send_message(int sock, const struct msg *msg) 1090{ 1091 char buf[256]; 1092 1093 if (env.debug) 1094 fprintf(stderr, "Sending msg: %s\n", str_msg(msg, buf)); 1095 return send(sock, msg, sizeof(*msg), 0); 1096} 1097 1098static int recv_message(int sock, struct msg *msg) 1099{ 1100 int ret; 1101 char buf[256]; 1102 1103 memset(msg, 0, sizeof(*msg)); 1104 ret = recv(sock, msg, sizeof(*msg), 0); 1105 if (ret >= 0) { 1106 if (env.debug) 1107 fprintf(stderr, "Received msg: %s\n", str_msg(msg, buf)); 1108 } 1109 return ret; 1110} 1111 1112static void run_one_test(int test_num) 1113{ 1114 struct prog_test_def *test = &prog_test_defs[test_num]; 1115 struct test_state *state = &test_states[test_num]; 1116 1117 env.test = test; 1118 env.test_state = state; 1119 1120 stdio_hijack(&state->log_buf, &state->log_cnt); 1121 1122 if (test->run_test) 1123 test->run_test(); 1124 else if (test->run_serial_test) 1125 test->run_serial_test(); 1126 1127 /* ensure last sub-test is finalized properly */ 1128 if (env.subtest_state) 1129 test__end_subtest(); 1130 1131 state->tested = true; 1132 1133 if (verbose() && env.worker_id == -1) 1134 print_test_result(test, state); 1135 1136 reset_affinity(); 1137 restore_netns(); 1138 if (test->need_cgroup_cleanup) 1139 cleanup_cgroup_environment(); 1140 1141 stdio_restore(); 1142 free(stop_libbpf_log_capture()); 1143 1144 dump_test_log(test, state, false, false, NULL); 1145} 1146 1147struct dispatch_data { 1148 int worker_id; 1149 int sock_fd; 1150}; 1151 1152static int read_prog_test_msg(int sock_fd, struct msg *msg, enum msg_type type) 1153{ 1154 if (recv_message(sock_fd, msg) < 0) 1155 return 1; 1156 1157 if (msg->type != type) { 1158 printf("%s: unexpected message type %d. expected %d\n", __func__, msg->type, type); 1159 return 1; 1160 } 1161 1162 return 0; 1163} 1164 1165static int dispatch_thread_read_log(int sock_fd, char **log_buf, size_t *log_cnt) 1166{ 1167 FILE *log_fp = NULL; 1168 int result = 0; 1169 1170 log_fp = open_memstream(log_buf, log_cnt); 1171 if (!log_fp) 1172 return 1; 1173 1174 while (true) { 1175 struct msg msg; 1176 1177 if (read_prog_test_msg(sock_fd, &msg, MSG_TEST_LOG)) { 1178 result = 1; 1179 goto out; 1180 } 1181 1182 fprintf(log_fp, "%s", msg.test_log.log_buf); 1183 if (msg.test_log.is_last) 1184 break; 1185 } 1186 1187out: 1188 fclose(log_fp); 1189 log_fp = NULL; 1190 return result; 1191} 1192 1193static int dispatch_thread_send_subtests(int sock_fd, struct test_state *state) 1194{ 1195 struct msg msg; 1196 struct subtest_state *subtest_state; 1197 int subtest_num = state->subtest_num; 1198 1199 state->subtest_states = malloc(subtest_num * sizeof(*subtest_state)); 1200 1201 for (int i = 0; i < subtest_num; i++) { 1202 subtest_state = &state->subtest_states[i]; 1203 1204 memset(subtest_state, 0, sizeof(*subtest_state)); 1205 1206 if (read_prog_test_msg(sock_fd, &msg, MSG_SUBTEST_DONE)) 1207 return 1; 1208 1209 subtest_state->name = strdup(msg.subtest_done.name); 1210 subtest_state->error_cnt = msg.subtest_done.error_cnt; 1211 subtest_state->skipped = msg.subtest_done.skipped; 1212 subtest_state->filtered = msg.subtest_done.filtered; 1213 1214 /* collect all logs */ 1215 if (msg.subtest_done.have_log) 1216 if (dispatch_thread_read_log(sock_fd, 1217 &subtest_state->log_buf, 1218 &subtest_state->log_cnt)) 1219 return 1; 1220 } 1221 1222 return 0; 1223} 1224 1225static void *dispatch_thread(void *ctx) 1226{ 1227 struct dispatch_data *data = ctx; 1228 int sock_fd; 1229 1230 sock_fd = data->sock_fd; 1231 1232 while (true) { 1233 int test_to_run = -1; 1234 struct prog_test_def *test; 1235 struct test_state *state; 1236 1237 /* grab a test */ 1238 { 1239 pthread_mutex_lock(¤t_test_lock); 1240 1241 if (current_test_idx >= prog_test_cnt) { 1242 pthread_mutex_unlock(¤t_test_lock); 1243 goto done; 1244 } 1245 1246 test = &prog_test_defs[current_test_idx]; 1247 test_to_run = current_test_idx; 1248 current_test_idx++; 1249 1250 pthread_mutex_unlock(¤t_test_lock); 1251 } 1252 1253 if (!test->should_run || test->run_serial_test) 1254 continue; 1255 1256 /* run test through worker */ 1257 { 1258 struct msg msg_do_test; 1259 1260 memset(&msg_do_test, 0, sizeof(msg_do_test)); 1261 msg_do_test.type = MSG_DO_TEST; 1262 msg_do_test.do_test.num = test_to_run; 1263 if (send_message(sock_fd, &msg_do_test) < 0) { 1264 perror("Fail to send command"); 1265 goto done; 1266 } 1267 env.worker_current_test[data->worker_id] = test_to_run; 1268 } 1269 1270 /* wait for test done */ 1271 do { 1272 struct msg msg; 1273 1274 if (read_prog_test_msg(sock_fd, &msg, MSG_TEST_DONE)) 1275 goto error; 1276 if (test_to_run != msg.test_done.num) 1277 goto error; 1278 1279 state = &test_states[test_to_run]; 1280 state->tested = true; 1281 state->error_cnt = msg.test_done.error_cnt; 1282 state->skip_cnt = msg.test_done.skip_cnt; 1283 state->sub_succ_cnt = msg.test_done.sub_succ_cnt; 1284 state->subtest_num = msg.test_done.subtest_num; 1285 1286 /* collect all logs */ 1287 if (msg.test_done.have_log) { 1288 if (dispatch_thread_read_log(sock_fd, 1289 &state->log_buf, 1290 &state->log_cnt)) 1291 goto error; 1292 } 1293 1294 /* collect all subtests and subtest logs */ 1295 if (!state->subtest_num) 1296 break; 1297 1298 if (dispatch_thread_send_subtests(sock_fd, state)) 1299 goto error; 1300 } while (false); 1301 1302 pthread_mutex_lock(&stdout_output_lock); 1303 dump_test_log(test, state, false, true, NULL); 1304 pthread_mutex_unlock(&stdout_output_lock); 1305 } /* while (true) */ 1306error: 1307 if (env.debug) 1308 fprintf(stderr, "[%d]: Protocol/IO error: %s.\n", data->worker_id, strerror(errno)); 1309 1310done: 1311 { 1312 struct msg msg_exit; 1313 1314 msg_exit.type = MSG_EXIT; 1315 if (send_message(sock_fd, &msg_exit) < 0) { 1316 if (env.debug) 1317 fprintf(stderr, "[%d]: send_message msg_exit: %s.\n", 1318 data->worker_id, strerror(errno)); 1319 } 1320 } 1321 return NULL; 1322} 1323 1324static void calculate_summary_and_print_errors(struct test_env *env) 1325{ 1326 int i; 1327 int succ_cnt = 0, fail_cnt = 0, sub_succ_cnt = 0, skip_cnt = 0; 1328 json_writer_t *w = NULL; 1329 1330 for (i = 0; i < prog_test_cnt; i++) { 1331 struct test_state *state = &test_states[i]; 1332 1333 if (!state->tested) 1334 continue; 1335 1336 sub_succ_cnt += state->sub_succ_cnt; 1337 skip_cnt += state->skip_cnt; 1338 1339 if (state->error_cnt) 1340 fail_cnt++; 1341 else 1342 succ_cnt++; 1343 } 1344 1345 if (env->json) { 1346 w = jsonw_new(env->json); 1347 if (!w) 1348 fprintf(env->stderr, "Failed to create new JSON stream."); 1349 } 1350 1351 if (w) { 1352 jsonw_start_object(w); 1353 jsonw_uint_field(w, "success", succ_cnt); 1354 jsonw_uint_field(w, "success_subtest", sub_succ_cnt); 1355 jsonw_uint_field(w, "skipped", skip_cnt); 1356 jsonw_uint_field(w, "failed", fail_cnt); 1357 jsonw_name(w, "results"); 1358 jsonw_start_array(w); 1359 } 1360 1361 /* 1362 * We only print error logs summary when there are failed tests and 1363 * verbose mode is not enabled. Otherwise, results may be incosistent. 1364 * 1365 */ 1366 if (!verbose() && fail_cnt) { 1367 printf("\nAll error logs:\n"); 1368 1369 /* print error logs again */ 1370 for (i = 0; i < prog_test_cnt; i++) { 1371 struct prog_test_def *test = &prog_test_defs[i]; 1372 struct test_state *state = &test_states[i]; 1373 1374 if (!state->tested || !state->error_cnt) 1375 continue; 1376 1377 dump_test_log(test, state, true, true, w); 1378 } 1379 } 1380 1381 if (w) { 1382 jsonw_end_array(w); 1383 jsonw_end_object(w); 1384 jsonw_destroy(&w); 1385 } 1386 1387 if (env->json) 1388 fclose(env->json); 1389 1390 printf("Summary: %d/%d PASSED, %d SKIPPED, %d FAILED\n", 1391 succ_cnt, sub_succ_cnt, skip_cnt, fail_cnt); 1392 1393 env->succ_cnt = succ_cnt; 1394 env->sub_succ_cnt = sub_succ_cnt; 1395 env->fail_cnt = fail_cnt; 1396 env->skip_cnt = skip_cnt; 1397} 1398 1399static void server_main(void) 1400{ 1401 pthread_t *dispatcher_threads; 1402 struct dispatch_data *data; 1403 struct sigaction sigact_int = { 1404 .sa_handler = sigint_handler, 1405 .sa_flags = SA_RESETHAND, 1406 }; 1407 int i; 1408 1409 sigaction(SIGINT, &sigact_int, NULL); 1410 1411 dispatcher_threads = calloc(sizeof(pthread_t), env.workers); 1412 data = calloc(sizeof(struct dispatch_data), env.workers); 1413 1414 env.worker_current_test = calloc(sizeof(int), env.workers); 1415 for (i = 0; i < env.workers; i++) { 1416 int rc; 1417 1418 data[i].worker_id = i; 1419 data[i].sock_fd = env.worker_socks[i]; 1420 rc = pthread_create(&dispatcher_threads[i], NULL, dispatch_thread, &data[i]); 1421 if (rc < 0) { 1422 perror("Failed to launch dispatcher thread"); 1423 exit(EXIT_ERR_SETUP_INFRA); 1424 } 1425 } 1426 1427 /* wait for all dispatcher to finish */ 1428 for (i = 0; i < env.workers; i++) { 1429 while (true) { 1430 int ret = pthread_tryjoin_np(dispatcher_threads[i], NULL); 1431 1432 if (!ret) { 1433 break; 1434 } else if (ret == EBUSY) { 1435 if (env.debug) 1436 fprintf(stderr, "Still waiting for thread %d (test %d).\n", 1437 i, env.worker_current_test[i] + 1); 1438 usleep(1000 * 1000); 1439 continue; 1440 } else { 1441 fprintf(stderr, "Unexpected error joining dispatcher thread: %d", ret); 1442 break; 1443 } 1444 } 1445 } 1446 free(dispatcher_threads); 1447 free(env.worker_current_test); 1448 free(data); 1449 1450 /* run serial tests */ 1451 save_netns(); 1452 1453 for (int i = 0; i < prog_test_cnt; i++) { 1454 struct prog_test_def *test = &prog_test_defs[i]; 1455 1456 if (!test->should_run || !test->run_serial_test) 1457 continue; 1458 1459 run_one_test(i); 1460 } 1461 1462 /* generate summary */ 1463 fflush(stderr); 1464 fflush(stdout); 1465 1466 calculate_summary_and_print_errors(&env); 1467 1468 /* reap all workers */ 1469 for (i = 0; i < env.workers; i++) { 1470 int wstatus, pid; 1471 1472 pid = waitpid(env.worker_pids[i], &wstatus, 0); 1473 if (pid != env.worker_pids[i]) 1474 perror("Unable to reap worker"); 1475 } 1476} 1477 1478static void worker_main_send_log(int sock, char *log_buf, size_t log_cnt) 1479{ 1480 char *src; 1481 size_t slen; 1482 1483 src = log_buf; 1484 slen = log_cnt; 1485 while (slen) { 1486 struct msg msg_log; 1487 char *dest; 1488 size_t len; 1489 1490 memset(&msg_log, 0, sizeof(msg_log)); 1491 msg_log.type = MSG_TEST_LOG; 1492 dest = msg_log.test_log.log_buf; 1493 len = slen >= MAX_LOG_TRUNK_SIZE ? MAX_LOG_TRUNK_SIZE : slen; 1494 memcpy(dest, src, len); 1495 1496 src += len; 1497 slen -= len; 1498 if (!slen) 1499 msg_log.test_log.is_last = true; 1500 1501 assert(send_message(sock, &msg_log) >= 0); 1502 } 1503} 1504 1505static void free_subtest_state(struct subtest_state *state) 1506{ 1507 if (state->log_buf) { 1508 free(state->log_buf); 1509 state->log_buf = NULL; 1510 state->log_cnt = 0; 1511 } 1512 free(state->name); 1513 state->name = NULL; 1514} 1515 1516static int worker_main_send_subtests(int sock, struct test_state *state) 1517{ 1518 int i, result = 0; 1519 struct msg msg; 1520 struct subtest_state *subtest_state; 1521 1522 memset(&msg, 0, sizeof(msg)); 1523 msg.type = MSG_SUBTEST_DONE; 1524 1525 for (i = 0; i < state->subtest_num; i++) { 1526 subtest_state = &state->subtest_states[i]; 1527 1528 msg.subtest_done.num = i; 1529 1530 strncpy(msg.subtest_done.name, subtest_state->name, MAX_SUBTEST_NAME); 1531 1532 msg.subtest_done.error_cnt = subtest_state->error_cnt; 1533 msg.subtest_done.skipped = subtest_state->skipped; 1534 msg.subtest_done.filtered = subtest_state->filtered; 1535 msg.subtest_done.have_log = false; 1536 1537 if (verbose() || state->force_log || subtest_state->error_cnt) { 1538 if (subtest_state->log_cnt) 1539 msg.subtest_done.have_log = true; 1540 } 1541 1542 if (send_message(sock, &msg) < 0) { 1543 perror("Fail to send message done"); 1544 result = 1; 1545 goto out; 1546 } 1547 1548 /* send logs */ 1549 if (msg.subtest_done.have_log) 1550 worker_main_send_log(sock, subtest_state->log_buf, subtest_state->log_cnt); 1551 1552 free_subtest_state(subtest_state); 1553 free(subtest_state->name); 1554 } 1555 1556out: 1557 for (; i < state->subtest_num; i++) 1558 free_subtest_state(&state->subtest_states[i]); 1559 free(state->subtest_states); 1560 return result; 1561} 1562 1563static int worker_main(int sock) 1564{ 1565 save_netns(); 1566 1567 while (true) { 1568 /* receive command */ 1569 struct msg msg; 1570 1571 if (recv_message(sock, &msg) < 0) 1572 goto out; 1573 1574 switch (msg.type) { 1575 case MSG_EXIT: 1576 if (env.debug) 1577 fprintf(stderr, "[%d]: worker exit.\n", 1578 env.worker_id); 1579 goto out; 1580 case MSG_DO_TEST: { 1581 int test_to_run = msg.do_test.num; 1582 struct prog_test_def *test = &prog_test_defs[test_to_run]; 1583 struct test_state *state = &test_states[test_to_run]; 1584 struct msg msg; 1585 1586 if (env.debug) 1587 fprintf(stderr, "[%d]: #%d:%s running.\n", 1588 env.worker_id, 1589 test_to_run + 1, 1590 test->test_name); 1591 1592 run_one_test(test_to_run); 1593 1594 memset(&msg, 0, sizeof(msg)); 1595 msg.type = MSG_TEST_DONE; 1596 msg.test_done.num = test_to_run; 1597 msg.test_done.error_cnt = state->error_cnt; 1598 msg.test_done.skip_cnt = state->skip_cnt; 1599 msg.test_done.sub_succ_cnt = state->sub_succ_cnt; 1600 msg.test_done.subtest_num = state->subtest_num; 1601 msg.test_done.have_log = false; 1602 1603 if (verbose() || state->force_log || state->error_cnt) { 1604 if (state->log_cnt) 1605 msg.test_done.have_log = true; 1606 } 1607 if (send_message(sock, &msg) < 0) { 1608 perror("Fail to send message done"); 1609 goto out; 1610 } 1611 1612 /* send logs */ 1613 if (msg.test_done.have_log) 1614 worker_main_send_log(sock, state->log_buf, state->log_cnt); 1615 1616 if (state->log_buf) { 1617 free(state->log_buf); 1618 state->log_buf = NULL; 1619 state->log_cnt = 0; 1620 } 1621 1622 if (state->subtest_num) 1623 if (worker_main_send_subtests(sock, state)) 1624 goto out; 1625 1626 if (env.debug) 1627 fprintf(stderr, "[%d]: #%d:%s done.\n", 1628 env.worker_id, 1629 test_to_run + 1, 1630 test->test_name); 1631 break; 1632 } /* case MSG_DO_TEST */ 1633 default: 1634 if (env.debug) 1635 fprintf(stderr, "[%d]: unknown message.\n", env.worker_id); 1636 return -1; 1637 } 1638 } 1639out: 1640 return 0; 1641} 1642 1643static void free_test_states(void) 1644{ 1645 int i, j; 1646 1647 for (i = 0; i < ARRAY_SIZE(prog_test_defs); i++) { 1648 struct test_state *test_state = &test_states[i]; 1649 1650 for (j = 0; j < test_state->subtest_num; j++) 1651 free_subtest_state(&test_state->subtest_states[j]); 1652 1653 free(test_state->subtest_states); 1654 free(test_state->log_buf); 1655 test_state->subtest_states = NULL; 1656 test_state->log_buf = NULL; 1657 } 1658} 1659 1660int main(int argc, char **argv) 1661{ 1662 static const struct argp argp = { 1663 .options = opts, 1664 .parser = parse_arg, 1665 .doc = argp_program_doc, 1666 }; 1667 struct sigaction sigact = { 1668 .sa_handler = crash_handler, 1669 .sa_flags = SA_RESETHAND, 1670 }; 1671 int err, i; 1672 1673 sigaction(SIGSEGV, &sigact, NULL); 1674 1675 err = argp_parse(&argp, argc, argv, 0, NULL, &env); 1676 if (err) 1677 return err; 1678 1679 err = cd_flavor_subdir(argv[0]); 1680 if (err) 1681 return err; 1682 1683 /* Use libbpf 1.0 API mode */ 1684 libbpf_set_strict_mode(LIBBPF_STRICT_ALL); 1685 libbpf_set_print(libbpf_print_fn); 1686 1687 srand(time(NULL)); 1688 1689 env.jit_enabled = is_jit_enabled(); 1690 env.nr_cpus = libbpf_num_possible_cpus(); 1691 if (env.nr_cpus < 0) { 1692 fprintf(stderr, "Failed to get number of CPUs: %d!\n", 1693 env.nr_cpus); 1694 return -1; 1695 } 1696 1697 env.stdout = stdout; 1698 env.stderr = stderr; 1699 1700 env.has_testmod = true; 1701 if (!env.list_test_names) { 1702 /* ensure previous instance of the module is unloaded */ 1703 unload_bpf_testmod(verbose()); 1704 1705 if (load_bpf_testmod(verbose())) { 1706 fprintf(env.stderr, "WARNING! Selftests relying on bpf_testmod.ko will be skipped.\n"); 1707 env.has_testmod = false; 1708 } 1709 } 1710 1711 /* initializing tests */ 1712 for (i = 0; i < prog_test_cnt; i++) { 1713 struct prog_test_def *test = &prog_test_defs[i]; 1714 1715 test->test_num = i + 1; 1716 test->should_run = should_run(&env.test_selector, 1717 test->test_num, test->test_name); 1718 1719 if ((test->run_test == NULL && test->run_serial_test == NULL) || 1720 (test->run_test != NULL && test->run_serial_test != NULL)) { 1721 fprintf(stderr, "Test %d:%s must have either test_%s() or serial_test_%sl() defined.\n", 1722 test->test_num, test->test_name, test->test_name, test->test_name); 1723 exit(EXIT_ERR_SETUP_INFRA); 1724 } 1725 } 1726 1727 /* ignore workers if we are just listing */ 1728 if (env.get_test_cnt || env.list_test_names) 1729 env.workers = 0; 1730 1731 /* launch workers if requested */ 1732 env.worker_id = -1; /* main process */ 1733 if (env.workers) { 1734 env.worker_pids = calloc(sizeof(__pid_t), env.workers); 1735 env.worker_socks = calloc(sizeof(int), env.workers); 1736 if (env.debug) 1737 fprintf(stdout, "Launching %d workers.\n", env.workers); 1738 for (i = 0; i < env.workers; i++) { 1739 int sv[2]; 1740 pid_t pid; 1741 1742 if (socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, sv) < 0) { 1743 perror("Fail to create worker socket"); 1744 return -1; 1745 } 1746 pid = fork(); 1747 if (pid < 0) { 1748 perror("Failed to fork worker"); 1749 return -1; 1750 } else if (pid != 0) { /* main process */ 1751 close(sv[1]); 1752 env.worker_pids[i] = pid; 1753 env.worker_socks[i] = sv[0]; 1754 } else { /* inside each worker process */ 1755 close(sv[0]); 1756 env.worker_id = i; 1757 return worker_main(sv[1]); 1758 } 1759 } 1760 1761 if (env.worker_id == -1) { 1762 server_main(); 1763 goto out; 1764 } 1765 } 1766 1767 /* The rest of the main process */ 1768 1769 /* on single mode */ 1770 save_netns(); 1771 1772 for (i = 0; i < prog_test_cnt; i++) { 1773 struct prog_test_def *test = &prog_test_defs[i]; 1774 1775 if (!test->should_run) 1776 continue; 1777 1778 if (env.get_test_cnt) { 1779 env.succ_cnt++; 1780 continue; 1781 } 1782 1783 if (env.list_test_names) { 1784 fprintf(env.stdout, "%s\n", test->test_name); 1785 env.succ_cnt++; 1786 continue; 1787 } 1788 1789 run_one_test(i); 1790 } 1791 1792 if (env.get_test_cnt) { 1793 printf("%d\n", env.succ_cnt); 1794 goto out; 1795 } 1796 1797 if (env.list_test_names) 1798 goto out; 1799 1800 calculate_summary_and_print_errors(&env); 1801 1802 close(env.saved_netns_fd); 1803out: 1804 if (!env.list_test_names && env.has_testmod) 1805 unload_bpf_testmod(verbose()); 1806 1807 free_test_selector(&env.test_selector); 1808 free_test_selector(&env.subtest_selector); 1809 free_test_states(); 1810 1811 if (env.succ_cnt + env.fail_cnt + env.skip_cnt == 0) 1812 return EXIT_NO_TEST; 1813 1814 return env.fail_cnt ? EXIT_FAILURE : EXIT_SUCCESS; 1815} 1816