[PATCH bpf 2/7] bpf/x86: prevent trampoline attachment when args location on stack is uncertain

[eBPF Foundation]

When the target function receives more arguments than available
registers, the additional arguments are passed on stack, and so the
generated trampoline needs to read those to prepare the bpf context,
but also to prepare the target function stack when it is in charge of
calling it. This works well for scalar types, but if the value is a
struct, we can not know for sure the exact struct location, as it may
have been packed or manually aligned to a greater value.

Prevent wrong readings by refusing trampoline attachment if the target
function receives a struct on stack. While at it, move the max bpf args
check in the new function.

Fixes: 473e3150e30a ("bpf, x86: allow function arguments up to 12 for TRACING")
Signed-off-by: Alexis Lothoré (eBPF Foundation) <alexis.loth...@bootlin.com>
---
 arch/x86/net/bpf_jit_comp.c | 36 ++++++++++++++++++++++++++++++------
 1 file changed, 30 insertions(+), 6 deletions(-)

diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c
index 
9689834de1bb1a90fdc28156e0e2a56ac0ff2076..120e05a978679c046631cc94d942800c3051ad0a
 100644
--- a/arch/x86/net/bpf_jit_comp.c
+++ b/arch/x86/net/bpf_jit_comp.c
@@ -3001,6 +3001,29 @@ static int invoke_bpf_mod_ret(const struct 
btf_func_model *m, u8 **pprog,
        return 0;
 }
 
+static int validate_args(const struct btf_func_model *m)
+{
+       int i, arg_regs = 0, nr_regs = 0;
+
+       for (i = 0; i < min_t(int, m->nr_args, MAX_BPF_FUNC_ARGS); i++) {
+               arg_regs = (m->arg_size[i] + 7) / 8;
+
+               if (nr_regs + arg_regs > MAX_REGS_FOR_ARGS &&
+                   m->arg_flags[i] & BTF_FMODEL_STRUCT_ARG)
+                       return -ENOTSUPP;
+               nr_regs += arg_regs;
+       }
+
+       /* x86-64 supports up to MAX_BPF_FUNC_ARGS arguments. 1-6
+        * are passed through regs, the remains are through stack.
+        */
+       if (nr_regs > MAX_BPF_FUNC_ARGS)
+               return -ENOTSUPP;
+
+
+       return 0;
+}
+
 /* mov rax, qword ptr [rbp - rounded_stack_depth - 8] */
 #define LOAD_TRAMP_TAIL_CALL_CNT_PTR(stack)    \
        __LOAD_TCC_PTR(-round_up(stack, 8) - 8)
@@ -3089,18 +3112,19 @@ static int __arch_prepare_bpf_trampoline(struct 
bpf_tramp_image *im, void *rw_im
        WARN_ON_ONCE((flags & BPF_TRAMP_F_INDIRECT) &&
                     (flags & ~(BPF_TRAMP_F_INDIRECT | 
BPF_TRAMP_F_RET_FENTRY_RET)));
 
+       /* make sure that any argument can be located and processed by the
+        * trampoline
+        */
+       ret = validate_args(m);
+       if (ret)
+               return ret;
+
        /* extra registers for struct arguments */
        for (i = 0; i < m->nr_args; i++) {
                if (m->arg_flags[i] & BTF_FMODEL_STRUCT_ARG)
                        nr_regs += (m->arg_size[i] + 7) / 8 - 1;
        }
 
-       /* x86-64 supports up to MAX_BPF_FUNC_ARGS arguments. 1-6
-        * are passed through regs, the remains are through stack.
-        */
-       if (nr_regs > MAX_BPF_FUNC_ARGS)
-               return -ENOTSUPP;
-
        /* Generated trampoline stack layout:
         *
         * RBP + 8         [ return address  ]

-- 
2.49.0