libbpf: move arena variables out of the zero page
Subsystems (5)
Emil Tsalapatis
reviewerv3 cover libbpf: move arena variables out of the zero page
Modify libbpf to place arena globals at the end of the arena mapping instead of the very beginning. This allows programs to leave the "zero page" of the arena unmapped, so that NULL arena pointer dereferences trigger a page fault and associated backtrace in BPF streams. In contrast, the current policy of placing global data in the zero pages means that NULL dereferences silently corrupt global data, e.g, arena qspinlock state. This makes arena bugs more difficult to debug.
The patchset adds code to libbpf to move global arena data to the end of the arena. At load time, libbpf adjusts each symbol's location within the arena to point to the right location in the arena. The patchset also adjusts the arena skeleton pointer to point to the arena globals, now that they are not in the beginning of the arena region.
CHANGESET
=========
v2->v3: (https://lore.kernel.org/bpf/[email protected]/)
- Remove unnecessary kernel bounds check in resolve_pseudo_ldimm64 (Andrii)
- Added patch to turn sym_off unsigned to prevent overflow (AI)
- Remove obsolete references to offsets from test patch description (Andrii)
- Use size_t for arena_data_off (Andrii)
- Remove extra mutable variable from offset calculations (Andrii)
v1->v2: (https://lore.kernel.org/bpf/[email protected])
- Moved globals to the end of the mapping: (Andrii)
- Removed extra parameter for offset and parameter picking logic
- Removed padding in the skeleton
- Removed additional libbpf call
- Added Reviewed-by from Eduard on patch 1
Emil Tsalapatis (5):
selftests/bpf: explicitly account for globals in verifier_arena_large bpf/verifier: do not limit maximum direct offset into arena map
libbpf: turn relo_core->sym_off unsigned
libbpf: move arena globals to the end of the arena selftests/bpf: add tests for the arena offset of globals
kernel/bpf/verifier.c | 5 -- tools/lib/bpf/libbpf.c | 21 ++++-- .../selftests/bpf/prog_tests/verifier.c | 4 + .../bpf/progs/verifier_arena_globals1.c | 75 +++++++++++++++++++ .../bpf/progs/verifier_arena_globals2.c | 49 ++++++++++++ .../bpf/progs/verifier_arena_large.c | 21 +++++- 6 files changed, 160 insertions(+), 15 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/verifier_arena_globals1.c create mode 100644 tools/testing/selftests/bpf/progs/verifier_arena_globals2.c
Signature · 1 line
2.49.0
Emil Tsalapatis
reviewerPATCH v3 1/5 selftests/bpf: explicitly account for globals in verifier_arena_large
The big_alloc1 test in verifier_arena_large assumes that the arena base and the first page allocated by bpf_arena_alloc_pages are identical. This is not the case, because the first page in the arena is populated by global arena data. The test still passes because the code makes the tacit assumption that the first page is on offset PAGE_SIZE instead of 0.
Make this distinction explicit in the code, and adjust the page offsets requested during the test to count from the beginning of the arena instead of using the address of the first allocated page.
--- .../selftests/bpf/progs/verifier_arena_large.c | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)
tools/testing/selftests/bpf/progs/verifier_arena_large.c +11 -4
@@ -23,18 +23,25 @@ int big_alloc1(void *ctx) {#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) volatile char __arena *page1, *page2, *no_page, *page3; - void __arena *base; +u64 base; - page1 = base =bpf_arena_alloc_pages (&arena,NULL ,1 ,NUMA_NO_NODE ,0 ); + base = (u64 )arena_base (&arena); + + page1 =bpf_arena_alloc_pages (&arena,NULL ,1 ,NUMA_NO_NODE ,0 );if (!page1)return 1 ; + +/* Account for global arena data. */ +if ((u64 )page1 != base +PAGE_SIZE ) +return 15 ; + *page1 =1 ; - page2 =bpf_arena_alloc_pages (&arena, base +ARENA_SIZE -PAGE_SIZE *2 , + page2 = bpf_arena_alloc_pages(&arena, (void __arena *)(ARENA_SIZE - PAGE_SIZE),1 ,NUMA_NO_NODE ,0 );if (!page2)return 2 ; *page2 =2 ; - no_page =bpf_arena_alloc_pages (&arena, base +ARENA_SIZE -PAGE_SIZE , + no_page = bpf_arena_alloc_pages(&arena, (void __arena *)ARENA_SIZE,1 ,NUMA_NO_NODE ,0 );if (no_page)return 3 ;
Signature · 1 line
2.49.0
Emil Tsalapatis
reviewerPATCH v3 2/5 bpf/verifier: do not limit maximum direct offset into arena map
In reply to Emil TsalapatisThe verifier currently limits direct offsets into a map to 512MiB to avoid overflow during pointer arithmetic. However, this prevents arena maps from using direct addressing instructions to access data at the end of > 512MiB arena maps. This is necessary when moving arena globals to the end of the arena instead of the front.
Refactor the verifier code to remove the offset calculation during direct value access calculations. This is possible because the only two map types that implement .map_direct_value_addr() are arrays and arenas, and they both do their own internal checks to ensure the offset is within bounds.
--- kernel/bpf/verifier.c | 5 ----- 1 file changed, 5 deletions(-)
kernel/bpf/verifier.c +0 -5
@@ -21136,11 +21136,6 @@ static int resolve_pseudo_ldimm64(struct bpf_verifier_env *env) }else {u32 off = insn[1 ].imm; -if (off >=BPF_MAX_VAR_OFF ) { -verbose (env,"direct value offset of %u is not allowed\n" , off); -return -EINVAL ; - } -if (!map->ops->map_direct_value_addr) {verbose (env,"no direct value access support for this map type\n" );return -EINVAL ;
Signature · 1 line
2.49.0
Re: [PATCH v3 2/5] bpf/verifier: do not limit maximum direct offset into arena map
Quoted 11 lines · Emil Tsalapatis
The verifier currently limits direct offsets into a map to 512MiB to avoid overflow during pointer arithmetic. However, this prevents arena maps from using direct addressing instructions to access data at the end of > 512MiB arena maps. This is necessary when moving arena globals to the end of the arena instead of the front.
Refactor the verifier code to remove the offset calculation during direct value access calculations. This is possible because the only two map types that implement .map_direct_value_addr() are arrays and arenas, and they both do their own internal checks to ensure the offset is within bounds.
Nit: instruction array map also implements it (bpf_insn_array.c).
Quoted 3 lines
Signed-off-by Emil Tsalapatis <[email protected]>---
I double checked implementations for all 3 map types and confirm that the above is correct. Also, I commented out the range checks in kernel implementations (as in the attached patch), and no tests seem to fail. Do we need to extend selftests?
[...]
kernel/bpf/arena.c +4 -2
@@ -388,8 +388,10 @@ static int arena_map_direct_value_addr(const struct bpf_map *map, u64 *imm, u32 { struct bpf_arena *arena = container_of(map, struct bpf_arena, map); -if ((u64 )off > arena->user_vm_end - arena->user_vm_start) -return -ERANGE ; +/* +* if ((u64)off > arena->user_vm_end - arena->user_vm_start) +* return -ERANGE; +*/ *imm = (unsigned long )arena->user_vm_start;return 0 ; }
kernel/bpf/arraymap.c +4 -2
@@ -193,8 +193,10 @@ static int array_map_direct_value_addr(const struct bpf_map *map, u64 *imm,if (map->max_entries !=1 )return -ENOTSUPP ; -if (off >= map->value_size) -return -EINVAL ; +/* +* if (off >= map->value_size) +* return -EINVAL; +*/ *imm = (unsigned long )array->value;return 0 ;
kernel/bpf/bpf_insn_array.c +5 -3
@@ -121,9 +121,11 @@ static int insn_array_map_direct_value_addr(const struct bpf_map *map, u64 *imm, {struct bpf_insn_array *insn_array =cast_insn_array (map); -if ((off %sizeof (long )) !=0 || - (off /sizeof (long )) >= map->max_entries) -return -EINVAL ; +/* +* if ((off % sizeof(long)) != 0 || +* (off / sizeof(long)) >= map->max_entries) +* return -EINVAL; +*/ /* from BPF's point of view, this map is a jump table */ *imm = (unsigned long )insn_array->ips + off;
Emil Tsalapatis
reviewerRe: [PATCH v3 2/5] bpf/verifier: do not limit maximum direct offset into arena map
Quoted 16 lines · Eduard Zingerman
Quoted 11 lines · Emil Tsalapatis
The verifier currently limits direct offsets into a map to 512MiB to avoid overflow during pointer arithmetic. However, this prevents arena maps from using direct addressing instructions to access data at the end of > 512MiB arena maps. This is necessary when moving arena globals to the end of the arena instead of the front.
Refactor the verifier code to remove the offset calculation during direct value access calculations. This is possible because the only two map types that implement .map_direct_value_addr() are arrays and arenas, and they both do their own internal checks to ensure the offset is within bounds.
Nit: instruction array map also implements it (
bpf_insn_array.c).Quoted 1 line
Quoted 7 lines
Quoted 2 lines
Signed-off-by Emil Tsalapatis <[email protected]>---
I double checked implementations for all 3 map types and confirm that the above is correct. Also, I commented out the range checks in kernel implementations (as in the attached patch), and no tests seem to fail. Do we need to extend selftests?
I forgot to address a couple selftest errors from this patch in this version, but after fixing them for v4 and applying the attached patch I am getting a couple failures - direct map access tests #332, #334, #336, #337, #338, #345. #332 (write test 7) is an unexpected load success, while the rest are about a mismatch in the error message. Maybe the test wasn't being marked as an unexpected success because I hadn't fixed it up?
Quoted 2 lines
Acked-by Eduard Zingerman <[email protected]>
I will omit the Acked-by tag in v4 because I changed the selftests - sorry for the after-the-fact changes.
Quoted 1 line
[...]
Eduard Zingerman
maintainerRe: [PATCH v3 2/5] bpf/verifier: do not limit maximum direct offset into arena map
Quoted 20 lines · Emil Tsalapatis
Quoted 19 lines · Eduard Zingerman
Quoted 11 lines · Emil Tsalapatis
The verifier currently limits direct offsets into a map to 512MiB to avoid overflow during pointer arithmetic. However, this prevents arena maps from using direct addressing instructions to access data at the end of > 512MiB arena maps. This is necessary when moving arena globals to the end of the arena instead of the front.
Refactor the verifier code to remove the offset calculation during direct value access calculations. This is possible because the only two map types that implement .map_direct_value_addr() are arrays and arenas, and they both do their own internal checks to ensure the offset is within bounds.
Nit: instruction array map also implements it (
bpf_insn_array.c).Quoted 3 lines
Signed-off-by Emil Tsalapatis <[email protected]>---
Quoted 8 lines
Quoted 4 lines
I double checked implementations for all 3 map types and confirm that the above is correct. Also, I commented out the range checks in kernel implementations (as in the attached patch), and no tests seem to fail. Do we need to extend selftests?
I forgot to address a couple selftest errors from this patch in this version, but after fixing them for v4 and applying the attached patch I am getting a couple failures - direct map access tests #332, #334, #336, #337, #338, #345.
Uh-oh, sorry, I forgot about test_verifier binary.
Quoted 3 lines
#332 (write test 7) is an unexpected load success, while the rest are about a mismatch in the error message. Maybe the test wasn't being marked as an unexpected success because I hadn't fixed it up?
For me it shows:
#332/p direct map access, write test 7 FAIL
Unexpected verifier log!
EXP: direct value offset of 4294967295 is not allowed
RES:
FAIL
Unexpected error message!
EXP: direct value offset of 4294967295 is not allowed
RES: invalid access to map value pointer, value_size=48 off=4294967295
So, seem to be an expected behavior given your changes?
Emil Tsalapatis
reviewerRe: [PATCH v3 2/5] bpf/verifier: do not limit maximum direct offset into arena map
Quoted 47 lines · Eduard Zingerman
Quoted 20 lines · Emil Tsalapatis
Quoted 19 lines · Eduard Zingerman
Quoted 11 lines · Emil Tsalapatis
The verifier currently limits direct offsets into a map to 512MiB to avoid overflow during pointer arithmetic. However, this prevents arena maps from using direct addressing instructions to access data at the end of > 512MiB arena maps. This is necessary when moving arena globals to the end of the arena instead of the front.
Refactor the verifier code to remove the offset calculation during direct value access calculations. This is possible because the only two map types that implement .map_direct_value_addr() are arrays and arenas, and they both do their own internal checks to ensure the offset is within bounds.
Nit: instruction array map also implements it (
bpf_insn_array.c).Quoted 3 lines
Signed-off-by Emil Tsalapatis <[email protected]>---
Quoted 8 lines
Quoted 4 lines
I double checked implementations for all 3 map types and confirm that the above is correct. Also, I commented out the range checks in kernel implementations (as in the attached patch), and no tests seem to fail. Do we need to extend selftests?
I forgot to address a couple selftest errors from this patch in this version, but after fixing them for v4 and applying the attached patch I am getting a couple failures - direct map access tests #332, #334, #336, #337, #338, #345.
Uh-oh, sorry, I forgot about
test_verifierbinary.Quoted 3 lines
#332 (write test 7) is an unexpected load success, while the rest are about a mismatch in the error message. Maybe the test wasn't being marked as an unexpected success because I hadn't fixed it up?
For me it shows:
#332/p direct map access, write test 7 FAIL
Unexpected verifier log!
EXP: direct value offset of 4294967295 is not allowed
RES:
FAIL
Unexpected error message!
EXP: direct value offset of 4294967295 is not allowed
RES: invalid access to map value pointer, value_size=48 off=4294967295
Quoted 1 line
So, seem to be an expected behavior given your changes?
Yes, for v3 this was the expected behavior: The tests used to trigger the old error msg (in EXP), but even after removing it they fail because the map isn't actually large enough to support the value offset offset of the tests ((-1) and (1UL << 29) for tests 7 and 12). The RES output is from the .map_direct_value_addr() method doing bounds checking and rejecting the out-of-bounds offset.
Emil Tsalapatis
reviewerPATCH v3 3/5 libbpf: turn relo_core->sym_off unsigned
In reply to Emil TsalapatisThe symbols' relocation offsets in BPF are stored in an int field, but cannot actually be negative. When in the next patch libbpf relocates globals to the end of the arena, it is also possible to have valid offsets > 2GiB that are used to calculate the final relo offsets. Avoid accidentally interpreting large offsets as negative by turning the sym_off field unsigned.
--- tools/lib/bpf/libbpf.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
tools/lib/bpf/libbpf.c +2 -2
@@ -380,7 +380,7 @@ struct reloc_desc {const struct bpf_core_relo *core_relo;/* used when type == RELO_CORE */ struct {int map_idx; -int sym_off; +unsigned int sym_off;/* * The following two fields can be unionized, as the * ext_idx field is used for extern symbols, and the
@@ -763,7 +763,7 @@ struct bpf_object {struct {struct bpf_program *prog; -int sym_off; +unsigned int sym_off;int fd; } *jumptable_maps;size_t jumptable_map_cnt;
Signature · 1 line
2.49.0
[email protected]
AI reviewRe: [PATCH v3 3/5] libbpf: turn relo_core->sym_off unsigned
The field type change looks correct, but does create_jt_map() defeat the purpose of this patch? That function declares a local variable "int sym_off" that immediately converts the unsigned field…
Quoted 14 lines
tools/lib/bpf/libbpf.c +1
-1@@ -380,7 +380,7 @@ struct reloc_desc {const struct bpf_core_relo *core_relo;/* used when type == RELO_CORE */ struct {int map_idx; -int sym_off; +unsigned int sym_off;/* * The following two fields can be unionized, as the * ext_idx field is used for extern symbols, and the
tools/lib/bpf/libbpf.c struct bpf_object { · line 769
Quoted 8 lines
tools/lib/bpf/libbpf.c +1
-1@@ -763,7 +763,7 @@ struct bpf_object {struct {struct bpf_program *prog; -int sym_off; +unsigned int sym_off;int fd; } *jumptable_maps;size_t jumptable_map_cnt;
The field type change looks correct, but does create_jt_map() defeat the purpose of this patch? That function declares a local variable "int sym_off" that immediately converts the unsigned field back to signed. When sym_off is >= 2GiB (the exact scenario this patch enables), the local variable will interpret it as negative, causing incorrect behavior in the modulo check, bounds check, and pointer arithmetic that follow.
---
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/20239524817
Emil Tsalapatis
reviewerRe: [PATCH v3 3/5] libbpf: turn relo_core->sym_off unsigned
Quoted 15 lines · bot+bpf-ci
Quoted 15 lines
tools/lib/bpf/libbpf.c +1
-1@@ -380,7 +380,7 @@ struct reloc_desc {const struct bpf_core_relo *core_relo;/* used when type == RELO_CORE */ struct {int map_idx; -int sym_off; +unsigned int sym_off;/* * The following two fields can be unionized, as the * ext_idx field is used for extern symbols, and the @@ -763,7 +763,7 @@ struct bpf_object {
Quoted 17 lines
tools/lib/bpf/libbpf.c struct bpf_object { · line 769
Quoted 7 lines
tools/lib/bpf/libbpf.c +1
-1struct {struct bpf_program *prog; -int sym_off; +unsigned int sym_off;int fd; } *jumptable_maps;size_t jumptable_map_cnt;The field type change looks correct, but does
create_jt_map()defeat the purpose of this patch? That function declares a local variable "intsym_off" that immediately converts the unsigned field back to signed. Whensym_offis >= 2GiB (the exact scenario this patch enables), the local variable will interpret it as negative, causing incorrect behavior in the modulo check, bounds check, and pointer arithmetic that follow.
The jumptable relocations handled by create_jt_map() don't have their symbol offset artificially inflated they way we do for symbols in the arena section, so keeping the sym_off signed inside create_jt_map() should not cause a problem. We should still change it to handle sym_off consistently across the codebase.
Quoted 5 lines
---
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.mdCI run summary: https://github.com/kernel-patches/bpf/actions/runs/20239524817
Re: [PATCH v3 3/5] libbpf: turn relo_core->sym_off unsigned
In reply to Emil TsalapatisQuoted 9 lines · Emil Tsalapatis
The symbols' relocation offsets in BPF are stored in an int field, but cannot actually be negative. When in the next patch libbpf relocates globals to the end of the arena, it is also possible to have valid offsets > 2GiB that are used to calculate the final relo offsets. Avoid accidentally interpreting large offsets as negative by turning the
sym_offfield unsigned.Signed-off-by Emil Tsalapatis <[email protected]>---
(But agree with the nit from LLM, create_jt_map() should be updated
for consistency).
Emil Tsalapatis
reviewerPATCH v3 4/5 libbpf: move arena globals to the end of the arena
In reply to Emil TsalapatisArena globals are currently placed at the beginning of the arena by libbpf. This is convenient, but prevents users from reserving guard pages in the beginning of the arena to identify NULL pointer dereferences. Adjust the load logic to place the globals at the end of the arena instead.
Also modify bpftool to set the arena pointer in the program's BPF skeleton to point to the globals. Users now call bpf_map__initial_value() to find the beginning of the arena mapping and use the arena pointer in the skeleton to determine which part of the mapping holds the arena globals and which part is free.
--- tools/lib/bpf/libbpf.c | 17 +++++++++++++---- .../selftests/bpf/progs/verifier_arena_large.c | 12 +++++++++--- 2 files changed, 22 insertions(+), 7 deletions(-)
tools/lib/bpf/libbpf.c +13 -4
@@ -757,6 +757,7 @@ struct bpf_object {int arena_map_idx;void *arena_data;size_t arena_data_sz; +size_t arena_data_off;void *jumptables_data;size_t jumptables_data_sz;
@@ -2991,10 +2992,11 @@ static int init_arena_map_data(struct bpf_object *obj, struct bpf_map *map, void *data, size_t data_sz) {const long page_sz =sysconf (_SC_PAGE_SIZE); +const size_t data_alloc_sz =roundup (data_sz, page_sz);size_t mmap_sz; mmap_sz =bpf_map_mmap_sz (map); -if (roundup (data_sz, page_sz) > mmap_sz) { +if (data_alloc_sz > mmap_sz) {pr_warn ("elf: sec '%s': declared ARENA map size (%zu) is too small to hold global __arena variables of size %zu\n" , sec_name, mmap_sz, data_sz);return -E2BIG ;
@@ -3006,6 +3008,9 @@ static int init_arena_map_data(struct bpf_object *obj, struct bpf_map *map,memcpy (obj->arena_data, data, data_sz); obj->arena_data_sz = data_sz; +/* place globals at the end of the arena */ + obj->arena_data_off = mmap_sz - data_alloc_sz; +/* make bpf_map__init_value() work for ARENA maps */ map->mmaped = obj->arena_data;
@@ -4663,7 +4668,7 @@ static int bpf_program__record_reloc(struct bpf_program *prog, reloc_desc->type =RELO_DATA ; reloc_desc->insn_idx = insn_idx; reloc_desc->map_idx = obj->arena_map_idx; - reloc_desc->sym_off = sym->st_value; + reloc_desc->sym_off = sym->st_value + obj->arena_data_off; map = &obj->maps[obj->arena_map_idx]; pr_debug("prog '%s': found arena map %d (%s, sec %d, off %zu) for insn %u\n",
@@ -5624,7 +5629,8 @@ bpf_object__create_maps(struct bpf_object *obj)return err; }if (obj->arena_data) { -memcpy (map->mmaped, obj->arena_data, obj->arena_data_sz); +memcpy (map->mmaped + obj->arena_data_off, obj->arena_data, + obj->arena_data_sz);zfree (&obj->arena_data); } }
@@ -14429,7 +14435,10 @@ int bpf_object__load_skeleton(struct bpf_object_skeleton *s)if (!map_skel->mmaped)continue ; - *map_skel->mmaped = map->mmaped; +if (map->def.type ==BPF_MAP_TYPE_ARENA ) + *map_skel->mmaped = map->mmaped + map->obj->arena_data_off; +else + *map_skel->mmaped = map->mmaped; }return 0 ;
tools/testing/selftests/bpf/progs/verifier_arena_large.c +9 -3
@@ -31,16 +31,22 @@ int big_alloc1(void *ctx)if (!page1)return 1 ; -/* Account for global arena data. */ -if ((u64 )page1 != base +PAGE_SIZE ) +if ((u64 )page1 != base)return 15 ; *page1 =1 ; - page2 = bpf_arena_alloc_pages(&arena, (void __arena *)(ARENA_SIZE - PAGE_SIZE), + page2 = bpf_arena_alloc_pages(&arena, (void __arena *)(ARENA_SIZE - 2 * PAGE_SIZE),1 ,NUMA_NO_NODE ,0 );if (!page2)return 2 ; *page2 =2 ; + +/* Test for the guard region at the end of the arena. */ + no_page = bpf_arena_alloc_pages(&arena, (void __arena *)ARENA_SIZE - PAGE_SIZE, +1 ,NUMA_NO_NODE ,0 ); +if (no_page) +return 16 ; + no_page = bpf_arena_alloc_pages(&arena, (void __arena *)ARENA_SIZE,1 ,NUMA_NO_NODE ,0 );if (no_page)
Signature · 1 line
2.49.0
Re: [PATCH v3 4/5] libbpf: move arena globals to the end of the arena
Quoted 12 lines · Emil Tsalapatis
Arena globals are currently placed at the beginning of the arena by libbpf. This is convenient, but prevents users from reserving guard pages in the beginning of the arena to identify NULL pointer dereferences. Adjust the load logic to place the globals at the end of the arena instead.
Also modify bpftool to set the arena pointer in the program's BPF skeleton to point to the globals. Users now call
bpf_map__initial_value()to find the beginning of the arena mapping and use the arena pointer in the skeleton to determine which part of the mapping holds the arena globals and which part is free.
Quoted 3 lines
Suggested-by Andrii Nakryiko <[email protected]>Signed-off-by Emil Tsalapatis <[email protected]>---
[...]
Emil Tsalapatis
reviewerPATCH v3 5/5 selftests/bpf: add tests for the arena offset of globals
In reply to Emil TsalapatisAdd tests for the new libbpf globals arena offset logic. The tests cover the case of globals being as large as the arena itself, and being smaller than the arena. In that case, the data is placed at the end of the arena, and the beginning of the arena is free.
--- .../selftests/bpf/prog_tests/verifier.c | 4 + .../bpf/progs/verifier_arena_globals1.c | 75 +++++++++++++++++++ .../bpf/progs/verifier_arena_globals2.c | 49 ++++++++++++ 3 files changed, 128 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/verifier_arena_globals1.c create mode 100644 tools/testing/selftests/bpf/progs/verifier_arena_globals2.c
tools/testing/selftests/bpf/prog_tests/verifier.c +4 -0
@@ -6,6 +6,8 @@#include "verifier_and.skel.h" #include "verifier_arena.skel.h" #include "verifier_arena_large.skel.h" +#include "verifier_arena_globals1.skel.h" +#include "verifier_arena_globals2.skel.h" #include "verifier_array_access.skel.h" #include "verifier_async_cb_context.skel.h" #include "verifier_basic_stack.skel.h"
@@ -147,6 +149,8 @@ static void run_tests_aux(const char *skel_name,void test_verifier_and (void ) {RUN (verifier_and); }void test_verifier_arena (void ) {RUN (verifier_arena); }void test_verifier_arena_large (void ) {RUN (verifier_arena_large); } +void test_verifier_arena_globals1 (void ) {RUN (verifier_arena_globals1); } +void test_verifier_arena_globals2 (void ) {RUN (verifier_arena_globals2); }void test_verifier_basic_stack (void ) {RUN (verifier_basic_stack); }void test_verifier_bitfield_write (void ) {RUN (verifier_bitfield_write); }void test_verifier_bounds (void ) {RUN (verifier_bounds); }
tools/testing/selftests/bpf/progs/verifier_arena_globals1.c new file +75 -0
75 lines not on this page · raw message
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c new file +49 -0
49 lines not on this page · raw message
Signature · 1 line
2.49.0
Eduard Zingerman
maintainerRe: [PATCH v3 5/5] selftests/bpf: add tests for the arena offset of globals
Quoted 81 lines · Emil Tsalapatis
Add tests for the new libbpf globals arena offset logic. The tests cover the case of globals being as large as the arena itself, and being smaller than the arena. In that case, the data is placed at the end of the arena, and the beginning of the arena is free.
Signed-off-by Emil Tsalapatis <[email protected]>--- .../selftests/bpf/prog_tests/verifier.c | 4 + .../bpf/progs/verifier_arena_globals1.c | 75 +++++++++++++++++++ .../bpf/progs/verifier_arena_globals2.c | 49 ++++++++++++ 3 files changed, 128 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/verifier_arena_globals1.c create mode 100644 tools/testing/selftests/bpf/progs/verifier_arena_globals2.ctools/testing/selftests/bpf/prog_tests/verifier.c +4
-0@@ -6,6 +6,8 @@#include "verifier_and.skel.h" #include "verifier_arena.skel.h" #include "verifier_arena_large.skel.h" +#include "verifier_arena_globals1.skel.h" +#include "verifier_arena_globals2.skel.h" #include "verifier_array_access.skel.h" #include "verifier_async_cb_context.skel.h" #include "verifier_basic_stack.skel.h" @@ -147,6 +149,8 @@ static void run_tests_aux(const char *skel_name,void test_verifier_and (void ) {RUN (verifier_and); }void test_verifier_arena (void ) {RUN (verifier_arena); }void test_verifier_arena_large (void ) {RUN (verifier_arena_large); } +void test_verifier_arena_globals1 (void ) {RUN (verifier_arena_globals1); } +void test_verifier_arena_globals2 (void ) {RUN (verifier_arena_globals2); }void test_verifier_basic_stack (void ) {RUN (verifier_basic_stack); }void test_verifier_bitfield_write (void ) {RUN (verifier_bitfield_write); }void test_verifier_bounds (void ) {RUN (verifier_bounds); }tools/testing/selftests/bpf/progs/verifier_arena_globals1.c new file +38
-0@@ -0,0 +1,75 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */ + +#define BPF_NO_KFUNC_PROTOTYPES +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> +#include "bpf_experimental.h" +#include "bpf_arena_common.h" +#include "bpf_misc.h" + +#define ARENA_PAGES (1UL<< (32 - 12)) +#define GLOBAL_PAGES (16) + +struct { + __uint(type, BPF_MAP_TYPE_ARENA); + __uint(map_flags, BPF_F_MMAPABLE); + __uint(max_entries, ARENA_PAGES); +#ifdef __TARGET_ARCH_arm64 + __ulong(map_extra, (1ull << 32) | (~0u - __PAGE_SIZE * ARENA_PAGES + 1)); +#else + __ulong(map_extra, (1ull << 44) | (~0u - __PAGE_SIZE * ARENA_PAGES + 1)); +#endif +} arena SEC(".maps"); + +/* +* Global data, to be placed at the end of the arena. +*/ +char __arena global_data[GLOBAL_PAGES][PAGE_SIZE]; + +SEC("syscall") +__success __retval(0) +int check_reserve1(void *ctx) +{ +#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) + __u8 __arena *guard, *globals; +int ret; +
tools/testing/selftests/bpf/progs/verifier_arena_globals1.c line 48
Quoted 10 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals1.c new file +10
-0+ guard = (void __arena *)arena_base(&arena); + globals = (void __arena *)(arena_base(&arena) + (ARENA_PAGES - GLOBAL_PAGES) * PAGE_SIZE); + +/* Reserve the region we've offset the globals by. */ + ret =bpf_arena_reserve_pages (&arena, guard,ARENA_PAGES -GLOBAL_PAGES ); +if (ret) +return 1 ; + +/* Make sure the globals are in the expected offset. */ + ret =bpf_arena_reserve_pages (&arena, globals,1 );
In addition to checking that reserving pages succeeds, do we need to test pages content here?
Quoted 52 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals1.c new file +27
-0+if (!ret) +return 2 ; +#endif +return 0 ; +} + +/* +* Relocation check by reading directly into the global data w/o using symbols. +*/ +SEC("syscall") +__success __retval(0) +int check_relocation(void *ctx) +{ +#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) +const u8 magic =0xfa ; + u8 __arena *ptr; + + global_data[GLOBAL_PAGES -1 ][PAGE_SIZE /2 ] = magic; + ptr = (u8 __arena *)((u64)(ARENA_PAGES * PAGE_SIZE - PAGE_SIZE / 2)); +if (*ptr != magic) +return 1 ; + +#endif +return 0 ; +} + +char _license[] SEC("license") = "GPL";tools/testing/selftests/bpf/progs/verifier_arena_globals2.c new file +19
-0@@ -0,0 +1,49 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */ + +#define BPF_NO_KFUNC_PROTOTYPES +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> +#include "bpf_misc.h" +#include "bpf_experimental.h" +#include "bpf_arena_common.h" + +#define ARENA_PAGES (32) + +struct { + __uint(type, BPF_MAP_TYPE_ARENA); + __uint(map_flags, BPF_F_MMAPABLE); + __uint(max_entries, ARENA_PAGES); +#ifdef __TARGET_ARCH_arm64 + __ulong(map_extra, (1ull << 32) | (~0u - __PAGE_SIZE * ARENA_PAGES + 1));
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c line 29
Quoted 10 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c new file +10
-0+#else +__ulong (map_extra, (1ull <<44 ) | (~0u - __PAGE_SIZE *ARENA_PAGES +1 )); +#endif +} arena SEC(".maps"); + +/* +* Fill the entire arena with global data. +* The offset into the arena should be 0. +*/ +char __arena global_data[PAGE_SIZE][ARENA_PAGES];
^^^^^^^^^
Nit: this is reversed compared to the declaration in the previous test:
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c line 33
Quoted 4 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c new file +4
-0+/* +* Global data, to be placed at the end of the arena. +*/ +char __arena global_data[GLOBAL_PAGES][PAGE_SIZE];
^^^^^^^^^
Quoted 20 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c new file +20
-0+ +SEC("syscall") +__success __retval(0) +int check_reserve2 (void *ctx) +{ +#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) + void __arena *guard; +int ret; + + guard = (void __arena *)arena_base(&arena); + +/* Make sure the data at offset 0 case is properly handled. */ + ret =bpf_arena_reserve_pages (&arena, guard,1 ); +if (!ret) +return 1 ; +#endif +return 0 ; +} + +char _license[] SEC("license") = "GPL";
Emil Tsalapatis
reviewerRe: [PATCH v3 5/5] selftests/bpf: add tests for the arena offset of globals
Quoted 87 lines · Eduard Zingerman
Quoted 86 lines · Emil Tsalapatis
Add tests for the new libbpf globals arena offset logic. The tests cover the case of globals being as large as the arena itself, and being smaller than the arena. In that case, the data is placed at the end of the arena, and the beginning of the arena is free.
Signed-off-by Emil Tsalapatis <[email protected]>--- .../selftests/bpf/prog_tests/verifier.c | 4 + .../bpf/progs/verifier_arena_globals1.c | 75 +++++++++++++++++++ .../bpf/progs/verifier_arena_globals2.c | 49 ++++++++++++ 3 files changed, 128 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/verifier_arena_globals1.c create mode 100644 tools/testing/selftests/bpf/progs/verifier_arena_globals2.ctools/testing/selftests/bpf/prog_tests/verifier.c +4
-0@@ -6,6 +6,8 @@#include "verifier_and.skel.h" #include "verifier_arena.skel.h" #include "verifier_arena_large.skel.h" +#include "verifier_arena_globals1.skel.h" +#include "verifier_arena_globals2.skel.h" #include "verifier_array_access.skel.h" #include "verifier_async_cb_context.skel.h" #include "verifier_basic_stack.skel.h" @@ -147,6 +149,8 @@ static void run_tests_aux(const char *skel_name,void test_verifier_and (void ) {RUN (verifier_and); }void test_verifier_arena (void ) {RUN (verifier_arena); }void test_verifier_arena_large (void ) {RUN (verifier_arena_large); } +void test_verifier_arena_globals1 (void ) {RUN (verifier_arena_globals1); } +void test_verifier_arena_globals2 (void ) {RUN (verifier_arena_globals2); }void test_verifier_basic_stack (void ) {RUN (verifier_basic_stack); }void test_verifier_bitfield_write (void ) {RUN (verifier_bitfield_write); }void test_verifier_bounds (void ) {RUN (verifier_bounds); }tools/testing/selftests/bpf/progs/verifier_arena_globals1.c new file +43
-0@@ -0,0 +1,75 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */ + +#define BPF_NO_KFUNC_PROTOTYPES +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> +#include "bpf_experimental.h" +#include "bpf_arena_common.h" +#include "bpf_misc.h" + +#define ARENA_PAGES (1UL<< (32 - 12)) +#define GLOBAL_PAGES (16) + +struct { + __uint(type, BPF_MAP_TYPE_ARENA); + __uint(map_flags, BPF_F_MMAPABLE); + __uint(max_entries, ARENA_PAGES); +#ifdef __TARGET_ARCH_arm64 + __ulong(map_extra, (1ull << 32) | (~0u - __PAGE_SIZE * ARENA_PAGES + 1)); +#else + __ulong(map_extra, (1ull << 44) | (~0u - __PAGE_SIZE * ARENA_PAGES + 1)); +#endif +} arena SEC(".maps"); + +/* +* Global data, to be placed at the end of the arena. +*/ +char __arena global_data[GLOBAL_PAGES][PAGE_SIZE]; + +SEC("syscall") +__success __retval(0) +int check_reserve1(void *ctx) +{ +#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) + __u8 __arena *guard, *globals; +int ret; + + guard = (void __arena *)arena_base(&arena); + globals = (void __arena *)(arena_base(&arena) + (ARENA_PAGES - GLOBAL_PAGES) * PAGE_SIZE); + +/* Reserve the region we've offset the globals by. */ + ret =bpf_arena_reserve_pages (&arena, guard,ARENA_PAGES -GLOBAL_PAGES );
Quoted 9 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals1.c line 48
Quoted 5 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals1.c new file +5
-0+if (ret) +return 1 ; + +/* Make sure the globals are in the expected offset. */ + ret =bpf_arena_reserve_pages (&arena, globals,1 );In addition to checking that reserving pages succeeds, do we need to test pages content here?
For sure, I will make sure the arena globals are writable.
Quoted 64 lines
Quoted 52 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals1.c new file +27
-0+if (!ret) +return 2 ; +#endif +return 0 ; +} + +/* +* Relocation check by reading directly into the global data w/o using symbols. +*/ +SEC("syscall") +__success __retval(0) +int check_relocation(void *ctx) +{ +#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) +const u8 magic =0xfa ; + u8 __arena *ptr; + + global_data[GLOBAL_PAGES -1 ][PAGE_SIZE /2 ] = magic; + ptr = (u8 __arena *)((u64)(ARENA_PAGES * PAGE_SIZE - PAGE_SIZE / 2)); +if (*ptr != magic) +return 1 ; + +#endif +return 0 ; +} + +char _license[] SEC("license") = "GPL";tools/testing/selftests/bpf/progs/verifier_arena_globals2.c new file +19
-0@@ -0,0 +1,49 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */ + +#define BPF_NO_KFUNC_PROTOTYPES +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> +#include "bpf_misc.h" +#include "bpf_experimental.h" +#include "bpf_arena_common.h" + +#define ARENA_PAGES (32) + +struct { + __uint(type, BPF_MAP_TYPE_ARENA); + __uint(map_flags, BPF_F_MMAPABLE); + __uint(max_entries, ARENA_PAGES); +#ifdef __TARGET_ARCH_arm64 + __ulong(map_extra, (1ull << 32) | (~0u - __PAGE_SIZE * ARENA_PAGES + 1));tools/testing/selftests/bpf/progs/verifier_arena_globals2.c line 29
Quoted 10 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c new file +10
-0+#else +__ulong (map_extra, (1ull <<44 ) | (~0u - __PAGE_SIZE *ARENA_PAGES +1 )); +#endif +} arena SEC(".maps"); + +/* +* Fill the entire arena with global data. +* The offset into the arena should be 0. +*/ +char __arena global_data[PAGE_SIZE][ARENA_PAGES];^^^^^^^^^
Quoted 8 lines
Nit: this is reversed compared to the declaration in the previous test:
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c line 33
Quoted 4 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c new file +4
-0+/* +* Global data, to be placed at the end of the arena. +*/ +char __arena global_data[GLOBAL_PAGES][PAGE_SIZE];^^^^^^^^^
Ack, will fix.
Quoted 20 lines
Quoted 20 lines
tools/testing/selftests/bpf/progs/verifier_arena_globals2.c new file +20
-0+ +SEC("syscall") +__success __retval(0) +int check_reserve2 (void *ctx) +{ +#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) + void __arena *guard; +int ret; + + guard = (void __arena *)arena_base(&arena); + +/* Make sure the data at offset 0 case is properly handled. */ + ret =bpf_arena_reserve_pages (&arena, guard,1 ); +if (!ret) +return 1 ; +#endif +return 0 ; +} + +char _license[] SEC("license") = "GPL";