bpf: Fix arena VMA use-after-free on fork
Subsystems (3)
v4 cover bpf: Fix arena VMA use-after-free on fork
arena_vm_open() only increments a refcount on the shared vma_list entry but never registers the new VMA. After fork + parent munmap, vml->vma becomes a dangling pointer. bpf_arena_free_pages -> zap_pages then dereferences it, causing a slab-use-after-free in zap_page_range_single.
Patch 1 fixes the bug by tracking each child VMA separately in arena_vm_open, and adds arena_vm_may_split() to prevent VMA splitting. Patch 2 adds a selftest that reproduces the issue (requires KASAN to detect the UAF).
v4:
- Fixed commit message: OOM case description, may_split rationale
v3:
- Added arena_vm_may_split() to prevent VMA splitting
- Reuse remember_vma() in arena_vm_open(), removed HugeTLB references
- selftests: fixed copyright, trimmed comments, use sysconf()
v2:
- Added missing Reported-by tag
Weiming Shi (2):
bpf: Fix use-after-free of arena VMA on fork selftests/bpf: Add test for arena VMA use-after-free on fork
kernel/bpf/arena.c | 23 ++++-- .../selftests/bpf/prog_tests/arena_fork.c | 80 +++++++++++++++++++ .../testing/selftests/bpf/progs/arena_fork.c | 41 ++++++++++ 3 files changed, 138 insertions(+), 6 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/arena_fork.c create mode 100644 tools/testing/selftests/bpf/progs/arena_fork.c
Signature · 1 line
2.43.0
PATCH v4 1/2 bpf: Fix use-after-free of arena VMA on fork
arena_vm_open() only increments a refcount on the shared vma_list entry but never registers the new VMA or updates the stored vma pointer. When the original VMA is unmapped while a forked copy still exists, arena_vm_close() drops the refcount without freeing the vma_list entry. The entry's vma pointer now refers to a freed vm_area_struct. A subsequent bpf_arena_free_pages() call iterates vma_list and passes the dangling pointer to zap_page_range_single(), causing a use-after-free.
The bug is reachable by any process with CAP_BPF and CAP_PERFMON that can create a BPF_MAP_TYPE_ARENA, mmap it, and fork. It triggers deterministically -- no race condition is involved.
BUG: KASAN: slab-use-after-free in zap_page_range_single (mm/memory.c:2234) Call Trace: <TASK> zap_page_range_single+0x101/0x110 mm/memory.c:2234 zap_pages+0x80/0xf0 kernel/bpf/arena.c:658 arena_free_pages+0x67a/0x860 kernel/bpf/arena.c:712 bpf_prog_test_run_syscall+0x3da net/bpf/test_run.c:1640 __sys_bpf+0x1662/0x50b0 kernel/bpf/syscall.c:6267 __x64_sys_bpf+0x73/0xb0 kernel/bpf/syscall.c:6360 do_syscall_64+0xf1/0x530 arch/x86/entry/syscall_64.c:63 entry_SYSCALL_64_after_hwframe+0x77 arch/x86/entry/entry_64.S:130 </TASK>
Fix this by tracking each child VMA separately. arena_vm_open() now clears the inherited vm_private_data and calls remember_vma() to register a fresh vma_list entry for the new VMA. If remember_vma() fails due to OOM, vm_private_data stays NULL and arena_vm_close() skips the cleanup for that VMA. The shared refcount is no longer needed and is removed.
Also add arena_vm_may_split() returning -EINVAL to prevent VMA splitting, so that arena_vm_open() only needs to handle fork and the vma_list tracking stays simple.
--- kernel/bpf/arena.c | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-)
kernel/bpf/arena.c +17 -6
@@ -317,7 +317,6 @@ static u64 arena_map_mem_usage(const struct bpf_map *map)struct vma_list {struct vm_area_struct *vma;struct list_head head; -refcount_t mmap_count; };static int remember_vma (struct bpf_arena *arena,struct vm_area_struct *vma)
@@ -327,7 +326,6 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma) vml =kmalloc_obj (*vml);if (!vml)return -ENOMEM ; -refcount_set (&vml->mmap_count,1 ); vma->vm_private_data = vml; vml->vma = vma;list_add (&vml->head, &arena->vma_list);
@@ -336,9 +334,17 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma)static void arena_vm_open (struct vm_area_struct *vma) { -struct vma_list *vml = vma->vm_private_data; +struct bpf_map *map = vma->vm_file->private_data; + struct bpf_arena *arena = container_of(map, struct bpf_arena, map); -refcount_inc (&vml->mmap_count); +/* +* vm_private_data points to the parent's vma_list entry after fork. +* Clear it and register this VMA separately. +*/ + vma->vm_private_data =NULL ; +guard (mutex)(&arena->lock); +/* OOM is silently ignored; arena_vm_close() handles NULL. */ +remember_vma (arena, vma); }static void arena_vm_close (struct vm_area_struct *vma)
@@ -347,10 +353,9 @@ static void arena_vm_close(struct vm_area_struct *vma) struct bpf_arena *arena = container_of(map, struct bpf_arena, map);struct vma_list *vml = vma->vm_private_data; -if (!refcount_dec_and_test (&vml->mmap_count)) +if (!vml)return ;guard (mutex)(&arena->lock); -/* update link list under lock */ list_del (&vml->head); vma->vm_private_data =NULL ;kfree (vml);
@@ -415,9 +420,15 @@ static vm_fault_t arena_vm_fault(struct vm_fault *vmf)return VM_FAULT_SIGSEGV ; } +static int arena_vm_may_split (struct vm_area_struct *vma,unsigned long addr) +{ +return -EINVAL ; +} +static const struct vm_operations_struct arena_vm_ops = { .open = arena_vm_open, .close = arena_vm_close, + .may_split = arena_vm_may_split, .fault = arena_vm_fault, };
Signature · 1 line
2.43.0
Emil Tsalapatis
reviewerRe: [PATCH bpf v4 1/2] bpf: Fix use-after-free of arena VMA on fork
Quoted 70 lines · Weiming Shi
arena_vm_open()only increments a refcount on the sharedvma_listentry but never registers the new VMA or updates the stored vma pointer. When the original VMA is unmapped while a forked copy still exists,arena_vm_close()drops the refcount without freeing thevma_listentry. The entry's vma pointer now refers to a freedvm_area_struct. A subsequentbpf_arena_free_pages()call iteratesvma_listand passes the dangling pointer tozap_page_range_single(), causing a use-after-free.The bug is reachable by any process with
CAP_BPFandCAP_PERFMONthat can create aBPF_MAP_TYPE_ARENA, mmap it, and fork. It triggers deterministically -- no race condition is involved.BUG: KASAN: slab-use-after-free in zap_page_range_single (mm/memory.c:2234) Call Trace: <TASK> zap_page_range_single+0x101/0x110 mm/memory.c:2234 zap_pages+0x80/0xf0 kernel/bpf/arena.c:658 arena_free_pages+0x67a/0x860 kernel/bpf/arena.c:712 bpf_prog_test_run_syscall+0x3da net/bpf/test_run.c:1640 __sys_bpf+0x1662/0x50b0 kernel/bpf/syscall.c:6267 __x64_sys_bpf+0x73/0xb0 kernel/bpf/syscall.c:6360 do_syscall_64+0xf1/0x530 arch/x86/entry/syscall_64.c:63 entry_SYSCALL_64_after_hwframe+0x77 arch/x86/entry/entry_64.S:130 </TASK>Fix this by tracking each child VMA separately.
arena_vm_open()now clears the inheritedvm_private_dataand callsremember_vma()to register a freshvma_listentry for the new VMA. Ifremember_vma()fails due to OOM,vm_private_datastays NULL andarena_vm_close()skips the cleanup for that VMA. The shared refcount is no longer needed and is removed.Also add
arena_vm_may_split()returning-EINVALto prevent VMA splitting, so thatarena_vm_open()only needs to handle fork and thevma_listtracking stays simple.Fixes b90d77e5fd78 ("bpf: Fix remap of arena.")Reported-by Xiang Mei <[email protected]>Signed-off-by Weiming Shi <[email protected]>--- kernel/bpf/arena.c | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-)kernel/bpf/arena.c +1
-3@@ -317,7 +317,6 @@ static u64 arena_map_mem_usage(const struct bpf_map *map)struct vma_list {struct vm_area_struct *vma;struct list_head head; -refcount_t mmap_count; };static int remember_vma (struct bpf_arena *arena,struct vm_area_struct *vma)@@ -327,7 +326,6 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma) vml =kmalloc_obj (*vml);if (!vml)return -ENOMEM ; -refcount_set (&vml->mmap_count,1 ); vma->vm_private_data = vml; vml->vma = vma;list_add (&vml->head, &arena->vma_list);@@ -336,9 +334,17 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma)static void arena_vm_open (struct vm_area_struct *vma) { -struct vma_list *vml = vma->vm_private_data; +struct bpf_map *map = vma->vm_file->private_data;
kernel/bpf/arena.c static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma) · line 346
Quoted 10 lines
kernel/bpf/arena.c +8
-1+ struct bpf_arena *arena = container_of(map, struct bpf_arena, map); -refcount_inc (&vml->mmap_count); +/* +* vm_private_data points to the parent's vma_list entry after fork. +* Clear it and register this VMA separately. +*/ + vma->vm_private_data =NULL ; +guard (mutex)(&arena->lock); +/* OOM is silently ignored; arena_vm_close() handles NULL. */
I don't see any way this approach gonna work, and frankly makes no sense to me. This patch doesn't take into account how the vma_list is actually used. It frankly makes no sense, Please think through this: If we could silently just not allocate the vml, why do we need it in the first place?
Quoted 32 lines
kernel/bpf/arena.c +8
-2+remember_vma (arena, vma); }static void arena_vm_close (struct vm_area_struct *vma)@@ -347,10 +353,9 @@ static void arena_vm_close(struct vm_area_struct *vma) struct bpf_arena *arena = container_of(map, struct bpf_arena, map);struct vma_list *vml = vma->vm_private_data; -if (!refcount_dec_and_test (&vml->mmap_count)) +if (!vml)return ;guard (mutex)(&arena->lock); -/* update link list under lock */ list_del (&vml->head); vma->vm_private_data =NULL ;kfree (vml);@@ -415,9 +420,15 @@ static vm_fault_t arena_vm_fault(struct vm_fault *vmf)return VM_FAULT_SIGSEGV ; } +static int arena_vm_may_split (struct vm_area_struct *vma,unsigned long addr) +{ +return -EINVAL ; +} +static const struct vm_operations_struct arena_vm_ops = { .open = arena_vm_open, .close = arena_vm_close, + .may_split = arena_vm_may_split, .fault = arena_vm_fault, };
Re: [PATCH bpf v4 1/2] bpf: Fix use-after-free of arena VMA on fork
Quoted 74 lines · Emil Tsalapatis
Quoted 72 lines · Weiming Shi
arena_vm_open()only increments a refcount on the sharedvma_listentry but never registers the new VMA or updates the stored vma pointer. When the original VMA is unmapped while a forked copy still exists,arena_vm_close()drops the refcount without freeing thevma_listentry. The entry's vma pointer now refers to a freedvm_area_struct. A subsequentbpf_arena_free_pages()call iteratesvma_listand passes the dangling pointer tozap_page_range_single(), causing a use-after-free.The bug is reachable by any process with
CAP_BPFandCAP_PERFMONthat can create aBPF_MAP_TYPE_ARENA, mmap it, and fork. It triggers deterministically -- no race condition is involved.BUG: KASAN: slab-use-after-free in zap_page_range_single (mm/memory.c:2234) Call Trace: <TASK> zap_page_range_single+0x101/0x110 mm/memory.c:2234 zap_pages+0x80/0xf0 kernel/bpf/arena.c:658 arena_free_pages+0x67a/0x860 kernel/bpf/arena.c:712 bpf_prog_test_run_syscall+0x3da net/bpf/test_run.c:1640 __sys_bpf+0x1662/0x50b0 kernel/bpf/syscall.c:6267 __x64_sys_bpf+0x73/0xb0 kernel/bpf/syscall.c:6360 do_syscall_64+0xf1/0x530 arch/x86/entry/syscall_64.c:63 entry_SYSCALL_64_after_hwframe+0x77 arch/x86/entry/entry_64.S:130 </TASK>Fix this by tracking each child VMA separately.
arena_vm_open()now clears the inheritedvm_private_dataand callsremember_vma()to register a freshvma_listentry for the new VMA. Ifremember_vma()fails due to OOM,vm_private_datastays NULL andarena_vm_close()skips the cleanup for that VMA. The shared refcount is no longer needed and is removed.Also add
arena_vm_may_split()returning-EINVALto prevent VMA splitting, so thatarena_vm_open()only needs to handle fork and thevma_listtracking stays simple.Fixes b90d77e5fd78 ("bpf: Fix remap of arena.")Reported-by Xiang Mei <[email protected]>Signed-off-by Weiming Shi <[email protected]>--- kernel/bpf/arena.c | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-)kernel/bpf/arena.c +2
-3@@ -317,7 +317,6 @@ static u64 arena_map_mem_usage(const struct bpf_map *map)struct vma_list {struct vm_area_struct *vma;struct list_head head; -refcount_t mmap_count; };static int remember_vma (struct bpf_arena *arena,struct vm_area_struct *vma)@@ -327,7 +326,6 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma) vml =kmalloc_obj (*vml);if (!vml)return -ENOMEM ; -refcount_set (&vml->mmap_count,1 ); vma->vm_private_data = vml; vml->vma = vma;list_add (&vml->head, &arena->vma_list);@@ -336,9 +334,17 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma)static void arena_vm_open (struct vm_area_struct *vma) { -struct vma_list *vml = vma->vm_private_data; +struct bpf_map *map = vma->vm_file->private_data; + struct bpf_arena *arena = container_of(map, struct bpf_arena, map);
Quoted 13 lines
kernel/bpf/arena.c static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma) · line 346
Quoted 8 lines
kernel/bpf/arena.c +7
-1-refcount_inc (&vml->mmap_count); +/* +* vm_private_data points to the parent's vma_list entry after fork. +* Clear it and register this VMA separately. +*/ + vma->vm_private_data =NULL ; +guard (mutex)(&arena->lock); +/* OOM is silently ignored; arena_vm_close() handles NULL. */ I don't see any way this approach gonna work, and frankly makes no sense to me. This patch doesn't take into account how the
vma_listis actually used. It frankly makes no sense, Please think through this: If we could silently just not allocate the vml, why do we need it in the first place?
+1
Weiming,
you should stop trusting AI so blindly.
First, analyze the root cause (the first paragraph of the commit log). Is this really the case?
Second, I copy pasted it to claude and got the same "fix" back, but implemented without your bug:
+ vml = kmalloc_obj(*vml);
+ if (!vml) {
+ vma->vm_private_data = NULL;
+ return;
+ } + vml->vma = vma; + vma->vm_private_data = vml; + guard(mutex)(&arena->lock); + list_add(&vml->head, &arena->vma_list);
at least this part is kinda makes sense...
and, of course, this part too:
- if (!refcount_dec_and_test(&vml->mmap_count))
+ if (!vml)
return;
when you look at it you MUST ask AI back:
"Is this buggy?"
and it will reply:
"
Right — silently dropping the VMA from the list means zap_pages() won't unmap pages from it, which is a correctness problem, not just degraded behavior. Since vm_open can't fail, the allocation should use __GFP_NOFAIL. The struct is tiny so that's fine.
"
and it proceeded adding __GFP_NOFAIL.
which is wrong too.
So please don't just throw broken patches at maintainers. Do your homework. Fixing one maybe-bug and introducing more real bugs is not a step forward.
pw-bot: cr
Re: [PATCH bpf v4 1/2] bpf: Fix use-after-free of arena VMA on fork
Quoted 130 lines · Alexei Starovoitov
Quoted 74 lines · Emil Tsalapatis
Quoted 72 lines · Weiming Shi
arena_vm_open()only increments a refcount on the sharedvma_listentry but never registers the new VMA or updates the stored vma pointer. When the original VMA is unmapped while a forked copy still exists,arena_vm_close()drops the refcount without freeing thevma_listentry. The entry's vma pointer now refers to a freedvm_area_struct. A subsequentbpf_arena_free_pages()call iteratesvma_listand passes the dangling pointer tozap_page_range_single(), causing a use-after-free.The bug is reachable by any process with
CAP_BPFandCAP_PERFMONthat can create aBPF_MAP_TYPE_ARENA, mmap it, and fork. It triggers deterministically -- no race condition is involved.BUG: KASAN: slab-use-after-free in zap_page_range_single (mm/memory.c:2234) Call Trace: <TASK> zap_page_range_single+0x101/0x110 mm/memory.c:2234 zap_pages+0x80/0xf0 kernel/bpf/arena.c:658 arena_free_pages+0x67a/0x860 kernel/bpf/arena.c:712 bpf_prog_test_run_syscall+0x3da net/bpf/test_run.c:1640 __sys_bpf+0x1662/0x50b0 kernel/bpf/syscall.c:6267 __x64_sys_bpf+0x73/0xb0 kernel/bpf/syscall.c:6360 do_syscall_64+0xf1/0x530 arch/x86/entry/syscall_64.c:63 entry_SYSCALL_64_after_hwframe+0x77 arch/x86/entry/entry_64.S:130 </TASK>Fix this by tracking each child VMA separately.
arena_vm_open()now clears the inheritedvm_private_dataand callsremember_vma()to register a freshvma_listentry for the new VMA. Ifremember_vma()fails due to OOM,vm_private_datastays NULL andarena_vm_close()skips the cleanup for that VMA. The shared refcount is no longer needed and is removed.Also add
arena_vm_may_split()returning-EINVALto prevent VMA splitting, so thatarena_vm_open()only needs to handle fork and thevma_listtracking stays simple.Fixes b90d77e5fd78 ("bpf: Fix remap of arena.")Reported-by Xiang Mei <[email protected]>Signed-off-by Weiming Shi <[email protected]>--- kernel/bpf/arena.c | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-)kernel/bpf/arena.c +2
-3@@ -317,7 +317,6 @@ static u64 arena_map_mem_usage(const struct bpf_map *map)struct vma_list {struct vm_area_struct *vma;struct list_head head; -refcount_t mmap_count; };static int remember_vma (struct bpf_arena *arena,struct vm_area_struct *vma)@@ -327,7 +326,6 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma) vml =kmalloc_obj (*vml);if (!vml)return -ENOMEM ; -refcount_set (&vml->mmap_count,1 ); vma->vm_private_data = vml; vml->vma = vma;list_add (&vml->head, &arena->vma_list);@@ -336,9 +334,17 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma)static void arena_vm_open (struct vm_area_struct *vma) { -struct vma_list *vml = vma->vm_private_data; +struct bpf_map *map = vma->vm_file->private_data; + struct bpf_arena *arena = container_of(map, struct bpf_arena, map);Quoted 13 lines
kernel/bpf/arena.c static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma) · line 346
Quoted 8 lines
kernel/bpf/arena.c +7
-1-refcount_inc (&vml->mmap_count); +/* +* vm_private_data points to the parent's vma_list entry after fork. +* Clear it and register this VMA separately. +*/ + vma->vm_private_data =NULL ; +guard (mutex)(&arena->lock); +/* OOM is silently ignored; arena_vm_close() handles NULL. */ I don't see any way this approach gonna work, and frankly makes no sense to me. This patch doesn't take into account how the
vma_listis actually used. It frankly makes no sense, Please think through this: If we could silently just not allocate the vml, why do we need it in the first place?+1
Weiming,
you should stop trusting AI so blindly.
First, analyze the root cause (the first paragraph of the commit log). Is this really the case?Second, I copy pasted it to claude and got the same "fix" back, but implemented without your bug:
(quoted diff) +9
-0+ vml = kmalloc_obj(*vml); + if (!vml) { + vma->vm_private_data = NULL; + return; + } + vml->vma = vma; + vma->vm_private_data = vml; + guard(mutex)(&arena->lock); + list_add(&vml->head, &arena->vma_list);at least this part is kinda makes sense...
and, of course, this part too:
kernel/bpf/arena.c +1
-1-if (!refcount_dec_and_test (&vml->mmap_count)) +if (!vml)return ;when you look at it you MUST ask AI back:
"Is this buggy?"and it will reply:
"
Right — silently dropping the VMA from the list meanszap_pages()won't unmap pages from it, which is a correctness problem, not just degraded behavior. Sincevm_opencan't fail, the allocation should use__GFP_NOFAIL. The struct is tiny so that's fine.
"and it proceeded adding
__GFP_NOFAIL.
Quoted 7 lines
which is wrong too.
So please don't just throw broken patches at maintainers. Do your homework. Fixing one maybe-bug and introducing more real bugs is not a step forward.
pw-bot: cr
Thanks for the detailed review, really appreciate it.
I traced through it with GDB + KASAN in QEMU. Here's what happens:
1. mmap → remember_vma()
vml->vma = 0xffff88800abfe700, mmap_count = 1
now Parent VMA = 0xffff88800abfe700
2. fork → arena_vm_open(child_vma)
vml->vma = 0xffff88800abfe700 (unchanged), mmap_count = 2 3. parent munmap → arena_vm_close(parent_vma)
mmap_count = 1
vml->vma is now dangling
4. child bpf_arena_free_pages → zap_pages()
reads vml->vma = 0xffff88800abfe700 → UAF
The core issue is that arena_vm_open() never registers the child VMA -- it only bumps the mmap_count . So vml->vma always points at the parent, and dangles once the parent unmaps.
What approach would you suggest for fixing this?
Re: [PATCH bpf v4 1/2] bpf: Fix use-after-free of arena VMA on fork
Quoted 154 lines · Weiming Shi
Quoted 130 lines · Alexei Starovoitov
Quoted 74 lines · Emil Tsalapatis
Quoted 72 lines · Weiming Shi
arena_vm_open()only increments a refcount on the sharedvma_listentry but never registers the new VMA or updates the stored vma pointer. When the original VMA is unmapped while a forked copy still exists,arena_vm_close()drops the refcount without freeing thevma_listentry. The entry's vma pointer now refers to a freedvm_area_struct. A subsequentbpf_arena_free_pages()call iteratesvma_listand passes the dangling pointer tozap_page_range_single(), causing a use-after-free.The bug is reachable by any process with
CAP_BPFandCAP_PERFMONthat can create aBPF_MAP_TYPE_ARENA, mmap it, and fork. It triggers deterministically -- no race condition is involved.BUG: KASAN: slab-use-after-free in zap_page_range_single (mm/memory.c:2234) Call Trace: <TASK> zap_page_range_single+0x101/0x110 mm/memory.c:2234 zap_pages+0x80/0xf0 kernel/bpf/arena.c:658 arena_free_pages+0x67a/0x860 kernel/bpf/arena.c:712 bpf_prog_test_run_syscall+0x3da net/bpf/test_run.c:1640 __sys_bpf+0x1662/0x50b0 kernel/bpf/syscall.c:6267 __x64_sys_bpf+0x73/0xb0 kernel/bpf/syscall.c:6360 do_syscall_64+0xf1/0x530 arch/x86/entry/syscall_64.c:63 entry_SYSCALL_64_after_hwframe+0x77 arch/x86/entry/entry_64.S:130 </TASK>Fix this by tracking each child VMA separately.
arena_vm_open()now clears the inheritedvm_private_dataand callsremember_vma()to register a freshvma_listentry for the new VMA. Ifremember_vma()fails due to OOM,vm_private_datastays NULL andarena_vm_close()skips the cleanup for that VMA. The shared refcount is no longer needed and is removed.Also add
arena_vm_may_split()returning-EINVALto prevent VMA splitting, so thatarena_vm_open()only needs to handle fork and thevma_listtracking stays simple.Fixes b90d77e5fd78 ("bpf: Fix remap of arena.")Reported-by Xiang Mei <[email protected]>Signed-off-by Weiming Shi <[email protected]>--- kernel/bpf/arena.c | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-)kernel/bpf/arena.c +2
-3@@ -317,7 +317,6 @@ static u64 arena_map_mem_usage(const struct bpf_map *map)struct vma_list {struct vm_area_struct *vma;struct list_head head; -refcount_t mmap_count; };static int remember_vma (struct bpf_arena *arena,struct vm_area_struct *vma)@@ -327,7 +326,6 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma) vml =kmalloc_obj (*vml);if (!vml)return -ENOMEM ; -refcount_set (&vml->mmap_count,1 ); vma->vm_private_data = vml; vml->vma = vma;list_add (&vml->head, &arena->vma_list);@@ -336,9 +334,17 @@ static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma)static void arena_vm_open (struct vm_area_struct *vma) { -struct vma_list *vml = vma->vm_private_data; +struct bpf_map *map = vma->vm_file->private_data; + struct bpf_arena *arena = container_of(map, struct bpf_arena, map);Quoted 13 lines
kernel/bpf/arena.c static int remember_vma(struct bpf_arena *arena, struct vm_area_struct *vma) · line 346
Quoted 8 lines
kernel/bpf/arena.c +7
-1-refcount_inc (&vml->mmap_count); +/* +* vm_private_data points to the parent's vma_list entry after fork. +* Clear it and register this VMA separately. +*/ + vma->vm_private_data =NULL ; +guard (mutex)(&arena->lock); +/* OOM is silently ignored; arena_vm_close() handles NULL. */ I don't see any way this approach gonna work, and frankly makes no sense to me. This patch doesn't take into account how the
vma_listis actually used. It frankly makes no sense, Please think through this: If we could silently just not allocate the vml, why do we need it in the first place?+1
Weiming,
you should stop trusting AI so blindly.
First, analyze the root cause (the first paragraph of the commit log). Is this really the case?Second, I copy pasted it to claude and got the same "fix" back, but implemented without your bug:
(quoted diff) +9
-0+ vml = kmalloc_obj(*vml); + if (!vml) { + vma->vm_private_data = NULL; + return; + } + vml->vma = vma; + vma->vm_private_data = vml; + guard(mutex)(&arena->lock); + list_add(&vml->head, &arena->vma_list);at least this part is kinda makes sense...
and, of course, this part too:
(quoted diff) +1
-1- if (!refcount_dec_and_test(&vml->mmap_count)) + if (!vml) return;when you look at it you MUST ask AI back:
"Is this buggy?"and it will reply:
"
Right — silently dropping the VMA from the list meanszap_pages()won't unmap pages from it, which is a correctness problem, not just degraded behavior. Sincevm_opencan't fail, the allocation should use__GFP_NOFAIL. The struct is tiny so that's fine.
"and it proceeded adding
__GFP_NOFAIL.Quoted 7 lines
which is wrong too.
So please don't just throw broken patches at maintainers. Do your homework. Fixing one maybe-bug and introducing more real bugs is not a step forward.
pw-bot: cr
Thanks for the detailed review, really appreciate it.
I traced through it with GDB + KASAN in QEMU. Here's what happens:
1. mmap →
remember_vma()vml->vma = 0xffff88800abfe700, mmap_count = 1 now Parent VMA = 0xffff88800abfe700 2. fork → arena_vm_open(child_vma) vml->vma = 0xffff88800abfe700 (unchanged), mmap_count = 23. parent munmap →
arena_vm_close(parent_vma)
mmap_count= 1
vml->vmais now dangling
Quoted 8 lines
4. child
bpf_arena_free_pages→zap_pages()reads vml->vma = 0xffff88800abfe700 → UAFThe core issue is that
arena_vm_open()never registers the child VMA -- it only bumps themmap_count. Sovml->vmaalways points at the parent, and dangles once the parent unmaps.What approach would you suggest for fixing this?
I'm thinking to just do this:
kernel/bpf/arena.c +0 -0
@@ -489,7 +489,7 @@ static int arena_map_mmap(struct bpf_map *map,
struct vm_area_struct *vma)
* clears VM_MAYEXEC. Set VM_DONTEXPAND as well to avoid
* potential change of user_vm_start.
*/
- vm_flags_set(vma, VM_DONTEXPAND);
+ vm_flags_set(vma, VM_DONTEXPAND | VM_DONTCOPY);
vma->vm_ops = &arena_vm_ops;
return 0;}
Re: [PATCH bpf v4 1/2] bpf: Fix use-after-free of arena VMA on fork
Quoted 40 lines · Alexei Starovoitov
Quoted 16 lines
Thanks for the detailed review, really appreciate it.
I traced through it with GDB + KASAN in QEMU. Here's what happens:
1. mmap →
remember_vma()vml->vma = 0xffff88800abfe700, mmap_count = 1 now Parent VMA = 0xffff88800abfe700 2. fork → arena_vm_open(child_vma) vml->vma = 0xffff88800abfe700 (unchanged), mmap_count = 23. parent munmap →
arena_vm_close(parent_vma)
mmap_count= 1
vml->vmais now danglingQuoted 8 lines
4. child
bpf_arena_free_pages→zap_pages()reads vml->vma = 0xffff88800abfe700 → UAFThe core issue is that
arena_vm_open()never registers the child VMA -- it only bumps themmap_count. Sovml->vmaalways points at the parent, and dangles once the parent unmaps.What approach would you suggest for fixing this?
I'm thinking to just do this:
kernel/bpf/arena.c +1
-1@@ -489,7 +489,7 @@ static int arena_map_mmap(struct bpf_map *map,struct vm_area_struct *vma) * clears VM_MAYEXEC. Set VM_DONTEXPAND as well to avoid * potential change of user_vm_start. */ -vm_flags_set (vma,VM_DONTEXPAND ); +vm_flags_set (vma,VM_DONTEXPAND |VM_DONTCOPY ); vma->vm_ops = &arena_vm_ops;return 0 ;
Quoted 1 line
}
sent the fix:
https://lore.kernel.org/bpf/[email protected]/
PATCH v4 2/2 selftests/bpf: Add test for arena VMA use-after-free on fork
In reply to Weiming ShiAdd a selftest that reproduces the arena VMA use-after-free fixed in the previous commit. The test creates an arena, mmaps it, allocates pages via BPF, forks, has the parent munmap the arena, then has the child call bpf_arena_free_pages. Without the fix this triggers a KASAN slab-use-after-free in zap_page_range_single.
Note: the UAF occurs entirely in kernel space and is not observable from userspace, so this test relies on KASAN to detect the bug. Without KASAN the test passes regardless of whether the fix is applied.
--- .../selftests/bpf/prog_tests/arena_fork.c | 80 +++++++++++++++++++ .../testing/selftests/bpf/progs/arena_fork.c | 41 ++++++++++ 2 files changed, 121 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/arena_fork.c create mode 100644 tools/testing/selftests/bpf/progs/arena_fork.c
tools/testing/selftests/bpf/prog_tests/arena_fork.c new file +80 -0
@@ -0,0 +1,80 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */ + +/* +* Test that forking a process with an arena mmap does not cause a +* use-after-free when the parent unmaps and the child frees arena pages. +*/ +#include <test_progs.h> +#include <sys/mman.h> +#include <sys/wait.h> +#include <unistd.h> + +#include "arena_fork.skel.h" + +void test_arena_fork (void ) +{ +LIBBPF_OPTS (bpf_test_run_opts, opts); +struct bpf_map_info info = {}; +__u32 info_len =sizeof (info); +struct arena_fork *skel; +long page_size; +size_t arena_sz; +void *arena_addr; +int arena_fd, ret, status; +pid_t pid; + + page_size =sysconf (_SC_PAGESIZE); +if (!ASSERT_GT (page_size,0 ,"page_size" )) +return ; + + skel =arena_fork__open_and_load (); +if (!ASSERT_OK_PTR (skel,"open_and_load" )) +return ; + + arena_fd =bpf_map__fd (skel->maps.arena); + +/* libbpf mmaps the arena via initial_value */ + arena_addr =bpf_map__initial_value (skel->maps.arena, &arena_sz); +if (!ASSERT_OK_PTR (arena_addr,"arena_mmap" )) + goto out; + +/* Get real arena byte size for munmap */ +bpf_map_get_info_by_fd (arena_fd, &info, &info_len); + arena_sz = (size_t )info.max_entries * page_size; + +/* Allocate 4 pages in the arena via BPF */ + ret =bpf_prog_test_run_opts (bpf_program__fd (skel->progs.arena_alloc), + &opts); +if (!ASSERT_OK (ret,"alloc_run" ) || + !ASSERT_OK (opts.retval,"alloc_ret" )) + goto out; + +/* Fault in a page so zap_pages has work to do */ + ((volatile char *)arena_addr)[0 ] ='A' ; + +/* Fork: child inherits the arena VMA */ + pid =fork (); +if (!ASSERT_GE (pid,0 ,"fork" )) + goto out; + +if (pid ==0 ) { +/* Child: parent will unmap first, then we free pages. */ +LIBBPF_OPTS (bpf_test_run_opts, child_opts); +int free_fd =bpf_program__fd (skel->progs.arena_free); + +usleep (200000 );/* let parent munmap first */ + + ret =bpf_prog_test_run_opts (free_fd, &child_opts); +_exit (ret || child_opts.retval); + } + +/* Parent: unmap the arena */ +munmap (arena_addr, arena_sz); + +waitpid (pid, &status,0 ); +ASSERT_TRUE (WIFEXITED (status),"child_exited" ); +ASSERT_EQ (WEXITSTATUS (status),0 ,"child_exit_code" ); +out: +arena_fork__destroy (skel); +}
tools/testing/selftests/bpf/progs/arena_fork.c new file +41 -0
41 lines not on this page · raw message
Signature · 1 line
2.43.0