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();