// 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);
}