906 lines · c
1// SPDX-License-Identifier: GPL-2.02#include <test_progs.h>3#include <bpf/btf.h>4 5static int duration = 0;6 7void btf_dump_printf(void *ctx, const char *fmt, va_list args)8{9 vfprintf(ctx, fmt, args);10}11 12static struct btf_dump_test_case {13 const char *name;14 const char *file;15 bool known_ptr_sz;16} btf_dump_test_cases[] = {17 {"btf_dump: syntax", "btf_dump_test_case_syntax", true},18 {"btf_dump: ordering", "btf_dump_test_case_ordering", false},19 {"btf_dump: padding", "btf_dump_test_case_padding", true},20 {"btf_dump: packing", "btf_dump_test_case_packing", true},21 {"btf_dump: bitfields", "btf_dump_test_case_bitfields", true},22 {"btf_dump: multidim", "btf_dump_test_case_multidim", false},23 {"btf_dump: namespacing", "btf_dump_test_case_namespacing", false},24};25 26static int btf_dump_all_types(const struct btf *btf, void *ctx)27{28 size_t type_cnt = btf__type_cnt(btf);29 struct btf_dump *d;30 int err = 0, id;31 32 d = btf_dump__new(btf, btf_dump_printf, ctx, NULL);33 err = libbpf_get_error(d);34 if (err)35 return err;36 37 for (id = 1; id < type_cnt; id++) {38 err = btf_dump__dump_type(d, id);39 if (err)40 goto done;41 }42 43done:44 btf_dump__free(d);45 return err;46}47 48static int test_btf_dump_case(int n, struct btf_dump_test_case *t)49{50 char test_file[256], out_file[256], diff_cmd[1024];51 struct btf *btf = NULL;52 int err = 0, fd = -1;53 FILE *f = NULL;54 55 snprintf(test_file, sizeof(test_file), "%s.bpf.o", t->file);56 57 btf = btf__parse_elf(test_file, NULL);58 if (!ASSERT_OK_PTR(btf, "btf_parse_elf")) {59 err = -PTR_ERR(btf);60 btf = NULL;61 goto done;62 }63 64 /* tests with t->known_ptr_sz have no "long" or "unsigned long" type,65 * so it's impossible to determine correct pointer size; but if they66 * do, it should be 8 regardless of host architecture, becaues BPF67 * target is always 64-bit68 */69 if (!t->known_ptr_sz) {70 btf__set_pointer_size(btf, 8);71 } else {72 CHECK(btf__pointer_size(btf) != 8, "ptr_sz", "exp %d, got %zu\n",73 8, btf__pointer_size(btf));74 }75 76 snprintf(out_file, sizeof(out_file), "/tmp/%s.output.XXXXXX", t->file);77 fd = mkstemp(out_file);78 if (!ASSERT_GE(fd, 0, "create_tmp")) {79 err = fd;80 goto done;81 }82 f = fdopen(fd, "w");83 if (CHECK(f == NULL, "open_tmp", "failed to open file: %s(%d)\n",84 strerror(errno), errno)) {85 close(fd);86 goto done;87 }88 89 err = btf_dump_all_types(btf, f);90 fclose(f);91 close(fd);92 if (CHECK(err, "btf_dump", "failure during C dumping: %d\n", err)) {93 goto done;94 }95 96 snprintf(test_file, sizeof(test_file), "progs/%s.c", t->file);97 if (access(test_file, R_OK) == -1)98 /*99 * When the test is run with O=, kselftest copies TEST_FILES100 * without preserving the directory structure.101 */102 snprintf(test_file, sizeof(test_file), "%s.c", t->file);103 /*104 * Diff test output and expected test output, contained between105 * START-EXPECTED-OUTPUT and END-EXPECTED-OUTPUT lines in test case.106 * For expected output lines, everything before '*' is stripped out.107 * Also lines containing comment start and comment end markers are108 * ignored. 109 */110 snprintf(diff_cmd, sizeof(diff_cmd),111 "awk '/START-EXPECTED-OUTPUT/{out=1;next} "112 "/END-EXPECTED-OUTPUT/{out=0} "113 "/\\/\\*|\\*\\//{next} " /* ignore comment start/end lines */114 "out {sub(/^[ \\t]*\\*/, \"\"); print}' '%s' | diff -u - '%s'",115 test_file, out_file);116 err = system(diff_cmd);117 if (CHECK(err, "diff",118 "differing test output, output=%s, err=%d, diff cmd:\n%s\n",119 out_file, err, diff_cmd))120 goto done;121 122 remove(out_file);123 124done:125 btf__free(btf);126 return err;127}128 129static char *dump_buf;130static size_t dump_buf_sz;131static FILE *dump_buf_file;132 133static void test_btf_dump_incremental(void)134{135 struct btf *btf = NULL;136 struct btf_dump *d = NULL;137 int id, err, i;138 139 dump_buf_file = open_memstream(&dump_buf, &dump_buf_sz);140 if (!ASSERT_OK_PTR(dump_buf_file, "dump_memstream"))141 return;142 btf = btf__new_empty();143 if (!ASSERT_OK_PTR(btf, "new_empty"))144 goto err_out;145 d = btf_dump__new(btf, btf_dump_printf, dump_buf_file, NULL);146 if (!ASSERT_OK(libbpf_get_error(d), "btf_dump__new"))147 goto err_out;148 149 /* First, generate BTF corresponding to the following C code:150 *151 * enum x;152 *153 * enum x { X = 1 };154 *155 * enum { Y = 1 };156 *157 * struct s;158 *159 * struct s { int x; };160 *161 */162 id = btf__add_enum(btf, "x", 4);163 ASSERT_EQ(id, 1, "enum_declaration_id");164 id = btf__add_enum(btf, "x", 4);165 ASSERT_EQ(id, 2, "named_enum_id");166 err = btf__add_enum_value(btf, "X", 1);167 ASSERT_OK(err, "named_enum_val_ok");168 169 id = btf__add_enum(btf, NULL, 4);170 ASSERT_EQ(id, 3, "anon_enum_id");171 err = btf__add_enum_value(btf, "Y", 1);172 ASSERT_OK(err, "anon_enum_val_ok");173 174 id = btf__add_int(btf, "int", 4, BTF_INT_SIGNED);175 ASSERT_EQ(id, 4, "int_id");176 177 id = btf__add_fwd(btf, "s", BTF_FWD_STRUCT);178 ASSERT_EQ(id, 5, "fwd_id");179 180 id = btf__add_struct(btf, "s", 4);181 ASSERT_EQ(id, 6, "struct_id");182 err = btf__add_field(btf, "x", 4, 0, 0);183 ASSERT_OK(err, "field_ok");184 185 for (i = 1; i < btf__type_cnt(btf); i++) {186 err = btf_dump__dump_type(d, i);187 ASSERT_OK(err, "dump_type_ok");188 }189 190 fflush(dump_buf_file);191 dump_buf[dump_buf_sz] = 0; /* some libc implementations don't do this */192 193 ASSERT_STREQ(dump_buf,194"enum x;\n"195"\n"196"enum x {\n"197" X = 1,\n"198"};\n"199"\n"200"enum {\n"201" Y = 1,\n"202"};\n"203"\n"204"struct s;\n"205"\n"206"struct s {\n"207" int x;\n"208"};\n\n", "c_dump1");209 210 /* Now, after dumping original BTF, append another struct that embeds211 * anonymous enum. It also has a name conflict with the first struct:212 *213 * struct s___2 {214 * enum { VAL___2 = 1 } x;215 * struct s s;216 * };217 *218 * This will test that btf_dump'er maintains internal state properly.219 * Note that VAL___2 enum value. It's because we've already emitted220 * that enum as a global anonymous enum, so btf_dump will ensure that221 * enum values don't conflict;222 *223 */224 fseek(dump_buf_file, 0, SEEK_SET);225 226 id = btf__add_struct(btf, "s", 4);227 ASSERT_EQ(id, 7, "struct_id");228 err = btf__add_field(btf, "x", 2, 0, 0);229 ASSERT_OK(err, "field_ok");230 err = btf__add_field(btf, "y", 3, 32, 0);231 ASSERT_OK(err, "field_ok");232 err = btf__add_field(btf, "s", 6, 64, 0);233 ASSERT_OK(err, "field_ok");234 235 for (i = 1; i < btf__type_cnt(btf); i++) {236 err = btf_dump__dump_type(d, i);237 ASSERT_OK(err, "dump_type_ok");238 }239 240 fflush(dump_buf_file);241 dump_buf[dump_buf_sz] = 0; /* some libc implementations don't do this */242 ASSERT_STREQ(dump_buf,243"struct s___2 {\n"244" enum x x;\n"245" enum {\n"246" Y___2 = 1,\n"247" } y;\n"248" struct s s;\n"249"};\n\n" , "c_dump1");250 251err_out:252 fclose(dump_buf_file);253 free(dump_buf);254 btf_dump__free(d);255 btf__free(btf);256}257 258#define STRSIZE 4096259 260static void btf_dump_snprintf(void *ctx, const char *fmt, va_list args)261{262 char *s = ctx, new[STRSIZE];263 264 vsnprintf(new, STRSIZE, fmt, args);265 if (strlen(s) < STRSIZE)266 strncat(s, new, STRSIZE - strlen(s) - 1);267}268 269static int btf_dump_data(struct btf *btf, struct btf_dump *d,270 char *name, char *prefix, __u64 flags, void *ptr,271 size_t ptr_sz, char *str, const char *expected_val)272{273 DECLARE_LIBBPF_OPTS(btf_dump_type_data_opts, opts);274 size_t type_sz;275 __s32 type_id;276 int ret = 0;277 278 if (flags & BTF_F_COMPACT)279 opts.compact = true;280 if (flags & BTF_F_NONAME)281 opts.skip_names = true;282 if (flags & BTF_F_ZERO)283 opts.emit_zeroes = true;284 if (prefix) {285 ASSERT_STRNEQ(name, prefix, strlen(prefix),286 "verify prefix match");287 name += strlen(prefix) + 1;288 }289 type_id = btf__find_by_name(btf, name);290 if (!ASSERT_GE(type_id, 0, "find type id"))291 return -ENOENT;292 type_sz = btf__resolve_size(btf, type_id);293 str[0] = '\0';294 ret = btf_dump__dump_type_data(d, type_id, ptr, ptr_sz, &opts);295 if (type_sz <= ptr_sz) {296 if (!ASSERT_EQ(ret, type_sz, "failed/unexpected type_sz"))297 return -EINVAL;298 } else {299 if (!ASSERT_EQ(ret, -E2BIG, "failed to return -E2BIG"))300 return -EINVAL;301 }302 if (!ASSERT_STREQ(str, expected_val, "ensure expected/actual match"))303 return -EFAULT;304 return 0;305}306 307#define TEST_BTF_DUMP_DATA(_b, _d, _prefix, _str, _type, _flags, \308 _expected, ...) \309 do { \310 char __ptrtype[64] = #_type; \311 char *_ptrtype = (char *)__ptrtype; \312 _type _ptrdata = __VA_ARGS__; \313 void *_ptr = &_ptrdata; \314 \315 (void) btf_dump_data(_b, _d, _ptrtype, _prefix, _flags, \316 _ptr, sizeof(_type), _str, \317 _expected); \318 } while (0)319 320/* Use where expected data string matches its stringified declaration */321#define TEST_BTF_DUMP_DATA_C(_b, _d, _prefix, _str, _type, _flags, \322 ...) \323 TEST_BTF_DUMP_DATA(_b, _d, _prefix, _str, _type, _flags, \324 "(" #_type ")" #__VA_ARGS__, __VA_ARGS__)325 326/* overflow test; pass typesize < expected type size, ensure E2BIG returned */327#define TEST_BTF_DUMP_DATA_OVER(_b, _d, _prefix, _str, _type, _type_sz, \328 _expected, ...) \329 do { \330 char __ptrtype[64] = #_type; \331 char *_ptrtype = (char *)__ptrtype; \332 _type _ptrdata = __VA_ARGS__; \333 void *_ptr = &_ptrdata; \334 \335 (void) btf_dump_data(_b, _d, _ptrtype, _prefix, 0, \336 _ptr, _type_sz, _str, _expected); \337 } while (0)338 339#define TEST_BTF_DUMP_VAR(_b, _d, _prefix, _str, _var, _type, _flags, \340 _expected, ...) \341 do { \342 _type _ptrdata = __VA_ARGS__; \343 void *_ptr = &_ptrdata; \344 \345 (void) btf_dump_data(_b, _d, _var, _prefix, _flags, \346 _ptr, sizeof(_type), _str, \347 _expected); \348 } while (0)349 350static void test_btf_dump_int_data(struct btf *btf, struct btf_dump *d,351 char *str)352{353#ifdef __SIZEOF_INT128__354 unsigned __int128 i = 0xffffffffffffffff;355 356 /* this dance is required because we cannot directly initialize357 * a 128-bit value to anything larger than a 64-bit value.358 */359 i = (i << 64) | (i - 1);360#endif361 /* simple int */362 TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, int, BTF_F_COMPACT, 1234);363 TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_NONAME,364 "1234", 1234);365 TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, 0, "(int)1234", 1234);366 367 /* zero value should be printed at toplevel */368 TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT, "(int)0", 0);369 TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_NONAME,370 "0", 0);371 TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_ZERO,372 "(int)0", 0);373 TEST_BTF_DUMP_DATA(btf, d, NULL, str, int,374 BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,375 "0", 0);376 TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, int, BTF_F_COMPACT, -4567);377 TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_NONAME,378 "-4567", -4567);379 TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, 0, "(int)-4567", -4567);380 381 TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, int, sizeof(int)-1, "", 1);382 383#ifdef __SIZEOF_INT128__384 /* gcc encode unsigned __int128 type with name "__int128 unsigned" in dwarf,385 * and clang encode it with name "unsigned __int128" in dwarf.386 * Do an availability test for either variant before doing actual test.387 */388 if (btf__find_by_name(btf, "unsigned __int128") > 0) {389 TEST_BTF_DUMP_DATA(btf, d, NULL, str, unsigned __int128, BTF_F_COMPACT,390 "(unsigned __int128)0xffffffffffffffff",391 0xffffffffffffffff);392 ASSERT_OK(btf_dump_data(btf, d, "unsigned __int128", NULL, 0, &i, 16, str,393 "(unsigned __int128)0xfffffffffffffffffffffffffffffffe"),394 "dump unsigned __int128");395 } else if (btf__find_by_name(btf, "__int128 unsigned") > 0) {396 TEST_BTF_DUMP_DATA(btf, d, NULL, str, __int128 unsigned, BTF_F_COMPACT,397 "(__int128 unsigned)0xffffffffffffffff",398 0xffffffffffffffff);399 ASSERT_OK(btf_dump_data(btf, d, "__int128 unsigned", NULL, 0, &i, 16, str,400 "(__int128 unsigned)0xfffffffffffffffffffffffffffffffe"),401 "dump unsigned __int128");402 } else {403 ASSERT_TRUE(false, "unsigned_int128_not_found");404 }405#endif406}407 408static void test_btf_dump_float_data(struct btf *btf, struct btf_dump *d,409 char *str)410{411 float t1 = 1.234567;412 float t2 = -1.234567;413 float t3 = 0.0;414 double t4 = 5.678912;415 double t5 = -5.678912;416 double t6 = 0.0;417 long double t7 = 9.876543;418 long double t8 = -9.876543;419 long double t9 = 0.0;420 421 /* since the kernel does not likely have any float types in its BTF, we422 * will need to add some of various sizes.423 */424 425 ASSERT_GT(btf__add_float(btf, "test_float", 4), 0, "add float");426 ASSERT_OK(btf_dump_data(btf, d, "test_float", NULL, 0, &t1, 4, str,427 "(test_float)1.234567"), "dump float");428 ASSERT_OK(btf_dump_data(btf, d, "test_float", NULL, 0, &t2, 4, str,429 "(test_float)-1.234567"), "dump float");430 ASSERT_OK(btf_dump_data(btf, d, "test_float", NULL, 0, &t3, 4, str,431 "(test_float)0.000000"), "dump float");432 433 ASSERT_GT(btf__add_float(btf, "test_double", 8), 0, "add_double");434 ASSERT_OK(btf_dump_data(btf, d, "test_double", NULL, 0, &t4, 8, str,435 "(test_double)5.678912"), "dump double");436 ASSERT_OK(btf_dump_data(btf, d, "test_double", NULL, 0, &t5, 8, str,437 "(test_double)-5.678912"), "dump double");438 ASSERT_OK(btf_dump_data(btf, d, "test_double", NULL, 0, &t6, 8, str,439 "(test_double)0.000000"), "dump double");440 441 ASSERT_GT(btf__add_float(btf, "test_long_double", 16), 0, "add long double");442 ASSERT_OK(btf_dump_data(btf, d, "test_long_double", NULL, 0, &t7, 16,443 str, "(test_long_double)9.876543"),444 "dump long_double");445 ASSERT_OK(btf_dump_data(btf, d, "test_long_double", NULL, 0, &t8, 16,446 str, "(test_long_double)-9.876543"),447 "dump long_double");448 ASSERT_OK(btf_dump_data(btf, d, "test_long_double", NULL, 0, &t9, 16,449 str, "(test_long_double)0.000000"),450 "dump long_double");451}452 453static void test_btf_dump_char_data(struct btf *btf, struct btf_dump *d,454 char *str)455{456 /* simple char */457 TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, char, BTF_F_COMPACT, 100);458 TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_NONAME,459 "100", 100);460 TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, 0, "(char)100", 100);461 /* zero value should be printed at toplevel */462 TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT,463 "(char)0", 0);464 TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_NONAME,465 "0", 0);466 TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_ZERO,467 "(char)0", 0);468 TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,469 "0", 0);470 TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, 0, "(char)0", 0);471 472 TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, char, sizeof(char)-1, "", 100);473}474 475static void test_btf_dump_typedef_data(struct btf *btf, struct btf_dump *d,476 char *str)477{478 /* simple typedef */479 TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, uint64_t, BTF_F_COMPACT, 100);480 TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT | BTF_F_NONAME,481 "1", 1);482 TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, 0, "(u64)1", 1);483 /* zero value should be printed at toplevel */484 TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT, "(u64)0", 0);485 TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT | BTF_F_NONAME,486 "0", 0);487 TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT | BTF_F_ZERO,488 "(u64)0", 0);489 TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64,490 BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,491 "0", 0);492 TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, 0, "(u64)0", 0);493 494 /* typedef struct */495 TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, atomic_t, BTF_F_COMPACT,496 {.counter = (int)1,});497 TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT | BTF_F_NONAME,498 "{1,}", { .counter = 1 });499 TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, 0,500"(atomic_t){\n"501" .counter = (int)1,\n"502"}",503 {.counter = 1,});504 /* typedef with 0 value should be printed at toplevel */505 TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT, "(atomic_t){}",506 {.counter = 0,});507 TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT | BTF_F_NONAME,508 "{}", {.counter = 0,});509 TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, 0,510"(atomic_t){\n"511"}",512 {.counter = 0,});513 TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT | BTF_F_ZERO,514 "(atomic_t){.counter = (int)0,}",515 {.counter = 0,});516 TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t,517 BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,518 "{0,}", {.counter = 0,});519 TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_ZERO,520"(atomic_t){\n"521" .counter = (int)0,\n"522"}",523 { .counter = 0,});524 525 /* overflow should show type but not value since it overflows */526 TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, atomic_t, sizeof(atomic_t)-1,527 "(atomic_t){\n", { .counter = 1});528}529 530static void test_btf_dump_enum_data(struct btf *btf, struct btf_dump *d,531 char *str)532{533 /* enum where enum value does (and does not) exist */534 TEST_BTF_DUMP_DATA_C(btf, d, "enum", str, enum bpf_cmd, BTF_F_COMPACT,535 BPF_MAP_CREATE);536 TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd, BTF_F_COMPACT,537 "(enum bpf_cmd)BPF_MAP_CREATE", 0);538 TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,539 BTF_F_COMPACT | BTF_F_NONAME,540 "BPF_MAP_CREATE",541 BPF_MAP_CREATE);542 TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd, 0,543 "(enum bpf_cmd)BPF_MAP_CREATE",544 BPF_MAP_CREATE);545 TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,546 BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,547 "BPF_MAP_CREATE", 0);548 TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,549 BTF_F_COMPACT | BTF_F_ZERO,550 "(enum bpf_cmd)BPF_MAP_CREATE",551 BPF_MAP_CREATE);552 TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,553 BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,554 "BPF_MAP_CREATE", BPF_MAP_CREATE);555 TEST_BTF_DUMP_DATA_C(btf, d, "enum", str, enum bpf_cmd, BTF_F_COMPACT, 2000);556 TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,557 BTF_F_COMPACT | BTF_F_NONAME,558 "2000", 2000);559 TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd, 0,560 "(enum bpf_cmd)2000", 2000);561 562 TEST_BTF_DUMP_DATA_OVER(btf, d, "enum", str, enum bpf_cmd,563 sizeof(enum bpf_cmd) - 1, "", BPF_MAP_CREATE);564}565 566static void test_btf_dump_struct_data(struct btf *btf, struct btf_dump *d,567 char *str)568{569 DECLARE_LIBBPF_OPTS(btf_dump_type_data_opts, opts);570 char zero_data[512] = { };571 char type_data[512];572 void *fops = type_data;573 void *skb = type_data;574 size_t type_sz;575 __s32 type_id;576 char *cmpstr;577 int ret;578 579 memset(type_data, 255, sizeof(type_data));580 581 /* simple struct */582 TEST_BTF_DUMP_DATA_C(btf, d, "struct", str, struct btf_enum, BTF_F_COMPACT,583 {.name_off = (__u32)3,.val = (__s32)-1,});584 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,585 BTF_F_COMPACT | BTF_F_NONAME,586 "{3,-1,}",587 { .name_off = 3, .val = -1,});588 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum, 0,589"(struct btf_enum){\n"590" .name_off = (__u32)3,\n"591" .val = (__s32)-1,\n"592"}",593 { .name_off = 3, .val = -1,});594 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,595 BTF_F_COMPACT | BTF_F_NONAME,596 "{-1,}",597 { .name_off = 0, .val = -1,});598 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,599 BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,600 "{0,-1,}",601 { .name_off = 0, .val = -1,});602 /* empty struct should be printed */603 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum, BTF_F_COMPACT,604 "(struct btf_enum){}",605 { .name_off = 0, .val = 0,});606 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,607 BTF_F_COMPACT | BTF_F_NONAME,608 "{}",609 { .name_off = 0, .val = 0,});610 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum, 0,611"(struct btf_enum){\n"612"}",613 { .name_off = 0, .val = 0,});614 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,615 BTF_F_COMPACT | BTF_F_ZERO,616 "(struct btf_enum){.name_off = (__u32)0,.val = (__s32)0,}",617 { .name_off = 0, .val = 0,});618 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,619 BTF_F_ZERO,620"(struct btf_enum){\n"621" .name_off = (__u32)0,\n"622" .val = (__s32)0,\n"623"}",624 { .name_off = 0, .val = 0,});625 626 /* struct with pointers */627 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, BTF_F_COMPACT,628 "(struct list_head){.next = (struct list_head *)0x1,}",629 { .next = (struct list_head *)1 });630 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, 0,631"(struct list_head){\n"632" .next = (struct list_head *)0x1,\n"633"}",634 { .next = (struct list_head *)1 });635 /* NULL pointer should not be displayed */636 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, BTF_F_COMPACT,637 "(struct list_head){}",638 { .next = (struct list_head *)0 });639 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, 0,640"(struct list_head){\n"641"}",642 { .next = (struct list_head *)0 });643 644 /* struct with function pointers */645 type_id = btf__find_by_name(btf, "file_operations");646 if (ASSERT_GT(type_id, 0, "find type id")) {647 type_sz = btf__resolve_size(btf, type_id);648 str[0] = '\0';649 650 ret = btf_dump__dump_type_data(d, type_id, fops, type_sz, &opts);651 ASSERT_EQ(ret, type_sz,652 "unexpected return value dumping file_operations");653 cmpstr =654"(struct file_operations){\n"655" .owner = (struct module *)0xffffffffffffffff,\n"656" .fop_flags = (fop_flags_t)4294967295,";657 658 ASSERT_STRNEQ(str, cmpstr, strlen(cmpstr), "file_operations");659 }660 661 /* struct with char array */662 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, BTF_F_COMPACT,663 "(struct bpf_prog_info){.name = (char[16])['f','o','o',],}",664 { .name = "foo",});665 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info,666 BTF_F_COMPACT | BTF_F_NONAME,667 "{['f','o','o',],}",668 {.name = "foo",});669 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, 0,670"(struct bpf_prog_info){\n"671" .name = (char[16])[\n"672" 'f',\n"673" 'o',\n"674" 'o',\n"675" ],\n"676"}",677 {.name = "foo",});678 /* leading null char means do not display string */679 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, BTF_F_COMPACT,680 "(struct bpf_prog_info){}",681 {.name = {'\0', 'f', 'o', 'o'}});682 /* handle non-printable characters */683 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, BTF_F_COMPACT,684 "(struct bpf_prog_info){.name = (char[16])[1,2,3,],}",685 { .name = {1, 2, 3, 0}});686 687 /* struct with non-char array */688 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, BTF_F_COMPACT,689 "(struct __sk_buff){.cb = (__u32[5])[1,2,3,4,5,],}",690 { .cb = {1, 2, 3, 4, 5,},});691 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff,692 BTF_F_COMPACT | BTF_F_NONAME,693 "{[1,2,3,4,5,],}",694 { .cb = { 1, 2, 3, 4, 5},});695 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, 0,696"(struct __sk_buff){\n"697" .cb = (__u32[5])[\n"698" 1,\n"699" 2,\n"700" 3,\n"701" 4,\n"702" 5,\n"703" ],\n"704"}",705 { .cb = { 1, 2, 3, 4, 5},});706 /* For non-char, arrays, show non-zero values only */707 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, BTF_F_COMPACT,708 "(struct __sk_buff){.cb = (__u32[5])[0,0,1,0,0,],}",709 { .cb = { 0, 0, 1, 0, 0},});710 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, 0,711"(struct __sk_buff){\n"712" .cb = (__u32[5])[\n"713" 0,\n"714" 0,\n"715" 1,\n"716" 0,\n"717" 0,\n"718" ],\n"719"}",720 { .cb = { 0, 0, 1, 0, 0},});721 722 /* struct with bitfields */723 TEST_BTF_DUMP_DATA_C(btf, d, "struct", str, struct bpf_insn, BTF_F_COMPACT,724 {.code = (__u8)1,.dst_reg = (__u8)0x2,.src_reg = (__u8)0x3,.off = (__s16)4,.imm = (__s32)5,});725 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_insn,726 BTF_F_COMPACT | BTF_F_NONAME,727 "{1,0x2,0x3,4,5,}",728 { .code = 1, .dst_reg = 0x2, .src_reg = 0x3, .off = 4,729 .imm = 5,});730 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_insn, 0,731"(struct bpf_insn){\n"732" .code = (__u8)1,\n"733" .dst_reg = (__u8)0x2,\n"734" .src_reg = (__u8)0x3,\n"735" .off = (__s16)4,\n"736" .imm = (__s32)5,\n"737"}",738 {.code = 1, .dst_reg = 2, .src_reg = 3, .off = 4, .imm = 5});739 740 /* zeroed bitfields should not be displayed */741 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_insn, BTF_F_COMPACT,742 "(struct bpf_insn){.dst_reg = (__u8)0x1,}",743 { .code = 0, .dst_reg = 1});744 745 /* struct with enum bitfield */746 type_id = btf__find_by_name(btf, "fs_context");747 if (ASSERT_GT(type_id, 0, "find fs_context")) {748 type_sz = btf__resolve_size(btf, type_id);749 str[0] = '\0';750 751 opts.emit_zeroes = true;752 ret = btf_dump__dump_type_data(d, type_id, zero_data, type_sz, &opts);753 ASSERT_EQ(ret, type_sz,754 "unexpected return value dumping fs_context");755 756 ASSERT_NEQ(strstr(str, "FS_CONTEXT_FOR_MOUNT"), NULL,757 "bitfield value not present");758 }759 760 /* struct with nested anon union */761 TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_sock_ops, BTF_F_COMPACT,762 "(struct bpf_sock_ops){.op = (__u32)1,(union){.args = (__u32[4])[1,2,3,4,],.reply = (__u32)1,.replylong = (__u32[4])[1,2,3,4,],},}",763 { .op = 1, .args = { 1, 2, 3, 4}});764 765 /* union with nested struct */766 TEST_BTF_DUMP_DATA(btf, d, "union", str, union bpf_iter_link_info, BTF_F_COMPACT,767 "(union bpf_iter_link_info){.map = (struct){.map_fd = (__u32)1,},.cgroup = (struct){.order = (enum bpf_cgroup_iter_order)BPF_CGROUP_ITER_SELF_ONLY,.cgroup_fd = (__u32)1,},.task = (struct){.tid = (__u32)1,.pid = (__u32)1,},}",768 { .cgroup = { .order = 1, .cgroup_fd = 1, }});769 770 /* struct skb with nested structs/unions; because type output is so771 * complex, we don't do a string comparison, just verify we return772 * the type size as the amount of data displayed.773 */774 type_id = btf__find_by_name(btf, "sk_buff");775 if (ASSERT_GT(type_id, 0, "find struct sk_buff")) {776 type_sz = btf__resolve_size(btf, type_id);777 str[0] = '\0';778 779 ret = btf_dump__dump_type_data(d, type_id, skb, type_sz, &opts);780 ASSERT_EQ(ret, type_sz,781 "unexpected return value dumping sk_buff");782 }783 784 /* overflow bpf_sock_ops struct with final element nonzero/zero.785 * Regardless of the value of the final field, we don't have all the786 * data we need to display it, so we should trigger an overflow.787 * In other words overflow checking should trump "is field zero?"788 * checks because if we've overflowed, it shouldn't matter what the789 * field is - we can't trust its value so shouldn't display it.790 */791 TEST_BTF_DUMP_DATA_OVER(btf, d, "struct", str, struct bpf_sock_ops,792 sizeof(struct bpf_sock_ops) - 1,793 "(struct bpf_sock_ops){\n\t.op = (__u32)1,\n",794 { .op = 1, .skb_hwtstamp = 2});795 TEST_BTF_DUMP_DATA_OVER(btf, d, "struct", str, struct bpf_sock_ops,796 sizeof(struct bpf_sock_ops) - 1,797 "(struct bpf_sock_ops){\n\t.op = (__u32)1,\n",798 { .op = 1, .skb_hwtstamp = 0});799}800 801static void test_btf_dump_var_data(struct btf *btf, struct btf_dump *d,802 char *str)803{804#if 0805 TEST_BTF_DUMP_VAR(btf, d, NULL, str, "cpu_number", int, BTF_F_COMPACT,806 "int cpu_number = (int)100", 100);807#endif808 TEST_BTF_DUMP_VAR(btf, d, NULL, str, "bpf_cgrp_storage_busy", int, BTF_F_COMPACT,809 "static int bpf_cgrp_storage_busy = (int)2", 2);810}811 812static void test_btf_datasec(struct btf *btf, struct btf_dump *d, char *str,813 const char *name, const char *expected_val,814 void *data, size_t data_sz)815{816 DECLARE_LIBBPF_OPTS(btf_dump_type_data_opts, opts);817 int ret = 0, cmp;818 size_t secsize;819 __s32 type_id;820 821 opts.compact = true;822 823 type_id = btf__find_by_name(btf, name);824 if (!ASSERT_GT(type_id, 0, "find type id"))825 return;826 827 secsize = btf__resolve_size(btf, type_id);828 ASSERT_EQ(secsize, 0, "verify section size");829 830 str[0] = '\0';831 ret = btf_dump__dump_type_data(d, type_id, data, data_sz, &opts);832 ASSERT_EQ(ret, 0, "unexpected return value");833 834 cmp = strcmp(str, expected_val);835 ASSERT_EQ(cmp, 0, "ensure expected/actual match");836}837 838static void test_btf_dump_datasec_data(char *str)839{840 struct btf *btf;841 char license[4] = "GPL";842 struct btf_dump *d;843 844 btf = btf__parse("xdping_kern.bpf.o", NULL);845 if (!ASSERT_OK_PTR(btf, "xdping_kern.bpf.o BTF not found"))846 return;847 848 d = btf_dump__new(btf, btf_dump_snprintf, str, NULL);849 if (!ASSERT_OK_PTR(d, "could not create BTF dump"))850 goto out;851 852 test_btf_datasec(btf, d, str, "license",853 "SEC(\"license\") char[4] _license = (char[4])['G','P','L',];",854 license, sizeof(license));855out:856 btf_dump__free(d);857 btf__free(btf);858}859 860void test_btf_dump() {861 char str[STRSIZE];862 struct btf_dump *d;863 struct btf *btf;864 int i;865 866 for (i = 0; i < ARRAY_SIZE(btf_dump_test_cases); i++) {867 struct btf_dump_test_case *t = &btf_dump_test_cases[i];868 869 if (!test__start_subtest(t->name))870 continue;871 872 test_btf_dump_case(i, &btf_dump_test_cases[i]);873 }874 if (test__start_subtest("btf_dump: incremental"))875 test_btf_dump_incremental();876 877 btf = libbpf_find_kernel_btf();878 if (!ASSERT_OK_PTR(btf, "no kernel BTF found"))879 return;880 881 d = btf_dump__new(btf, btf_dump_snprintf, str, NULL);882 if (!ASSERT_OK_PTR(d, "could not create BTF dump"))883 return;884 885 /* Verify type display for various types. */886 if (test__start_subtest("btf_dump: int_data"))887 test_btf_dump_int_data(btf, d, str);888 if (test__start_subtest("btf_dump: float_data"))889 test_btf_dump_float_data(btf, d, str);890 if (test__start_subtest("btf_dump: char_data"))891 test_btf_dump_char_data(btf, d, str);892 if (test__start_subtest("btf_dump: typedef_data"))893 test_btf_dump_typedef_data(btf, d, str);894 if (test__start_subtest("btf_dump: enum_data"))895 test_btf_dump_enum_data(btf, d, str);896 if (test__start_subtest("btf_dump: struct_data"))897 test_btf_dump_struct_data(btf, d, str);898 if (test__start_subtest("btf_dump: var_data"))899 test_btf_dump_var_data(btf, d, str);900 btf_dump__free(d);901 btf__free(btf);902 903 if (test__start_subtest("btf_dump: datasec_data"))904 test_btf_dump_datasec_data(str);905}906