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
  42int env_verbosity = 0;
  43
  44static bool verbose(void)
  45{
  46	return env.verbosity > VERBOSE_NONE;
  47}
  48
  49static 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
  76static 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
  91static 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
 113static 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 */
 132static 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 */
 157struct test_env env = {};
 158
 159struct 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 */
 173int 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 */
 189static 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
 221static 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
 240static 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
 251static 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
 265static 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
 286static 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
 308static 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
 326static 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
 339static char *test_result(bool failed, bool skipped)
 340{
 341	return failed ? "FAIL" : (skipped ? "SKIP" : "OK");
 342}
 343
 344#define TEST_NUM_WIDTH 7
 345
 346static 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
 364static 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
 372static 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
 390static 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
 402static 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
 477static 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 */
 482static 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
 505static 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
 514static 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
 523void 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
 548bool 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
 606void test__force_log(void)
 607{
 608	env.test_state->force_log = true;
 609}
 610
 611void 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
 619void 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
 627int 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
 660int 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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 673int 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
 700int 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
 730out:
 731	free(val_buf1);
 732	free(val_buf2);
 733	return err;
 734}
 735
 736struct 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 */
 758struct 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;
 798fail:
 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 */
 811void 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
 829static 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
 839static const int prog_test_cnt = ARRAY_SIZE(prog_test_defs);
 840
 841static struct test_state test_states[ARRAY_SIZE(prog_test_defs)];
 842
 843const char *argp_program_version = "test_progs 0.1";
 844const char *argp_program_bug_address = "<bpf@vger.kernel.org>";
 845static 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
 853enum 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
 870static 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
 903static FILE *libbpf_capture_stream;
 904
 905static 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 */
 916int 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 */
 937char *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
 953static 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
 971static 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
 989static 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
 996extern int extra_prog_load_log_flags;
 997
 998static 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 */
