bpf: Allow type tag BTF records to succeed other modifier records

llvm commit [1] allowed attaching type tag records to modifier BTF
records. This is useful for using typedefs that encompass a base type
and a type tag, e.g.:

typedef struct rbtree __arena rbtree_t;

Modify btf_check_type_tags() so that it allows this sequence of records.
The function now only checks for record loops in BTF modifier record
chains. Rename to btf_check_modifier_chain_length to reflect this.

Also expand the BTF modifier traversal code to take into account that
type record can be interleaved with other modifier records. In effect
this means traversing all modifiers to collect the type tags.

Also modify existing selftests to now accept modifier records (const,
typedef) that point to type tag records.

[1] https://github.com/llvm/llvm-project/pull/203089

Signed-off-by: Emil Tsalapatis <emil@etsalapatis.com>
Link: https://lore.kernel.org/r/20260616061454.7869-1-emil@etsalapatis.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index 15ae7c43f594bebcf941760d7554732439e129ff..64572f85edc832298d57e008cd4871049f22ed7f 100644 (file)
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -28,6 +28,7 @@
 #include <linux/string.h>
 #include <linux/sysfs.h>
 #include <linux/overflow.h>
+#include <linux/bitops.h>
 
 #include <net/netfilter/nf_bpf_link.h>
 
@@ -3472,12 +3473,69 @@ static int btf_find_struct(const struct btf *btf, const struct btf_type *t,
        return BTF_FIELD_FOUND;
 }
 
