xref: /linux/tools/testing/selftests/bpf/test_progs.c (revision d0d106a2bd21499901299160744e5fe9f4c83ddb)
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
backtrace(void ** buffer,int size)31 __weak int backtrace(void **buffer, int size)
32 {
33 	return 0;
34 }
35 
backtrace_symbols_fd(void * const * buffer,int size,int fd)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 
verbose(void)44 static bool verbose(void)
45 {
46 	return env.verbosity > VERBOSE_NONE;
47 }
48 
stdio_hijack_init(char ** log_buf,size_t * log_cnt)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 
stdio_hijack(char ** log_buf,size_t * log_cnt)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 
stdio_restore_cleanup(void)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 
stdio_restore(void)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 */
glob_match(const char * str,const char * pat)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  */
usleep(useconds_t usec)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  */
watchdog_timer_func(union sigval sigval)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 
watchdog_start(void)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 
watchdog_stop(void)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 
watchdog_init(void)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 
should_run(struct test_selector * sel,int num,const char * name)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 
match_subtest(struct test_filter_set * filter,const char * test_name,const char * subtest_name)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 
should_run_subtest(struct test_selector * sel,struct test_selector * subtest_sel,int subtest_num,const char * test_name,const char * subtest_name)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 
should_tmon(struct test_selector * sel,const char * name)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 
test_result(bool failed,bool skipped)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 
print_test_result(const struct prog_test_def * test,const struct test_state * test_state)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 
print_test_log(char * log_buf,size_t log_cnt)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 
print_subtest_name(int test_num,int subtest_num,const char * test_name,char * subtest_name,char * result)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 
jsonw_write_log_message(json_writer_t * w,char * log_buf,size_t log_cnt)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 
dump_test_log(const struct prog_test_def * test,const struct test_state * test_state,bool skip_ok_subtests,bool par_exec_result,json_writer_t * w)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  */
reset_affinity(void)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 
save_netns(void)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 
restore_netns(void)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 
test__end_subtest(void)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 
test__start_subtest(const char * subtest_name)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 
test__force_log(void)606 void test__force_log(void)
607 {
608 	env.test_state->force_log = true;
609 }
610 
test__skip(void)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 
test__fail(void)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 
test__join_cgroup(const char * path)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 
bpf_find_map(const char * test,struct bpf_object * obj,const char * name)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 
compare_map_keys(int map1_fd,int map2_fd)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 
compare_stack_ips(int smap_fd,int amap_fd,int stack_trace_len)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  */
netns_new(const char * nsname,bool open)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  */
netns_free(struct netns_obj * netns_obj)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 = "<bpf@vger.kernel.org>";
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  */
start_libbpf_log_capture(void)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  */
stop_libbpf_log_capture(void)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 
libbpf_print_fn(enum libbpf_print_level level,const char * format,va_list args)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 
free_test_filter_set(const struct test_filter_set * set)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 
free_test_selector(struct test_selector * test_selector)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 
parse_arg(int key,char * arg,struct argp_state * state)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  */
cd_flavor_subdir(const char * exec_name)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 
trigger_module_test_read(int read_sz)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 
trigger_module_test_write(int write_sz)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 
write_sysctl(const char * sysctl,const char * value)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 
get_bpf_max_tramp_links_from(struct btf * btf)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 
get_bpf_max_tramp_links(void)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
crash_handler(int signum)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 
hexdump(const char * prefix,const void * buf,size_t len)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 
sigint_handler(int signum)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 
str_msg(const struct msg * msg,char * buf)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 
send_message(int sock,const struct msg * msg)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 
recv_message(int sock,struct msg * msg)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 
run_one_test(int test_num)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 
read_prog_test_msg(int sock_fd,struct msg * msg,enum msg_type type)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 
dispatch_thread_read_log(int sock_fd,char ** log_buf,size_t * log_cnt)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 
dispatch_thread_send_subtests(int sock_fd,struct test_state * state)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 
dispatch_thread(void * ctx)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 
calculate_summary_and_print_errors(struct test_env * env)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 
server_main(void)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 
worker_main_send_log(int sock,char * log_buf,size_t log_cnt)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 
free_subtest_state(struct subtest_state * state)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 
worker_main_send_subtests(int sock,struct test_state * state)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 
worker_main(int sock)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 
free_test_states(void)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 
main(int argc,char ** argv)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 }
2082