Skip to content

Commit

Permalink
tools/bpf: extends test_btf to test load/retrieve func_type info
Browse files Browse the repository at this point in the history 
A two function bpf program is loaded with btf and func_info.
After successful prog load, the bpf_get_info syscall is called
to retrieve prog info to ensure the types returned from the
kernel matches the types passed to the kernel from the
user space.

Several negative tests are also added to test loading/retriving
of func_type info.

Signed-off-by: Yonghong Song <yhs@fb.com>
Signed-off-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
  • Loading branch information
Yonghong Song authored and Alexei Starovoitov committed Nov 20, 2018
1 parent 7e0d0fb commit 4798c4b
Showing 1 changed file with 329 additions and 3 deletions.
332 changes: 329 additions & 3 deletions tools/testing/selftests/bpf/test_btf.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@
#include <linux/btf.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/filter.h>
#include <bpf/bpf.h>
#include <sys/resource.h>
#include <libelf.h>
Expand All @@ -22,9 +23,13 @@
#include "bpf_rlimit.h"
#include "bpf_util.h"

#define MAX_INSNS 512
#define MAX_SUBPROGS 16

static uint32_t pass_cnt;
static uint32_t error_cnt;
static uint32_t skip_cnt;
static bool jit_enabled;

#define CHECK(condition, format...) ({ \
int __ret = !!(condition); \
Expand Down Expand Up @@ -60,6 +65,24 @@ static int __base_pr(const char *format, ...)
return err;
}

static bool is_jit_enabled(void)
{
const char *jit_sysctl = "/proc/sys/net/core/bpf_jit_enable";
bool enabled = false;
int sysctl_fd;

sysctl_fd = open(jit_sysctl, 0, O_RDONLY);
if (sysctl_fd != -1) {
char tmpc;

if (read(sysctl_fd, &tmpc, sizeof(tmpc)) == 1)
enabled = (tmpc != '0');
close(sysctl_fd);
}

return enabled;
}

#define BTF_INFO_ENC(kind, root, vlen) \
((!!(root) << 31) | ((kind) << 24) | ((vlen) & BTF_MAX_VLEN))

Expand Down Expand Up @@ -115,6 +138,7 @@ static struct args {
bool get_info_test;
bool pprint_test;
bool always_log;
bool func_type_test;
} args;

static char btf_log_buf[BTF_LOG_BUF_SIZE];
Expand Down Expand Up @@ -2947,16 +2971,310 @@ static int test_pprint(void)
return err;
}

static struct btf_func_type_test {
const char *descr;
const char *str_sec;
__u32 raw_types[MAX_NR_RAW_TYPES];
__u32 str_sec_size;
struct bpf_insn insns[MAX_INSNS];
__u32 prog_type;
__u32 func_info[MAX_SUBPROGS][2];
__u32 func_info_rec_size;
__u32 func_info_cnt;
bool expected_prog_load_failure;
} func_type_test[] = {
{
.descr = "func_type (main func + one sub)",
.raw_types = {
BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4), /* [2] */
BTF_FUNC_PROTO_ENC(1, 2), /* [3] */
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
BTF_FUNC_PROTO_ENC(1, 2), /* [4] */
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
BTF_FUNC_ENC(NAME_TBD, 3), /* [5] */
BTF_FUNC_ENC(NAME_TBD, 4), /* [6] */
BTF_END_RAW,
},
.str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
.str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
.insns = {
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
BPF_MOV64_IMM(BPF_REG_0, 1),
BPF_EXIT_INSN(),
BPF_MOV64_IMM(BPF_REG_0, 2),
BPF_EXIT_INSN(),
},
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
.func_info = { {0, 5}, {3, 6} },
.func_info_rec_size = 8,
.func_info_cnt = 2,
},

{
.descr = "func_type (Incorrect func_info_rec_size)",
.raw_types = {
BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4), /* [2] */
BTF_FUNC_PROTO_ENC(1, 2), /* [3] */
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
BTF_FUNC_PROTO_ENC(1, 2), /* [4] */
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
BTF_FUNC_ENC(NAME_TBD, 3), /* [5] */
BTF_FUNC_ENC(NAME_TBD, 4), /* [6] */
BTF_END_RAW,
},
.str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
.str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
.insns = {
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
BPF_MOV64_IMM(BPF_REG_0, 1),
BPF_EXIT_INSN(),
BPF_MOV64_IMM(BPF_REG_0, 2),
BPF_EXIT_INSN(),
},
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
.func_info = { {0, 5}, {3, 6} },
.func_info_rec_size = 4,
.func_info_cnt = 2,
.expected_prog_load_failure = true,
},

