bpf: btf: Change how section is supported in btf_header

There are currently unused section descriptions in the btf_header.  Those
sections are here to support future BTF use cases.  For example, the
func section (func_off) is to support function signature (e.g. the BPF
prog function signature).

Instead of spelling out all potential sections up-front in the btf_header.
This patch makes changes to btf_header such that extending it (e.g. adding
a section) is possible later.  The unused ones can be removed for now and
they can be added back later.

This patch:
1. adds a hdr_len to the btf_header.  It will allow adding
sections (and other info like parent_label and parent_name)
later.  The check is similar to the existing bpf_attr.
If a user passes in a longer hdr_len, the kernel
ensures the extra tailing bytes are 0.

2. allows the section order in the BTF object to be
different from its sec_off order in btf_header.

3. each sec_off is followed by a sec_len.  It must not have gap or
overlapping among sections.

The string section is ensured to be at the end due to the 4 bytes
alignment requirement of the type section.

The above changes will allow enough flexibility to
add new sections (and other info) to the btf_header later.

This patch also removes an unnecessary !err check
at the end of btf_parse().

Signed-off-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

diff --git a/include/uapi/linux/btf.h b/include/uapi/linux/btf.h
index bcb56ee4701461a6b4a0134903a1eeef8e275ca6..4fa479741a0204a1fbc90862cdacb7152b9b6b3c 100644 (file)
--- a/include/uapi/linux/btf.h
+++ b/include/uapi/linux/btf.h
@@ -12,15 +12,11 @@ struct btf_header {
        __u16   magic;
        __u8    version;
        __u8    flags;
-
-       __u32   parent_label;
-       __u32   parent_name;
+       __u32   hdr_len;
 
        /* All offsets are in bytes relative to the end of this header */
-       __u32   label_off;      /* offset of label section      */
-       __u32   object_off;     /* offset of data object section*/
-       __u32   func_off;       /* offset of function section   */
        __u32   type_off;       /* offset of type section       */
+       __u32   type_len;       /* length of type section       */
        __u32   str_off;        /* offset of string section     */
        __u32   str_len;        /* length of string section     */
 };

diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index ded10ab47b8acb4d90902debceecfae484caa73f..75da6cbae47d3c199d5c59d837146d5aec5b6d24 100644 (file)
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -12,6 +12,7 @@
 #include <linux/uaccess.h>
 #include <linux/kernel.h>
 #include <linux/idr.h>
+#include <linux/sort.h>
 #include <linux/bpf_verifier.h>
 #include <linux/btf.h>
 
