1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (c) 2017 Facebook 3 */ 4 #include "test_progs.h" 5 #include "cgroup_helpers.h" 6 #include "bpf_rlimit.h" 7 #include <argp.h> 8 #include <string.h> 9 10 /* defined in test_progs.h */ 11 struct test_env env; 12 13 struct prog_test_def { 14 const char *test_name; 15 int test_num; 16 void (*run_test)(void); 17 bool force_log; 18 int error_cnt; 19 int skip_cnt; 20 bool tested; 21 bool need_cgroup_cleanup; 22 23 const char *subtest_name; 24 int subtest_num; 25 26 /* store counts before subtest started */ 27 int old_error_cnt; 28 }; 29 30 static bool should_run(struct test_selector *sel, int num, const char *name) 31 { 32 if (sel->name && sel->name[0] && !strstr(name, sel->name)) 33 return false; 34 35 if (!sel->num_set) 36 return true; 37 38 return num < sel->num_set_len && sel->num_set[num]; 39 } 40 41 static void dump_test_log(const struct prog_test_def *test, bool failed) 42 { 43 if (stdout == env.stdout) 44 return; 45 46 fflush(stdout); /* exports env.log_buf & env.log_cnt */ 47 48 if (env.verbose || test->force_log || failed) { 49 if (env.log_cnt) { 50 env.log_buf[env.log_cnt] = '\0'; 51 fprintf(env.stdout, "%s", env.log_buf); 52 if (env.log_buf[env.log_cnt - 1] != '\n') 53 fprintf(env.stdout, "\n"); 54 } 55 } 56 57 fseeko(stdout, 0, SEEK_SET); /* rewind */ 58 } 59 60 static void skip_account(void) 61 { 62 if (env.test->skip_cnt) { 63 env.skip_cnt++; 64 env.test->skip_cnt = 0; 65 } 66 } 67 68 void test__end_subtest() 69 { 70 struct prog_test_def *test = env.test; 71 int sub_error_cnt = test->error_cnt - test->old_error_cnt; 72 73 if (sub_error_cnt) 74 env.fail_cnt++; 75 else 76 env.sub_succ_cnt++; 77 skip_account(); 78 79 dump_test_log(test, sub_error_cnt); 80 81 fprintf(env.stdout, "#%d/%d %s:%s\n", 82 test->test_num, test->subtest_num, 83 test->subtest_name, sub_error_cnt ? "FAIL" : "OK"); 84 } 85 86 bool test__start_subtest(const char *name) 87 { 88 struct prog_test_def *test = env.test; 89 90 if (test->subtest_name) { 91 test__end_subtest(); 92 test->subtest_name = NULL; 93 } 94 95 test->subtest_num++; 96 97 if (!name || !name[0]) { 98 fprintf(env.stderr, 99 "Subtest #%d didn't provide sub-test name!\n", 100 test->subtest_num); 101 return false; 102 } 103 104 if (!should_run(&env.subtest_selector, test->subtest_num, name)) 105 return false; 106 107 test->subtest_name = name; 108 env.test->old_error_cnt = env.test->error_cnt; 109 110 return true; 111 } 112 113 void test__force_log() { 114 env.test->force_log = true; 115 } 116 117 void test__skip(void) 118 { 119 env.test->skip_cnt++; 120 } 121 122 void test__fail(void) 123 { 124 env.test->error_cnt++; 125 } 126 127 int test__join_cgroup(const char *path) 128 { 129 int fd; 130 131 if (!env.test->need_cgroup_cleanup) { 132 if (setup_cgroup_environment()) { 133 fprintf(stderr, 134 "#%d %s: Failed to setup cgroup environment\n", 135 env.test->test_num, env.test->test_name); 136 return -1; 137 } 138 139 env.test->need_cgroup_cleanup = true; 140 } 141 142 fd = create_and_get_cgroup(path); 143 if (fd < 0) { 144 fprintf(stderr, 145 "#%d %s: Failed to create cgroup '%s' (errno=%d)\n", 146 env.test->test_num, env.test->test_name, path, errno); 147 return fd; 148 } 149 150 if (join_cgroup(path)) { 151 fprintf(stderr, 152 "#%d %s: Failed to join cgroup '%s' (errno=%d)\n", 153 env.test->test_num, env.test->test_name, path, errno); 154 return -1; 155 } 156 157 return fd; 158 } 159 160 struct ipv4_packet pkt_v4 = { 161 .eth.h_proto = __bpf_constant_htons(ETH_P_IP), 162 .iph.ihl = 5, 163 .iph.protocol = IPPROTO_TCP, 164 .iph.tot_len = __bpf_constant_htons(MAGIC_BYTES), 165 .tcp.urg_ptr = 123, 166 .tcp.doff = 5, 167 }; 168 169 struct ipv6_packet pkt_v6 = { 170 .eth.h_proto = __bpf_constant_htons(ETH_P_IPV6), 171 .iph.nexthdr = IPPROTO_TCP, 172 .iph.payload_len = __bpf_constant_htons(MAGIC_BYTES), 173 .tcp.urg_ptr = 123, 174 .tcp.doff = 5, 175 }; 176 177 int bpf_find_map(const char *test, struct bpf_object *obj, const char *name) 178 { 179 struct bpf_map *map; 180 181 map = bpf_object__find_map_by_name(obj, name); 182 if (!map) { 183 printf("%s:FAIL:map '%s' not found\n", test, name); 184 test__fail(); 185 return -1; 186 } 187 return bpf_map__fd(map); 188 } 189 190 static bool is_jit_enabled(void) 191 { 192 const char *jit_sysctl = "/proc/sys/net/core/bpf_jit_enable"; 193 bool enabled = false; 194 int sysctl_fd; 195 196 sysctl_fd = open(jit_sysctl, 0, O_RDONLY); 197 if (sysctl_fd != -1) { 198 char tmpc; 199 200 if (read(sysctl_fd, &tmpc, sizeof(tmpc)) == 1) 201 enabled = (tmpc != '0'); 202 close(sysctl_fd); 203 } 204 205 return enabled; 206 } 207 208 int compare_map_keys(int map1_fd, int map2_fd) 209 { 210 __u32 key, next_key; 211 char val_buf[PERF_MAX_STACK_DEPTH * 212 sizeof(struct bpf_stack_build_id)]; 213 int err; 214 215 err = bpf_map_get_next_key(map1_fd, NULL, &key); 216 if (err) 217 return err; 218 err = bpf_map_lookup_elem(map2_fd, &key, val_buf); 219 if (err) 220 return err; 221 222 while (bpf_map_get_next_key(map1_fd, &key, &next_key) == 0) { 223 err = bpf_map_lookup_elem(map2_fd, &next_key, val_buf); 224 if (err) 225 return err; 226 227 key = next_key; 228 } 229 if (errno != ENOENT) 230 return -1; 231 232 return 0; 233 } 234 235 int compare_stack_ips(int smap_fd, int amap_fd, int stack_trace_len) 236 { 237 __u32 key, next_key, *cur_key_p, *next_key_p; 238 char *val_buf1, *val_buf2; 239 int i, err = 0; 240 241 val_buf1 = malloc(stack_trace_len); 242 val_buf2 = malloc(stack_trace_len); 243 cur_key_p = NULL; 244 next_key_p = &key; 245 while (bpf_map_get_next_key(smap_fd, cur_key_p, next_key_p) == 0) { 246 err = bpf_map_lookup_elem(smap_fd, next_key_p, val_buf1); 247 if (err) 248 goto out; 249 err = bpf_map_lookup_elem(amap_fd, next_key_p, val_buf2); 250 if (err) 251 goto out; 252 for (i = 0; i < stack_trace_len; i++) { 253 if (val_buf1[i] != val_buf2[i]) { 254 err = -1; 255 goto out; 256 } 257 } 258 key = *next_key_p; 259 cur_key_p = &key; 260 next_key_p = &next_key; 261 } 262 if (errno != ENOENT) 263 err = -1; 264 265 out: 266 free(val_buf1); 267 free(val_buf2); 268 return err; 269 } 270 271 int extract_build_id(char *build_id, size_t size) 272 { 273 FILE *fp; 274 char *line = NULL; 275 size_t len = 0; 276 277 fp = popen("readelf -n ./urandom_read | grep 'Build ID'", "r"); 278 if (fp == NULL) 279 return -1; 280 281 if (getline(&line, &len, fp) == -1) 282 goto err; 283 fclose(fp); 284 285 if (len > size) 286 len = size; 287 memcpy(build_id, line, len); 288 build_id[len] = '\0'; 289 return 0; 290 err: 291 fclose(fp); 292 return -1; 293 } 294 295 void *spin_lock_thread(void *arg) 296 { 297 __u32 duration, retval; 298 int err, prog_fd = *(u32 *) arg; 299 300 err = bpf_prog_test_run(prog_fd, 10000, &pkt_v4, sizeof(pkt_v4), 301 NULL, NULL, &retval, &duration); 302 CHECK(err || retval, "", 303 "err %d errno %d retval %d duration %d\n", 304 err, errno, retval, duration); 305 pthread_exit(arg); 306 } 307 308 /* extern declarations for test funcs */ 309 #define DEFINE_TEST(name) extern void test_##name(); 310 #include <prog_tests/tests.h> 311 #undef DEFINE_TEST 312 313 static struct prog_test_def prog_test_defs[] = { 314 #define DEFINE_TEST(name) { \ 315 .test_name = #name, \ 316 .run_test = &test_##name, \ 317 }, 318 #include <prog_tests/tests.h> 319 #undef DEFINE_TEST 320 }; 321 const int prog_test_cnt = ARRAY_SIZE(prog_test_defs); 322 323 const char *argp_program_version = "test_progs 0.1"; 324 const char *argp_program_bug_address = "<bpf@vger.kernel.org>"; 325 const char argp_program_doc[] = "BPF selftests test runner"; 326 327 enum ARG_KEYS { 328 ARG_TEST_NUM = 'n', 329 ARG_TEST_NAME = 't', 330 ARG_VERIFIER_STATS = 's', 331 ARG_VERBOSE = 'v', 332 }; 333 334 static const struct argp_option opts[] = { 335 { "num", ARG_TEST_NUM, "NUM", 0, 336 "Run test number NUM only " }, 337 { "name", ARG_TEST_NAME, "NAME", 0, 338 "Run tests with names containing NAME" }, 339 { "verifier-stats", ARG_VERIFIER_STATS, NULL, 0, 340 "Output verifier statistics", }, 341 { "verbose", ARG_VERBOSE, "LEVEL", OPTION_ARG_OPTIONAL, 342 "Verbose output (use -vv for extra verbose output)" }, 343 {}, 344 }; 345 346 static int libbpf_print_fn(enum libbpf_print_level level, 347 const char *format, va_list args) 348 { 349 if (!env.very_verbose && level == LIBBPF_DEBUG) 350 return 0; 351 vprintf(format, args); 352 return 0; 353 } 354 355 int parse_num_list(const char *s, struct test_selector *sel) 356 { 357 int i, set_len = 0, num, start = 0, end = -1; 358 bool *set = NULL, *tmp, parsing_end = false; 359 char *next; 360 361 while (s[0]) { 362 errno = 0; 363 num = strtol(s, &next, 10); 364 if (errno) 365 return -errno; 366 367 if (parsing_end) 368 end = num; 369 else 370 start = num; 371 372 if (!parsing_end && *next == '-') { 373 s = next + 1; 374 parsing_end = true; 375 continue; 376 } else if (*next == ',') { 377 parsing_end = false; 378 s = next + 1; 379 end = num; 380 } else if (*next == '\0') { 381 parsing_end = false; 382 s = next; 383 end = num; 384 } else { 385 return -EINVAL; 386 } 387 388 if (start > end) 389 return -EINVAL; 390 391 if (end + 1 > set_len) { 392 set_len = end + 1; 393 tmp = realloc(set, set_len); 394 if (!tmp) { 395 free(set); 396 return -ENOMEM; 397 } 398 set = tmp; 399 } 400 for (i = start; i <= end; i++) { 401 set[i] = true; 402 } 403 404 } 405 406 if (!set) 407 return -EINVAL; 408 409 sel->num_set = set; 410 sel->num_set_len = set_len; 411 412 return 0; 413 } 414 415 static error_t parse_arg(int key, char *arg, struct argp_state *state) 416 { 417 struct test_env *env = state->input; 418 419 switch (key) { 420 case ARG_TEST_NUM: { 421 char *subtest_str = strchr(arg, '/'); 422 423 if (subtest_str) { 424 *subtest_str = '\0'; 425 if (parse_num_list(subtest_str + 1, 426 &env->subtest_selector)) { 427 fprintf(stderr, 428 "Failed to parse subtest numbers.\n"); 429 return -EINVAL; 430 } 431 } 432 if (parse_num_list(arg, &env->test_selector)) { 433 fprintf(stderr, "Failed to parse test numbers.\n"); 434 return -EINVAL; 435 } 436 break; 437 } 438 case ARG_TEST_NAME: { 439 char *subtest_str = strchr(arg, '/'); 440 441 if (subtest_str) { 442 *subtest_str = '\0'; 443 env->subtest_selector.name = strdup(subtest_str + 1); 444 if (!env->subtest_selector.name) 445 return -ENOMEM; 446 } 447 env->test_selector.name = strdup(arg); 448 if (!env->test_selector.name) 449 return -ENOMEM; 450 break; 451 } 452 case ARG_VERIFIER_STATS: 453 env->verifier_stats = true; 454 break; 455 case ARG_VERBOSE: 456 if (arg) { 457 if (strcmp(arg, "v") == 0) { 458 env->very_verbose = true; 459 } else { 460 fprintf(stderr, 461 "Unrecognized verbosity setting ('%s'), only -v and -vv are supported\n", 462 arg); 463 return -EINVAL; 464 } 465 } 466 env->verbose = true; 467 break; 468 case ARGP_KEY_ARG: 469 argp_usage(state); 470 break; 471 case ARGP_KEY_END: 472 break; 473 default: 474 return ARGP_ERR_UNKNOWN; 475 } 476 return 0; 477 } 478 479 static void stdio_hijack(void) 480 { 481 #ifdef __GLIBC__ 482 env.stdout = stdout; 483 env.stderr = stderr; 484 485 if (env.verbose) { 486 /* nothing to do, output to stdout by default */ 487 return; 488 } 489 490 /* stdout and stderr -> buffer */ 491 fflush(stdout); 492 493 stdout = open_memstream(&env.log_buf, &env.log_cnt); 494 if (!stdout) { 495 stdout = env.stdout; 496 perror("open_memstream"); 497 return; 498 } 499 500 stderr = stdout; 501 #endif 502 } 503 504 static void stdio_restore(void) 505 { 506 #ifdef __GLIBC__ 507 if (stdout == env.stdout) 508 return; 509 510 fclose(stdout); 511 free(env.log_buf); 512 513 env.log_buf = NULL; 514 env.log_cnt = 0; 515 516 stdout = env.stdout; 517 stderr = env.stderr; 518 #endif 519 } 520 521 int main(int argc, char **argv) 522 { 523 static const struct argp argp = { 524 .options = opts, 525 .parser = parse_arg, 526 .doc = argp_program_doc, 527 }; 528 int err, i; 529 530 err = argp_parse(&argp, argc, argv, 0, NULL, &env); 531 if (err) 532 return err; 533 534 libbpf_set_print(libbpf_print_fn); 535 536 srand(time(NULL)); 537 538 env.jit_enabled = is_jit_enabled(); 539 540 stdio_hijack(); 541 for (i = 0; i < prog_test_cnt; i++) { 542 struct prog_test_def *test = &prog_test_defs[i]; 543 544 env.test = test; 545 test->test_num = i + 1; 546 547 if (!should_run(&env.test_selector, 548 test->test_num, test->test_name)) 549 continue; 550 551 test->run_test(); 552 /* ensure last sub-test is finalized properly */ 553 if (test->subtest_name) 554 test__end_subtest(); 555 556 test->tested = true; 557 if (test->error_cnt) 558 env.fail_cnt++; 559 else 560 env.succ_cnt++; 561 skip_account(); 562 563 dump_test_log(test, test->error_cnt); 564 565 fprintf(env.stdout, "#%d %s:%s\n", 566 test->test_num, test->test_name, 567 test->error_cnt ? "FAIL" : "OK"); 568 569 if (test->need_cgroup_cleanup) 570 cleanup_cgroup_environment(); 571 } 572 stdio_restore(); 573 printf("Summary: %d/%d PASSED, %d SKIPPED, %d FAILED\n", 574 env.succ_cnt, env.sub_succ_cnt, env.skip_cnt, env.fail_cnt); 575 576 free(env.test_selector.num_set); 577 free(env.subtest_selector.num_set); 578 579 return env.fail_cnt ? EXIT_FAILURE : EXIT_SUCCESS; 580 } 581