verify scalar ids mapping in regsafe()
Subsystems (4)
Eduard Zingerman
maintainerv6 cover verify scalar ids mapping in regsafe()
Update regsafe() to use check_ids() for scalar values. Otherwise the following unsafe pattern is accepted by verifier:
1: r9 = ... some pointer with range X ...
2: r6 = ... unbound scalar ID=a ...
3: r7 = ... unbound scalar ID=b ...
4: if (r6 > r7) goto +1
5: r6 = r7
6: if (r6 > X) goto ...
--- checkpoint ---
7: r9 += r7
8: *(u64 *)r9 = Y
This example is unsafe because not all execution paths verify r7 range. Because of the jump at (4) the verifier would arrive at (6) in two states:
I. r6{.id=b}, r7{.id=b} via path 1-6;
II. r6{.id=a}, r7{.id=b} via path 1-4, 6.
Currently regsafe() does not call check_ids() for scalar registers, thus from POV of regsafe() states (I) and (II) are identical.
The change is split in two parts:
- patches #1,2: update for mark_chain_precision() to propagate precision marks through scalar IDs.
- patches #3,4: update for regsafe() to use a special version of check_ids() for precise scalar values.
Changelog:
- V5 -> V6:
- check_ids() is modified to disallow mapping different 'old_id' to
the same 'cur_id', check_scalar_ids() simplified (Andrii);
- idset_push() updated to return -EFAULT instead of -1 (Andrii);
- comments fixed in check_ids_in_regsafe() test case
(Maxim Mikityanskiy); - fixed memset warning in states_equal() reported in [4].
- V4 -> V5 (all changes are based on feedback for V4 from Andrii):
- mark_precise_scalar_ids() error code is updated to EFAULT;
- bpf_verifier_env::idmap_scratch field type is changed to struct
bpf_idmap to encapsulate temporary ID generation counter;
- regsafe() is updated to call scalar_regs_exact() only for env->explore_alu_limits case (this had no measurable impact on verification duration when tested using veristat).
- V3 -> V4:
- check_ids() in regsafe() is replaced by check_scalar_ids(), as discussed with Andrii in [3],
Note: I did not transfer Andrii's ack for patch #3 from V3 because
of the changes to the algorithm.
- reg_id_scratch is renamed to idset_scratch;
- mark_precise_scalar_ids() is modified to propagate error from
idset_push();
- test cases adjusted according to feedback from Andrii for V3.
- V2 -> V3:
- u32_hashset for IDs used for range transfer is removed;
- mark_chain_precision() is updated as discussed with Andrii in [2].
- V1 -> v2:
- 'rold->precise' and 'rold->id' checks are dropped as unsafe
(thanks to discussion with Yonghong);
- patches #3,4 adding tracking of ids used for range transfer in order to mitigate performance impact.
- RFC -> V1:
- Function verifier.c:mark_equal_scalars_as_read() is dropped, as it was an incorrect fix for problem solved by commit [3].
- check_ids() is called only for precise scalar values.
- Test case updated to use inline assembly.
[V1] https://lore.kernel.org/bpf/[email protected]/ [V2] https://lore.kernel.org/bpf/[email protected]/ [V3] https://lore.kernel.org/bpf/[email protected]/ [V4] https://lore.kernel.org/bpf/[email protected]/ [V5] https://lore.kernel.org/bpf/[email protected]/ [RFC] https://lore.kernel.org/bpf/[email protected]/ [1] https://gist.github.com/eddyz87/a32ea7e62a27d3c201117c9a39ab4286 [2] https://lore.kernel.org/bpf/[email protected]/T/#mc21009dcd8574b195c1860a98014bb037f16f450 [3] https://lore.kernel.org/bpf/[email protected]/T/#m89da8eeb2fa8c9ca1202c5d0b6660e1f72e45e04 [4] https://lore.kernel.org/oe-kbuild-all/[email protected]/
Eduard Zingerman (4):
bpf: use scalar ids in mark_chain_precision() selftests/bpf: check if mark_chain_precision() follows scalar ids
bpf: verify scalar ids mapping in regsafe() using check_ids() selftests/bpf: verify that check_ids() is used for scalars in
regsafe()
include/linux/bpf_verifier.h | 25 +- kernel/bpf/verifier.c | 206 +++++- .../selftests/bpf/prog_tests/verifier.c | 2 + .../selftests/bpf/progs/verifier_scalar_ids.c | 659 ++++++++++++++++++ .../testing/selftests/bpf/verifier/precise.c | 8 +- 5 files changed, 867 insertions(+), 33 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/verifier_scalar_ids.c
Signature · 1 line
2.40.1
Eduard Zingerman
maintainerPATCH v6 1/4 bpf: use scalar ids in mark_chain_precision()
Change mark_chain_precision() to track precision in situations like below:
r2 = unknown value
...
--- state #0 ---
...
r1 = r2 // r1 and r2 now share the same ID
...
--- state #1 {r1.id = A, r2.id = A} ---
...
if (r2 > 10) goto exit; // find_equal_scalars() assigns range to r1
...
--- state #2 {r1.id = A, r2.id = A} ---
r3 = r10
r3 += r1 // need to mark both r1 and r2At the beginning of the processing of each state, ensure that if a register with a scalar ID is marked as precise, all registers sharing this ID are also marked as precise.
This property would be used by a follow-up change in regsafe().
--- include/linux/bpf_verifier.h | 10 +- kernel/bpf/verifier.c | 115 ++++++++++++++++++ .../testing/selftests/bpf/verifier/precise.c | 8 +- 3 files changed, 128 insertions(+), 5 deletions(-)
include/linux/bpf_verifier.h +9 -1
@@ -559,6 +559,11 @@ struct backtrack_state {u64 stack_masks[MAX_CALL_FRAMES ]; }; +struct bpf_idset { +u32 count; +u32 ids[BPF_ID_MAP_SIZE ]; +}; +/* single container for all structs * one verifier_env per bpf_check() call */
@@ -590,7 +595,10 @@ struct bpf_verifier_env {const struct bpf_line_info *prev_linfo;struct bpf_verifier_log log;struct bpf_subprog_info subprog_info[BPF_MAX_SUBPROGS +1 ]; -struct bpf_id_pair idmap_scratch[BPF_ID_MAP_SIZE ]; +union { +struct bpf_id_pair idmap_scratch[BPF_ID_MAP_SIZE ]; +struct bpf_idset idset_scratch; + };struct {int *insn_state;int *insn_stack;
kernel/bpf/verifier.c +115 -0
127 lines not on this page · raw message
tools/testing/selftests/bpf/verifier/precise.c +4 -4
@@ -46,7 +46,7 @@ mark_precise: frame0: regs=r2 stack= before 20\ mark_precise: frame0: parent state regs=r2 stack=:\ mark_precise: frame0: last_idx 19 first_idx 10\ - mark_precise: frame0: regs=r2 stack= before 19\ + mark_precise: frame0: regs=r2,r9 stack= before 19\ mark_precise: frame0: regs=r9 stack= before 18\ mark_precise: frame0: regs=r8,r9 stack= before 17\ mark_precise: frame0: regs=r0,r9 stack= before 15\
@@ -106,10 +106,10 @@ mark_precise: frame0: regs=r2 stack= before 22\ mark_precise: frame0: parent state regs=r2 stack=:\ mark_precise: frame0: last_idx 20 first_idx 20\ - mark_precise: frame0: regs=r2 stack= before 20\ - mark_precise: frame0: parent state regs=r2 stack=:\ + mark_precise: frame0: regs=r2,r9 stack= before 20\ + mark_precise: frame0: parent state regs=r2,r9 stack=:\ mark_precise: frame0: last_idx 19 first_idx 17\ - mark_precise: frame0: regs=r2 stack= before 19\ + mark_precise: frame0: regs=r2,r9 stack= before 19\ mark_precise: frame0: regs=r9 stack= before 18\ mark_precise: frame0: regs=r8,r9 stack= before 17\ mark_precise: frame0: parent state regs= stack=:",
Signature · 1 line
2.40.1
Eduard Zingerman
maintainerPATCH v6 2/4 selftests/bpf: check if mark_chain_precision() follows scalar ids
In reply to Eduard ZingermanCheck __mark_chain_precision() log to verify that scalars with same IDs are marked as precise. Use several scenarios to test that precision marks are propagated through:
- registers of scalar type with the same ID within one state;
- registers of scalar type with the same ID cross several states;
- registers of scalar type with the same ID cross several stack frames;
- stack slot of scalar type with the same ID;
- multiple scalar IDs are tracked independently.
--- .../selftests/bpf/prog_tests/verifier.c | 2 + .../selftests/bpf/progs/verifier_scalar_ids.c | 344 ++++++++++++++++++ 2 files changed, 346 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/verifier_scalar_ids.c
tools/testing/selftests/bpf/prog_tests/verifier.c +2 -0
@@ -50,6 +50,7 @@#include "verifier_regalloc.skel.h" #include "verifier_ringbuf.skel.h" #include "verifier_runtime_jit.skel.h" +#include "verifier_scalar_ids.skel.h" #include "verifier_search_pruning.skel.h" #include "verifier_sock.skel.h" #include "verifier_spill_fill.skel.h"
@@ -150,6 +151,7 @@ void test_verifier_ref_tracking(void) { RUN(verifier_ref_tracking); }void test_verifier_regalloc (void ) {RUN (verifier_regalloc); }void test_verifier_ringbuf (void ) {RUN (verifier_ringbuf); }void test_verifier_runtime_jit (void ) {RUN (verifier_runtime_jit); } +void test_verifier_scalar_ids (void ) {RUN (verifier_scalar_ids); }void test_verifier_search_pruning (void ) {RUN (verifier_search_pruning); }void test_verifier_sock (void ) {RUN (verifier_sock); }void test_verifier_spill_fill (void ) {RUN (verifier_spill_fill); }
tools/testing/selftests/bpf/progs/verifier_scalar_ids.c new file +344 -0
344 lines not on this page · raw message
Signature · 1 line
2.40.1
Eduard Zingerman
maintainerPATCH v6 3/4 bpf: verify scalar ids mapping in regsafe() using check_ids()
In reply to Eduard ZingermanMake sure that the following unsafe example is rejected by verifier:
1: r9 = ... some pointer with range X ...
2: r6 = ... unbound scalar ID=a ...
3: r7 = ... unbound scalar ID=b ...
4: if (r6 > r7) goto +1
5: r6 = r7
6: if (r6 > X) goto ...
--- checkpoint ---
7: r9 += r7
8: *(u64 *)r9 = Y
This example is unsafe because not all execution paths verify r7 range. Because of the jump at (4) the verifier would arrive at (6) in two states:
I. r6{.id=b}, r7{.id=b} via path 1-6;
II. r6{.id=a}, r7{.id=b} via path 1-4, 6.
Currently regsafe() does not call check_ids() for scalar registers, thus from POV of regsafe() states (I) and (II) are identical. If the path 1-6 is taken by verifier first, and checkpoint is created at (6) the path [1-4, 6] would be considered safe.
Changes in this commit:
- check_ids() is modified to disallow mapping multiple old_id to the same cur_id.
- check_scalar_ids() is added, unlike check_ids() it treats ID zero as a unique scalar ID.
- check_scalar_ids() needs to generate temporary unique IDs, field 'tmp_id_gen' is added to bpf_verifier_env::idmap_scratch to facilitate this.
- regsafe() is updated to:
- use check_scalar_ids() for precise scalar registers.
- compare scalar registers using memcmp only for explore_alu_limits branch. This simplifies control flow for scalar case, and has no measurable performance impact.
- check_alu_op() is updated to avoid generating bpf_reg_state::id for constant scalar values when processing BPF_MOV. ID is needed to propagate range information for identical values, but there is nothing to propagate for constants.
--- include/linux/bpf_verifier.h | 17 ++++--- kernel/bpf/verifier.c | 91 +++++++++++++++++++++++++++--------- 2 files changed, 79 insertions(+), 29 deletions(-)
include/linux/bpf_verifier.h +11 -6
@@ -313,11 +313,6 @@ struct bpf_idx_pair {u32 idx; }; -struct bpf_id_pair { -u32 old; -u32 cur; -}; -#define MAX_CALL_FRAMES 8/* Maximum number of register states that can exist at once */ #define BPF_ID_MAP_SIZE ((MAX_BPF_REG + MAX_BPF_STACK / BPF_REG_SIZE) * MAX_CALL_FRAMES)
@@ -559,6 +554,16 @@ struct backtrack_state {u64 stack_masks[MAX_CALL_FRAMES ]; }; +struct bpf_id_pair { +u32 old; +u32 cur; +}; + +struct bpf_idmap { +u32 tmp_id_gen; +struct bpf_id_pair map[BPF_ID_MAP_SIZE ]; +}; +struct bpf_idset {u32 count;u32 ids[BPF_ID_MAP_SIZE ];
@@ -596,7 +601,7 @@ struct bpf_verifier_env {struct bpf_verifier_log log;struct bpf_subprog_info subprog_info[BPF_MAX_SUBPROGS +1 ];union { -struct bpf_id_pair idmap_scratch[BPF_ID_MAP_SIZE ]; +struct bpf_idmap idmap_scratch;struct bpf_idset idset_scratch; };struct {
kernel/bpf/verifier.c +68 -23
185 lines not on this page · raw message
Signature · 1 line
2.40.1
Eduard Zingerman
maintainerPATCH v6 4/4 selftests/bpf: verify that check_ids() is used for scalars in regsafe()
In reply to Eduard ZingermanVerify that the following example is rejected by verifier:
r9 = ... some pointer with range X ...
r6 = ... unbound scalar ID=a ...
r7 = ... unbound scalar ID=b ...
if (r6 > r7) goto +1
r7 = r6
if (r7 > X) goto exit
r9 += r6
*(u64 *)r9 = Y
Also add test cases to:
- check that check_alu_op() for BPF_MOV instruction does not allocate scalar ID if source register is a constant;
- check that unique scalar IDs are ignored when new verifier state is compared to cached verifier state;
- check that two different scalar IDs in a verified state can't be mapped to the same scalar ID in current state.
--- .../selftests/bpf/progs/verifier_scalar_ids.c | 315 ++++++++++++++++++ 1 file changed, 315 insertions(+)
tools/testing/selftests/bpf/progs/verifier_scalar_ids.c +315 -0
@@ -341,4 +341,319 @@ __naked void precision_two_ids(void) : __clobber_all); } +/* Verify that check_ids() is used by regsafe() for scalars. +* +* r9 = ... some pointer with range X ... +* r6 = ... unbound scalar ID=a ... +* r7 = ... unbound scalar ID=b ... +* if (r6 > r7) goto +1 +* r7 = r6 +* if (r7 > X) goto exit +* r9 += r6 +* ... access memory using r9 ... +* +* The memory access is safe only if r7 is bounded, +* which is true for one branch and not true for another. +*/ +SEC("socket") +__failure __msg("register with unbounded min value") +__flag (BPF_F_TEST_STATE_FREQ) +__naked void check_ids_in_regsafe(void) +{ + asmvolatile ( +/* Bump allocated stack */ +"r1 = 0;" +"*(u64*)(r10 - 8) = r1;" +/* r9 = pointer to stack */ +"r9 = r10;" +"r9 += -8;" +/* r7 = ktime_get_ns() */ +"call %[bpf_ktime_get_ns];" +"r7 = r0;" +/* r6 = ktime_get_ns() */ +"call %[bpf_ktime_get_ns];" +"r6 = r0;" +/* if r6 > r7 is an unpredictable jump */ +"if r6 > r7 goto l1_%=;" +"r7 = r6;" +"l1_%=:" +/* if r7 > 4 ...; transfers range to r6 on one execution path +* but does not transfer on another +*/ +"if r7 > 4 goto l2_%=;" +/* Access memory at r9[r6], r6 is not always bounded */ +"r9 += r6;" +"r0 = *(u8*)(r9 + 0);" +"l2_%=:" +"r0 = 0;" +"exit;" + : + : __imm(bpf_ktime_get_ns) + : __clobber_all); +} + +/* Similar to check_ids_in_regsafe. +* The l0 could be reached in two states: +* +* (1) r6{.id=A}, r7{.id=A}, r8{.id=B} +* (2) r6{.id=B}, r7{.id=A}, r8{.id=B} +* +* Where (2) is not safe, as "r7 > 4" check won't propagate range for it. +* This example would be considered safe without changes to +* mark_chain_precision() to track scalar values with equal IDs. +*/ +SEC("socket") +__failure __msg("register with unbounded min value") +__flag (BPF_F_TEST_STATE_FREQ) +__naked void check_ids_in_regsafe_2(void) +{ + asmvolatile ( +/* Bump allocated stack */ +"r1 = 0;" +"*(u64*)(r10 - 8) = r1;" +/* r9 = pointer to stack */ +"r9 = r10;" +"r9 += -8;" +/* r8 = ktime_get_ns() */ +"call %[bpf_ktime_get_ns];" +"r8 = r0;" +/* r7 = ktime_get_ns() */ +"call %[bpf_ktime_get_ns];" +"r7 = r0;" +/* r6 = ktime_get_ns() */ +"call %[bpf_ktime_get_ns];" +"r6 = r0;" +/* scratch .id from r0 */ +"r0 = 0;" +/* if r6 > r7 is an unpredictable jump */ +"if r6 > r7 goto l1_%=;" +/* tie r6 and r7 .id */ +"r6 = r7;" +"l0_%=:" +/* if r7 > 4 exit(0) */ +"if r7 > 4 goto l2_%=;" +/* Access memory at r9[r6] */ +"r9 += r6;" +"r0 = *(u8*)(r9 + 0);" +"l2_%=:" +"r0 = 0;" +"exit;" +"l1_%=:" +/* tie r6 and r8 .id */ +"r6 = r8;" +"goto l0_%=;" + : + : __imm(bpf_ktime_get_ns) + : __clobber_all); +} + +/* Check that scalar IDs *are not* generated on register to register +* assignments if source register is a constant. +* +* If such IDs *are* generated the 'l1' below would be reached in +* two states: +* +* (1) r1{.id=A}, r2{.id=A} +* (2) r1{.id=C}, r2{.id=C} +* +* Thus forcing 'if r1 == r2' verification twice. +*/ +SEC("socket") +__success __log_level(2) +__msg("11: (1d) if r3 == r4 goto pc+0") +__msg("frame 0: propagating r3,r4") +__msg("11: safe") +__msg("processed 15 insns") +__flag (BPF_F_TEST_STATE_FREQ) +__naked void no_scalar_id_for_const(void) +{ + asmvolatile ( +"call %[bpf_ktime_get_ns];" +/* unpredictable jump */ +"if r0 > 7 goto l0_%=;" +/* possibly generate same scalar ids for r3 and r4 */ +"r1 = 0;" +"r1 = r1;" +"r3 = r1;" +"r4 = r1;" +"goto l1_%=;" +"l0_%=:" +/* possibly generate different scalar ids for r3 and r4 */ +"r1 = 0;" +"r2 = 0;" +"r3 = r1;" +"r4 = r2;" +"l1_%=:" +/* predictable jump, marks r3 and r4 precise */ +"if r3 == r4 goto +0;" +"r0 = 0;" +"exit;" + : + : __imm(bpf_ktime_get_ns) + : __clobber_all); +} + +/* Same as no_scalar_id_for_const() but for 32-bit values */ +SEC("socket") +__success __log_level(2) +__msg("11: (1e) if w3 == w4 goto pc+0") +__msg("frame 0: propagating r3,r4") +__msg("11: safe") +__msg("processed 15 insns") +__flag (BPF_F_TEST_STATE_FREQ) +__naked void no_scalar_id_for_const32(void) +{ + asmvolatile ( +"call %[bpf_ktime_get_ns];" +/* unpredictable jump */ +"if r0 > 7 goto l0_%=;" +/* possibly generate same scalar ids for r3 and r4 */ +"w1 = 0;" +"w1 = w1;" +"w3 = w1;" +"w4 = w1;" +"goto l1_%=;" +"l0_%=:" +/* possibly generate different scalar ids for r3 and r4 */ +"w1 = 0;" +"w2 = 0;" +"w3 = w1;" +"w4 = w2;" +"l1_%=:" +/* predictable jump, marks r1 and r2 precise */ +"if w3 == w4 goto +0;" +"r0 = 0;" +"exit;" + : + : __imm(bpf_ktime_get_ns) + : __clobber_all); +} + +/* Check that unique scalar IDs are ignored when new verifier state is +* compared to cached verifier state. For this test: +* - cached state has no id on r1 +* - new state has a unique id on r1 +*/ +SEC("socket") +__success __log_level(2) +__msg("6: (25) if r6 > 0x7 goto pc+1") +__msg("7: (57) r1 &= 255") +__msg("8: (bf) r2 = r10") +__msg("from 6 to 8: safe") +__msg("processed 12 insns") +__flag (BPF_F_TEST_STATE_FREQ) +__naked void ignore_unique_scalar_ids_cur(void) +{ + asmvolatile ( +"call %[bpf_ktime_get_ns];" +"r6 = r0;" +"call %[bpf_ktime_get_ns];" +"r0 &= 0xff;" +/* r1.id == r0.id */ +"r1 = r0;" +/* make r1.id unique */ +"r0 = 0;" +"if r6 > 7 goto l0_%=;" +/* clear r1 id, but keep the range compatible */ +"r1 &= 0xff;" +"l0_%=:" +/* get here in two states: +* - first: r1 has no id (cached state) +* - second: r1 has a unique id (should be considered equivalent) +*/ +"r2 = r10;" +"r2 += r1;" +"exit;" + : + : __imm(bpf_ktime_get_ns) + : __clobber_all); +} + +/* Check that unique scalar IDs are ignored when new verifier state is +* compared to cached verifier state. For this test: +* - cached state has a unique id on r1 +* - new state has no id on r1 +*/ +SEC("socket") +__success __log_level(2) +__msg("6: (25) if r6 > 0x7 goto pc+1") +__msg("7: (05) goto pc+1") +__msg("9: (bf) r2 = r10") +__msg("9: safe") +__msg("processed 13 insns") +__flag (BPF_F_TEST_STATE_FREQ) +__naked void ignore_unique_scalar_ids_old(void) +{ + asmvolatile ( +"call %[bpf_ktime_get_ns];" +"r6 = r0;" +"call %[bpf_ktime_get_ns];" +"r0 &= 0xff;" +/* r1.id == r0.id */ +"r1 = r0;" +/* make r1.id unique */ +"r0 = 0;" +"if r6 > 7 goto l1_%=;" +"goto l0_%=;" +"l1_%=:" +/* clear r1 id, but keep the range compatible */ +"r1 &= 0xff;" +"l0_%=:" +/* get here in two states: +* - first: r1 has a unique id (cached state) +* - second: r1 has no id (should be considered equivalent) +*/ +"r2 = r10;" +"r2 += r1;" +"exit;" + : + : __imm(bpf_ktime_get_ns) + : __clobber_all); +} + +/* Check that two different scalar IDs in a verified state can't be +* mapped to the same scalar ID in current state. +*/ +SEC("socket") +__success __log_level(2) +/* The exit instruction should be reachable from two states, +* use two matches and "processed .. insns" to ensure this. + */ +__msg("13: (95) exit") +__msg("13: (95) exit") +__msg("processed 18 insns") +__flag (BPF_F_TEST_STATE_FREQ) +__naked void two_old_ids_one_cur_id(void) +{ + asmvolatile ( +/* Give unique scalar IDs to r{6,7} */ +"call %[bpf_ktime_get_ns];" +"r0 &= 0xff;" +"r6 = r0;" +"call %[bpf_ktime_get_ns];" +"r0 &= 0xff;" +"r7 = r0;" +"r0 = 0;" +/* Maybe make r{6,7} IDs identical */ +"if r6 > r7 goto l0_%=;" +"goto l1_%=;" +"l0_%=:" +"r6 = r7;" +"l1_%=:" +/* Mark r{6,7} precise. +* Get here in two states: +* - first: r6{.id=A}, r7{.id=B} (cached state) +* - second: r6{.id=A}, r7{.id=A} +* Currently we don't want to consider such states equivalent. +* Thus "exit;" would be verified twice. +*/ +"r2 = r10;" +"r2 += r6;" +"r2 += r7;" +"exit;" + : + : __imm(bpf_ktime_get_ns) + : __clobber_all); +} + char _license[] SEC("license") = "GPL";
Signature · 1 line
2.40.1
This series was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Andrii Nakryiko <[email protected]>:
Quoted 11 lines · On Tue, 13 Jun 2023 18:38:20 +0300 you wrote:
Update
regsafe()to usecheck_ids()for scalar values. Otherwise the following unsafe pattern is accepted by verifier:1: r9 = ... some pointer with range X ...
2: r6 = ... unbound scalar ID=a ...
3: r7 = ... unbound scalar ID=b ...
4: if (r6 > r7) goto +1
5: r6 = r7
6: if (r6 > X) goto ...[...]
Here is the summary with links:
- [bpf-next,v6,1/4] bpf: use scalar ids in mark_chain_precision()
https://git.kernel.org/bpf/bpf-next/c/904e6ddf4133 - [bpf-next,v6,2/4] selftests/bpf: check if mark_chain_precision() follows scalar ids https://git.kernel.org/bpf/bpf-next/c/dec020280373 - [bpf-next,v6,3/4] bpf: verify scalar ids mapping in regsafe() using check_ids() https://git.kernel.org/bpf/bpf-next/c/1ffc85d9298e - [bpf-next,v6,4/4] selftests/bpf: verify that check_ids() is used for scalars in regsafe() https://git.kernel.org/bpf/bpf-next/c/18b89265572b
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html