tools/testing/selftests/bpf/test_progs.c

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