Skip to contentSkip to conversation

libbpf: move arena variables out of the zero page

PATCH Superseded Emil Tsalapatis 3 participants 16 messages Dec 15, 2025 – Dec 16, 2025

Subsystems (5)
Kselftest BPF BPF selftests BPF core +1 more subsystems

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore

Emil Tsalapatis

author reviewer
#0 lore raw

v3 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
author reviewer
#1 lore raw

PATCH 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
index f19e15400b3e..bd430a34c3ab 100644
@@ -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
author reviewer
#2 lore raw

PATCH v3 2/5 bpf/verifier: do not limit maximum direct offset into arena map

In reply to 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.

---
 kernel/bpf/verifier.c | 5 -----
 1 file changed, 5 deletions(-)
kernel/bpf/verifier.c +0 -5
index bb7eca1025c3..dbb60d6bb73c 100644
@@ -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
maintainer Acked-by on v3 2/5
#3 lore raw

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

---

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
index 1074ac4459f2..cf38388bb094 100644
@@ -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
index 1eeb31c5b317..e13c58f2e3b8 100644
@@ -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
index c96630cb75bf..aa4b71365541 100644
@@ -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;
author reviewer
#4 lore raw

Re: [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

---

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

I will omit the Acked-by tag in v4 because I changed the selftests - sorry for the after-the-fact changes.

Quoted 1 line

[...]

maintainer
#5 lore raw

Re: [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

---

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?

author reviewer
#6 lore raw

Re: [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

---

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

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.

author reviewer
#7 lore raw

PATCH v3 3/5 libbpf: turn relo_core->sym_off unsigned

In reply to 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_off field unsigned.

---
 tools/lib/bpf/libbpf.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
tools/lib/bpf/libbpf.c +2 -2
index c7c79014d46c..5e66bbc2ab85 100644
@@ -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
#8 lore raw

Re: [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
index c7c79014d46c..5e66bbc2ab85 100644
@@ -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

author reviewer
#9 lore raw

Re: [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
index c7c79014d46c..5e66bbc2ab85 100644
@@ -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 -1
 	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.

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.md

CI run summary: https://github.com/kernel-patches/bpf/actions/runs/20239524817

maintainer Acked-by on v3 3/5
#10 lore raw

Re: [PATCH v3 3/5] libbpf: turn relo_core->sym_off unsigned

In reply to Emil Tsalapatis
Quoted 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_off field unsigned.

---

(But agree with the nit from LLM, create_jt_map() should be updated
for consistency).

author reviewer
#11 lore raw

PATCH v3 4/5 libbpf: move arena globals to the end of the arena

In reply to 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.

---
 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
index 5e66bbc2ab85..135f5b36256e 100644
@@ -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
index bd430a34c3ab..2b8cf2a4d880 100644
@@ -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
maintainer Acked-by on v3 4/5
#12 lore raw

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

---

[...]

author reviewer
#13 lore raw

PATCH v3 5/5 selftests/bpf: add tests for the arena offset of globals

In reply to 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.

---
 .../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
index 4b4b081b46cc..5829ffd70f8f 100644
@@ -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
maintainer
#14 lore raw

Re: [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.

---
 .../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
index 4b4b081b46cc..5829ffd70f8f 100644
@@ -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
new file mode 100644
index 000000000000..d998a277e5e7
@@ -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
new file mode 100644
index 000000000000..5a6f6bc3b00c
@@ -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";
author reviewer
#15 lore raw

Re: [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.

---
 .../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
index 4b4b081b46cc..5829ffd70f8f 100644
@@ -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
new file mode 100644
index 000000000000..d998a277e5e7
@@ -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
new file mode 100644
index 000000000000..5a6f6bc3b00c
@@ -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";