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