@@ -184,15 +185,13 @@ static DEFINE_IDR(btf_idr);
 static DEFINE_SPINLOCK(btf_idr_lock);
 
 struct btf {
-       union {
-               struct btf_header *hdr;
-               void *data;
-       };
+       void *data;
        struct btf_type **types;
        u32 *resolved_ids;
        u32 *resolved_sizes;
        const char *strings;
        void *nohdr_data;
+       struct btf_header hdr;
        u32 nr_types;
        u32 types_size;
        u32 data_size;
@@ -228,6 +227,11 @@ enum resolve_mode {
 
 #define MAX_RESOLVE_DEPTH 32
 
+struct btf_sec_info {
+       u32 off;
+       u32 len;
+};
+
 struct btf_verifier_env {
        struct btf *btf;
        u8 *visit_states;
@@ -418,14 +422,14 @@ static const struct btf_kind_operations *btf_type_ops(const struct btf_type *t)
 static bool btf_name_offset_valid(const struct btf *btf, u32 offset)
 {
        return !BTF_STR_TBL_ELF_ID(offset) &&
-               BTF_STR_OFFSET(offset) < btf->hdr->str_len;
+               BTF_STR_OFFSET(offset) < btf->hdr.str_len;
 }
 
 static const char *btf_name_by_offset(const struct btf *btf, u32 offset)
 {
        if (!BTF_STR_OFFSET(offset))
                return "(anon)";
-       else if (BTF_STR_OFFSET(offset) < btf->hdr->str_len)
+       else if (BTF_STR_OFFSET(offset) < btf->hdr.str_len)
                return &btf->strings[BTF_STR_OFFSET(offset)];
        else
                return "(invalid-name-offset)";
@@ -536,7 +540,8 @@ static void btf_verifier_log_member(struct btf_verifier_env *env,
        __btf_verifier_log(log, "\n");
 }
 
-static void btf_verifier_log_hdr(struct btf_verifier_env *env)
+static void btf_verifier_log_hdr(struct btf_verifier_env *env,
+                                u32 btf_data_size)
 {
        struct bpf_verifier_log *log = &env->log;
        const struct btf *btf = env->btf;
@@ -545,19 +550,16 @@ static void btf_verifier_log_hdr(struct btf_verifier_env *env)
        if (!bpf_verifier_log_needed(log))
                return;
 
-       hdr = btf->hdr;
+       hdr = &btf->hdr;
        __btf_verifier_log(log, "magic: 0x%x\n", hdr->magic);
        __btf_verifier_log(log, "version: %u\n", hdr->version);
        __btf_verifier_log(log, "flags: 0x%x\n", hdr->flags);
-       __btf_verifier_log(log, "parent_label: %u\n", hdr->parent_label);
-       __btf_verifier_log(log, "parent_name: %u\n", hdr->parent_name);
-       __btf_verifier_log(log, "label_off: %u\n", hdr->label_off);
-       __btf_verifier_log(log, "object_off: %u\n", hdr->object_off);
-       __btf_verifier_log(log, "func_off: %u\n", hdr->func_off);
+       __btf_verifier_log(log, "hdr_len: %u\n", hdr->hdr_len);
        __btf_verifier_log(log, "type_off: %u\n", hdr->type_off);
+       __btf_verifier_log(log, "type_len: %u\n", hdr->type_len);
        __btf_verifier_log(log, "str_off: %u\n", hdr->str_off);
        __btf_verifier_log(log, "str_len: %u\n", hdr->str_len);
-       __btf_verifier_log(log, "btf_total_size: %u\n", btf->data_size);
+       __btf_verifier_log(log, "btf_total_size: %u\n", btf_data_size);
 }
 
 static int btf_add_type(struct btf_verifier_env *env, struct btf_type *t)
@@ -1754,9 +1756,9 @@ static int btf_check_all_metas(struct btf_verifier_env *env)
        struct btf_header *hdr;
        void *cur, *end;
 
-       hdr = btf->hdr;
+       hdr = &btf->hdr;
        cur = btf->nohdr_data + hdr->type_off;
-       end = btf->nohdr_data + hdr->str_off;
+       end = btf->nohdr_data + hdr->type_len;
 
        env->log_type_id = 1;
        while (cur < end) {
@@ -1866,8 +1868,20 @@ static int btf_check_all_types(struct btf_verifier_env *env)
 
 static int btf_parse_type_sec(struct btf_verifier_env *env)
 {
+       const struct btf_header *hdr = &env->btf->hdr;
        int err;
 
+       /* Type section must align to 4 bytes */
+       if (hdr->type_off & (sizeof(u32) - 1)) {
+               btf_verifier_log(env, "Unaligned type_off");
+               return -EINVAL;
+       }
+
+       if (!hdr->type_len) {
+               btf_verifier_log(env, "No type found");
+               return -EINVAL;
+       }
+
        err = btf_check_all_metas(env);
        if (err)
                return err;
@@ -1881,10 +1895,15 @@ static int btf_parse_str_sec(struct btf_verifier_env *env)
        struct btf *btf = env->btf;
        const char *start, *end;
 
-       hdr = btf->hdr;
+       hdr = &btf->hdr;
        start = btf->nohdr_data + hdr->str_off;
        end = start + hdr->str_len;
 
+       if (end != btf->data + btf->data_size) {
+               btf_verifier_log(env, "String section is not at the end");
+               return -EINVAL;
+       }
+
        if (!hdr->str_len || hdr->str_len - 1 > BTF_MAX_NAME_OFFSET ||
            start[0] || end[-1]) {
                btf_verifier_log(env, "Invalid string section");
@@ -1896,20 +1915,122 @@ static int btf_parse_str_sec(struct btf_verifier_env *env)
        return 0;
 }
 
-static int btf_parse_hdr(struct btf_verifier_env *env)
+static const size_t btf_sec_info_offset[] = {
+       offsetof(struct btf_header, type_off),
+       offsetof(struct btf_header, str_off),
+};
+
+static int btf_sec_info_cmp(const void *a, const void *b)
+{
+       const struct btf_sec_info *x = a;
+       const struct btf_sec_info *y = b;
+
+       return (int)(x->off - y->off) ? : (int)(x->len - y->len);
+}
+
+static int btf_check_sec_info(struct btf_verifier_env *env,
+                             u32 btf_data_size)
 {
+       const unsigned int nr_secs = ARRAY_SIZE(btf_sec_info_offset);
+       struct btf_sec_info secs[nr_secs];
+       u32 total, expected_total, i;
        const struct btf_header *hdr;
-       struct btf *btf = env->btf;
-       u32 meta_left;
+       const struct btf *btf;
+
+       btf = env->btf;
+       hdr = &btf->hdr;
 
-       if (btf->data_size < sizeof(*hdr)) {
+       /* Populate the secs from hdr */
+       for (i = 0; i < nr_secs; i++)
+               secs[i] = *(struct btf_sec_info *)((void *)hdr +
+                                                  btf_sec_info_offset[i]);
+
+       sort(secs, nr_secs, sizeof(struct btf_sec_info),
+            btf_sec_info_cmp, NULL);
+
+       /* Check for gaps and overlap among sections */
+       total = 0;
+       expected_total = btf_data_size - hdr->hdr_len;
+       for (i = 0; i < nr_secs; i++) {
+               if (expected_total < secs[i].off) {
+                       btf_verifier_log(env, "Invalid section offset");
+                       return -EINVAL;
+               }
+               if (total < secs[i].off) {
+                       /* gap */
+                       btf_verifier_log(env, "Unsupported section found");
+                       return -EINVAL;
+               }
+               if (total > secs[i].off) {
+                       btf_verifier_log(env, "Section overlap found");
+                       return -EINVAL;
+               }
+               if (expected_total - total < secs[i].len) {
+                       btf_verifier_log(env,
+                                        "Total section length too long");
+                       return -EINVAL;
+               }
+               total += secs[i].len;
+       }
+
+       /* There is data other than hdr and known sections */
+       if (expected_total != total) {
+               btf_verifier_log(env, "Unsupported section found");
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+static int btf_parse_hdr(struct btf_verifier_env *env, void __user *btf_data,
+                        u32 btf_data_size)
+{
+       const struct btf_header *hdr;
+       u32 hdr_len, hdr_copy;
+       /*
+        * Minimal part of the "struct btf_header" that
+        * contains the hdr_len.
+        */
+       struct btf_min_header {
+               u16     magic;
+               u8      version;
+               u8      flags;
+               u32     hdr_len;
+       } __user *min_hdr;
+       struct btf *btf;
+       int err;
+
+       btf = env->btf;
+       min_hdr = btf_data;
+
+       if (btf_data_size < sizeof(*min_hdr)) {
+               btf_verifier_log(env, "hdr_len not found");
+               return -EINVAL;
+       }
+
+       if (get_user(hdr_len, &min_hdr->hdr_len))
+               return -EFAULT;
+
+       if (btf_data_size < hdr_len) {
                btf_verifier_log(env, "btf_header not found");
                return -EINVAL;
        }
 
-       btf_verifier_log_hdr(env);
+       err = bpf_check_uarg_tail_zero(btf_data, sizeof(btf->hdr), hdr_len);
+       if (err) {
+               if (err == -E2BIG)
+                       btf_verifier_log(env, "Unsupported btf_header");
+               return err;
+       }
+
+       hdr_copy = min_t(u32, hdr_len, sizeof(btf->hdr));
+       if (copy_from_user(&btf->hdr, btf_data, hdr_copy))
+               return -EFAULT;
+
+       hdr = &btf->hdr;
+
+       btf_verifier_log_hdr(env, btf_data_size);
 
-       hdr = btf->hdr;
        if (hdr->magic != BTF_MAGIC) {
                btf_verifier_log(env, "Invalid magic");
                return -EINVAL;
@@ -1925,26 +2046,14 @@ static int btf_parse_hdr(struct btf_verifier_env *env)
                return -ENOTSUPP;
        }
 
-       meta_left = btf->data_size - sizeof(*hdr);
-       if (!meta_left) {
+       if (btf_data_size == hdr->hdr_len) {
                btf_verifier_log(env, "No data");
                return -EINVAL;
        }
 
-       if (meta_left < hdr->type_off || hdr->str_off <= hdr->type_off ||
-           /* Type section must align to 4 bytes */
-           hdr->type_off & (sizeof(u32) - 1)) {
-               btf_verifier_log(env, "Invalid type_off");
-               return -EINVAL;
-       }
-
-       if (meta_left < hdr->str_off ||
-           meta_left - hdr->str_off < hdr->str_len) {
-               btf_verifier_log(env, "Invalid str_off or str_len");
-               return -EINVAL;
-       }
-
-       btf->nohdr_data = btf->hdr + 1;
+       err = btf_check_sec_info(env, btf_data_size);
+       if (err)
+               return err;
 
        return 0;
 }
@@ -1987,6 +2096,11 @@ static struct btf *btf_parse(void __user *btf_data, u32 btf_data_size,
                err = -ENOMEM;
                goto errout;
        }
+       env->btf = btf;
+
+       err = btf_parse_hdr(env, btf_data, btf_data_size);
+       if (err)
+               goto errout;
 
        data = kvmalloc(btf_data_size, GFP_KERNEL | __GFP_NOWARN);
        if (!data) {
@@ -1996,18 +2110,13 @@ static struct btf *btf_parse(void __user *btf_data, u32 btf_data_size,
 
        btf->data = data;
        btf->data_size = btf_data_size;
+       btf->nohdr_data = btf->data + btf->hdr.hdr_len;
 
        if (copy_from_user(data, btf_data, btf_data_size)) {
                err = -EFAULT;
                goto errout;
        }
 
-       env->btf = btf;
-
-       err = btf_parse_hdr(env);
-       if (err)
-               goto errout;
-
        err = btf_parse_str_sec(env);
        if (err)
                goto errout;
@@ -2016,16 +2125,14 @@ static struct btf *btf_parse(void __user *btf_data, u32 btf_data_size,
        if (err)
                goto errout;
 
-       if (!err && log->level && bpf_verifier_log_full(log)) {
+       if (log->level && bpf_verifier_log_full(log)) {
                err = -ENOSPC;
                goto errout;
        }
 
-       if (!err) {
-               btf_verifier_env_free(env);
-               refcount_set(&btf->refcnt, 1);
-               return btf;
-       }
+       btf_verifier_env_free(env);
+       refcount_set(&btf->refcnt, 1);
+       return btf;
 
 errout:
        btf_verifier_env_free(env);