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