+struct btf_type_tag_match {
+       const char *name;
+       u32 flag;
+};
+
+struct btf_type_tag_walk_ctx {
+       const struct btf_type *t;       /* Input/Output */
+       u32 id;                         /* Output */
+       u32 res;                        /* Output */
+};
+
+static int btf_type_tag_walk(const struct btf *btf,
+                            struct btf_type_tag_walk_ctx *ctx,
+                            const struct btf_type_tag_match *matches,
+                            u32 match_cnt)
+{
+       const struct btf_type *t = ctx->t;
+       u32 res = 0;
+       const char *tag;
+       u32 id, i;
+
+       do {
+               id = t->type;
+               t = btf_type_by_id(btf, id);
+
+               if (!btf_type_is_modifier(t))
+                       break;
+
+               if (!btf_type_is_type_tag(t) || btf_type_kflag(t))
+                       continue;
+
+               tag = __btf_name_by_offset(btf, t->name_off);
+               for (i = 0; i < match_cnt; i++) {
+                       if (strcmp(tag, matches[i].name))
+                               continue;
+                       res |= matches[i].flag;
+                       break;
+               }
+       } while (true);
+
+       /* We only support a single tag. */
+       if (hweight32(res) > 1)
+               return -EINVAL;
+
+       ctx->t = t;
+       ctx->id = id;
+       ctx->res = res;
+
+       return 0;
+}
+
 static int btf_find_kptr(const struct btf *btf, const struct btf_type *t,
                         u32 off, int sz, struct btf_field_info *info, u32 field_mask)
 {
-       enum btf_field_type type;
-       const char *tag_value;
-       bool is_type_tag;
+       static const struct btf_type_tag_match kptr_type_tags[] = {
+               { "kptr_untrusted", BPF_KPTR_UNREF },
+               { "kptr", BPF_KPTR_REF },
+               { "percpu_kptr", BPF_KPTR_PERCPU },
+               { "uptr", BPF_UPTR },
+       };
+       struct btf_type_tag_walk_ctx ctx;
+       enum btf_field_type type = 0;
+       int err;
        u32 res_id;
 
        /* Permit modifiers on the pointer itself */
@@ -3486,30 +3544,20 @@ static int btf_find_kptr(const struct btf *btf, const struct btf_type *t,
        /* For PTR, sz is always == 8 */
        if (!btf_type_is_ptr(t))
                return BTF_FIELD_IGNORE;
-       t = btf_type_by_id(btf, t->type);
-       is_type_tag = btf_type_is_type_tag(t) && !btf_type_kflag(t);
-       if (!is_type_tag)
-               return BTF_FIELD_IGNORE;
-       /* Reject extra tags */
-       if (btf_type_is_type_tag(btf_type_by_id(btf, t->type)))
-               return -EINVAL;
-       tag_value = __btf_name_by_offset(btf, t->name_off);
-       if (!strcmp("kptr_untrusted", tag_value))
-               type = BPF_KPTR_UNREF;
-       else if (!strcmp("kptr", tag_value))
-               type = BPF_KPTR_REF;
-       else if (!strcmp("percpu_kptr", tag_value))
-               type = BPF_KPTR_PERCPU;
-       else if (!strcmp("uptr", tag_value))
-               type = BPF_UPTR;
-       else
-               return -EINVAL;
+
+       ctx.t = t;
+       err = btf_type_tag_walk(btf, &ctx, kptr_type_tags,
+                               ARRAY_SIZE(kptr_type_tags));
+       if (err)
+               return err;
+
+       t = ctx.t;
+       res_id = ctx.id;
+       type = ctx.res;
 
        if (!(type & field_mask))
                return BTF_FIELD_IGNORE;
 
-       /* Get the base type */
-       t = btf_type_skip_modifiers(btf, t->type, &res_id);
        /* Only pointer to struct is allowed */
        if (!__btf_type_is_struct(t))
                return -EINVAL;
@@ -5859,11 +5907,10 @@ struct btf_struct_meta *btf_find_struct_meta(const struct btf *btf, u32 btf_id)
        return bsearch(&btf_id, tab->types, tab->cnt, sizeof(tab->types[0]), btf_id_cmp_func);
 }
 
-static int btf_check_type_tags(struct btf_verifier_env *env,
-                              struct btf *btf, int start_id)
+static int btf_check_modifier_chain_length(struct btf_verifier_env *env,
+                                          struct btf *btf, int start_id)
 {
        int i, n, good_id = start_id - 1;
-       bool in_tags;
 
        n = btf_nr_types(btf);
        for (i = start_id; i < n; i++) {
@@ -5879,20 +5926,12 @@ static int btf_check_type_tags(struct btf_verifier_env *env,
 
                cond_resched();
 
-               in_tags = btf_type_is_type_tag(t);
                while (btf_type_is_modifier(t)) {
                        if (!chain_limit--) {
                                btf_verifier_log(env, "Max chain length or cycle detected");
                                return -ELOOP;
                        }
-                       if (btf_type_is_type_tag(t)) {
-                               if (!in_tags) {
-                                       btf_verifier_log(env, "Type tags don't precede modifiers");
-                                       return -EINVAL;
-                               }
-                       } else if (in_tags) {
-                               in_tags = false;
-                       }
+
                        if (cur_id <= good_id)
                                break;
                        /* Move to next type */
@@ -5970,7 +6009,7 @@ static struct btf *btf_parse(const union bpf_attr *attr, bpfptr_t uattr,
        if (err)
                goto errout;
 
-       err = btf_check_type_tags(env, btf, 1);
+       err = btf_check_modifier_chain_length(env, btf, 1);
        if (err)
                goto errout;
 
@@ -6378,7 +6417,7 @@ static struct btf *btf_parse_base(struct btf_verifier_env *env, const char *name
        if (err)
                goto errout;
 
-       err = btf_check_type_tags(env, btf, 1);
+       err = btf_check_modifier_chain_length(env, btf, 1);
        if (err)
                goto errout;
 
@@ -6504,7 +6543,7 @@ static struct btf *btf_parse_module(const char *module_name, const void *data,
        if (err)
                goto errout;
 
-       err = btf_check_type_tags(env, btf, btf_nr_types(base_btf));
+       err = btf_check_modifier_chain_length(env, btf, btf_nr_types(base_btf));
        if (err)
                goto errout;
 
@@ -6810,14 +6849,18 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,
                    const struct bpf_prog *prog,
                    struct bpf_insn_access_aux *info)
 {
+       static const struct btf_type_tag_match ctx_type_tags[] = {
+               { "user", MEM_USER },
+               { "percpu", MEM_PERCPU },
+       };
        const struct btf_type *t = prog->aux->attach_func_proto;
        struct bpf_prog *tgt_prog = prog->aux->dst_prog;
        struct btf *btf = bpf_prog_get_target_btf(prog);
        const char *tname = prog->aux->attach_func_name;
        struct bpf_verifier_log *log = info->log;
+       struct btf_type_tag_walk_ctx ctx;
        const struct btf_param *args;
        bool ptr_err_raw_tp = false;
-       const char *tag_value;
        u32 nr_args, arg;
        int i, ret;
 
@@ -7020,22 +7063,18 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type,
        }
 
        info->btf = btf;
-       info->btf_id = t->type;
-       t = btf_type_by_id(btf, t->type);
-
-       if (btf_type_is_type_tag(t) && !btf_type_kflag(t)) {
-               tag_value = __btf_name_by_offset(btf, t->name_off);
-               if (strcmp(tag_value, "user") == 0)
-                       info->reg_type |= MEM_USER;
-               if (strcmp(tag_value, "percpu") == 0)
-                       info->reg_type |= MEM_PERCPU;
+       ctx.t = t;
+       ret = btf_type_tag_walk(btf, &ctx, ctx_type_tags,
+                               ARRAY_SIZE(ctx_type_tags));
+       if (ret) {
+               bpf_log(log, "func '%s' arg%d type %s has multiple type tags\n",
+                       tname, arg, btf_type_str(t));
+               return false;
        }
+       info->reg_type |= ctx.res;
+       info->btf_id = ctx.id;
+       t = ctx.t;
 
-       /* skip modifiers */
-       while (btf_type_is_modifier(t)) {
-               info->btf_id = t->type;
-               t = btf_type_by_id(btf, t->type);
-       }
        if (!btf_type_is_struct(t)) {
                bpf_log(log,
                        "func '%s' arg%d type %s is not a struct\n",
@@ -7074,7 +7113,7 @@ static int btf_struct_walk(struct bpf_verifier_log *log, const struct btf *btf,
        u32 i, moff, mtrue_end, msize = 0, total_nelems = 0;
        const struct btf_type *mtype, *elem_type = NULL;
        const struct btf_member *member;
-       const char *tname, *mname, *tag_value;
+       const char *tname, *mname;
        u32 vlen, elem_id, mid;
 
 again:
@@ -7270,8 +7309,15 @@ error:
                }
 
                if (btf_type_is_ptr(mtype)) {
-                       const struct btf_type *stype, *t;
+                       static const struct btf_type_tag_match walk_type_tags[] = {
+                               { "user", MEM_USER },
+                               { "percpu", MEM_PERCPU },
+                               { "rcu", MEM_RCU },
+                       };
                        enum bpf_type_flag tmp_flag = 0;
+                       struct btf_type_tag_walk_ctx ctx = { .t = mtype };
+                       const struct btf_type *stype;
+                       int err;
                        u32 id;
 
                        if (msize != size || off != moff) {
@@ -7281,22 +7327,17 @@ error:
                                return -EACCES;
                        }
 
-                       /* check type tag */
-                       t = btf_type_by_id(btf, mtype->type);
-                       if (btf_type_is_type_tag(t) && !btf_type_kflag(t)) {
-                               tag_value = __btf_name_by_offset(btf, t->name_off);
-                               /* check __user tag */
-                               if (strcmp(tag_value, "user") == 0)
-                                       tmp_flag = MEM_USER;
-                               /* check __percpu tag */
-                               if (strcmp(tag_value, "percpu") == 0)
-                                       tmp_flag = MEM_PERCPU;
-                               /* check __rcu tag */
-                               if (strcmp(tag_value, "rcu") == 0)
-                                       tmp_flag = MEM_RCU;
+                       err = btf_type_tag_walk(btf, &ctx, walk_type_tags,
+                                               ARRAY_SIZE(walk_type_tags));
+                       if (err) {
+                               bpf_log(log, "type '%s' has multiple type tags\n",
+                                       btf_type_str(mtype));
+                               return err;
                        }
+                       tmp_flag = ctx.res;
+                       id = ctx.id;
+                       stype = ctx.t;
 
-                       stype = btf_type_skip_modifiers(btf, mtype->type, &id);
                        if (btf_type_is_struct(stype)) {
                                *next_btf_id = id;
                                *flag |= tmp_flag;
@@ -7867,7 +7908,12 @@ static int btf_scan_type_tags(struct bpf_verifier_env *env,
                              const struct btf *btf, u32 type_id,
                              u32 *tags)
 {
+       static const struct btf_type_tag_match func_type_tags[] = {
+               { "arena", ARG_TAG_ARENA },
+       };
+       struct btf_type_tag_walk_ctx ctx;
        const struct btf_type *t;
+       int err;
 
        /* Find the first pointer type in the chain. */
        t = btf_type_skip_modifiers(btf, type_id, NULL);
@@ -7879,24 +7925,15 @@ static int btf_scan_type_tags(struct bpf_verifier_env *env,
        if (!t || !btf_type_is_ptr(t))
                return 0;
 
-       /* We got a pointer, get all associated type tags. */
-       for (t = btf_type_by_id(btf, t->type); t && btf_type_is_modifier(t);
-               t = btf_type_by_id(btf, t->type)) {
-
-               /* Skip non-type tag modifiers. */
-               if (!btf_type_is_type_tag(t))
-                       continue;
-
-               const char *tag = __btf_name_by_offset(btf, t->name_off);
-
-               if (strcmp(tag, "arena") == 0) {
-                       *tags |= ARG_TAG_ARENA;
-               } else {
-                       bpf_log(&env->log, "function signature member has unsupported type tag '%s'\n",
-                               tag);
-                       return -EOPNOTSUPP;
-               }
+       ctx.t = t;
+       err = btf_type_tag_walk(btf, &ctx, func_type_tags,
+                               ARRAY_SIZE(func_type_tags));
+       if (err) {
+               bpf_log(&env->log,
+                       "function signature member has multiple type tags\n");
+               return err;
        }
+       *tags |= ctx.res;
 
        return 0;
 }

diff --git a/tools/testing/selftests/bpf/prog_tests/btf.c b/tools/testing/selftests/bpf/prog_tests/btf.c
index 96f719a0cec9d41f876dc6125cdfaad3d3a62ca5..66855cbd6b73f68eff9ee4f114ff127aba955a42 100644 (file)
--- a/tools/testing/selftests/bpf/prog_tests/btf.c
+++ b/tools/testing/selftests/bpf/prog_tests/btf.c
@@ -4121,8 +4121,6 @@ static struct btf_raw_test raw_tests[] = {
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 1,
-       .btf_load_err = true,
-       .err_str = "Type tags don't precede modifiers",
 },
 {
        .descr = "type_tag test #3, type tag order",
@@ -4141,8 +4139,6 @@ static struct btf_raw_test raw_tests[] = {
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 1,
-       .btf_load_err = true,
-       .err_str = "Type tags don't precede modifiers",
 },
 {
        .descr = "type_tag test #4, type tag order",
@@ -4161,8 +4157,6 @@ static struct btf_raw_test raw_tests[] = {
        .key_type_id = 1,
        .value_type_id = 1,
        .max_entries = 1,
-       .btf_load_err = true,
-       .err_str = "Type tags don't precede modifiers",
 },
 {
        .descr = "type_tag test #5, type tag order",
@@ -4198,11 +4192,9 @@ static struct btf_raw_test raw_tests[] = {
        .map_name = "tag_type_check_btf",
        .key_size = sizeof(int),
        .value_size = 4,
-       .key_type_id = 1,
-       .value_type_id = 1,
+       .key_type_id = 4,
+       .value_type_id = 4,
        .max_entries = 1,
-       .btf_load_err = true,
-       .err_str = "Type tags don't precede modifiers",
 },
 {
        .descr = "type_tag test #7, tag with kflag",