bpf: prepare btf_prepare_func_args() for handling static subprogs

Generalize btf_prepare_func_args() to support both global and static
subprogs. We are going to utilize this property in the next patch,
reusing btf_prepare_func_args() for subprog call logic instead of
reparsing BTF information in a completely separate implementation.

btf_prepare_func_args() now detects whether subprog is global or static
makes slight logic adjustments for static func cases, like not failing
fatally (-EFAULT) for conditions that are allowable for static subprogs.

Somewhat subtle (but major!) difference is the handling of pointer arguments.
Both global and static functions need to handle special context
arguments (which are pointers to predefined type names), but static
subprogs give up on any other pointers, falling back to marking subprog
as "unreliable", disabling the use of BTF type information altogether.

For global functions, though, we are assuming that such pointers to
unrecognized types are just pointers to fixed-sized memory region (or
error out if size cannot be established, like for `void *` pointers).

This patch accommodates these small differences and sets up a stage for
refactoring in the next patch, eliminating a separate BTF-based parsing
logic in btf_check_func_arg_match().

Acked-by: Eduard Zingerman <eddyz87@gmail.com>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/r/20231215011334.2307144-4-andrii@kernel.org
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h
index 5742e9c0a7b866a53183d67e45e4c6eb5778ef9e..d3ea9ef0476777db6289a9239ec7cbf6e592c47e 100644 (file)
--- a/include/linux/bpf_verifier.h
+++ b/include/linux/bpf_verifier.h
@@ -738,6 +738,11 @@ struct bpf_verifier_env {
        char tmp_str_buf[TMP_STR_BUF_LEN];
 };
 
+static inline struct bpf_func_info_aux *subprog_aux(struct bpf_verifier_env *env, int subprog)
+{
+       return &env->prog->aux->func_info_aux[subprog];
+}
+
 static inline struct bpf_subprog_info *subprog_info(struct bpf_verifier_env *env, int subprog)
 {
        return &env->subprog_info[subprog];

diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index 33d9a1c73f6e1ece67f0ec7717cb3dcab3d6a295..d321340e16f1a6366acd0173873a88a2441a4b66 100644 (file)
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -6914,6 +6914,7 @@ int btf_check_subprog_call(struct bpf_verifier_env *env, int subprog,
  */
 int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog)
 {
+       bool is_global = subprog_aux(env, subprog)->linkage == BTF_FUNC_GLOBAL;
        struct bpf_subprog_info *sub = subprog_info(env, subprog);
        struct bpf_verifier_log *log = &env->log;
        struct bpf_prog *prog = env->prog;
@@ -6927,14 +6928,15 @@ int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog)
        if (sub->args_cached)
                return 0;
 
-       if (!prog->aux->func_info ||
-           prog->aux->func_info_aux[subprog].linkage != BTF_FUNC_GLOBAL) {
+       if (!prog->aux->func_info) {
                bpf_log(log, "Verifier bug\n");
                return -EFAULT;
        }
 
        btf_id = prog->aux->func_info[subprog].type_id;
        if (!btf_id) {
+               if (!is_global) /* not fatal for static funcs */
+                       return -EINVAL;
                bpf_log(log, "Global functions need valid BTF\n");
                return -EFAULT;
        }
@@ -6990,16 +6992,14 @@ int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog)
                        sub->args[i].arg_type = ARG_ANYTHING;
                        continue;
                }
-               if (btf_type_is_ptr(t)) {
+               if (btf_type_is_ptr(t) && btf_get_prog_ctx_type(log, btf, t, prog_type, i)) {
+                       sub->args[i].arg_type = ARG_PTR_TO_CTX;
+                       continue;
+               }
+               if (is_global && btf_type_is_ptr(t)) {
                        u32 mem_size;
 
-                       if (btf_get_prog_ctx_type(log, btf, t, prog_type, i)) {
-                               sub->args[i].arg_type = ARG_PTR_TO_CTX;
-                               continue;
-                       }
-
                        t = btf_type_skip_modifiers(btf, t->type, NULL);
-
                        ref_t = btf_resolve_size(btf, t, &mem_size);
                        if (IS_ERR(ref_t)) {
                                bpf_log(log,

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index c26e9ab5226c7658059df4002cdec952f3b03991..6c9ecb86a8d9788ba762244a80f237c8cd2d6bcf 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -437,11 +437,6 @@ static const char *subprog_name(const struct bpf_verifier_env *env, int subprog)
        return btf_type_name(env->prog->aux->btf, info->type_id);
 }
 
-static struct bpf_func_info_aux *subprog_aux(const struct bpf_verifier_env *env, int subprog)
-{
-       return &env->prog->aux->func_info_aux[subprog];
-}
-
 static void mark_subprog_exc_cb(struct bpf_verifier_env *env, int subprog)
 {
        struct bpf_subprog_info *info = subprog_info(env, subprog);