1 // SPDX-License-Identifier: GPL-2.0 2 #include <test_progs.h> 3 #include <bpf/btf.h> 4 5 static int duration = 0; 6 7 void btf_dump_printf(void *ctx, const char *fmt, va_list args) 8 { 9 vfprintf(ctx, fmt, args); 10 } 11 12 static 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 26 static 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 43 done: 44 btf_dump__free(d); 45 return err; 46 } 47 48 static 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 they 66 * do, it should be 8 regardless of host architecture, becaues BPF 67 * target is always 64-bit 68 */ 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_FILES 100 * 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 between 105 * 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 are 108 * 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 124 done: 125 btf__free(btf); 126 return err; 127 } 128 129 static char *dump_buf; 130 static size_t dump_buf_sz; 131 static FILE *dump_buf_file; 132 133 static 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 embeds 211 * 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 emitted 220 * that enum as a global anonymous enum, so btf_dump will ensure that 221 * 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 251 err_out: 252 fclose(dump_buf_file); 253 free(dump_buf); 254 btf_dump__free(d); 255 btf__free(btf); 256 } 257 258 #define STRSIZE 4096 259 260 static 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 269 static 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 350 static 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 initialize 357 * a 128-bit value to anything larger than a 64-bit value. 358 */ 359 i = (i << 64) | (i - 1); 360 #endif 361 /* 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 #endif 406 } 407 408 static 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, we 422 * 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 453 static 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 475 static 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 530 static 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 566 static 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 " .llseek = (loff_t (*)(struct file *, loff_t, int))0xffffffffffffffff,"; 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 so 771 * complex, we don't do a string comparison, just verify we return 772 * 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 the 786 * 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 the 789 * 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 801 static void test_btf_dump_var_data(struct btf *btf, struct btf_dump *d, 802 char *str) 803 { 804 #if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__) 805 TEST_BTF_DUMP_VAR(btf, d, NULL, str, "cpu_number", int, BTF_F_COMPACT, 806 "int cpu_number = (int)100", 100); 807 #endif 808 TEST_BTF_DUMP_VAR(btf, d, NULL, str, "cpu_profile_flip", int, BTF_F_COMPACT, 809 "static int cpu_profile_flip = (int)2", 2); 810 } 811 812 static 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 838 static 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)); 855 out: 856 btf_dump__free(d); 857 btf__free(btf); 858 } 859 860 void 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