| // SPDX-License-Identifier: GPL-2.0 | |
| #include <test_progs.h> | |
| #include <bpftool_helpers.h> | |
| #include <bpf/btf.h> | |
| #include <limits.h> | |
| #include <unistd.h> | |
| #include "btf_helpers.h" | |
| #include "testing_helpers.h" | |
| #define DUMP_BUF_SZ (16 * 1024) | |
| #define EXPECTED_SORTED "bpftool_btf_dump_sorted.expected" | |
| #define EXPECTED_UNSORTED "bpftool_btf_dump_unsorted.expected" | |
| /* | |
| * struct holey { | |
| * int c; | |
| * <64-bit hole> | |
| * int tail; | |
| * }; | |
| * enum { E0 = 1 }; | |
| * struct s { int f; }; | |
| */ | |
| static struct btf *mk_btf(void) | |
| { | |
| struct btf *btf; | |
| btf = btf__new_empty(); | |
| if (!ASSERT_OK_PTR(btf, "new_empty")) | |
| return NULL; | |
| btf__add_int(btf, "int", 4, BTF_INT_SIGNED); | |
| btf__add_int(btf, "long int", 4, BTF_INT_SIGNED); | |
| btf__add_struct(btf, "holey", 16); | |
| btf__add_field(btf, "c", 1, 0, 0); | |
| btf__add_field(btf, "tail", 1, 96, 0); | |
| btf__add_enum(btf, NULL, 4); | |
| btf__add_enum_value(btf, "E0", 1); | |
| btf__add_struct(btf, "s", 4); | |
| btf__add_field(btf, "f", 1, 0, 0); | |
| VALIDATE_RAW_BTF( | |
| btf, | |
| "[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED", | |
| "[2] INT 'long int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED", | |
| "[3] STRUCT 'holey' size=16 vlen=2\n" | |
| "\t'c' type_id=1 bits_offset=0\n" | |
| "\t'tail' type_id=1 bits_offset=96", | |
| "[4] ENUM '(anon)' encoding=UNSIGNED size=4 vlen=1\n" | |
| "\t'E0' val=1", | |
| "[5] STRUCT 's' size=4 vlen=1\n" | |
| "\t'f' type_id=1 bits_offset=0"); | |
| return btf; | |
| } | |
| static struct btf *mk_loc_btf(void) | |
| { | |
| struct btf *btf; | |
| btf = btf__new_empty(); | |
| if (!ASSERT_OK_PTR(btf, "new_empty")) | |
| return NULL; | |
| btf__add_int(btf, "int", 4, BTF_INT_SIGNED); | |
| btf__add_func_proto(btf, 1); | |
| btf__add_func_param(btf, "arg1", 1); | |
| btf__add_func_param(btf, "arg2", 1); | |
| btf__add_func_param(btf, "arg3", 1); | |
| btf__add_func_param(btf, "arg4", 1); | |
| btf__add_func_param(btf, "arg5", 1); | |
| btf__add_func_param(btf, "arg6", 1); | |
| btf__add_func(btf, "foo", BTF_FUNC_STATIC, 2); | |
| btf__add_loc_param(btf, 4, BTF_LOC_PARAM_REG); | |
| btf__add_loc_param_value(btf, 1); | |
| btf__add_loc_param(btf, 8, BTF_LOC_PARAM_REG | | |
| BTF_LOC_PARAM_DEREF | BTF_LOC_PARAM_OFFSET); | |
| btf__add_loc_param_value(btf, 2); | |
| btf__add_loc_param_value(btf, 0x10); | |
| btf__add_loc_param(btf, 8, BTF_LOC_PARAM_REG | | |
| BTF_LOC_PARAM_OFFSET | BTF_LOC_PARAM_SIGNED); | |
| btf__add_loc_param_value(btf, BTF_LOC_PARAM_FBREG); | |
| btf__add_loc_param_value(btf, -0x10); | |
| btf__add_loc_param(btf, 8, BTF_LOC_PARAM_ADDR | BTF_LOC_PARAM_CONST); | |
| btf__add_loc_param_value(btf, 0x9abcdef0); | |
| btf__add_loc_param_value(btf, 0x12345678); | |
| btf__add_loc_param(btf, 8, BTF_LOC_PARAM_CONST); | |
| btf__add_loc_param_value(btf, 0xfeedface); | |
| btf__add_loc_param_value(btf, 0xdeadbeef); | |
| btf__add_loc_param(btf, 8, BTF_LOC_PARAM_REG | | |
| BTF_LOC_PARAM_DEREF | BTF_LOC_PARAM_OFFSET | | |
| BTF_LOC_PARAM_SIGNED); | |
| btf__add_loc_param_value(btf, BTF_LOC_PARAM_FBREG); | |
| btf__add_loc_param_value(btf, -0x20); | |
| btf__add_loc_proto(btf); | |
| btf__add_loc_proto_param(btf, 4); | |
| btf__add_loc_proto_param(btf, 5); | |
| btf__add_loc_proto_param(btf, 6); | |
| btf__add_loc_proto_param(btf, 7); | |
| btf__add_loc_proto_param(btf, 8); | |
| btf__add_loc_proto_param(btf, 9); | |
| btf__add_locsec(btf, "inline.text"); | |
| btf__add_locsec_loc(btf, 3, 10, 64); | |
| return btf; | |
| } | |
| static int btf_to_tmpfile(const struct btf *btf, char *path) | |
| { | |
| ssize_t written; | |
| const void *raw; | |
| __u32 sz; | |
| int fd; | |
| raw = btf__raw_data(btf, &sz); | |
| if (!ASSERT_OK_PTR(raw, "raw_data")) | |
| return -1; | |
| snprintf(path, PATH_MAX, "/tmp/bpftool_btf_dump.XXXXXX"); | |
| fd = mkstemp(path); | |
| if (!ASSERT_OK_FD(fd, "mkstemp_btf")) | |
| return -1; | |
| written = write(fd, raw, sz); | |
| close(fd); | |
| if (!ASSERT_EQ(written, sz, "write_btf")) { | |
| unlink(path); | |
| return -1; | |
| } | |
| return 0; | |
| } | |
| static char *dump_c(const char *btf_path, bool sorted) | |
| { | |
| char args[MAX_BPFTOOL_CMD_LEN]; | |
| char *buf; | |
| int err; | |
| buf = malloc(DUMP_BUF_SZ); | |
| if (!ASSERT_OK_PTR(buf, "alloc_dump")) | |
| return NULL; | |
| snprintf(args, sizeof(args), "btf dump file %s format c%s", | |
| btf_path, sorted ? "" : " unsorted"); | |
| err = get_bpftool_command_output(args, buf, DUMP_BUF_SZ); | |
| if (!ASSERT_OK(err, "btf_dump_format_c")) { | |
| free(buf); | |
| return NULL; | |
| } | |
| return buf; | |
| } | |
| static char *dump_raw(const char *btf_path) | |
| { | |
| char args[MAX_BPFTOOL_CMD_LEN]; | |
| char *buf; | |
| int err; | |
| buf = malloc(DUMP_BUF_SZ); | |
| if (!ASSERT_OK_PTR(buf, "alloc_dump")) | |
| return NULL; | |
| snprintf(args, sizeof(args), "btf dump file %s", btf_path); | |
| err = get_bpftool_command_output(args, buf, DUMP_BUF_SZ); | |
| if (!ASSERT_OK(err, "btf_dump_raw")) { | |
| free(buf); | |
| return NULL; | |
| } | |
| return buf; | |
| } | |
| static char *read_expected(const char *path) | |
| { | |
| char *buf = NULL; | |
| size_t cap = 0; | |
| FILE *f; | |
| int err; | |
| f = fopen(path, "r"); | |
| if (!f) { | |
| err = errno; | |
| PRINT_FAIL("can't open expected output '%s': errno %d\n", path, err); | |
| return NULL; | |
| } | |
| /* no NUL in a generated header, so this reads to the end */ | |
| if (getdelim(&buf, &cap, '\0', f) < 0) { | |
| err = errno; | |
| PRINT_FAIL("can't read expected output '%s': errno %d\n", path, err); | |
| free(buf); | |
| buf = NULL; | |
| } | |
| fclose(f); | |
| return buf; | |
| } | |
| static void test_dump(const char *btf_path, bool sorted) | |
| { | |
| const char *exp_path; | |
| char *dump, *exp; | |
| exp_path = sorted ? EXPECTED_SORTED : EXPECTED_UNSORTED; | |
| dump = dump_c(btf_path, sorted); | |
| if (!dump) | |
| return; | |
| exp = read_expected(exp_path); | |
| if (!exp) | |
| goto out_dump; | |
| ASSERT_TEXT_EQ(dump, exp, sorted ? "cmp_sorted" : "cmp_unsorted"); | |
| free(exp); | |
| out_dump: | |
| free(dump); | |
| } | |
| static void test_loc_dump(const char *btf_path) | |
| { | |
| const char expected[] = | |
| "[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED\n" | |
| "[2] FUNC_PROTO '(anon)' ret_type_id=1 vlen=6\n" | |
| "\t'arg1' type_id=1\n" | |
| "\t'arg2' type_id=1\n" | |
| "\t'arg3' type_id=1\n" | |
| "\t'arg4' type_id=1\n" | |
| "\t'arg5' type_id=1\n" | |
| "\t'arg6' type_id=1\n" | |
| "[3] FUNC 'foo' type_id=2 linkage=static\n" | |
| "[4] LOC_PARAM '(anon)' size=4 flags=0x8 vlen=1 values='reg1'\n" | |
| "[5] LOC_PARAM '(anon)' size=8 flags=0x38 vlen=2 values='*(reg2 + 0x10)'\n" | |
| "[6] LOC_PARAM '(anon)' size=8 flags=0x29 vlen=2 values='fbreg - 0x10'\n" | |
| "[7] LOC_PARAM '(anon)' size=8 flags=0x6 vlen=2 values='address 0x123456789abcdef0'\n" | |
| "[8] LOC_PARAM '(anon)' size=8 flags=0x2 vlen=2 values='const 0xdeadbeeffeedface'\n" | |
| "[9] LOC_PARAM '(anon)' size=8 flags=0x39 vlen=2 values='*(fbreg - 0x20)'\n" | |
| "[10] LOC_PROTO '(anon)' vlen=6\n" | |
| "\ttype_id=4 value='reg1'\n" | |
| "\ttype_id=5 value='*(reg2 + 0x10)'\n" | |
| "\ttype_id=6 value='fbreg - 0x10'\n" | |
| "\ttype_id=7 value='address 0x123456789abcdef0'\n" | |
| "\ttype_id=8 value='const 0xdeadbeeffeedface'\n" | |
| "\ttype_id=9 value='*(fbreg - 0x20)'\n" | |
| "[11] LOCSEC 'inline.text' vlen=1\n" | |
| "\tfunc='foo(arg1 [reg1], arg2 [*(reg2 + 0x10)], arg3 [fbreg - 0x10], arg4 [address 0x123456789abcdef0], arg5 [const 0xdeadbeeffeedface], arg6 [*(fbreg - 0x20)])' func_type_id=3 loc_proto_type_id=10 offset=64\n"; | |
| char *dump; | |
| dump = dump_raw(btf_path); | |
| if (!dump) | |
| return; | |
| ASSERT_TEXT_EQ(dump, expected, "cmp_loc_dump"); | |
| free(dump); | |
| } | |
| void test_bpftool_btf_dump(void) | |
| { | |
| char path[PATH_MAX]; | |
| struct btf *btf = NULL; | |
| btf = mk_btf(); | |
| if (!btf) | |
| return; | |
| if (btf_to_tmpfile(btf, path)) | |
| goto out_btf; | |
| if (test__start_subtest("c_sorted")) | |
| test_dump(path, true); | |
| if (test__start_subtest("c_unsorted")) | |
| test_dump(path, false); | |
| unlink(path); | |
| btf__free(btf); | |
| btf = mk_loc_btf(); | |
| if (!btf) | |
| return; | |
| if (btf_to_tmpfile(btf, path)) | |
| goto out_btf; | |
| if (test__start_subtest("loc_dump")) | |
| test_loc_dump(path); | |
| unlink(path); | |
| out_btf: | |
| btf__free(btf); | |
| } |