{
.descr = "func_type (Incorrect func_info_cnt)",
.raw_types = {
BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4), /* [2] */
BTF_FUNC_PROTO_ENC(1, 2), /* [3] */
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
BTF_FUNC_PROTO_ENC(1, 2), /* [4] */
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
BTF_FUNC_ENC(NAME_TBD, 3), /* [5] */
BTF_FUNC_ENC(NAME_TBD, 4), /* [6] */
BTF_END_RAW,
},
.str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
.str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
.insns = {
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
BPF_MOV64_IMM(BPF_REG_0, 1),
BPF_EXIT_INSN(),
BPF_MOV64_IMM(BPF_REG_0, 2),
BPF_EXIT_INSN(),
},
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
.func_info = { {0, 5}, {3, 6} },
.func_info_rec_size = 8,
.func_info_cnt = 1,
.expected_prog_load_failure = true,
},

{
.descr = "func_type (Incorrect bpf_func_info.insn_offset)",
.raw_types = {
BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4), /* [2] */
BTF_FUNC_PROTO_ENC(1, 2), /* [3] */
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
BTF_FUNC_PROTO_ENC(1, 2), /* [4] */
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
BTF_FUNC_ENC(NAME_TBD, 3), /* [5] */
BTF_FUNC_ENC(NAME_TBD, 4), /* [6] */
BTF_END_RAW,
},
.str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
.str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
.insns = {
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
BPF_MOV64_IMM(BPF_REG_0, 1),
BPF_EXIT_INSN(),
BPF_MOV64_IMM(BPF_REG_0, 2),
BPF_EXIT_INSN(),
},
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
.func_info = { {0, 5}, {2, 6} },
.func_info_rec_size = 8,
.func_info_cnt = 2,
.expected_prog_load_failure = true,
},

};

static size_t probe_prog_length(const struct bpf_insn *fp)
{
size_t len;

for (len = MAX_INSNS - 1; len > 0; --len)
if (fp[len].code != 0 || fp[len].imm != 0)
break;
return len + 1;
}

