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 "bpf_rlimit.h"
8 #include <argp.h>
9 #include <pthread.h>
10 #include <sched.h>
11 #include <signal.h>
12 #include <string.h>
13 #include <execinfo.h> /* backtrace */
14
15 #define EXIT_NO_TEST 2
16 #define EXIT_ERR_SETUP_INFRA 3
17
18 /* defined in test_progs.h */
19 struct test_env env = {};
20
21 struct prog_test_def {
22 const char *test_name;
23 int test_num;
24 void (*run_test)(void);
25 bool force_log;
26 int error_cnt;
27 int skip_cnt;
28 bool tested;
29 bool need_cgroup_cleanup;
30
31 char *subtest_name;
32 int subtest_num;
33
34 /* store counts before subtest started */
35 int old_error_cnt;
36 };
37
38 /* Override C runtime library's usleep() implementation to ensure nanosleep()
39 * is always called. Usleep is frequently used in selftests as a way to
40 * trigger kprobe and tracepoints.
41 */
usleep(useconds_t usec)42 int usleep(useconds_t usec)
43 {
44 struct timespec ts = {
45 .tv_sec = usec / 1000000,
46 .tv_nsec = (usec % 1000000) * 1000,
47 };
48
49 return syscall(__NR_nanosleep, &ts, NULL);
50 }
51
should_run(struct test_selector * sel,int num,const char * name)52 static bool should_run(struct test_selector *sel, int num, const char *name)
53 {
54 int i;
55
56 for (i = 0; i < sel->blacklist.cnt; i++) {
57 if (strstr(name, sel->blacklist.strs[i]))
58 return false;
59 }
60
61 for (i = 0; i < sel->whitelist.cnt; i++) {
62 if (strstr(name, sel->whitelist.strs[i]))
63 return true;
64 }
65
66 if (!sel->whitelist.cnt && !sel->num_set)
67 return true;
68
69 return num < sel->num_set_len && sel->num_set[num];
70 }
71
dump_test_log(const struct prog_test_def * test,bool failed)72 static void dump_test_log(const struct prog_test_def *test, bool failed)
73 {
74 if (stdout == env.stdout)
75 return;
76
77 fflush(stdout); /* exports env.log_buf & env.log_cnt */
78
79 if (env.verbosity > VERBOSE_NONE || test->force_log || failed) {
80 if (env.log_cnt) {
81 env.log_buf[env.log_cnt] = '\0';
82 fprintf(env.stdout, "%s", env.log_buf);
83 if (env.log_buf[env.log_cnt - 1] != '\n')
84 fprintf(env.stdout, "\n");
85 }
86 }
87
88 fseeko(stdout, 0, SEEK_SET); /* rewind */
89 }
90
skip_account(void)91 static void skip_account(void)
92 {
93 if (env.test->skip_cnt) {
94 env.skip_cnt++;
95 env.test->skip_cnt = 0;
96 }
97 }
98
99 static void stdio_restore(void);
100
101 /* A bunch of tests set custom affinity per-thread and/or per-process. Reset
102 * it after each test/sub-test.
103 */
reset_affinity()104 static void reset_affinity() {
105
106 cpu_set_t cpuset;
107 int i, err;
108
109 CPU_ZERO(&cpuset);
110 for (i = 0; i < env.nr_cpus; i++)
111 CPU_SET(i, &cpuset);
112
113 err = sched_setaffinity(0, sizeof(cpuset), &cpuset);
114 if (err < 0) {
115 stdio_restore();
116 fprintf(stderr, "Failed to reset process affinity: %d!\n", err);
117 exit(EXIT_ERR_SETUP_INFRA);
118 }
119 err = pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
120 if (err < 0) {
121 stdio_restore();
122 fprintf(stderr, "Failed to reset thread affinity: %d!\n", err);
123 exit(EXIT_ERR_SETUP_INFRA);
124 }
125 }
126
save_netns(void)127 static void save_netns(void)
128 {
129 env.saved_netns_fd = open("/proc/self/ns/net", O_RDONLY);
130 if (env.saved_netns_fd == -1) {
131 perror("open(/proc/self/ns/net)");
132 exit(EXIT_ERR_SETUP_INFRA);
133 }
134 }
135
restore_netns(void)136 static void restore_netns(void)
137 {
138 if (setns(env.saved_netns_fd, CLONE_NEWNET) == -1) {
139 stdio_restore();
140 perror("setns(CLONE_NEWNS)");
141 exit(EXIT_ERR_SETUP_INFRA);
142 }
143 }
144
test__end_subtest()145 void test__end_subtest()
146 {
147 struct prog_test_def *test = env.test;
148 int sub_error_cnt = test->error_cnt - test->old_error_cnt;
149
150 if (sub_error_cnt)
151 env.fail_cnt++;
152 else
153 env.sub_succ_cnt++;
154 skip_account();
155
156 dump_test_log(test, sub_error_cnt);
157
158 fprintf(env.stdout, "#%d/%d %s:%s\n",
159 test->test_num, test->subtest_num,
160 test->subtest_name, sub_error_cnt ? "FAIL" : "OK");
161
162 free(test->subtest_name);
163 test->subtest_name = NULL;
164 }
165
test__start_subtest(const char * name)166 bool test__start_subtest(const char *name)
167 {
168 struct prog_test_def *test = env.test;
169
170 if (test->subtest_name)
171 test__end_subtest();
172
173 test->subtest_num++;
174
175 if (!name || !name[0]) {
176 fprintf(env.stderr,
177 "Subtest #%d didn't provide sub-test name!\n",
178 test->subtest_num);
179 return false;
180 }
181
182 if (!should_run(&env.subtest_selector, test->subtest_num, name))
183 return false;
184
185 test->subtest_name = strdup(name);
186 if (!test->subtest_name) {
187 fprintf(env.stderr,
188 "Subtest #%d: failed to copy subtest name!\n",
189 test->subtest_num);
190 return false;
191 }
192 env.test->old_error_cnt = env.test->error_cnt;
193
194 return true;
195 }
196
test__force_log()197 void test__force_log() {
198 env.test->force_log = true;
199 }
200
test__skip(void)201 void test__skip(void)
202 {
203 env.test->skip_cnt++;
204 }
205
test__fail(void)206 void test__fail(void)
207 {
208 env.test->error_cnt++;
209 }
210
test__join_cgroup(const char * path)211 int test__join_cgroup(const char *path)
212 {
213 int fd;
214
215 if (!env.test->need_cgroup_cleanup) {
216 if (setup_cgroup_environment()) {
217 fprintf(stderr,
218 "#%d %s: Failed to setup cgroup environment\n",
219 env.test->test_num, env.test->test_name);
220 return -1;
221 }
222
223 env.test->need_cgroup_cleanup = true;
224 }
225
226 fd = create_and_get_cgroup(path);
227 if (fd < 0) {
228 fprintf(stderr,
229 "#%d %s: Failed to create cgroup '%s' (errno=%d)\n",
230 env.test->test_num, env.test->test_name, path, errno);
231 return fd;
232 }
233
234 if (join_cgroup(path)) {
235 fprintf(stderr,
236 "#%d %s: Failed to join cgroup '%s' (errno=%d)\n",
237 env.test->test_num, env.test->test_name, path, errno);
238 return -1;
239 }
240
241 return fd;
242 }
243
bpf_find_map(const char * test,struct bpf_object * obj,const char * name)244 int bpf_find_map(const char *test, struct bpf_object *obj, const char *name)
245 {
246 struct bpf_map *map;
247
248 map = bpf_object__find_map_by_name(obj, name);
249 if (!map) {
250 fprintf(stdout, "%s:FAIL:map '%s' not found\n", test, name);
251 test__fail();
252 return -1;
253 }
254 return bpf_map__fd(map);
255 }
256
is_jit_enabled(void)257 static bool is_jit_enabled(void)
258 {
259 const char *jit_sysctl = "/proc/sys/net/core/bpf_jit_enable";
260 bool enabled = false;
261 int sysctl_fd;
262
263 sysctl_fd = open(jit_sysctl, 0, O_RDONLY);
264 if (sysctl_fd != -1) {
265 char tmpc;
266
267 if (read(sysctl_fd, &tmpc, sizeof(tmpc)) == 1)
268 enabled = (tmpc != '0');
269 close(sysctl_fd);
270 }
271
272 return enabled;
273 }
274
compare_map_keys(int map1_fd,int map2_fd)275 int compare_map_keys(int map1_fd, int map2_fd)
276 {
277 __u32 key, next_key;
278 char val_buf[PERF_MAX_STACK_DEPTH *
279 sizeof(struct bpf_stack_build_id)];
280 int err;
281
282 err = bpf_map_get_next_key(map1_fd, NULL, &key);
283 if (err)
284 return err;
285 err = bpf_map_lookup_elem(map2_fd, &key, val_buf);
286 if (err)
287 return err;
288
289 while (bpf_map_get_next_key(map1_fd, &key, &next_key) == 0) {
290 err = bpf_map_lookup_elem(map2_fd, &next_key, val_buf);
291 if (err)
292 return err;
293
294 key = next_key;
295 }
296 if (errno != ENOENT)
297 return -1;
298
299 return 0;
300 }
301
compare_stack_ips(int smap_fd,int amap_fd,int stack_trace_len)302 int compare_stack_ips(int smap_fd, int amap_fd, int stack_trace_len)
303 {
304 __u32 key, next_key, *cur_key_p, *next_key_p;
305 char *val_buf1, *val_buf2;
306 int i, err = 0;
307
308 val_buf1 = malloc(stack_trace_len);
309 val_buf2 = malloc(stack_trace_len);
310 cur_key_p = NULL;
311 next_key_p = &key;
312 while (bpf_map_get_next_key(smap_fd, cur_key_p, next_key_p) == 0) {
313 err = bpf_map_lookup_elem(smap_fd, next_key_p, val_buf1);
314 if (err)
315 goto out;
316 err = bpf_map_lookup_elem(amap_fd, next_key_p, val_buf2);
317 if (err)
318 goto out;
319 for (i = 0; i < stack_trace_len; i++) {
320 if (val_buf1[i] != val_buf2[i]) {
321 err = -1;
322 goto out;
323 }
324 }
325 key = *next_key_p;
326 cur_key_p = &key;
327 next_key_p = &next_key;
328 }
329 if (errno != ENOENT)
330 err = -1;
331
332 out:
333 free(val_buf1);
334 free(val_buf2);
335 return err;
336 }
337
extract_build_id(char * build_id,size_t size)338 int extract_build_id(char *build_id, size_t size)
339 {
340 FILE *fp;
341 char *line = NULL;
342 size_t len = 0;
343
344 fp = popen("readelf -n ./urandom_read | grep 'Build ID'", "r");
345 if (fp == NULL)
346 return -1;
347
348 if (getline(&line, &len, fp) == -1)
349 goto err;
350 pclose(fp);
351
352 if (len > size)
353 len = size;
354 memcpy(build_id, line, len);
355 build_id[len] = '\0';
356 free(line);
357 return 0;
358 err:
359 pclose(fp);
360 return -1;
361 }
362
363 /* extern declarations for test funcs */
364 #define DEFINE_TEST(name) extern void test_##name(void);
365 #include <prog_tests/tests.h>
366 #undef DEFINE_TEST
367
368 static struct prog_test_def prog_test_defs[] = {
369 #define DEFINE_TEST(name) { \
370 .test_name = #name, \
371 .run_test = &test_##name, \
372 },
373 #include <prog_tests/tests.h>
374 #undef DEFINE_TEST
375 };
376 const int prog_test_cnt = ARRAY_SIZE(prog_test_defs);
377
378 const char *argp_program_version = "test_progs 0.1";
379 const char *argp_program_bug_address = "<bpf@vger.kernel.org>";
380 const char argp_program_doc[] = "BPF selftests test runner";
381
382 enum ARG_KEYS {
383 ARG_TEST_NUM = 'n',
384 ARG_TEST_NAME = 't',
385 ARG_TEST_NAME_BLACKLIST = 'b',
386 ARG_VERIFIER_STATS = 's',
387 ARG_VERBOSE = 'v',
388 ARG_GET_TEST_CNT = 'c',
389 ARG_LIST_TEST_NAMES = 'l',
390 };
391
392 static const struct argp_option opts[] = {
393 { "num", ARG_TEST_NUM, "NUM", 0,
394 "Run test number NUM only " },
395 { "name", ARG_TEST_NAME, "NAMES", 0,
396 "Run tests with names containing any string from NAMES list" },
397 { "name-blacklist", ARG_TEST_NAME_BLACKLIST, "NAMES", 0,
398 "Don't run tests with names containing any string from NAMES list" },
399 { "verifier-stats", ARG_VERIFIER_STATS, NULL, 0,
400 "Output verifier statistics", },
401 { "verbose", ARG_VERBOSE, "LEVEL", OPTION_ARG_OPTIONAL,
402 "Verbose output (use -vv or -vvv for progressively verbose output)" },
403 { "count", ARG_GET_TEST_CNT, NULL, 0,
404 "Get number of selected top-level tests " },
405 { "list", ARG_LIST_TEST_NAMES, NULL, 0,
406 "List test names that would run (without running them) " },
407 {},
408 };
409
libbpf_print_fn(enum libbpf_print_level level,const char * format,va_list args)410 static int libbpf_print_fn(enum libbpf_print_level level,
411 const char *format, va_list args)
412 {
413 if (env.verbosity < VERBOSE_VERY && level == LIBBPF_DEBUG)
414 return 0;
415 vfprintf(stdout, format, args);
416 return 0;
417 }
418
free_str_set(const struct str_set * set)419 static void free_str_set(const struct str_set *set)
420 {
421 int i;
422
423 if (!set)
424 return;
425
426 for (i = 0; i < set->cnt; i++)
427 free((void *)set->strs[i]);
428 free(set->strs);
429 }
430
parse_str_list(const char * s,struct str_set * set)431 static int parse_str_list(const char *s, struct str_set *set)
432 {
433 char *input, *state = NULL, *next, **tmp, **strs = NULL;
434 int cnt = 0;
435
436 input = strdup(s);
437 if (!input)
438 return -ENOMEM;
439
440 set->cnt = 0;
441 set->strs = NULL;
442
443 while ((next = strtok_r(state ? NULL : input, ",", &state))) {
444 tmp = realloc(strs, sizeof(*strs) * (cnt + 1));
445 if (!tmp)
446 goto err;
447 strs = tmp;
448
449 strs[cnt] = strdup(next);
450 if (!strs[cnt])
451 goto err;
452
453 cnt++;
454 }
455
456 set->cnt = cnt;
457 set->strs = (const char **)strs;
458 free(input);
459 return 0;
460 err:
461 free(strs);
462 free(input);
463 return -ENOMEM;
464 }
465
466 extern int extra_prog_load_log_flags;
467
parse_arg(int key,char * arg,struct argp_state * state)468 static error_t parse_arg(int key, char *arg, struct argp_state *state)
469 {
470 struct test_env *env = state->input;
471
472 switch (key) {
473 case ARG_TEST_NUM: {
474 char *subtest_str = strchr(arg, '/');
475
476 if (subtest_str) {
477 *subtest_str = '\0';
478 if (parse_num_list(subtest_str + 1,
479 &env->subtest_selector.num_set,
480 &env->subtest_selector.num_set_len)) {
481 fprintf(stderr,
482 "Failed to parse subtest numbers.\n");
483 return -EINVAL;
484 }
485 }
486 if (parse_num_list(arg, &env->test_selector.num_set,
487 &env->test_selector.num_set_len)) {
488 fprintf(stderr, "Failed to parse test numbers.\n");
489 return -EINVAL;
490 }
491 break;
492 }
493 case ARG_TEST_NAME: {
494 char *subtest_str = strchr(arg, '/');
495
496 if (subtest_str) {
497 *subtest_str = '\0';
498 if (parse_str_list(subtest_str + 1,
499 &env->subtest_selector.whitelist))
500 return -ENOMEM;
501 }
502 if (parse_str_list(arg, &env->test_selector.whitelist))
503 return -ENOMEM;
504 break;
505 }
506 case ARG_TEST_NAME_BLACKLIST: {
507 char *subtest_str = strchr(arg, '/');
508
509 if (subtest_str) {
510 *subtest_str = '\0';
511 if (parse_str_list(subtest_str + 1,
512 &env->subtest_selector.blacklist))
513 return -ENOMEM;
514 }
515 if (parse_str_list(arg, &env->test_selector.blacklist))
516 return -ENOMEM;
517 break;
518 }
519 case ARG_VERIFIER_STATS:
520 env->verifier_stats = true;
521 break;
522 case ARG_VERBOSE:
523 env->verbosity = VERBOSE_NORMAL;
524 if (arg) {
525 if (strcmp(arg, "v") == 0) {
526 env->verbosity = VERBOSE_VERY;
527 extra_prog_load_log_flags = 1;
528 } else if (strcmp(arg, "vv") == 0) {
529 env->verbosity = VERBOSE_SUPER;
530 extra_prog_load_log_flags = 2;
531 } else {
532 fprintf(stderr,
533 "Unrecognized verbosity setting ('%s'), only -v and -vv are supported\n",
534 arg);
535 return -EINVAL;
536 }
537 }
538 break;
539 case ARG_GET_TEST_CNT:
540 env->get_test_cnt = true;
541 break;
542 case ARG_LIST_TEST_NAMES:
543 env->list_test_names = true;
544 break;
545 case ARGP_KEY_ARG:
546 argp_usage(state);
547 break;
548 case ARGP_KEY_END:
549 break;
550 default:
551 return ARGP_ERR_UNKNOWN;
552 }
553 return 0;
554 }
555
stdio_hijack(void)556 static void stdio_hijack(void)
557 {
558 #ifdef __GLIBC__
559 env.stdout = stdout;
560 env.stderr = stderr;
561
562 if (env.verbosity > VERBOSE_NONE) {
563 /* nothing to do, output to stdout by default */
564 return;
565 }
566
567 /* stdout and stderr -> buffer */
568 fflush(stdout);
569
570 stdout = open_memstream(&env.log_buf, &env.log_cnt);
571 if (!stdout) {
572 stdout = env.stdout;
573 perror("open_memstream");
574 return;
575 }
576
577 stderr = stdout;
578 #endif
579 }
580
stdio_restore(void)581 static void stdio_restore(void)
582 {
583 #ifdef __GLIBC__
584 if (stdout == env.stdout)
585 return;
586
587 fclose(stdout);
588 free(env.log_buf);
589
590 env.log_buf = NULL;
591 env.log_cnt = 0;
592
593 stdout = env.stdout;
594 stderr = env.stderr;
595 #endif
596 }
597
598 /*
599 * Determine if test_progs is running as a "flavored" test runner and switch
600 * into corresponding sub-directory to load correct BPF objects.
601 *
602 * This is done by looking at executable name. If it contains "-flavor"
603 * suffix, then we are running as a flavored test runner.
604 */
cd_flavor_subdir(const char * exec_name)605 int cd_flavor_subdir(const char *exec_name)
606 {
607 /* General form of argv[0] passed here is:
608 * some/path/to/test_progs[-flavor], where -flavor part is optional.
609 * First cut out "test_progs[-flavor]" part, then extract "flavor"
610 * part, if it's there.
611 */
612 const char *flavor = strrchr(exec_name, '/');
613
614 if (!flavor)
615 return 0;
616 flavor++;
617 flavor = strrchr(flavor, '-');
618 if (!flavor)
619 return 0;
620 flavor++;
621 if (env.verbosity > VERBOSE_NONE)
622 fprintf(stdout, "Switching to flavor '%s' subdirectory...\n", flavor);
623
624 return chdir(flavor);
625 }
626
627 #define MAX_BACKTRACE_SZ 128
crash_handler(int signum)628 void crash_handler(int signum)
629 {
630 void *bt[MAX_BACKTRACE_SZ];
631 size_t sz;
632
633 sz = backtrace(bt, ARRAY_SIZE(bt));
634
635 if (env.test)
636 dump_test_log(env.test, true);
637 if (env.stdout)
638 stdio_restore();
639
640 fprintf(stderr, "Caught signal #%d!\nStack trace:\n", signum);
641 backtrace_symbols_fd(bt, sz, STDERR_FILENO);
642 }
643
main(int argc,char ** argv)644 int main(int argc, char **argv)
645 {
646 static const struct argp argp = {
647 .options = opts,
648 .parser = parse_arg,
649 .doc = argp_program_doc,
650 };
651 struct sigaction sigact = {
652 .sa_handler = crash_handler,
653 .sa_flags = SA_RESETHAND,
654 };
655 int err, i;
656
657 sigaction(SIGSEGV, &sigact, NULL);
658
659 err = argp_parse(&argp, argc, argv, 0, NULL, &env);
660 if (err)
661 return err;
662
663 err = cd_flavor_subdir(argv[0]);
664 if (err)
665 return err;
666
667 libbpf_set_print(libbpf_print_fn);
668
669 srand(time(NULL));
670
671 env.jit_enabled = is_jit_enabled();
672 env.nr_cpus = libbpf_num_possible_cpus();
673 if (env.nr_cpus < 0) {
674 fprintf(stderr, "Failed to get number of CPUs: %d!\n",
675 env.nr_cpus);
676 return -1;
677 }
678
679 save_netns();
680 stdio_hijack();
681 for (i = 0; i < prog_test_cnt; i++) {
682 struct prog_test_def *test = &prog_test_defs[i];
683
684 env.test = test;
685 test->test_num = i + 1;
686
687 if (!should_run(&env.test_selector,
688 test->test_num, test->test_name))
689 continue;
690
691 if (env.get_test_cnt) {
692 env.succ_cnt++;
693 continue;
694 }
695
696 if (env.list_test_names) {
697 fprintf(env.stdout, "%s\n", test->test_name);
698 env.succ_cnt++;
699 continue;
700 }
701
702 test->run_test();
703 /* ensure last sub-test is finalized properly */
704 if (test->subtest_name)
705 test__end_subtest();
706
707 test->tested = true;
708 if (test->error_cnt)
709 env.fail_cnt++;
710 else
711 env.succ_cnt++;
712 skip_account();
713
714 dump_test_log(test, test->error_cnt);
715
716 fprintf(env.stdout, "#%d %s:%s\n",
717 test->test_num, test->test_name,
718 test->error_cnt ? "FAIL" : "OK");
719
720 reset_affinity();
721 restore_netns();
722 if (test->need_cgroup_cleanup)
723 cleanup_cgroup_environment();
724 }
725 stdio_restore();
726
727 if (env.get_test_cnt) {
728 printf("%d\n", env.succ_cnt);
729 goto out;
730 }
731
732 if (env.list_test_names)
733 goto out;
734
735 fprintf(stdout, "Summary: %d/%d PASSED, %d SKIPPED, %d FAILED\n",
736 env.succ_cnt, env.sub_succ_cnt, env.skip_cnt, env.fail_cnt);
737
738 out:
739 free_str_set(&env.test_selector.blacklist);
740 free_str_set(&env.test_selector.whitelist);
741 free(env.test_selector.num_set);
742 free_str_set(&env.subtest_selector.blacklist);
743 free_str_set(&env.subtest_selector.whitelist);
744 free(env.subtest_selector.num_set);
745 close(env.saved_netns_fd);
746
747 if (env.succ_cnt + env.fail_cnt + env.skip_cnt == 0)
748 return EXIT_NO_TEST;
749
750 return env.fail_cnt ? EXIT_FAILURE : EXIT_SUCCESS;
751 }
752