bpf: extract bpf_ctx_convert_map logic and make it more reusable

Refactor btf_get_prog_ctx_type() a bit to allow reuse of
bpf_ctx_convert_map logic in more than one places. Simplify interface by
returning btf_type instead of btf_member (field reference in BTF).

To do the above we need to touch and start untangling
btf_translate_to_vmlinux() implementation. We do the bare minimum to
not regress anything for btf_translate_to_vmlinux(), but its
implementation is very questionable for what it claims to be doing.
Mapping kfunc argument types to kernel corresponding types conceptually
is quite different from recognizing program context types. Fixing this
is out of scope for this change though.

Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/r/20240118033143.3384355-3-andrii@kernel.org
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/include/linux/btf.h b/include/linux/btf.h
index 59d404e22814e885ae8429a361f2f43bed3b8f30..cf5c6ff489812e1cabe102f89a69c561319f6e99 100644 (file)
--- a/include/linux/btf.h
+++ b/include/linux/btf.h
@@ -512,7 +512,7 @@ s32 btf_find_dtor_kfunc(struct btf *btf, u32 btf_id);
 int register_btf_id_dtor_kfuncs(const struct btf_id_dtor_kfunc *dtors, u32 add_cnt,
                                struct module *owner);
 struct btf_struct_meta *btf_find_struct_meta(const struct btf *btf, u32 btf_id);
-const struct btf_member *
+const struct btf_type *
 btf_get_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,
                      const struct btf_type *t, enum bpf_prog_type prog_type,
                      int arg);

diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index 51e8b4bee0c8323b42cdee3c29cdaca00bbb95aa..10ac9efc662d0493afddbb74cde18cd307ee20c3 100644 (file)
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -5615,21 +5615,46 @@ static u8 bpf_ctx_convert_map[] = {
 #undef BPF_MAP_TYPE
 #undef BPF_LINK_TYPE
 
-const struct btf_member *
-btf_get_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,
-                     const struct btf_type *t, enum bpf_prog_type prog_type,
-                     int arg)
+static const struct btf_type *find_canonical_prog_ctx_type(enum bpf_prog_type prog_type)
 {
        const struct btf_type *conv_struct;
-       const struct btf_type *ctx_struct;
        const struct btf_member *ctx_type;
-       const char *tname, *ctx_tname;
 
        conv_struct = bpf_ctx_convert.t;
-       if (!conv_struct) {
-               bpf_log(log, "btf_vmlinux is malformed\n");
+       if (!conv_struct)
                return NULL;
-       }
+       /* prog_type is valid bpf program type. No need for bounds check. */
+       ctx_type = btf_type_member(conv_struct) + bpf_ctx_convert_map[prog_type] * 2;
+       /* ctx_type is a pointer to prog_ctx_type in vmlinux.
+        * Like 'struct __sk_buff'
+        */
+       return btf_type_by_id(btf_vmlinux, ctx_type->type);
+}
+
+static int find_kern_ctx_type_id(enum bpf_prog_type prog_type)
+{
+       const struct btf_type *conv_struct;
+       const struct btf_member *ctx_type;
+
+       conv_struct = bpf_ctx_convert.t;
+       if (!conv_struct)
+               return -EFAULT;
+       /* prog_type is valid bpf program type. No need for bounds check. */
+       ctx_type = btf_type_member(conv_struct) + bpf_ctx_convert_map[prog_type] * 2 + 1;
+       /* ctx_type is a pointer to prog_ctx_type in vmlinux.
+        * Like 'struct sk_buff'
+        */
+       return ctx_type->type;
+}
+
+const struct btf_type *
+btf_get_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,
+                     const struct btf_type *t, enum bpf_prog_type prog_type,
+                     int arg)
+{
+       const struct btf_type *ctx_type;
+       const char *tname, *ctx_tname;
+
        t = btf_type_by_id(btf, t->type);
        while (btf_type_is_modifier(t))
                t = btf_type_by_id(btf, t->type);
@@ -5646,17 +5671,15 @@ btf_get_prog_ctx_type(struct bpf_verifier_log *log, const struct btf *btf,
                bpf_log(log, "arg#%d struct doesn't have a name\n", arg);
                return NULL;
        }
-       /* prog_type is valid bpf program type. No need for bounds check. */
-       ctx_type = btf_type_member(conv_struct) + bpf_ctx_convert_map[prog_type] * 2;
-       /* ctx_struct is a pointer to prog_ctx_type in vmlinux.
-        * Like 'struct __sk_buff'
-        */
-       ctx_struct = btf_type_by_id(btf_vmlinux, ctx_type->type);
-       if (!ctx_struct)
+
+       ctx_type = find_canonical_prog_ctx_type(prog_type);
+       if (!ctx_type) {
+               bpf_log(log, "btf_vmlinux is malformed\n");
                /* should not happen */
                return NULL;
+       }
 again:
-       ctx_tname = btf_name_by_offset(btf_vmlinux, ctx_struct->name_off);
+       ctx_tname = btf_name_by_offset(btf_vmlinux, ctx_type->name_off);
        if (!ctx_tname) {
                /* should not happen */
                bpf_log(log, "Please fix kernel include/linux/bpf_types.h\n");
@@ -5677,10 +5700,10 @@ again:
                /* bpf_user_pt_regs_t is a typedef, so resolve it to
                 * underlying struct and check name again
                 */
-               if (!btf_type_is_modifier(ctx_struct))
+               if (!btf_type_is_modifier(ctx_type))
                        return NULL;
-               while (btf_type_is_modifier(ctx_struct))
-                       ctx_struct = btf_type_by_id(btf_vmlinux, ctx_struct->type);
+               while (btf_type_is_modifier(ctx_type))
+                       ctx_type = btf_type_by_id(btf_vmlinux, ctx_type->type);
                goto again;
        }
        return ctx_type;
@@ -5692,13 +5715,9 @@ static int btf_translate_to_vmlinux(struct bpf_verifier_log *log,
                                     enum bpf_prog_type prog_type,
                                     int arg)
 {
-       const struct btf_member *prog_ctx_type, *kern_ctx_type;
-
-       prog_ctx_type = btf_get_prog_ctx_type(log, btf, t, prog_type, arg);
-       if (!prog_ctx_type)
+       if (!btf_get_prog_ctx_type(log, btf, t, prog_type, arg))
                return -ENOENT;
-       kern_ctx_type = prog_ctx_type + 1;
-       return kern_ctx_type->type;
+       return find_kern_ctx_type_id(prog_type);
 }
 
 int get_kern_ctx_btf_id(struct bpf_verifier_log *log, enum bpf_prog_type prog_type)