tools/bpf: extends test_btf to test load/retrieve func_type info

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>

1 files changed, 329 insertions, 3 deletions

diff --git a/tools/testing/selftests/bpf/test_btf.c b/tools/testing/selftests/bpf/test_btf.c
index e0eeee5c8c04..8fd3a16fea4d 100644
--- a/tools/testing/selftests/bpf/test_btf.c
+++ b/tools/testing/selftests/bpf/test_btf.c
@@ -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>
@@ -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);                                      \
@@ -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))
 
@@ -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];
@@ -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) {
@@ -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);
@@ -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();
 
@@ -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();