* [PATCH bpf-next 0/2] bpf: The register of an implicit kfunc argument is not live
@ 2026-11-01 17:44 Alexei Starovoitov
2026-11-01 17:44 ` [PATCH bpf-next 1/2] " Alexei Starovoitov
` (2 more replies)
0 siblings, 3 replies; 6+ messages in thread
From: Alexei Starovoitov @ 2026-11-01 17:44 UTC (permalink / raw)
To: bpf; +Cc: daniel, andrii, eddyz87, memxor
From: Alexei Starovoitov <ast@kernel.org>
The verifier fills in the last arguments of a kfunc that has
KF_IMPLICIT_ARGS, for example 'aux' of almost all scx_bpf_*() kfuncs. The
prog does not pass them. But the analysis of live registers counts their
registers as read by the call. Such a register is live from the previous
call to this one. Scalar evolution has no formula for it and gives up on
the loop, and the verifier compares it when it looks for an equal state.
Patch 1 does not count these registers as used. Patch 2 has the tests.
veristat, progs that load before (A) and after (B):
progs of progs that change insns
--------------------- ----- ----------- -------
sched-ext/scx 493 26 -10.52%
scx, as BPF CI has it 428 26 -18.87%
tools/sched_ext 240 6 -0.08%
selftests 3891 52 -0.32%
36 builds of Cilium 5029 0
No verdict changes. Progs of sched-ext/scx that change by more than 4%, and
the progs that need more insns:
Program Insns (A) Insns (B) Insns (DIFF)
--------------------- --------- --------- -----------------
lavd_dispatch 281049 5589 -275460 (-98.01%)
pandemonium_init 341 95 -246 (-72.14%)
arena_selftest_rbtree 140933 95177 -45756 (-32.47%)
arena_selftest_atq 171003 125246 -45757 (-26.76%)
p2dq_select_cpu 1179 1074 -105 (-8.91%)
chaos_select_cpu 1194 1089 -105 (-8.79%)
beerland_dispatch 551 515 -36 (-6.53%)
layered_running 1693 1590 -103 (-6.08%)
p2dq_update_idle 622 590 -32 (-5.14%)
mlfq_select_cpu 7227 6929 -298 (-4.12%)
mlfq_enqueue 3889 3893 +4 (+0.10%)
flow_enqueue 219201 219547 +346 (+0.16%)
lavd_enqueue 174292 176453 +2161 (+1.24%)
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Alexei Starovoitov (2):
bpf: The register of an implicit kfunc argument is not live
selftests/bpf: Test liveness of an implicit kfunc argument
include/linux/bpf_verifier.h | 2 +
kernel/bpf/liveness.c | 3 +-
kernel/bpf/verifier.c | 9 +++
.../bpf/progs/compute_live_registers.c | 13 +++++
.../selftests/bpf/progs/kfunc_implicit_args.c | 55 +++++++++++++++++++
.../selftests/bpf/progs/verifier_scev.c | 33 +++++++++++
6 files changed, 114 insertions(+), 1 deletion(-)
base-commit: a30c772627b2ef4bc715332b1b04938a914556cd
--
2.55.0
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH bpf-next 1/2] bpf: The register of an implicit kfunc argument is not live
2026-11-01 17:44 [PATCH bpf-next 0/2] bpf: The register of an implicit kfunc argument is not live Alexei Starovoitov
@ 2026-11-01 17:44 ` Alexei Starovoitov
2026-11-01 17:44 ` [PATCH bpf-next 2/2] selftests/bpf: Test liveness of an implicit kfunc argument Alexei Starovoitov
2026-11-03 18:40 ` [PATCH bpf-next 0/2] bpf: The register of an implicit kfunc argument is not live patchwork-bot+netdevbpf
2 siblings, 0 replies; 6+ messages in thread
From: Alexei Starovoitov @ 2026-11-01 17:44 UTC (permalink / raw)
To: bpf; +Cc: daniel, andrii, eddyz87, memxor
From: Alexei Starovoitov <ast@kernel.org>
The verifier fills in the last arguments of a kfunc that has
KF_IMPLICIT_ARGS. The prog does not pass them:
bpf_stream_vprintk(stream_id, fmt, args, len) the prog calls
bpf_stream_vprintk(stream_id, fmt, args, len, aux) the kernel has
The prog sets r1-r4. The verifier adds 'r5 = aux' in front of the call.
bpf_compute_live_registers() counts the arguments of the second prototype.
Thus r5 is live before the call, and up to the previous insn that writes to
r5. In a loop that is the same call in the previous iteration: r5 is live
at the loop head, its value is what the call left in it, and it has no
formula. Scalar evolution gives up on a loop that has such a register. The
verifier also compares r5 when it looks for an equal state.
Let bpf_get_call_summary() tell how many of the last argument slots are
implicit, and do not count them as used.
Nothing reads r5 between the last write of the prog and 'r5 = aux':
check_func_arg() does not look at the register of such an argument, and a
jump to the call goes to the added insn. The call clobbers r5 as before.
Almost all scx_bpf_*() kfuncs have an implicit argument. So have
bpf_obj_new(), bpf_obj_drop(), bpf_list_push_*(), bpf_rbtree_add() and
bpf_stream_*().
Insns that the verifier processes:
progs progs that change insns
----------------------- ----------------- -------
scx, as BPF CI has it 26 of 466 -18.9 %
scx, master 26 of 563 -10.5 %
selftests 52 of 6329 -0.3 %
lavd_dispatch of scx_lavd goes from 281049 to 5589. No prog of Cilium
changes, no verdict changes. In each set of scx 3 progs get more insns, at
most 1.2 %: a path ends earlier, and that moves where later paths end.
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
---
include/linux/bpf_verifier.h | 2 ++
kernel/bpf/liveness.c | 3 ++-
kernel/bpf/verifier.c | 9 +++++++++
3 files changed, 13 insertions(+), 1 deletion(-)
diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h
index 7baeb831281f..c28f43d60900 100644
--- a/include/linux/bpf_verifier.h
+++ b/include/linux/bpf_verifier.h
@@ -1235,6 +1235,8 @@ static inline bool bpf_ret_reg_pair(struct bpf_verifier_env *env, int subprog)
struct bpf_call_summary {
u8 arg_slot_cnt;
+ /* the last of them are filled in by the verifier, the prog doesn't pass them */
+ u8 implicit_slot_cnt;
bool is_void;
bool fastcall;
};
diff --git a/kernel/bpf/liveness.c b/kernel/bpf/liveness.c
index e657e6d95408..215f839bd2fb 100644
--- a/kernel/bpf/liveness.c
+++ b/kernel/bpf/liveness.c
@@ -2621,7 +2621,8 @@ static void compute_insn_live_regs(struct bpf_verifier_env *env,
def = ALL_CALLER_SAVED_REGS;
use = def & ~BIT(BPF_REG_0);
if (bpf_get_call_summary(env, insn, &cs)) {
- use = GENMASK(min_t(u8, cs.arg_slot_cnt, MAX_BPF_FUNC_REG_ARGS), 1);
+ use = GENMASK(min_t(u8, cs.arg_slot_cnt - cs.implicit_slot_cnt,
+ MAX_BPF_FUNC_REG_ARGS), 1);
} else if (bpf_pseudo_call(insn)) {
/* a static callee's reads are added in bpf_compute_live_registers() */
subprog = callee_subprog(env, insn);
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 1b6c0674ff6a..8509e65889bd 100644
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -19687,6 +19687,7 @@ bool bpf_get_call_summary(struct bpf_verifier_env *env, struct bpf_insn *call,
bpf_jit_inlines_helper_call(call->imm));
cs->is_void = fn->ret_type == RET_VOID;
cs->arg_slot_cnt = 0;
+ cs->implicit_slot_cnt = 0;
for (i = 0; i < ARRAY_SIZE(fn->arg_type); ++i) {
if (fn->arg_type[i] == ARG_UNUSED)
break;
@@ -19703,6 +19704,14 @@ bool bpf_get_call_summary(struct bpf_verifier_env *env, struct bpf_insn *call,
/* error would be reported later */
return false;
cs->arg_slot_cnt = btf_proto_slots(meta.btf, meta.func_proto);
+ cs->implicit_slot_cnt = 0;
+ if (meta.kfunc_flags & KF_IMPLICIT_ARGS) {
+ const struct btf_type *func = btf_type_by_id(meta.btf, meta.func_id);
+
+ /* the prototype without implicit args, see is_kfunc_arg_implicit() */
+ cs->implicit_slot_cnt = cs->arg_slot_cnt -
+ btf_proto_slots(meta.btf, btf_type_by_id(meta.btf, func->type));
+ }
cs->fastcall = meta.kfunc_flags & KF_FASTCALL;
cs->is_void = btf_type_is_void(btf_type_by_id(meta.btf, meta.func_proto->type));
return true;
--
2.55.0
^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH bpf-next 2/2] selftests/bpf: Test liveness of an implicit kfunc argument
2026-11-01 17:44 [PATCH bpf-next 0/2] bpf: The register of an implicit kfunc argument is not live Alexei Starovoitov
2026-11-01 17:44 ` [PATCH bpf-next 1/2] " Alexei Starovoitov
@ 2026-11-01 17:44 ` Alexei Starovoitov
2026-11-01 18:31 ` bot+bpf-ci
2026-11-03 18:40 ` [PATCH bpf-next 0/2] bpf: The register of an implicit kfunc argument is not live patchwork-bot+netdevbpf
2 siblings, 1 reply; 6+ messages in thread
From: Alexei Starovoitov @ 2026-11-01 17:44 UTC (permalink / raw)
To: bpf; +Cc: daniel, andrii, eddyz87, memxor
From: Alexei Starovoitov <ast@kernel.org>
The register of an implicit argument is not live before the call:
kfunc live
------------------------------------ -----
bpf_stream_vprintk() r1-r4
bpf_kfunc_implicit_arg_legacy() r1-r2
bpf_kfunc_implicit_arg_legacy_impl() r1-r3
The last kfunc has no KF_IMPLICIT_ARGS: the prog passes all three
arguments.
kfunc_implicit_arg_in_a_loop calls bpf_stream_print_stack() 4 times. r2 is
its implicit argument. The test expects that the loop is counted and that
each live register has a formula.
Two more progs run. One jumps to the call, one has may_goto in front of the
call. The kfunc has to get aux in both.
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
---
.../bpf/progs/compute_live_registers.c | 13 +++++
.../selftests/bpf/progs/kfunc_implicit_args.c | 55 +++++++++++++++++++
.../selftests/bpf/progs/verifier_scev.c | 33 +++++++++++
3 files changed, 101 insertions(+)
diff --git a/tools/testing/selftests/bpf/progs/compute_live_registers.c b/tools/testing/selftests/bpf/progs/compute_live_registers.c
index 1ff24bbc7beb..de0496ce7d5e 100644
--- a/tools/testing/selftests/bpf/progs/compute_live_registers.c
+++ b/tools/testing/selftests/bpf/progs/compute_live_registers.c
@@ -538,6 +538,19 @@ void gotox(void)
#endif /* gotox: x86, arm64, riscv64 */
+extern int bpf_stream_vprintk(int stream_id, const char *fmt__str, const void *args,
+ __u32 len__sz) __weak __ksym;
+
+/* The verifier fills in the implicit argument of the kfunc. The prog does not pass r5. */
+SEC("syscall")
+__log_level(2)
+__msg(": .1234..... (85) call bpf_stream_vprintk")
+int kfunc_implicit_arg(void *ctx)
+{
+ bpf_stream_printk(1 /* BPF_STDOUT */, "x");
+ return 0;
+}
+
/* to retain debug info for BTF generation */
void kfunc_root(void)
{
diff --git a/tools/testing/selftests/bpf/progs/kfunc_implicit_args.c b/tools/testing/selftests/bpf/progs/kfunc_implicit_args.c
index 89b6a47e22dd..250fc0c7b355 100644
--- a/tools/testing/selftests/bpf/progs/kfunc_implicit_args.c
+++ b/tools/testing/selftests/bpf/progs/kfunc_implicit_args.c
@@ -27,15 +27,70 @@ int test_kfunc_implicit_arg_impl_illegal(void *ctx)
}
SEC("syscall")
+__log_level(2)
+__msg(": .12....... (85) call bpf_kfunc_implicit_arg_legacy#")
__retval(7)
int test_kfunc_implicit_arg_legacy(void *ctx)
{
return bpf_kfunc_implicit_arg_legacy(3, 4);
}
+/* The prog passes all three arguments of this kfunc. */
SEC("syscall")
+__log_level(2)
+__msg(": .123...... (85) call bpf_kfunc_implicit_arg_legacy_impl#")
__retval(11)
int test_kfunc_implicit_arg_legacy_impl(void *ctx)
{
return bpf_kfunc_implicit_arg_legacy_impl(5, 6, NULL);
}
+
+/*
+ * The verifier adds 'r2 = aux' in front of the call. A jump to the call has to
+ * execute the new insn: the kfunc returns -EINVAL when aux is NULL.
+ */
+SEC("syscall")
+__retval(5)
+__naked void implicit_arg_jump_to_call(void)
+{
+ asm volatile (
+ "call %[bpf_get_prandom_u32];"
+ "r1 = 5;"
+ "r2 = 0;"
+ "if r0 != 0 goto 1f;"
+ "r2 = 0;"
+"1:"
+ "call %[bpf_kfunc_implicit_arg];"
+ "exit;"
+ :
+ : __imm(bpf_get_prandom_u32),
+ __imm(bpf_kfunc_implicit_arg)
+ : __clobber_all);
+}
+
+/*
+ * r0 and r1 are live at may_goto, r2 is the first register that is not. The
+ * insns that the verifier adds for may_goto are free to use r2: 'r2 = aux'
+ * comes behind them.
+ */
+SEC("syscall")
+__retval(5)
+__naked void implicit_arg_after_may_goto(void)
+{
+ asm volatile (
+ "r6 = 1;"
+"1:"
+ "r0 = r6;"
+ "r1 = r6;"
+ "may_goto 2f;"
+ "call %[bpf_kfunc_implicit_arg];"
+ "if r0 != r6 goto 2f;"
+ "r6 += 1;"
+ "if r6 < 5 goto 1b;"
+ "r0 = r6;"
+"2:"
+ "exit;"
+ :
+ : __imm(bpf_kfunc_implicit_arg)
+ : __clobber_all);
+}
diff --git a/tools/testing/selftests/bpf/progs/verifier_scev.c b/tools/testing/selftests/bpf/progs/verifier_scev.c
index fa01a616af9d..bede3f48fe38 100644
--- a/tools/testing/selftests/bpf/progs/verifier_scev.c
+++ b/tools/testing/selftests/bpf/progs/verifier_scev.c
@@ -1411,6 +1411,39 @@ __naked void widened_reg_is_not_linked(void)
: __clobber_all);
}
+extern int bpf_stream_print_stack(int stream_id) __weak __ksym;
+
+/*
+ * The verifier fills in r2, the implicit argument of the kfunc. The call clobbers r2 and nothing
+ * sets it: if r2 is live at the head of the loop it has no formula.
+ */
+SEC("syscall")
+__success __retval(0)
+__log_level(2)
+__msg("loop header at 1, header_count is 4 ")
+__not_msg("can't widen")
+__naked void kfunc_implicit_arg_in_a_loop(void)
+{
+ asm volatile (
+ "r6 = 0;"
+"1:"
+ "r1 = 2;"
+ "call %[bpf_stream_print_stack];"
+ "r6 += 1;"
+ "if r6 < 4 goto 1b;"
+ "r0 = 0;"
+ "exit;"
+ :
+ : __imm(bpf_stream_print_stack)
+ : __clobber_all);
+}
+
+/* to retain debug info for BTF generation */
+void kfunc_root(void)
+{
+ bpf_stream_print_stack(0);
+}
+
/* The unknown SCEV of an unbound STACK_MISC slot must not prevent widening. */
SEC("tracepoint")
__success
--
2.55.0
^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH bpf-next 2/2] selftests/bpf: Test liveness of an implicit kfunc argument
2026-11-01 17:44 ` [PATCH bpf-next 2/2] selftests/bpf: Test liveness of an implicit kfunc argument Alexei Starovoitov
@ 2026-11-01 18:31 ` bot+bpf-ci
2026-11-02 17:37 ` Alexei Starovoitov
0 siblings, 1 reply; 6+ messages in thread
From: bot+bpf-ci @ 2026-11-01 18:31 UTC (permalink / raw)
To: alexei.starovoitov, bpf
Cc: daniel, andrii, eddyz87, memxor, ast, andrii, daniel, martin.lau,
eddyz87, yonghong.song, mason, ihor.solodrai
[-- Attachment #1: Type: text/plain, Size: 3330 bytes --]
> selftests/bpf: Test liveness of an implicit kfunc argument
TL;DR: The new selftest uses the may_goto mnemonic in inline asm without an
__BPF_FEATURE_MAY_GOTO guard, so older clang (e.g. 18) may fail to assemble it
and break the whole selftest build.
> diff --git a/tools/testing/selftests/bpf/progs/kfunc_implicit_args.c b/tools/testing/selftests/bpf/progs/kfunc_implicit_args.c
> --- a/tools/testing/selftests/bpf/progs/kfunc_implicit_args.c
> +++ b/tools/testing/selftests/bpf/progs/kfunc_implicit_args.c
[ ... ]
> +/*
> + * r0 and r1 are live at may_goto, r2 is the first register that is not. The
> + * insns that the verifier adds for may_goto are free to use r2: 'r2 = aux'
> + * comes behind them.
> + */
> +SEC("syscall")
> +__retval(5)
> +__naked void implicit_arg_after_may_goto(void)
> +{
> + asm volatile (
> + "r6 = 1;"
> +"1:"
> + "r0 = r6;"
> + "r1 = r6;"
> + "may_goto 2f;"
^^^^
Can this build with a clang that predates the BPF assembler support for the
may_goto mnemonic?
implicit_arg_after_may_goto() writes may_goto straight into the inline asm
with no guard. The LLVM BPF assembler learned the mnemonic after LLVM 18
was released, together with the __BPF_FEATURE_MAY_GOTO macro. Commit
965c6167c93f ("selftests/bpf: Using llvm may_goto inline asm for cond_break
macro") says "Using llvm may_goto insn is controlled by macro
__BPF_FEATURE_MAY_GOTO".
With an older clang, the asm fails to assemble, so kfunc_implicit_args.bpf.o
is not built. kfunc_implicit_args.skel.h is then missing, and test_progs
and its no_alu32 and cpuv4 flavors fail to build. That takes down the
whole BPF selftest build, not only this test.
This looks like the only unguarded use of the mnemonic under progs/. The
other users either guard it:
verifier_large_stack.c and verifier_stack_ptr.c:
#ifdef __BPF_FEATURE_MAY_GOTO
...
may_goto l0_%=;
or encode the instruction as raw bytes, as compute_live_registers.c and
verifier_may_goto_1.c do:
".8byte %[may_goto];"
...
__imm_insn(may_goto, BPF_RAW_INSN(BPF_JMP | BPF_JCOND, ...))
libarena/include/bpf_may_goto.h also falls back to ".byte 0xe5 ..." when
__BPF_FEATURE_MAY_GOTO is not defined.
The selftests still support pre-19 compilers on purpose: bpf_misc.h gates
features on __clang_major__ >= 18, and commit f7213961e8e2 gates on LLVM 23
and falls back to a dummy test. Ubuntu 24.04 ships clang 18 as its default.
The default LLVM version in .github/scripts/matrix.py is 21, so that
configuration would not exercise this.
Should implicit_arg_after_may_goto() be wrapped in #ifdef
__BPF_FEATURE_MAY_GOTO, as verifier_large_stack.c does? Alternatively,
could the instruction be encoded with .8byte and __imm_insn(), as
compute_live_registers.c does? For that option the file would need
BPF_RAW_INSN, since it includes vmlinux.h and not
../../../include/linux/filter.h.
> + "call %[bpf_kfunc_implicit_arg];"
> + "if r0 != r6 goto 2f;"
> + "r6 += 1;"
> + "if r6 < 5 goto 1b;"
> + "r0 = r6;"
> +"2:"
> + "exit;"
> + :
> + : __imm(bpf_kfunc_implicit_arg)
> + : __clobber_all);
> +}
---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
CI run summary: https://github.com/kernel-patches/bpf/actions/runs/41334428337
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH bpf-next 2/2] selftests/bpf: Test liveness of an implicit kfunc argument
2026-11-01 18:31 ` bot+bpf-ci
@ 2026-11-02 17:37 ` Alexei Starovoitov
0 siblings, 0 replies; 6+ messages in thread
From: Alexei Starovoitov @ 2026-11-02 17:37 UTC (permalink / raw)
To: bot+bpf-ci, bpf
Cc: daniel, andrii, eddyz87, memxor, martin.lau, yonghong.song, mason,
ihor.solodrai
On Sun, Nov 01, 2026 at 10:31 AM bot+bpf-ci@kernel.org <bot+bpf-ci@kernel.org> wrote:
>> +__naked void implicit_arg_after_may_goto(void)
>> +{
>> + asm volatile (
>> + "r6 = 1;"
>> +"1:"
>> + "r0 = r6;"
>> + "r1 = r6;"
>> + "may_goto 2f;"
> ^^^^
>
> Can this build with a clang that predates the BPF assembler support for the
> may_goto mnemonic?
Not a bug.
clang 18 can't build test_progs without this patch either.
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH bpf-next 0/2] bpf: The register of an implicit kfunc argument is not live
2026-11-01 17:44 [PATCH bpf-next 0/2] bpf: The register of an implicit kfunc argument is not live Alexei Starovoitov
2026-11-01 17:44 ` [PATCH bpf-next 1/2] " Alexei Starovoitov
2026-11-01 17:44 ` [PATCH bpf-next 2/2] selftests/bpf: Test liveness of an implicit kfunc argument Alexei Starovoitov
@ 2026-11-03 18:40 ` patchwork-bot+netdevbpf
2 siblings, 0 replies; 6+ messages in thread
From: patchwork-bot+netdevbpf @ 2026-11-03 18:40 UTC (permalink / raw)
To: Alexei Starovoitov; +Cc: bpf, daniel, andrii, eddyz87, memxor
Hello:
This series was applied to bpf/bpf-next.git (master)
by Alexei Starovoitov <ast@kernel.org>:
On Sun, 1 Nov 2026 17:44:03 +0000 you wrote:
> From: Alexei Starovoitov <ast@kernel.org>
>
> The verifier fills in the last arguments of a kfunc that has
> KF_IMPLICIT_ARGS, for example 'aux' of almost all scx_bpf_*() kfuncs. The
> prog does not pass them. But the analysis of live registers counts their
> registers as read by the call. Such a register is live from the previous
> call to this one. Scalar evolution has no formula for it and gives up on
> the loop, and the verifier compares it when it looks for an equal state.
>
> [...]
Here is the summary with links:
- [bpf-next,1/2] bpf: The register of an implicit kfunc argument is not live
https://git.kernel.org/bpf/bpf-next/c/2b1947689c29
- [bpf-next,2/2] selftests/bpf: Test liveness of an implicit kfunc argument
https://git.kernel.org/bpf/bpf-next/c/ef41474ed6cb
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2026-11-03 18:40 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-01 17:44 [PATCH bpf-next 0/2] bpf: The register of an implicit kfunc argument is not live Alexei Starovoitov
2026-11-01 17:44 ` [PATCH bpf-next 1/2] " Alexei Starovoitov
2026-11-01 17:44 ` [PATCH bpf-next 2/2] selftests/bpf: Test liveness of an implicit kfunc argument Alexei Starovoitov
2026-11-01 18:31 ` bot+bpf-ci
2026-11-02 17:37 ` Alexei Starovoitov
2026-11-03 18:40 ` [PATCH bpf-next 0/2] bpf: The register of an implicit kfunc argument is not live patchwork-bot+netdevbpf
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.