1148int 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
1172int 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
1187int 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
1211int 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
1228int 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
1251int 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
1266void 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
1285static void sigint_handler(int signum)
1286{
1287	int i;
1288
1289	for (i = 0; i < env.workers; i++)
1290		if (env.worker_socks[i] > 0)
1291			close(env.worker_socks[i]);
1292}
1293
1294static int current_test_idx;
1295static pthread_mutex_t current_test_lock;
1296static pthread_mutex_t stdout_output_lock;
1297
1298static inline const char *str_msg(const struct msg *msg, char *buf)
1299{
1300	switch (msg->type) {
1301	case MSG_DO_TEST:
1302		sprintf(buf, "MSG_DO_TEST %d", msg->do_test.num);
1303		break;
1304	case MSG_TEST_DONE:
1305		sprintf(buf, "MSG_TEST_DONE %d (log: %d)",
1306			msg->test_done.num,
1307			msg->test_done.have_log);
1308		break;
1309	case MSG_SUBTEST_DONE:
1310		sprintf(buf, "MSG_SUBTEST_DONE %d (log: %d)",
1311			msg->subtest_done.num,
1312			msg->subtest_done.have_log);
1313		break;
1314	case MSG_TEST_LOG:
1315		sprintf(buf, "MSG_TEST_LOG (cnt: %zu, last: %d)",
1316			strlen(msg->test_log.log_buf),
1317			msg->test_log.is_last);
1318		break;
1319	case MSG_EXIT:
1320		sprintf(buf, "MSG_EXIT");
1321		break;
1322	default:
1323		sprintf(buf, "UNKNOWN");
1324		break;
1325	}
1326
1327	return buf;
1328}
1329
1330static int send_message(int sock, const struct msg *msg)
1331{
1332	char buf[256];
1333
1334	if (env.debug)
1335		fprintf(stderr, "Sending msg: %s\n", str_msg(msg, buf));
1336	return send(sock, msg, sizeof(*msg), 0);
1337}
1338
1339static int recv_message(int sock, struct msg *msg)
1340{
1341	int ret;
1342	char buf[256];
1343
1344	memset(msg, 0, sizeof(*msg));
1345	ret = recv(sock, msg, sizeof(*msg), 0);
1346	if (ret >= 0) {
1347		if (env.debug)
1348			fprintf(stderr, "Received msg: %s\n", str_msg(msg, buf));
1349	}
1350	return ret;
1351}
1352
1353static void run_one_test(int test_num)
1354{
1355	struct prog_test_def *test = &prog_test_defs[test_num];
1356	struct test_state *state = &test_states[test_num];
1357
1358	env.test = test;
1359	env.test_state = state;
1360
1361	stdio_hijack(&state->log_buf, &state->log_cnt);
1362
1363	watchdog_start();
1364	if (test->run_test)
1365		test->run_test();
1366	else if (test->run_serial_test)
1367		test->run_serial_test();
1368	watchdog_stop();
1369
1370	/* ensure last sub-test is finalized properly */
1371	if (env.subtest_state)
1372		test__end_subtest();
1373
1374	state->tested = true;
1375
1376	if (verbose() && env.worker_id == -1)
1377		print_test_result(test, state);
1378
1379	reset_affinity();
1380	restore_netns();
1381	if (test->need_cgroup_cleanup)
1382		cleanup_cgroup_environment();
1383
1384	stdio_restore();
1385	free(stop_libbpf_log_capture());
1386
1387	dump_test_log(test, state, false, false, NULL);
1388}
1389
1390struct dispatch_data {
1391	int worker_id;
1392	int sock_fd;
1393};
1394
1395static int read_prog_test_msg(int sock_fd, struct msg *msg, enum msg_type type)
1396{
1397	if (recv_message(sock_fd, msg) < 0)
1398		return 1;
1399
1400	if (msg->type != type) {
1401		printf("%s: unexpected message type %d. expected %d\n", __func__, msg->type, type);
1402		return 1;
1403	}
1404
1405	return 0;
1406}
1407
1408static int dispatch_thread_read_log(int sock_fd, char **log_buf, size_t *log_cnt)
1409{
1410	FILE *log_fp = NULL;
1411	int result = 0;
1412
1413	log_fp = open_memstream(log_buf, log_cnt);
1414	if (!log_fp)
1415		return 1;
1416
1417	while (true) {
1418		struct msg msg;
1419
1420		if (read_prog_test_msg(sock_fd, &msg, MSG_TEST_LOG)) {
1421			result = 1;
1422			goto out;
1423		}
1424
1425		fprintf(log_fp, "%s", msg.test_log.log_buf);
1426		if (msg.test_log.is_last)
1427			break;
1428	}
1429
1430out:
1431	fclose(log_fp);
1432	log_fp = NULL;
1433	return result;
1434}
1435
1436static int dispatch_thread_send_subtests(int sock_fd, struct test_state *state)
1437{
1438	struct msg msg;
1439	struct subtest_state *subtest_state;
1440	int subtest_num = state->subtest_num;
1441
1442	state->subtest_states = malloc(subtest_num * sizeof(*subtest_state));
1443
1444	for (int i = 0; i < subtest_num; i++) {
1445		subtest_state = &state->subtest_states[i];
1446
1447		memset(subtest_state, 0, sizeof(*subtest_state));
1448
1449		if (read_prog_test_msg(sock_fd, &msg, MSG_SUBTEST_DONE))
1450			return 1;
1451
1452		subtest_state->name = strdup(msg.subtest_done.name);
1453		subtest_state->error_cnt = msg.subtest_done.error_cnt;
1454		subtest_state->skipped = msg.subtest_done.skipped;
1455		subtest_state->filtered = msg.subtest_done.filtered;
1456
1457		/* collect all logs */
1458		if (msg.subtest_done.have_log)
1459			if (dispatch_thread_read_log(sock_fd,
1460						     &subtest_state->log_buf,
1461						     &subtest_state->log_cnt))
1462				return 1;
1463	}
1464
1465	return 0;
1466}
1467
1468static void *dispatch_thread(void *ctx)
1469{
1470	struct dispatch_data *data = ctx;
1471	int sock_fd;
1472
1473	sock_fd = data->sock_fd;
1474
1475	while (true) {
1476		int test_to_run = -1;
1477		struct prog_test_def *test;
1478		struct test_state *state;
1479
1480		/* grab a test */
1481		{
1482			pthread_mutex_lock(&current_test_lock);
1483
1484			if (current_test_idx >= prog_test_cnt) {
1485				pthread_mutex_unlock(&current_test_lock);
1486				goto done;
1487			}
1488
1489			test = &prog_test_defs[current_test_idx];
1490			test_to_run = current_test_idx;
1491			current_test_idx++;
1492
1493			pthread_mutex_unlock(&current_test_lock);
1494		}
1495
1496		if (!test->should_run || test->run_serial_test)
1497			continue;
1498
1499		/* run test through worker */
1500		{
1501			struct msg msg_do_test;
1502
1503			memset(&msg_do_test, 0, sizeof(msg_do_test));
1504			msg_do_test.type = MSG_DO_TEST;
1505			msg_do_test.do_test.num = test_to_run;
1506			if (send_message(sock_fd, &msg_do_test) < 0) {
1507				perror("Fail to send command");
1508				goto done;
1509			}
1510			env.worker_current_test[data->worker_id] = test_to_run;
1511		}
1512
1513		/* wait for test done */
1514		do {
1515			struct msg msg;
1516
1517			if (read_prog_test_msg(sock_fd, &msg, MSG_TEST_DONE))
1518				goto error;
1519			if (test_to_run != msg.test_done.num)
1520				goto error;
1521
1522			state = &test_states[test_to_run];
1523			state->tested = true;
1524			state->error_cnt = msg.test_done.error_cnt;
1525			state->skip_cnt = msg.test_done.skip_cnt;
1526			state->sub_succ_cnt = msg.test_done.sub_succ_cnt;
1527			state->subtest_num = msg.test_done.subtest_num;
1528
1529			/* collect all logs */
1530			if (msg.test_done.have_log) {
1531				if (dispatch_thread_read_log(sock_fd,
1532							     &state->log_buf,
1533							     &state->log_cnt))
1534					goto error;
1535			}
1536
1537			/* collect all subtests and subtest logs */
1538			if (!state->subtest_num)
1539				break;
1540
1541			if (dispatch_thread_send_subtests(sock_fd, state))
1542				goto error;
1543		} while (false);
1544
1545		pthread_mutex_lock(&stdout_output_lock);
1546		dump_test_log(test, state, false, true, NULL);
1547		pthread_mutex_unlock(&stdout_output_lock);
1548	} /* while (true) */
1549error:
1550	if (env.debug)
1551		fprintf(stderr, "[%d]: Protocol/IO error: %s.\n", data->worker_id, strerror(errno));
1552
1553done:
1554	{
1555		struct msg msg_exit;
1556
1557		msg_exit.type = MSG_EXIT;
1558		if (send_message(sock_fd, &msg_exit) < 0) {
1559			if (env.debug)
1560				fprintf(stderr, "[%d]: send_message msg_exit: %s.\n",
1561					data->worker_id, strerror(errno));
1562		}
1563	}
1564	return NULL;
1565}
1566
1567static void calculate_summary_and_print_errors(struct test_env *env)
1568{
1569	int i;
1570	int succ_cnt = 0, fail_cnt = 0, sub_succ_cnt = 0, skip_cnt = 0;
1571	json_writer_t *w = NULL;
1572
1573	for (i = 0; i < prog_test_cnt; i++) {
1574		struct test_state *state = &test_states[i];
1575
1576		if (!state->tested)
1577			continue;
1578
1579		sub_succ_cnt += state->sub_succ_cnt;
1580		skip_cnt += state->skip_cnt;
1581
1582		if (state->error_cnt)
1583			fail_cnt++;
1584		else
1585			succ_cnt++;
1586	}
1587
1588	if (env->json) {
1589		w = jsonw_new(env->json);
1590		if (!w)
1591			fprintf(env->stderr_saved, "Failed to create new JSON stream.");
1592	}
1593
1594	if (w) {
1595		jsonw_start_object(w);
1596		jsonw_uint_field(w, "success", succ_cnt);
1597		jsonw_uint_field(w, "success_subtest", sub_succ_cnt);
1598		jsonw_uint_field(w, "skipped", skip_cnt);
1599		jsonw_uint_field(w, "failed", fail_cnt);
1600		jsonw_name(w, "results");
1601		jsonw_start_array(w);
1602	}
1603
1604	/*
1605	 * We only print error logs summary when there are failed tests and
1606	 * verbose mode is not enabled. Otherwise, results may be inconsistent.
1607	 *
1608	 */
1609	if (!verbose() && fail_cnt) {
1610		printf("\nAll error logs:\n");
1611
1612		/* print error logs again */
1613		for (i = 0; i < prog_test_cnt; i++) {
1614			struct prog_test_def *test = &prog_test_defs[i];
1615			struct test_state *state = &test_states[i];
1616
1617			if (!state->tested || !state->error_cnt)
1618				continue;
1619
1620			dump_test_log(test, state, true, true, w);
1621		}
1622	}
1623
1624	if (w) {
1625		jsonw_end_array(w);
1626		jsonw_end_object(w);
1627		jsonw_destroy(&w);
1628	}
1629
1630	if (env->json)
1631		fclose(env->json);
1632
1633	printf("Summary: %d/%d PASSED, %d SKIPPED, %d FAILED\n",
1634	       succ_cnt, sub_succ_cnt, skip_cnt, fail_cnt);
1635
1636	env->succ_cnt = succ_cnt;
1637	env->sub_succ_cnt = sub_succ_cnt;
1638	env->fail_cnt = fail_cnt;
1639	env->skip_cnt = skip_cnt;
1640}
1641
1642static void server_main(void)
1643{
1644	pthread_t *dispatcher_threads;
1645	struct dispatch_data *data;
1646	struct sigaction sigact_int = {
1647		.sa_handler = sigint_handler,
1648		.sa_flags = SA_RESETHAND,
1649	};
1650	int i;
1651
1652	sigaction(SIGINT, &sigact_int, NULL);
1653
1654	dispatcher_threads = calloc(sizeof(pthread_t), env.workers);
1655	data = calloc(sizeof(struct dispatch_data), env.workers);
1656
1657	env.worker_current_test = calloc(sizeof(int), env.workers);
1658	for (i = 0; i < env.workers; i++) {
1659		int rc;
1660
1661		data[i].worker_id = i;
1662		data[i].sock_fd = env.worker_socks[i];
1663		rc = pthread_create(&dispatcher_threads[i], NULL, dispatch_thread, &data[i]);
1664		if (rc < 0) {
1665			perror("Failed to launch dispatcher thread");
1666			exit(EXIT_ERR_SETUP_INFRA);
1667		}
1668	}
1669
1670	/* wait for all dispatcher to finish */
1671	for (i = 0; i < env.workers; i++) {
1672		while (true) {
1673			int ret = pthread_tryjoin_np(dispatcher_threads[i], NULL);
1674
1675			if (!ret) {
1676				break;
1677			} else if (ret == EBUSY) {
1678				if (env.debug)
1679					fprintf(stderr, "Still waiting for thread %d (test %d).\n",
1680						i,  env.worker_current_test[i] + 1);
1681				usleep(1000 * 1000);
1682				continue;
1683			} else {
1684				fprintf(stderr, "Unexpected error joining dispatcher thread: %d", ret);
1685				break;
1686			}
1687		}
1688	}
1689	free(dispatcher_threads);
1690	free(env.worker_current_test);
1691	free(data);
1692
1693	/* run serial tests */
1694	save_netns();
1695
1696	for (int i = 0; i < prog_test_cnt; i++) {
1697		struct prog_test_def *test = &prog_test_defs[i];
1698
1699		if (!test->should_run || !test->run_serial_test)
1700			continue;
1701
1702		run_one_test(i);
1703	}
1704
1705	/* generate summary */
1706	fflush(stderr);
1707	fflush(stdout);
1708
1709	calculate_summary_and_print_errors(&env);
1710
1711	/* reap all workers */
1712	for (i = 0; i < env.workers; i++) {
1713		int wstatus, pid;
1714
1715		pid = waitpid(env.worker_pids[i], &wstatus, 0);
1716		if (pid != env.worker_pids[i])
1717			perror("Unable to reap worker");
1718	}
1719}
1720
1721static void worker_main_send_log(int sock, char *log_buf, size_t log_cnt)
1722{
1723	char *src;
1724	size_t slen;
1725
1726	src = log_buf;
1727	slen = log_cnt;
1728	while (slen) {
1729		struct msg msg_log;
1730		char *dest;
1731		size_t len;
1732
1733		memset(&msg_log, 0, sizeof(msg_log));
1734		msg_log.type = MSG_TEST_LOG;
1735		dest = msg_log.test_log.log_buf;
1736		len = slen >= MAX_LOG_TRUNK_SIZE ? MAX_LOG_TRUNK_SIZE : slen;
1737		memcpy(dest, src, len);
1738
1739		src += len;
1740		slen -= len;
1741		if (!slen)
1742			msg_log.test_log.is_last = true;
1743
1744		assert(send_message(sock, &msg_log) >= 0);
1745	}
1746}
1747
1748static void free_subtest_state(struct subtest_state *state)
1749{
1750	if (state->log_buf) {
1751		free(state->log_buf);
1752		state->log_buf = NULL;
1753		state->log_cnt = 0;
1754	}
1755	free(state->name);
1756	state->name = NULL;
1757}
1758
1759static int worker_main_send_subtests(int sock, struct test_state *state)
1760{
1761	int i, result = 0;
1762	struct msg msg;
1763	struct subtest_state *subtest_state;
1764
1765	memset(&msg, 0, sizeof(msg));
1766	msg.type = MSG_SUBTEST_DONE;
1767
1768	for (i = 0; i < state->subtest_num; i++) {
1769		subtest_state = &state->subtest_states[i];
1770
1771		msg.subtest_done.num = i;
1772
1773		strncpy(msg.subtest_done.name, subtest_state->name, MAX_SUBTEST_NAME);
1774
1775		msg.subtest_done.error_cnt = subtest_state->error_cnt;
1776		msg.subtest_done.skipped = subtest_state->skipped;
1777		msg.subtest_done.filtered = subtest_state->filtered;
1778		msg.subtest_done.have_log = false;
1779
1780		if (verbose() || state->force_log || subtest_state->error_cnt) {
1781			if (subtest_state->log_cnt)
1782				msg.subtest_done.have_log = true;
1783		}
1784
1785		if (send_message(sock, &msg) < 0) {
1786			perror("Fail to send message done");
1787			result = 1;
1788			goto out;
1789		}
1790
1791		/* send logs */
1792		if (msg.subtest_done.have_log)
1793			worker_main_send_log(sock, subtest_state->log_buf, subtest_state->log_cnt);
1794
1795		free_subtest_state(subtest_state);
1796		free(subtest_state->name);
1797	}
1798
1799out:
1800	for (; i < state->subtest_num; i++)
1801		free_subtest_state(&state->subtest_states[i]);
1802	free(state->subtest_states);
1803	return result;
1804}
1805
1806static int worker_main(int sock)
1807{
1808	save_netns();
1809	watchdog_init();
1810
1811	while (true) {
1812		/* receive command */
1813		struct msg msg;
1814
1815		if (recv_message(sock, &msg) < 0)
1816			goto out;
1817
1818		switch (msg.type) {
1819		case MSG_EXIT:
1820			if (env.debug)
1821				fprintf(stderr, "[%d]: worker exit.\n",
1822					env.worker_id);
1823			goto out;
1824		case MSG_DO_TEST: {
1825			int test_to_run = msg.do_test.num;
1826			struct prog_test_def *test = &prog_test_defs[test_to_run];
1827			struct test_state *state = &test_states[test_to_run];
1828			struct msg msg;
1829
1830			if (env.debug)
1831				fprintf(stderr, "[%d]: #%d:%s running.\n",
1832					env.worker_id,
1833					test_to_run + 1,
1834					test->test_name);
1835
1836			run_one_test(test_to_run);
1837
1838			memset(&msg, 0, sizeof(msg));
1839			msg.type = MSG_TEST_DONE;
1840			msg.test_done.num = test_to_run;
1841			msg.test_done.error_cnt = state->error_cnt;
1842			msg.test_done.skip_cnt = state->skip_cnt;
1843			msg.test_done.sub_succ_cnt = state->sub_succ_cnt;
1844			msg.test_done.subtest_num = state->subtest_num;
1845			msg.test_done.have_log = false;
1846
1847			if (verbose() || state->force_log || state->error_cnt) {
1848				if (state->log_cnt)
1849					msg.test_done.have_log = true;
1850			}
1851			if (send_message(sock, &msg) < 0) {
1852				perror("Fail to send message done");
1853				goto out;
1854			}
1855
1856			/* send logs */
1857			if (msg.test_done.have_log)
1858				worker_main_send_log(sock, state->log_buf, state->log_cnt);
1859
1860			if (state->log_buf) {
1861				free(state->log_buf);
1862				state->log_buf = NULL;
1863				state->log_cnt = 0;
1864			}
1865
1866			if (state->subtest_num)
1867				if (worker_main_send_subtests(sock, state))
1868					goto out;
1869
1870			if (env.debug)
1871				fprintf(stderr, "[%d]: #%d:%s done.\n",
1872					env.worker_id,
1873					test_to_run + 1,
1874					test->test_name);
1875			break;
1876		} /* case MSG_DO_TEST */
1877		default:
1878			if (env.debug)
1879				fprintf(stderr, "[%d]: unknown message.\n",  env.worker_id);
1880			return -1;
1881		}
1882	}
1883out:
1884	return 0;
1885}
1886
1887static void free_test_states(void)
1888{
1889	int i, j;
1890
1891	for (i = 0; i < ARRAY_SIZE(prog_test_defs); i++) {
1892		struct test_state *test_state = &test_states[i];
1893
1894		for (j = 0; j < test_state->subtest_num; j++)
1895			free_subtest_state(&test_state->subtest_states[j]);
1896
1897		free(test_state->subtest_states);
1898		free(test_state->log_buf);
1899		test_state->subtest_states = NULL;
1900		test_state->log_buf = NULL;
1901	}
1902}
1903
1904int main(int argc, char **argv)
1905{
1906	static const struct argp argp = {
1907		.options = opts,
1908		.parser = parse_arg,
1909		.doc = argp_program_doc,
1910	};
1911	struct sigaction sigact = {
1912		.sa_handler = crash_handler,
1913		.sa_flags = SA_RESETHAND,
1914		};
1915	int err, i;
1916
1917	sigaction(SIGSEGV, &sigact, NULL);
1918
1919	env.secs_till_notify = 10;
1920	env.secs_till_kill = 120;
1921	err = argp_parse(&argp, argc, argv, 0, NULL, &env);
1922	if (err)
1923		return err;
1924
1925	err = cd_flavor_subdir(argv[0]);
1926	if (err)
1927		return err;
1928
1929	watchdog_init();
1930
1931	/* Use libbpf 1.0 API mode */
1932	libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
 
1933	libbpf_set_print(libbpf_print_fn);
1934
1935	srand(time(NULL));
1936
1937	env.jit_enabled = is_jit_enabled();
1938	env.nr_cpus = libbpf_num_possible_cpus();
1939	if (env.nr_cpus < 0) {
1940		fprintf(stderr, "Failed to get number of CPUs: %d!\n",
1941			env.nr_cpus);
1942		return -1;
1943	}
1944
1945	env.stdout_saved = stdout;
1946	env.stderr_saved = stderr;
1947
1948	env.has_testmod = true;
1949	if (!env.list_test_names) {
1950		/* ensure previous instance of the module is unloaded */
1951		unload_bpf_testmod(verbose());
1952
1953		if (load_bpf_testmod(verbose())) {
1954			fprintf(env.stderr_saved, "WARNING! Selftests relying on bpf_testmod.ko will be skipped.\n");
1955			env.has_testmod = false;
1956		}
1957	}
1958
1959	/* initializing tests */
1960	for (i = 0; i < prog_test_cnt; i++) {
1961		struct prog_test_def *test = &prog_test_defs[i];
1962
 
1963		test->test_num = i + 1;
1964		test->should_run = should_run(&env.test_selector,
1965					      test->test_num, test->test_name);
1966
1967		if ((test->run_test == NULL && test->run_serial_test == NULL) ||
1968		    (test->run_test != NULL && test->run_serial_test != NULL)) {
1969			fprintf(stderr, "Test %d:%s must have either test_%s() or serial_test_%sl() defined.\n",
1970				test->test_num, test->test_name, test->test_name, test->test_name);
1971			exit(EXIT_ERR_SETUP_INFRA);
1972		}
1973		if (test->should_run)
1974			test->should_tmon = should_tmon(&env.tmon_selector, test->test_name);
1975	}
1976
1977	/* ignore workers if we are just listing */
1978	if (env.get_test_cnt || env.list_test_names)
1979		env.workers = 0;
1980
1981	/* launch workers if requested */
1982	env.worker_id = -1; /* main process */
1983	if (env.workers) {
1984		env.worker_pids = calloc(sizeof(pid_t), env.workers);
1985		env.worker_socks = calloc(sizeof(int), env.workers);
1986		if (env.debug)
1987			fprintf(stdout, "Launching %d workers.\n", env.workers);
1988		for (i = 0; i < env.workers; i++) {
1989			int sv[2];
1990			pid_t pid;
1991
1992			if (socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, sv) < 0) {
1993				perror("Fail to create worker socket");
1994				return -1;
1995			}
1996			pid = fork();
1997			if (pid < 0) {
1998				perror("Failed to fork worker");
1999				return -1;
2000			} else if (pid != 0) { /* main process */
2001				close(sv[1]);
2002				env.worker_pids[i] = pid;
2003				env.worker_socks[i] = sv[0];
2004			} else { /* inside each worker process */
2005				close(sv[0]);
2006				env.worker_id = i;
2007				return worker_main(sv[1]);
2008			}
2009		}
2010
2011		if (env.worker_id == -1) {
2012			server_main();
2013			goto out;
2014		}
2015	}
2016
2017	/* The rest of the main process */
2018
2019	/* on single mode */
2020	save_netns();
2021
2022	for (i = 0; i < prog_test_cnt; i++) {
2023		struct prog_test_def *test = &prog_test_defs[i];
2024
2025		if (!test->should_run)
 
2026			continue;
2027
2028		if (env.get_test_cnt) {
2029			env.succ_cnt++;
2030			continue;
2031		}
2032
2033		if (env.list_test_names) {
2034			fprintf(env.stdout_saved, "%s\n", test->test_name);
2035			env.succ_cnt++;
2036			continue;
2037		}
2038
2039		run_one_test(i);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2040	}
 
 
 
2041
2042	if (env.get_test_cnt) {
2043		printf("%d\n", env.succ_cnt);
2044		goto out;
2045	}
2046
2047	if (env.list_test_names)
2048		goto out;
2049
2050	calculate_summary_and_print_errors(&env);
 
2051
2052	close(env.saved_netns_fd);
2053out:
2054	if (!env.list_test_names && env.has_testmod)
2055		unload_bpf_testmod(verbose());
2056
2057	free_test_selector(&env.test_selector);
2058	free_test_selector(&env.subtest_selector);
2059	free_test_selector(&env.tmon_selector);
2060	free_test_states();
2061
2062	if (env.succ_cnt + env.fail_cnt + env.skip_cnt == 0)
2063		return EXIT_NO_TEST;
2064
2065	return env.fail_cnt ? EXIT_FAILURE : EXIT_SUCCESS;
2066}