static int do_test_func_type(int test_num)
{
const struct btf_func_type_test *test = &func_type_test[test_num];
unsigned int raw_btf_size, info_len, rec_size;
int i, btf_fd = -1, prog_fd = -1, err = 0;
struct bpf_load_program_attr attr = {};
void *raw_btf, *func_info = NULL;
struct bpf_prog_info info = {};
struct bpf_func_info *finfo;

fprintf(stderr, "%s......", test->descr);
raw_btf = btf_raw_create(&hdr_tmpl, test->raw_types,
test->str_sec, test->str_sec_size,
&raw_btf_size);

if (!raw_btf)
return -1;

*btf_log_buf = '\0';
btf_fd = bpf_load_btf(raw_btf, raw_btf_size,
btf_log_buf, BTF_LOG_BUF_SIZE,
args.always_log);
free(raw_btf);

if (CHECK(btf_fd == -1, "invalid btf_fd errno:%d", errno)) {
err = -1;
goto done;
}

if (*btf_log_buf && args.always_log)
fprintf(stderr, "\n%s", btf_log_buf);

attr.prog_type = test->prog_type;
attr.insns = test->insns;
attr.insns_cnt = probe_prog_length(attr.insns);
attr.license = "GPL";
attr.prog_btf_fd = btf_fd;
attr.func_info_rec_size = test->func_info_rec_size;
attr.func_info_cnt = test->func_info_cnt;
attr.func_info = test->func_info;

*btf_log_buf = '\0';
prog_fd = bpf_load_program_xattr(&attr, btf_log_buf,
BTF_LOG_BUF_SIZE);
if (test->expected_prog_load_failure && prog_fd == -1) {
err = 0;
goto done;
}
if (CHECK(prog_fd == -1, "invalid prog_id errno:%d", errno)) {
fprintf(stderr, "%s\n", btf_log_buf);
err = -1;
goto done;
}
if (!jit_enabled) {
skip_cnt++;
fprintf(stderr, "SKIPPED, please enable sysctl bpf_jit_enable\n");
err = 0;
goto done;
}

/* get necessary lens */
info_len = sizeof(struct bpf_prog_info);
err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
if (CHECK(err == -1, "invalid get info (1st) errno:%d", errno)) {
fprintf(stderr, "%s\n", btf_log_buf);
err = -1;
goto done;
}
if (CHECK(info.func_info_cnt != 2,
"incorrect info.func_info_cnt (1st) %d\n",
info.func_info_cnt)) {
err = -1;
goto done;
}
rec_size = info.func_info_rec_size;
if (CHECK(rec_size < 4,
"incorrect info.func_info_rec_size (1st) %d\n", rec_size)) {
err = -1;
goto done;
}

func_info = malloc(info.func_info_cnt * rec_size);
if (CHECK(!func_info, "out of memeory")) {
err = -1;
goto done;
}

/* reset info to only retrieve func_info related data */
memset(&info, 0, sizeof(info));
info.func_info_cnt = 2;
info.func_info_rec_size = rec_size;
info.func_info = ptr_to_u64(func_info);
err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
if (CHECK(err == -1, "invalid get info (2nd) errno:%d", errno)) {
fprintf(stderr, "%s\n", btf_log_buf);
err = -1;
goto done;
}
if (CHECK(info.func_info_cnt != 2,
"incorrect info.func_info_cnt (2nd) %d\n",
info.func_info_cnt)) {
err = -1;
goto done;
}
if (CHECK(info.func_info_rec_size != rec_size,
"incorrect info.func_info_rec_size (2nd) %d\n",
info.func_info_rec_size)) {
err = -1;
goto done;
}

finfo = func_info;
for (i = 0; i < 2; i++) {
if (CHECK(finfo->type_id != test->func_info[i][1],
"incorrect func_type %u expected %u",
finfo->type_id, test->func_info[i][1])) {
err = -1;
goto done;
}
finfo = (void *)finfo + rec_size;
}

done:
if (*btf_log_buf && (err || args.always_log))
fprintf(stderr, "\n%s", btf_log_buf);

if (btf_fd != -1)
close(btf_fd);
if (prog_fd != -1)
close(prog_fd);
free(func_info);
return err;
}

static int test_func_type(void)
{
unsigned int i;
int err = 0;

for (i = 0; i < ARRAY_SIZE(func_type_test); i++)
err |= count_result(do_test_func_type(i));

return err;
}

static void usage(const char *cmd)
{
fprintf(stderr, "Usage: %s [-l] [[-r test_num (1 - %zu)] | [-g test_num (1 - %zu)] | [-f test_num (1 - %zu)] | [-p]]\n",
fprintf(stderr, "Usage: %s [-l] [[-r test_num (1 - %zu)] |"
" [-g test_num (1 - %zu)] |"
" [-f test_num (1 - %zu)] | [-p] | [-k] ]\n",
cmd, ARRAY_SIZE(raw_tests), ARRAY_SIZE(get_info_tests),
ARRAY_SIZE(file_tests));
}

static int parse_args(int argc, char **argv)
{
const char *optstr = "lpf:r:g:";
const char *optstr = "lpkf:r:g:";
int opt;

while ((opt = getopt(argc, argv, optstr)) != -1) {
Expand All @@ -2979,6 +3297,9 @@ static int parse_args(int argc, char **argv)
case 'p':
args.pprint_test = true;
break;
case 'k':
args.func_type_test = true;
break;
case 'h':
usage(argv[0]);
exit(0);
Expand Down Expand Up @@ -3032,6 +3353,8 @@ int main(int argc, char **argv)
if (args.always_log)
libbpf_set_print(__base_pr, __base_pr, __base_pr);

jit_enabled = is_jit_enabled();

if (args.raw_test)
err |= test_raw();

Expand All @@ -3044,8 +3367,11 @@ int main(int argc, char **argv)
if (args.pprint_test)
err |= test_pprint();

if (args.func_type_test)
err |= test_func_type();

if (args.raw_test || args.get_info_test || args.file_test ||
args.pprint_test)
args.pprint_test || args.func_type_test)
goto done;

err |= test_raw();
Expand Down

0 comments on commit 4798c4b

Please sign in to comment.