bpf: Allow type tag BTF records to succeed other modifier records
Subsystems (3)
Emil Tsalapatis
reviewerPATCH v2 1/1 bpf: Allow type tag BTF records to succeed other modifier records
As of recently, Clang is able to attach 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.
---
Changelog v1->v2:
- Factor main type tag walk into a separate function (Eduard). The change makes certain code paths now more permissive (unrecognized tags do not cause an error for kptrs, and we can have multiple instances of the same tag), but imo handling those edge cases was a grey area in the first place and it is better to consistently scan type tags the same way everywhere.
kernel/bpf/btf.c | 209 +++++++++++-------- tools/testing/selftests/bpf/prog_tests/btf.c | 12 +- 2 files changed, 125 insertions(+), 96 deletions(-)
kernel/bpf/btf.c +123 -86
@@ -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 ;
@@ -5860,11 +5908,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++) {
@@ -5880,20 +5927,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 */
@@ -5971,7 +6010,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;
@@ -6379,7 +6418,7 @@ static struct btf *btf_parse_base(struct btf_verifier_env *env, const char *nameif (err) goto errout; - err =btf_check_type_tags (env, btf,1 ); + err =btf_check_modifier_chain_length (env, btf,1 );if (err) goto errout;
@@ -6505,7 +6544,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;
@@ -6811,14 +6850,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;
@@ -7021,22 +7064,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",
@@ -7075,7 +7114,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:
@@ -7271,8 +7310,15 @@ static int btf_struct_walk(struct bpf_verifier_log *log, const struct btf *btf, }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) {
@@ -7282,22 +7328,17 @@ static int btf_struct_walk(struct bpf_verifier_log *log, const struct btf *btf,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;
@@ -7868,7 +7909,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 );
@@ -7880,24 +7926,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 ; }
tools/testing/selftests/bpf/prog_tests/btf.c +2 -10
@@ -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",
Signature · 1 line
2.54.0
[email protected]
AI reviewThis looks like it relaxes a constraint that was added earlier. It removes the "Type tags don't precede modifiers" check (the in_tags logic in btf_check_type_tags()) that rejects valid BTF now…
Quoted 16 lines
bpf: Allow type tag BTF records to succeed other modifier records
As of recently, Clang is able to attach 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
__arenarbtree_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 tobtf_check_modifier_chain_lengthto 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.
Quoted 6 lines
Also modify existing selftests to now accept modifier records (const, typedef) that point to type tag records.
Cc Yonghong Song <[email protected]>Cc Vineet Gupta <[email protected]>Signed-off-by Emil Tsalapatis <[email protected]>
This looks like it relaxes a constraint that was added earlier. It removes the "Type tags don't precede modifiers" check (the in_tags logic in btf_check_type_tags()) that rejects valid BTF now produced by Clang.
That check was introduced by commit eb596b090558 ("bpf: Ensure type tags precede modifiers in BTF"). Should this carry:
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/27598443532
Emil Tsalapatis
reviewerQuoted 23 lines · bot+bpf-ci
Quoted 16 lines
bpf: Allow type tag BTF records to succeed other modifier records
As of recently, Clang is able to attach 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
__arenarbtree_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 tobtf_check_modifier_chain_lengthto 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.
Quoted 6 lines
Also modify existing selftests to now accept modifier records (const, typedef) that point to type tag records.
Cc Yonghong Song <[email protected]>Cc Vineet Gupta <[email protected]>Signed-off-by Emil Tsalapatis <[email protected]>
Quoted 9 lines
This looks like it relaxes a constraint that was added earlier. It removes the "Type tags don't precede modifiers" check (the
in_tagslogic inbtf_check_type_tags()) that rejects valid BTF now produced by Clang.That check was introduced by commit
eb596b090558("bpf: Ensure type tags precede modifiers in BTF"). Should this carry:Fixes eb596b090558 ("bpf: Ensure type tags precede modifiers in BTF")
This is not a fix. Circumstances have just changed and we must now account for interleaving modifiers and type tags. The previous behavior was fine, and the new behavior is fine too.
Quoted 6 lines
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.mdCI run summary: https://github.com/kernel-patches/bpf/actions/runs/27598443532
Yonghong Song
reviewerQuoted 2 lines · Emil Tsalapatis
As of recently, Clang is able to attach type tag records to modifier BTF records. This is useful for using typedefs that encompass a base type
Please add the following link in the commit message:
https://github.com/llvm/llvm-project/pull/203089
The above 'clang is able to attach type tag records to modifier BTF records' is not precise. The context for this requires typedef.
Quoted 7 lines
and a type tag, e.g.:
typedef struct rbtree
__arenarbtree_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 tobtf_check_modifier_chain_lengthto reflect this.
Currently, for clang, the typetag is always right after typedef, e.g.,
typedef struct rbtree __arena const rbtree_t
=> typedef -> __arena -> const -> struct rbtree
typedef const struct rbtree __arena rbtree_t
=> typedef -> __arena -> const -> struct rbtree
typedef struct rbtree const __arena rbtree_t
=> typedef -> __arena -> const -> struct rbtree
gcc has not yet implemented this (typedef struct rbtree __arena rbtree_t). Not sure whether gcc will follow the above clang pattern or
it may generate something like
typedef -> const -> __arena -> struct rbbree
or not.
But considering gcc also follows pattern like
ptr -> __arena -> const -> struct rbtree
likely in the future they may support like
typedef -> __arena -> const -> struct rbtreeMaybe we should keep similar ordering ('ptr -> __arena' => 'typedef -> __arena')?
Jose, David, what do you think?
Quoted 93 lines
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.
Cc Yonghong Song <[email protected]>Cc Vineet Gupta <[email protected]>Signed-off-by Emil Tsalapatis <[email protected]>---
Changelog
v1->v2:- Factor main type tag walk into a separate function (Eduard). The change makes certain code paths now more permissive (unrecognized tags do not cause an error for kptrs, and we can have multiple instances of the same tag), but imo handling those edge cases was a grey area in the first place and it is better to consistently scan type tags the same way everywhere.
kernel/bpf/btf.c | 209 +++++++++++-------- tools/testing/selftests/bpf/prog_tests/btf.c | 12 +- 2 files changed, 125 insertions(+), 96 deletions(-)kernel/bpf/btf.c +52
-0@@ -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 ; +} +
[...]
This patch was applied to bpf/bpf.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This patch was applied to bpf/bpf.git (master)
by Alexei Starovoitov <[email protected]>:
Quoted 11 lines · On Tue, 16 Jun 2026 02:14:54 -0400 you wrote:
As of recently, Clang is able to attach 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
__arenarbtree_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 tobtf_check_modifier_chain_lengthto reflect this.[...]
Here is the summary with links:
- [bpf-next,v2] bpf: Allow type tag BTF records to succeed other modifier records
https://git.kernel.org/bpf/bpf/c/39799c63578e
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html