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