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