From: kernel test robot <lkp@intel.com>
To: Alexei Starovoitov <alexei.starovoitov@gmail.com>, bpf@vger.kernel.org
Cc: oe-kbuild-all@lists.linux.dev, daniel@iogearbox.net,
andrii@kernel.org, eddyz87@gmail.com, memxor@gmail.com
Subject: Re: [PATCH bpf 51/81] bpf: Check stack and count calls of recursive subprogs at run time
Date: Mon, 26 Oct 2026 20:51:11 +0800 [thread overview]
Message-ID: <202610262057.WlLdhg8d-lkp@intel.com> (raw)
In-Reply-To: <20261026025943.404450-52-alexei.starovoitov@gmail.com>
Hi Alexei,
kernel test robot noticed the following build errors:
[auto build test ERROR on bpf/master]
url: https://github.com/intel-lab-lkp/linux/commits/Alexei-Starovoitov/selftests-bpf-Remove-tests-for-global-data-in-arena/20261026-025822
base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git master
patch link: https://lore.kernel.org/r/20261026025943.404450-52-alexei.starovoitov%40gmail.com
patch subject: [PATCH bpf 51/81] bpf: Check stack and count calls of recursive subprogs at run time
config: powerpc-randconfig-1000-20261026 (https://download.01.org/0day-ci/archive/20261026/202610262057.WlLdhg8d-lkp@intel.com/config)
compiler: powerpc-linux-gcc (GCC) 8.5.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20261026/202610262057.WlLdhg8d-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202610262057.WlLdhg8d-lkp@intel.com/
All errors (new ones prefixed by >>):
kernel/bpf/fixups.c: In function 'bpf_insert_recursion_checks':
>> kernel/bpf/fixups.c:792:28: error: macro "__fortify_memcpy_chk" passed 9 arguments, but takes just 8
2 * sizeof(buf[0]));
^
In file included from include/linux/string.h:396,
from include/crypto/sha2.h:10,
from include/linux/bpf.h:11,
from kernel/bpf/fixups.c:3:
>> include/linux/fortify-string.h:638:26: error: '__fortify_memcpy_chk' undeclared (first use in this function); did you mean 'fortify_memcpy_chk'?
#define memcpy(p, q, s) __fortify_memcpy_chk(p, q, s, \
^~~~~~~~~~~~~~~~~~~~
kernel/bpf/fixups.c:791:3: note: in expansion of macro 'memcpy'
memcpy(buf + n, (struct bpf_insn[]){ BPF_LD_IMM64(BPF_REG_0, (long)depth) },
^~~~~~
include/linux/fortify-string.h:638:26: note: each undeclared identifier is reported only once for each function it appears in
#define memcpy(p, q, s) __fortify_memcpy_chk(p, q, s, \
^~~~~~~~~~~~~~~~~~~~
kernel/bpf/fixups.c:791:3: note: in expansion of macro 'memcpy'
memcpy(buf + n, (struct bpf_insn[]){ BPF_LD_IMM64(BPF_REG_0, (long)depth) },
^~~~~~
kernel/bpf/fixups.c:834:27: error: macro "__fortify_memcpy_chk" passed 9 arguments, but takes just 8
2 * sizeof(buf[0]));
^
kernel/bpf/fixups.c:865:28: error: macro "__fortify_memcpy_chk" passed 9 arguments, but takes just 8
2 * sizeof(buf[0]));
^
vim +/__fortify_memcpy_chk +792 kernel/bpf/fixups.c
696
697 /*
698 * How deep a recursion goes is not known, so it is counted at run time. In the same
699 * spirit as may_goto: the program goes on for as long as there is budget and
700 * takes a way out that was verified when there is none.
701 *
702 * Every subprog on a cycle of the call graph adds its weight to a per-cpu
703 * counter of the program when it is entered and takes it back at every exit.
704 * The weight is the part of the budget that its frame takes: of the stack
705 * room, or of the room in the stack in arena, whichever is larger. So these
706 * frames take no more than BPF_RECURSION_STACK, on top of the chain of calls
707 * without recursion that check_max_stack_depth() looked at.
708 *
709 * A subprog that calls itself twice doesn't have to go deep to go on forever. So
710 * the calls are counted too: BPF_MAX_LOOPS of them in a run of the prog, like the
711 * callbacks of bpf_loop(). Once they are used up every call returns at once, and
712 * the frames that are there come to an end.
713 *
714 * Another run of the program on the same cpu, in interrupt or after
715 * preemption, counts in the same counter. Then there is less for both.
716 */
717 int bpf_insert_recursion_checks(struct bpf_verifier_env *env)
718 {
719 struct bpf_subprog_info *si = env->subprog_info;
720 u32 frame, min_frame = U32_MAX, arena_frame = 0, arena_room = 0, weight;
721 u32 limit = BPF_RECURSION_STACK;
722 struct bpf_insn buf[24], first;
723 struct bpf_prog *new_prog;
724 struct bpf_recursion_budget __percpu *depth;
725 /* Only this cpu touches the counters */
726 int fetch_add = BPF_ADD | BPF_FETCH |
727 (bpf_jit_supports_local_atomics() ? BPF_ATOMIC_LOCAL : 0);
728 int i, s, n, bail, bail_len, err;
729
730 for (s = 0; s < env->subprog_cnt; s++) {
731 if (!si[s].recursive)
732 continue;
733 frame = recursive_frame_size(env, s);
734 si[s].recursion_weight = DIV_ROUND_UP(frame * BPF_RECURSION_UNITS, limit);
735 min_frame = min(min_frame, frame);
736 arena_frame = max(arena_frame, si[s].arena_stack_depth);
737 }
738 if (min_frame == U32_MAX)
739 return 0;
740 if (arena_frame) {
741 /*
742 * One more frame is for the subprog that finds that there is no
743 * budget: it has its frame by then.
744 */
745 u32 room = BPF_ARENA_STACK_MAX - env->max_arena_stack_depth;
746
747 if (room < 2 * arena_frame) {
748 verbose(env, "no room in the stack in arena for recursion\n");
749 return -EACCES;
750 }
751 /* no more than the frames that fit in the stack can take */
752 arena_room = min(room - arena_frame, limit / min_frame * arena_frame);
753 env->max_arena_stack_depth += arena_room + arena_frame;
754 }
755 for (s = 0; s < env->subprog_cnt; s++) {
756 if (!si[s].recursive)
757 continue;
758 if (si[s].arena_stack_depth)
759 si[s].recursion_weight = max(si[s].recursion_weight,
760 DIV_ROUND_UP(si[s].arena_stack_depth *
761 BPF_RECURSION_UNITS, arena_room));
762 if (si[s].recursion_weight > BPF_RECURSION_UNITS) {
763 verbose(env, "the frame of recursive %s() is too large\n",
764 bpf_subprog_name(env, s));
765 return -EACCES;
766 }
767 }
768
769 depth = alloc_percpu_gfp(struct bpf_recursion_budget, GFP_KERNEL_ACCOUNT);
770 if (!depth)
771 return -ENOMEM;
772 env->prog->aux->call_depth = depth;
773 env->prog->jit_required = 1;
774
775 /* From the last one, so that nothing moves in those that are yet to be done. */
776 for (s = env->subprog_cnt - 1; s > 0; s--) {
777 if (!si[s].recursive)
778 continue;
779 /*
780 * R0 has nothing at the entry. The address is not for AX:
781 * blinding of constants takes ld_imm64 apart with the help of
782 * AX. It leaves alone the insns that have AX in them.
783 */
784 n = 0;
785 first = env->prog->insnsi[si[s].start];
786 /* The exit drops the frame in the stack in arena. Take it before the check. */
787 if (is_arena_sp_adj(&first)) {
788 buf[n++] = first;
789 first = BPF_JMP_A(0);
790 }
791 memcpy(buf + n, (struct bpf_insn[]){ BPF_LD_IMM64(BPF_REG_0, (long)depth) },
> 792 2 * sizeof(buf[0]));
793 n += 2;
794 buf[n++] = BPF_MOV64_PERCPU_REG(BPF_REG_0, BPF_REG_0);
795 weight = si[s].recursion_weight;
796 bail_len = bpf_ret_reg_pair(env, s) ? 3 : 2;
797 buf[n++] = BPF_MOV64_IMM(BPF_REG_AX, weight);
798 buf[n++] = BPF_ATOMIC_OP(BPF_W, fetch_add, BPF_REG_0, BPF_REG_AX,
799 offsetof(struct bpf_recursion_budget, depth));
800 buf[n++] = BPF_JMP_IMM(BPF_JGT, BPF_REG_AX, BPF_RECURSION_UNITS - weight, 3);
801 buf[n++] = BPF_MOV64_IMM(BPF_REG_AX, 1);
802 buf[n++] = BPF_ATOMIC_OP(BPF_W, fetch_add, BPF_REG_0, BPF_REG_AX,
803 offsetof(struct bpf_recursion_budget, calls));
804 buf[n++] = BPF_JMP_IMM(BPF_JLT, BPF_REG_AX, BPF_MAX_LOOPS, bail_len);
805 bail = n;
806 buf[n++] = BPF_MOV64_IMM(BPF_REG_0, 0);
807 if (bpf_ret_reg_pair(env, s))
808 buf[n++] = BPF_MOV64_IMM(BPF_REG_2, 0);
809 buf[n++] = budget_exit_insn(env, &si[s]);
810 buf[n] = first;
811 err = bpf_adj_moved_insn(&buf[n], n);
812 if (err) {
813 verbose(env, "insn %d cannot be patched due to 16-bit range\n",
814 env->insn_aux_data[si[s].start].orig_idx);
815 return err;
816 }
817 n++;
818 new_prog = __bpf_patch_insn_data(env, si[s].start, buf, n, BPF_PATCH_MOVE_TARGET);
819 if (!new_prog)
820 return -ENOMEM;
821 env->prog = new_prog;
822 env->insn_aux_data[si[s].start + bail].recursion_bail = true;
823 /* calls get to the check, jumps to the first insn do not */
824 err = adjust_jmp_off(env->prog, si[s].start, n - 1);
825 if (err)
826 return err;
827 }
828
829 /*
830 * The calls are counted anew when a run begins. For async callbacks see
831 * bpf_prog_begin_run(). R0 has nothing at the entry.
832 */
833 memcpy(buf, (struct bpf_insn[]){ BPF_LD_IMM64(BPF_REG_0, (long)depth) },
834 2 * sizeof(buf[0]));
835 buf[2] = BPF_MOV64_PERCPU_REG(BPF_REG_0, BPF_REG_0);
836 /* calls and reported */
837 buf[3] = BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 0);
838 buf[4] = env->prog->insnsi[0];
839 err = bpf_adj_moved_insn(&buf[4], 4);
840 if (err) {
841 verbose(env, "insn %d cannot be patched due to 16-bit range\n",
842 env->insn_aux_data[0].orig_idx);
843 return err;
844 }
845 new_prog = __bpf_patch_insn_data(env, 0, buf, 5, BPF_PATCH_MOVE_TARGET);
846 if (!new_prog)
847 return -ENOMEM;
848 env->prog = new_prog;
849 /* a jump to the first insn doesn't begin a run */
850 err = adjust_jmp_off(env->prog, 0, 4);
851 if (err)
852 return err;
853
854 /* R1 is nothing to the caller. Jumps to exit get to what is added. */
855 for (i = 0; i < env->prog->len; i++) {
856 if (bpf_is_ldimm64(&env->prog->insnsi[i])) {
857 i++;
858 continue;
859 }
860 if (env->prog->insnsi[i].code != (BPF_JMP | BPF_EXIT) ||
861 !bpf_find_containing_subprog(env, i)->recursive)
862 continue;
863 n = 0;
864 memcpy(buf, (struct bpf_insn[]){ BPF_LD_IMM64(BPF_REG_1, (long)depth) },
865 2 * sizeof(buf[0]));
866 n += 2;
867 buf[n++] = BPF_MOV64_PERCPU_REG(BPF_REG_1, BPF_REG_1);
868 weight = bpf_find_containing_subprog(env, i)->recursion_weight;
869 buf[n++] = BPF_MOV64_IMM(BPF_REG_AX, -(int)weight);
870 buf[n++] = BPF_ATOMIC_OP(BPF_W, fetch_add, BPF_REG_1, BPF_REG_AX,
871 offsetof(struct bpf_recursion_budget, depth));
872 buf[n++] = env->prog->insnsi[i];
873 new_prog = bpf_patch_insn_data(env, i, buf, n);
874 if (!new_prog)
875 return -ENOMEM;
876 env->prog = new_prog;
877 i += n - 1;
878 }
879 return 0;
880 }
881
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
next prev parent reply other threads:[~2026-10-26 12:51 UTC|newest]
Thread overview: 145+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-10-26 2:58 [PATCH bpf 00/81] bpf: Stack in arena and a verifier that joins states Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 01/81] selftests/bpf: Remove tests for global data in arena Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 02/81] libbpf: Remove .arena.data Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 03/81] libbpf: Keep format strings of bpf_printk() in .rodata Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 04/81] selftests/bpf: Remove tests for arena access through numbers Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 05/81] bpf: Remove BPF_F_ARENA_SCALAR Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 06/81] bpf, x86: Remove r0_on_stack from fetching atomics in arena Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 07/81] bpf: One time slice of may_goto for a run of a prog Alexei Starovoitov
2026-10-26 12:50 ` kernel test robot
2026-10-26 14:43 ` kernel test robot
2026-10-26 17:35 ` Kumar Kartikeya Dwivedi
2026-10-27 16:39 ` Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 08/81] selftests/bpf: Test may_goto in a loop that calls a subprog that spins Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 09/81] bpf: Clear delta of a register that scalar evolution widens Alexei Starovoitov
2026-10-26 20:09 ` Daniel Borkmann
2026-10-27 21:23 ` Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 10/81] selftests/bpf: Test that a widened register is not linked Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 11/81] selftests/bpf: Wait for the last maps of map_kptr to be freed Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 12/81] bpf: Don't widen a pointer to a buffer in scalar evolution Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 13/81] selftests/bpf: Test a loop that moves a pointer to a buffer Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 14/81] bpf: Fix a false verifier bug in the clamp of scalar evolution Alexei Starovoitov
2026-10-26 23:45 ` Eduard Zingerman
2026-10-27 16:32 ` Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 15/81] selftests/bpf: Test induction variables that come back out of range Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 16/81] libbpf: Make arena 1 Gbyte when max_entries is not set Alexei Starovoitov
2026-10-26 16:54 ` Andrii Nakryiko
2026-10-26 16:59 ` Kumar Kartikeya Dwivedi
2026-10-27 0:13 ` Alexei Starovoitov
2026-10-27 21:11 ` Kumar Kartikeya Dwivedi
2026-10-27 21:22 ` Alexei Starovoitov
2026-10-27 21:28 ` Andrii Nakryiko
2026-10-27 21:29 ` Kumar Kartikeya Dwivedi
2026-10-26 2:58 ` [PATCH bpf 17/81] selftests/bpf: Test the default size of arena Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 18/81] bpf: Treat addr_space_cast of a pointer that is not in arena as a move Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 19/81] selftests/bpf: Test addr_space_cast of pointers that are not in arena Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 20/81] libbpf: Support .bss.addr_space.1 section Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 21/81] libbpf: Relocate pointers that are stored in arena Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 22/81] selftests/bpf: Test pointers in arena and .bss.addr_space.1 Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 23/81] bpf: Introduce bpf register BPF_REG_ARENA_SP Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 24/81] bpf: Add stacks for programs to arena Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 25/81] bpf, x86: Add BPF_ATOMIC_LOCAL Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 26/81] bpf: Support BPF_REG_ARENA_SP in the verifier Alexei Starovoitov
2026-10-26 17:47 ` Kumar Kartikeya Dwivedi
2026-10-26 23:51 ` Alexei Starovoitov
2026-10-27 0:18 ` Kumar Kartikeya Dwivedi
2026-10-27 18:45 ` Alexei Starovoitov
2026-10-27 20:23 ` Kumar Kartikeya Dwivedi
2026-10-28 4:47 ` Alexei Starovoitov
2026-10-28 11:00 ` Kumar Kartikeya Dwivedi
2026-10-28 19:01 ` Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 27/81] bpf, x86: Support BPF_REG_ARENA_SP Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 28/81] bpf, arm64: " Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 29/81] selftests/bpf: Add tests for BPF_REG_ARENA_SP Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 30/81] bpf: Add bpf_arena_memcmp() and bpf_arena_memcpy() kfuncs Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 31/81] bpf: Add bpf_alloc() and bpf_free() kfuncs Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 32/81] bpf: Count stack arguments of a static subprog from its code Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:58 ` [PATCH bpf 33/81] selftests/bpf: Test static subprogs that don't take what BTF says Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 34/81] bpf: Let scalar evolution see loads from read-only maps Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 35/81] selftests/bpf: Test scalar evolution with a loop bound in .rodata Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 36/81] bpf: Helpers don't write through ARG_ANYTHING Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 37/81] selftests/bpf: Test scalar evolution with stack address as ARG_ANYTHING Alexei Starovoitov
2026-10-26 2:58 ` [PATCH bpf 38/81] bpf: Simplify (zext32 (zext32 x)) in scalar evolution Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 39/81] selftests/bpf: Test scalar evolution with a latch on a 32-bit copy Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 40/81] bpf: Keep the range of a packet pointer when a number >= 0 is added Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 41/81] selftests/bpf: Test range of a packet pointer after a number " Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 42/81] bpf: Allow BPF_MAX_SUBPROGS targets of a read from a table of functions Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 43/81] bpf: Tell user space that a run of a prog was cut short Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 44/81] bpf: Mask the count of a 32-bit shift in scalar evolution Alexei Starovoitov
2026-10-26 3:52 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 45/81] selftests/bpf: Expect the masked count of 32-bit shifts Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 46/81] bpf: Finish the insn in the state that maybe_fork_scalars() splits off Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 47/81] bpf: Add join of verifier states Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 48/81] bpf: Describe loops that scalar evolution cannot count exactly Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 49/81] selftests/bpf: Adjust tests to loops that are counted now Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 50/81] bpf: Add may_goto to the loops that the verifier marks Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 51/81] bpf: Check stack and count calls of recursive subprogs at run time Alexei Starovoitov
2026-10-26 4:09 ` bot+bpf-ci
2026-10-26 12:51 ` kernel test robot [this message]
2026-10-26 2:59 ` [PATCH bpf 52/81] bpf: Add the main pass as a fixpoint over the control flow graph Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 53/81] bpf: Verify programs " Alexei Starovoitov
2026-10-26 4:25 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 54/81] bpf: Allow 24 arguments of static subprogs Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 55/81] selftests/bpf: Test a static subprog with 24 arguments Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 56/81] bpf: Bump MAX_CALL_FRAMES to 32 Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 57/81] selftests/bpf: Test 32 and 33 call frames Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 58/81] bpf: Bump BPF_MAX_SUBPROGS to 1024 Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 59/81] selftests/bpf: Make room in veristat for the stats of 1024 subprogs Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 60/81] bpf: Remove is_state_visited() Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 61/81] bpf: Remove precision tracking Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 62/81] bpf: Remove prune points, levels of state comparison and pop_stack() Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 63/81] bpf: Print 0 as the limit in the statistics line Alexei Starovoitov
2026-10-26 3:52 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 64/81] bpf: Remove bpf_compute_scc() Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 65/81] bpf: Update comments about paths, pruning and explored states Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 66/81] bpf: Remove iter.depth Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 67/81] bpf: Remove leftovers of precision tracking and read marks Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 68/81] bpf: Track a pointer to one of a set of functions Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 69/81] bpf, docs: Rewrite verifier.rst Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 70/81] selftests/bpf: Adjust tests of precision tracking Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 71/81] selftests/bpf: Adjust tests of linked registers and spills Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 72/81] selftests/bpf: Adjust tests of pruning Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 73/81] selftests/bpf: Adjust tests of loops Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 74/81] selftests/bpf: Adjust tests of recursion Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 75/81] selftests/bpf: Adjust tests to the order of verification and to the log Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 76/81] selftests/bpf: Adjust tests of unprivileged progs Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 77/81] selftests/bpf: Test states that are not joined Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 78/81] selftests/bpf: Test progs that run out of budget Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 2:59 ` [PATCH bpf 79/81] selftests/bpf: Test 'unwound' in bpf_prog_info Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 80/81] selftests/bpf: Test the stack in arena after recursion ran out of budget Alexei Starovoitov
2026-10-26 2:59 ` [PATCH bpf 81/81] selftests/bpf: Test callx of one of a set of functions Alexei Starovoitov
2026-10-26 3:53 ` bot+bpf-ci
2026-10-26 16:57 ` [PATCH bpf 00/81] bpf: Stack in arena and a verifier that joins states Ihor Solodrai
2026-10-26 23:53 ` Alexei Starovoitov
2026-10-27 0:04 ` Ihor Solodrai
2026-10-27 0:14 ` Alexei Starovoitov
2026-10-27 5:08 ` Ihor Solodrai
2026-10-26 22:28 ` Ihor Solodrai
2026-10-26 23:45 ` Alexei Starovoitov
2026-10-27 0:01 ` Ihor Solodrai
2026-10-27 0:13 ` Ihor Solodrai
2026-10-27 0:16 ` Alexei Starovoitov
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=202610262057.WlLdhg8d-lkp@intel.com \
--to=lkp@intel.com \
--cc=alexei.starovoitov@gmail.com \
--cc=andrii@kernel.org \
--cc=bpf@vger.kernel.org \
--cc=daniel@iogearbox.net \
--cc=eddyz87@gmail.com \
--cc=memxor@gmail.com \
--cc=oe-kbuild-all@lists.linux.dev \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox