Re: [PATCH bpf-next v2 1/2] bpf: Verify global subprogs in each sleepability context

[sashiko-bot@kernel.org]

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:

Pre-existing issues:
- [High] Global subprograms can bypass caller lock and reference balancing by using bpf_tail_call(), leading to permanent resource leaks.
--

commit abbef478df8567a76eb64989bbf7f08c717afd13
Author: Kumar Kartikeya Dwivedi <memxor@gmail.com>

bpf: Verify global subprogs in each sleepability context

This commit updates global subprogram verification to independently verify
each context (sleepable and non-sleepable) that calls it. This prevents
non-sleepable callbacks from incorrectly treating the context as sleepable
and allowing RCU-protected pointer misuse.

> diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
> index 5b51e7ee1a3f9..f759a020c8a5a 100644
> --- a/kernel/bpf/verifier.c
> +++ b/kernel/bpf/verifier.c
> @@ -9988,11 +9989,10 @@ static int check_func_call(struct bpf_verifier_env *env, struct bpf_insn *insn,
>  		if (env->log.level & BPF_LOG_LEVEL)
>  			verbose(env, "Func#%d ('%s') is global and assumed valid.\n",
>  				subprog, sub_name);
> +		sub_aux->called[in_sleepable_context(env)] = true;

[Severity: High]
This is a pre-existing issue, but while reviewing the global subprogram
execution context changes here, I noticed a potential resource leak
related to tail calls.

When a global subprogram is verified independently with a fresh verifier
root in do_check_common():

kernel/bpf/verifier.c:do_check_common() {
        ...
        state = kzalloc_obj(struct bpf_verifier_state, GFP_KERNEL_ACCOUNT);
        ...
}

The new state starts with zero locks and references. If the global
subprogram executes a bpf_tail_call(), check_resource_leak() inside the
subprogram's verification will succeed.

However, back in the caller's context in check_func_call(), the verifier
seems to evaluate the call assuming it will return normally:

kernel/bpf/verifier.c:check_func_call() {
        if (bpf_subprog_is_global(env, subprog)) {
                ...
                if (env->subprog_info[subprog].might_throw) {
                        branch = push_stack(...);
                        return process_bpf_exit_full(env, NULL, true);
                }
                /* continue with next insn after call */
                return 0;
        }
}

The caller check correctly handles divergence for might_throw, but
appears to silently ignore has_tail_call for global subprograms. If a
user program acquires a resource (e.g. bpf_rcu_read_lock) and then
calls a global subprogram that performs a tail call, does this bypass
the caller's resource cleanup and validations, permanently leaking the
resource?

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20260905051224.2325381-1-memxor@gmail.com?part=1