bpf: Consolidate sleepable checks in check_helper_call()
PATCH 1/2 bpf: Consolidate sleepable checks in check_helper_call()
check_helper_call() prints the error message for every env->cur_state->active* element when calling a sleepable helper. Consolidate all of them into a single print statement.
The check for env->cur_state->active_locks was not part of the removed print statements and will not be triggered with the consolidated print as well because it is checked in do_check() before check_helper_call() is even reached.
--- kernel/bpf/verifier.c | 40 ++++++++++++++++++---------------------- 1 file changed, 18 insertions(+), 22 deletions(-)
kernel/bpf/verifier.c +18 -22
@@ -11549,6 +11549,19 @@ static inline bool in_sleepable_context(struct bpf_verifier_env *env)in_sleepable (env); } +static const char *non_sleepable_context_description (struct bpf_verifier_env *env) +{ +if (env->cur_state->active_rcu_locks) +return "rcu_read_lock region" ; +if (env->cur_state->active_preempt_locks) +return "non-preemptible region" ; +if (env->cur_state->active_irq_id) +return "IRQ-disabled region" ; +if (env->cur_state->active_locks) +return "lock region" ; +return "non-sleepable context" ; +} +static int check_helper_call (struct bpf_verifier_env *env,struct bpf_insn *insn,int *insn_idx_p) {
@@ -11609,28 +11622,11 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insnreturn err; } -if (env->cur_state->active_rcu_locks) { -if (fn->might_sleep) { -verbose (env,"sleepable helper %s#%d in rcu_read_lock region\n" , -func_id_name (func_id), func_id); -return -EINVAL ; - } - } - -if (env->cur_state->active_preempt_locks) { -if (fn->might_sleep) { -verbose (env,"sleepable helper %s#%d in non-preemptible region\n" , -func_id_name (func_id), func_id); -return -EINVAL ; - } - } - -if (env->cur_state->active_irq_id) { -if (fn->might_sleep) { -verbose (env,"sleepable helper %s#%d in IRQ-disabled region\n" , -func_id_name (func_id), func_id); -return -EINVAL ; - } +if (fn->might_sleep && !in_sleepable_context (env)) { +verbose (env,"sleepable helper %s#%d in %s\n" , +func_id_name (func_id), func_id, +non_sleepable_context_description (env)); +return -EINVAL ; }/* Track non-sleepable context for helpers. */
base-commit: f620af11c27b8ec9994a39fe968aa778112d1566
Signature · 1 line
2.47.3
PATCH 2/2 bpf: Consolidate sleepable checks in check_kfunc_call()
check_kfunc_call() has multiple scattered checks that reject sleepable kfuncs in various non-sleepable contexts (RCU, preempt-disabled, IRQ- disabled). These are the same conditions already checked by in_sleepable_context(), so replace them with a single consolidated check.
This also simplifies the preempt lock tracking by flattening the nested if/else structure into a linear chain: preempt_disable increments, preempt_enable checks for underflow and decrements, and the sleepable check uses in_sleepable_context() which covers all non-sleepable contexts uniformly.
No functional change since in_sleepable_context() checks all the same state (active_rcu_locks, active_preempt_locks, active_locks, active_irq_id, in_sleepable).
--- kernel/bpf/verifier.c | 35 ++++++++++++----------------------- 1 file changed, 12 insertions(+), 23 deletions(-)
kernel/bpf/verifier.c +12 -23
@@ -14153,34 +14153,23 @@ static int check_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn, } })); } - }else if (sleepable && env->cur_state->active_rcu_locks) { -verbose (env,"kernel func %s is sleepable within rcu_read_lock region\n" , func_name); -return -EACCES ; - } - -if (in_rbtree_lock_required_cb (env) && (rcu_lock || rcu_unlock)) { -verbose (env,"Calling bpf_rcu_read_{lock,unlock} in unnecessary rbtree callback\n" ); -return -EACCES ; - } - -if (env->cur_state->active_preempt_locks) { -if (preempt_disable) { - env->cur_state->active_preempt_locks++; - }else if (preempt_enable) { - env->cur_state->active_preempt_locks--; - }else if (sleepable) { -verbose (env,"kernel func %s is sleepable within non-preemptible region\n" , func_name); -return -EACCES ; - } }else if (preempt_disable) { env->cur_state->active_preempt_locks++; }else if (preempt_enable) { -verbose (env,"unmatched attempt to enable preemption (kernel function %s)\n" , func_name); -return -EINVAL ; +if (env->cur_state->active_preempt_locks ==0 ) { +verbose (env,"unmatched attempt to enable preemption (kernel function %s)\n" , + func_name); +return -EINVAL ; + } + env->cur_state->active_preempt_locks--; + }else if (sleepable && !in_sleepable_context (env)) { +verbose (env,"kernel func %s is sleepable within %s\n" , + func_name,non_sleepable_context_description (env)); +return -EACCES ; } -if (env->cur_state->active_irq_id && sleepable) { -verbose (env,"kernel func %s is sleepable within IRQ-disabled region\n" , func_name); +if (in_rbtree_lock_required_cb (env) && (rcu_lock || rcu_unlock)) { +verbose (env,"Calling bpf_rcu_read_{lock,unlock} in unnecessary rbtree callback\n" );return -EACCES ; }
Signature · 1 line
2.47.3
Re: [PATCH bpf-next 2/2] bpf: Consolidate sleepable checks in check_kfunc_call()
Quoted 50 lines · Puranjay Mohan
check_kfunc_call()has multiple scattered checks that reject sleepable kfuncs in various non-sleepable contexts (RCU, preempt-disabled, IRQ- disabled). These are the same conditions already checked byin_sleepable_context(), so replace them with a single consolidated check.This also simplifies the preempt lock tracking by flattening the nested if/else structure into a linear chain:
preempt_disableincrements,preempt_enablechecks for underflow and decrements, and the sleepable check usesin_sleepable_context()which covers all non-sleepable contexts uniformly.No functional change since
in_sleepable_context()checks all the same state (active_rcu_locks,active_preempt_locks,active_locks,active_irq_id,in_sleepable).Signed-off-by Puranjay Mohan <[email protected]>--- kernel/bpf/verifier.c | 35 ++++++++++++----------------------- 1 file changed, 12 insertions(+), 23 deletions(-)kernel/bpf/verifier.c +0
-19@@ -14153,34 +14153,23 @@ static int check_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn, } })); } - }else if (sleepable && env->cur_state->active_rcu_locks) { -verbose (env,"kernel func %s is sleepable within rcu_read_lock region\n" , func_name); -return -EACCES ; - } - -if (in_rbtree_lock_required_cb (env) && (rcu_lock || rcu_unlock)) { -verbose (env,"Calling bpf_rcu_read_{lock,unlock} in unnecessary rbtree callback\n" ); -return -EACCES ; - } - -if (env->cur_state->active_preempt_locks) { -if (preempt_disable) { - env->cur_state->active_preempt_locks++; - }else if (preempt_enable) { - env->cur_state->active_preempt_locks--; - }else if (sleepable) { -verbose (env,"kernel func %s is sleepable within non-preemptible region\n" , func_name); -return -EACCES ; - } }else if (preempt_disable) { env->cur_state->active_preempt_locks++;
kernel/bpf/verifier.c static int check_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn, · line 14165
Quoted 10 lines
kernel/bpf/verifier.c +7
-2}else if (preempt_enable) { -verbose (env,"unmatched attempt to enable preemption (kernel function %s)\n" , func_name); -return -EINVAL ; +if (env->cur_state->active_preempt_locks ==0 ) { +verbose (env,"unmatched attempt to enable preemption (kernel function %s)\n" , + func_name); +return -EINVAL ; + } + env->cur_state->active_preempt_locks--; + }else if (sleepable && !in_sleepable_context (env)) {
nit: it may be a little bit more readable if we put this check separately, not in else if, so we get the next structure:
```
if (rcu_lock) {
} else if (rcu_unlock) {
} else if (preempt_disable) {
} else if (preempt_enable) {
}
if (sleepable && !in_sleepable_context(env)) {
}
```the motivation is that logically this looks separated from the active_*_lock accounting.
Overall the change looks like an improvement.
Quoted 14 lines
kernel/bpf/verifier.c +5
-2+verbose (env,"kernel func %s is sleepable within %s\n" , + func_name,non_sleepable_context_description (env)); +return -EACCES ; } -if (env->cur_state->active_irq_id && sleepable) { -verbose (env,"kernel func %s is sleepable within IRQ-disabled region\n" , func_name); +if (in_rbtree_lock_required_cb (env) && (rcu_lock || rcu_unlock)) { +verbose (env,"Calling bpf_rcu_read_{lock,unlock} in unnecessary rbtree callback\n" );return -EACCES ; }Signature · 1 line
2.47.3
Re: [PATCH bpf-next 2/2] bpf: Consolidate sleepable checks in check_kfunc_call()
In reply to Puranjay MohanQuoted 12 lines · Puranjay Mohan
check_kfunc_call()has multiple scattered checks that reject sleepable kfuncs in various non-sleepable contexts (RCU, preempt-disabled, IRQ- disabled). These are the same conditions already checked byin_sleepable_context(), so replace them with a single consolidated check.This also simplifies the preempt lock tracking by flattening the nested if/else structure into a linear chain:
preempt_disableincrements,preempt_enablechecks for underflow and decrements, and the sleepable check usesin_sleepable_context()which covers all non-sleepable contexts uniformly.
Quoted 6 lines
No functional change since
in_sleepable_context()checks all the same state (active_rcu_locks,active_preempt_locks,active_locks,active_irq_id,in_sleepable).Signed-off-by Puranjay Mohan <[email protected]>---
[...]
Quoted 11 lines · Puranjay Mohan
check_helper_call()prints the error message for every env->cur_state->active* element when calling a sleepable helper. Consolidate all of them into a single print statement.The check for
env->cur_state->active_lockswas not part of the removed print statements and will not be triggered with the consolidated print as well because it is checked indo_check()beforecheck_helper_call()is even reached.Signed-off-by Puranjay Mohan <[email protected]>---
Quoted 65 lines
kernel/bpf/verifier.c | 40 ++++++++++++++++++---------------------- 1 file changed, 18 insertions(+), 22 deletions(-)kernel/bpf/verifier.c +18
-22@@ -11549,6 +11549,19 @@ static inline bool in_sleepable_context(struct bpf_verifier_env *env)in_sleepable (env); } +static const char *non_sleepable_context_description (struct bpf_verifier_env *env) +{ +if (env->cur_state->active_rcu_locks) +return "rcu_read_lock region" ; +if (env->cur_state->active_preempt_locks) +return "non-preemptible region" ; +if (env->cur_state->active_irq_id) +return "IRQ-disabled region" ; +if (env->cur_state->active_locks) +return "lock region" ; +return "non-sleepable context" ; +} +static int check_helper_call (struct bpf_verifier_env *env,struct bpf_insn *insn,int *insn_idx_p) {@@ -11609,28 +11622,11 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insnreturn err; } -if (env->cur_state->active_rcu_locks) { -if (fn->might_sleep) { -verbose (env,"sleepable helper %s#%d in rcu_read_lock region\n" , -func_id_name (func_id), func_id); -return -EINVAL ; - } - } - -if (env->cur_state->active_preempt_locks) { -if (fn->might_sleep) { -verbose (env,"sleepable helper %s#%d in non-preemptible region\n" , -func_id_name (func_id), func_id); -return -EINVAL ; - } - } - -if (env->cur_state->active_irq_id) { -if (fn->might_sleep) { -verbose (env,"sleepable helper %s#%d in IRQ-disabled region\n" , -func_id_name (func_id), func_id); -return -EINVAL ; - } +if (fn->might_sleep && !in_sleepable_context (env)) { +verbose (env,"sleepable helper %s#%d in %s\n" , +func_id_name (func_id), func_id, +non_sleepable_context_description (env)); +return -EINVAL ; }/* Track non-sleepable context for helpers. */ base-commit:
f620af11c27b8ec9994a39fe968aa778112d1566Signature · 1 line
2.47.3
Eduard Zingerman
maintainerOn Wed, 2026-02-25 at 05:49 -0800, Puranjay Mohan wrote:
[...]
Quoted 22 lines
kernel/bpf/verifier.c +0
-0@@ -11609,28 +11622,11 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn return err; }kernel/bpf/verifier.c +0
-17-if (env->cur_state->active_rcu_locks) { -if (fn->might_sleep) { -verbose (env,"sleepable helper %s#%d in rcu_read_lock region\n" , -func_id_name (func_id), func_id); -return -EINVAL ; - } - } - -if (env->cur_state->active_preempt_locks) { -if (fn->might_sleep) { -verbose (env,"sleepable helper %s#%d in non-preemptible region\n" , -func_id_name (func_id), func_id); -return -EINVAL ; - } - } - -if (env->cur_state->active_irq_id) {
kernel/bpf/verifier.c static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn · line 11629
Quoted 10 lines
kernel/bpf/verifier.c +5
-5-if (fn->might_sleep) { -verbose (env,"sleepable helper %s#%d in IRQ-disabled region\n" , -func_id_name (func_id), func_id); -return -EINVAL ; - } +if (fn->might_sleep && !in_sleepable_context (env)) { +verbose (env,"sleepable helper %s#%d in %s\n" , +func_id_name (func_id), func_id, +non_sleepable_context_description (env)); +return -EINVAL ;
A few checks above there is:
if (!in_sleepable(env) && fn->might_sleep) {
verbose(env, "helper call might sleep in a non-sleepable prog\n");
return -EINVAL;
}'fn->might_sleep && !in_sleepable_context(env)' covers this case, do we want to remove it as well?