bpf: Tighten cgroup storage cookie checks for prog arrays
Subsystems (4)
PATCH v3 1/2 bpf: Tighten cgroup storage cookie checks for prog arrays
The recent KCTF-reported cgroup local storage issue assigned CVE-2025-38502 was fixed by commit abad3d0bad72 ("bpf: Fix oob access in cgroup local storage").
However, the previous fixes are still incomplete. The current prog-array compatibility check treats a program with no cgroup storage as compatible with any stored storage cookie. This allows a storage-less program to bridge a tail-call chain between an entry program and a storage-using callee even though runtime cgroup local storage still follows the caller context.
Require exact per-type storage_cookie equality when checking prog-array compatibility. This blocks zero-storage bridge programs from joining a prog-array owned by a storage-using program and closes the residual A -> B(no storage) -> C(storage) path.
This also aligns with Amery Hung's earlier NULL-storage tail-call fix by requiring storage use to match consistently across prog-array users.
---
v1: https://lore.kernel.org/bpf/[email protected]/
v1 -> v2:
- refine the commit message and mention the relation to Amery Hung's NULL-storage tail-call fix
- add patch 2/2 selftests for tail-call cgroup storage prog-array checks
v2: https://lore.kernel.org/bpf/[email protected]/T/#t
v2 -> v3:
- use abad3d0bad72 as the Fixes tag
--- kernel/bpf/core.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
kernel/bpf/core.c +6 -2
@@ -2470,8 +2470,12 @@ static bool __bpf_prog_map_compatible(struct bpf_map *map,break ; cookie = aux->cgroup_storage[i] ? aux->cgroup_storage[i]->cookie :0 ; - ret = map->owner->storage_cookie[i] == cookie || - !cookie; +/* +* Tail calls keep using the caller cgroup storage +* context, so prog-array members must use the same +* storage cookie. +*/ + ret = map->owner->storage_cookie[i] == cookie; }if (ret && map->owner->attach_func_proto != aux->attach_func_proto) {
Signature · 1 line
2.53.0
PATCH v3 2/2 selftests/bpf: Cover tail-call cgroup storage prog-array checks
Add tail-call selftests for prog-array ownership when cgroup storage is in use. Verify that loading succeeds when callers and callees reuse the owner's cgroup storage map, and that loading fails for a different storage map and for the A(storage) -> B(no storage) -> C(storage) bridge case from patch 1.
---
v2: https://lore.kernel.org/bpf/[email protected]/T/#t
v2 -> v3:
- add explicit A(storage) -> B(no storage) -> C(storage) bridge coverage
--- .../selftests/bpf/prog_tests/tailcalls.c | 159 ++++++++++++++++++ .../bpf/progs/tailcall_cgrp_storage.c | 44 +++++ .../progs/tailcall_cgrp_storage_no_storage.c | 20 +++ .../bpf/progs/tailcall_cgrp_storage_owner.c | 32 ++++ 4 files changed, 255 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/tailcall_cgrp_storage.c create mode 100644 tools/testing/selftests/bpf/progs/tailcall_cgrp_storage_no_storage.c create mode 100644 tools/testing/selftests/bpf/progs/tailcall_cgrp_storage_owner.c
tools/testing/selftests/bpf/prog_tests/tailcalls.c +159 -0
@@ -8,6 +8,9 @@#include "tailcall_freplace.skel.h" #include "tc_bpf2bpf.skel.h" #include "tailcall_fail.skel.h" +#include "tailcall_cgrp_storage_owner.skel.h" +#include "tailcall_cgrp_storage_no_storage.skel.h" +#include "tailcall_cgrp_storage.skel.h" #include "tailcall_sleepable.skel.h" /* test_tailcall_1 checks basic functionality by patching multiple locations
@@ -1654,6 +1657,154 @@ static void test_tailcall_failure()RUN_TESTS (tailcall_fail); } +static void test_tailcall_cgrp_storage (void ) +{ +struct tailcall_cgrp_storage_owner *owner_skel =NULL ; +struct tailcall_cgrp_storage *skel =NULL ; +int err, key =0 , prog_array_fd, prog_fd, storage_map_fd; + + owner_skel =tailcall_cgrp_storage_owner__open_and_load (); +if (!ASSERT_OK_PTR (owner_skel,"owner_open_and_load" )) +return ; + + prog_array_fd =bpf_map__fd (owner_skel->maps.prog_array); + storage_map_fd =bpf_map__fd (owner_skel->maps.storage_map); + + skel =tailcall_cgrp_storage__open (); +if (!ASSERT_OK_PTR (skel,"tailcall_cgrp_storage__open" )) + goto out; + + err =bpf_map__reuse_fd (skel->maps.prog_array, prog_array_fd); +if (!ASSERT_OK (err,"reuse_prog_array" )) + goto out; + + err =bpf_map__reuse_fd (skel->maps.storage_map, storage_map_fd); +if (!ASSERT_OK (err,"reuse_storage_map" )) + goto out; + + err =bpf_object__load (skel->obj); +if (!ASSERT_OK (err,"tailcall_cgrp_storage__load" )) + goto out; + + prog_fd =bpf_program__fd (skel->progs.callee_prog); + err =bpf_map_update_elem (prog_array_fd, &key, &prog_fd,BPF_ANY ); +ASSERT_OK (err,"update_prog_array" ); + +out: +tailcall_cgrp_storage__destroy (skel); +tailcall_cgrp_storage_owner__destroy (owner_skel); +} + +static void test_tailcall_cgrp_storage_diff_storage (void ) +{ +struct tailcall_cgrp_storage_owner *owner_skel =NULL ; +struct tailcall_cgrp_storage *skel =NULL ; +int err, prog_array_fd; + + owner_skel =tailcall_cgrp_storage_owner__open_and_load (); +if (!ASSERT_OK_PTR (owner_skel,"owner_open_and_load" )) +return ; + + prog_array_fd =bpf_map__fd (owner_skel->maps.prog_array); + + skel =tailcall_cgrp_storage__open (); +if (!ASSERT_OK_PTR (skel,"tailcall_cgrp_storage__open" )) + goto out; + + err =bpf_map__reuse_fd (skel->maps.prog_array, prog_array_fd); +if (!ASSERT_OK (err,"reuse_prog_array" )) + goto out; + + err =bpf_object__load (skel->obj); +ASSERT_ERR (err,"tailcall_cgrp_storage__load" ); + +out: +tailcall_cgrp_storage__destroy (skel); +tailcall_cgrp_storage_owner__destroy (owner_skel); +} + +static void test_tailcall_cgrp_storage_no_storage (void ) +{ +struct tailcall_cgrp_storage_owner *owner_skel =NULL ; +struct tailcall_cgrp_storage_no_storage *skel =NULL ; +int err, prog_array_fd; + + owner_skel =tailcall_cgrp_storage_owner__open_and_load (); +if (!ASSERT_OK_PTR (owner_skel,"owner_open_and_load" )) +return ; + + prog_array_fd =bpf_map__fd (owner_skel->maps.prog_array); + + skel =tailcall_cgrp_storage_no_storage__open (); +if (!ASSERT_OK_PTR (skel,"tailcall_cgrp_storage_no_storage__open" )) + goto out; + + err =bpf_map__reuse_fd (skel->maps.prog_array, prog_array_fd); +if (!ASSERT_OK (err,"reuse_prog_array" )) + goto out; + + err =bpf_object__load (skel->obj); +ASSERT_ERR (err,"tailcall_cgrp_storage_no_storage__load" ); + +out: +tailcall_cgrp_storage_no_storage__destroy (skel); +tailcall_cgrp_storage_owner__destroy (owner_skel); +} + +static void test_tailcall_cgrp_storage_no_storage_bridge (void ) +{ +struct tailcall_cgrp_storage_owner *owner_skel =NULL ; +struct tailcall_cgrp_storage_no_storage *bridge_skel =NULL ; +struct tailcall_cgrp_storage *callee_skel =NULL ; +int err, key =0 , prog_array_fd, prog_fd, storage_map_fd; + + owner_skel =tailcall_cgrp_storage_owner__open_and_load (); +if (!ASSERT_OK_PTR (owner_skel,"owner_open_and_load" )) +return ; + + prog_array_fd =bpf_map__fd (owner_skel->maps.prog_array); + storage_map_fd =bpf_map__fd (owner_skel->maps.storage_map); + + callee_skel =tailcall_cgrp_storage__open (); +if (!ASSERT_OK_PTR (callee_skel,"tailcall_cgrp_storage__open" )) + goto out; + +bpf_program__set_autoload (callee_skel->progs.caller_prog, false); + + err =bpf_map__reuse_fd (callee_skel->maps.prog_array, prog_array_fd); +if (!ASSERT_OK (err,"reuse_prog_array" )) + goto out; + + err =bpf_map__reuse_fd (callee_skel->maps.storage_map, storage_map_fd); +if (!ASSERT_OK (err,"reuse_storage_map" )) + goto out; + + err =bpf_object__load (callee_skel->obj); +if (!ASSERT_OK (err,"tailcall_cgrp_storage__load" )) + goto out; + + prog_fd =bpf_program__fd (callee_skel->progs.callee_prog); + err =bpf_map_update_elem (prog_array_fd, &key, &prog_fd,BPF_ANY ); +if (!ASSERT_OK (err,"update_prog_array" )) + goto out; + + bridge_skel =tailcall_cgrp_storage_no_storage__open (); +if (!ASSERT_OK_PTR (bridge_skel,"tailcall_cgrp_storage_no_storage__open" )) + goto out; + + err =bpf_map__reuse_fd (bridge_skel->maps.prog_array, prog_array_fd); +if (!ASSERT_OK (err,"reuse_prog_array" )) + goto out; + + err =bpf_object__load (bridge_skel->obj); +ASSERT_ERR (err,"tailcall_cgrp_storage_no_storage_bridge__load" ); + +out: +tailcall_cgrp_storage_no_storage__destroy (bridge_skel); +tailcall_cgrp_storage__destroy (callee_skel); +tailcall_cgrp_storage_owner__destroy (owner_skel); +} + noinline void uprobe_sleepable_trigger(void) { asmvolatile ("" );
@@ -1777,6 +1928,14 @@ void test_tailcalls(void)test_tailcall_freplace ();if (test__start_subtest ("tailcall_bpf2bpf_freplace" ))test_tailcall_bpf2bpf_freplace (); +if (test__start_subtest ("tailcall_cgrp_storage" )) +test_tailcall_cgrp_storage (); +if (test__start_subtest ("tailcall_cgrp_storage_diff_storage" )) +test_tailcall_cgrp_storage_diff_storage (); +if (test__start_subtest ("tailcall_cgrp_storage_no_storage" )) +test_tailcall_cgrp_storage_no_storage (); +if (test__start_subtest ("tailcall_cgrp_storage_no_storage_bridge" )) +test_tailcall_cgrp_storage_no_storage_bridge ();if (test__start_subtest ("tailcall_failure" ))test_tailcall_failure ();if (test__start_subtest ("tailcall_sleepable" ))
tools/testing/selftests/bpf/progs/tailcall_cgrp_storage.c new file +44 -0
44 lines not on this page · raw message
tools/testing/selftests/bpf/progs/tailcall_cgrp_storage_no_storage.c new file +20 -0
@@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> + +struct { + __uint(type, BPF_MAP_TYPE_PROG_ARRAY); + __uint(max_entries, 1); + __uint(key_size, sizeof(__u32)); + __uint(value_size, sizeof(__u32)); +} prog_array SEC(".maps"); + +SEC("cgroup_skb/egress") +int caller_prog (struct __sk_buff *skb) +{ +bpf_tail_call (skb, &prog_array,0 ); +return 1 ; +} + +char _license[] SEC("license") = "GPL";
tools/testing/selftests/bpf/progs/tailcall_cgrp_storage_owner.c new file +32 -0
@@ -0,0 +1,32 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <vmlinux.h> +#include <bpf/bpf_helpers.h> + +struct { + __uint(type, BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE); + __type(key, struct bpf_cgroup_storage_key); + __type(value, __u64); +} storage_map SEC(".maps"); + +struct { + __uint(type, BPF_MAP_TYPE_PROG_ARRAY); + __uint(max_entries, 1); + __uint(key_size, sizeof(__u32)); + __uint(value_size, sizeof(__u32)); +} prog_array SEC(".maps"); + +SEC("cgroup_skb/egress") +int prog_array_owner (struct __sk_buff *skb) +{ +__u64 *storage; + + storage =bpf_get_local_storage (&storage_map,0 ); +if (storage) + *storage =1 ; + +bpf_tail_call (skb, &prog_array,0 ); +return 1 ; +} + +char _license[] SEC("license") = "GPL";
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v3 2/2] selftests/bpf: Cover tail-call cgroup storage prog-array checks
In the v2 review Leon Hwang asked that these new subtests be placed at the tail of test_tailcalls():
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/tailcalls.c +0
-0
[ ... ]
Quoted 15 lines
tools/testing/selftests/bpf/prog_tests/tailcalls.c +8
-0@@ -1777,6 +1928,14 @@ void test_tailcalls(void)test_tailcall_freplace ();if (test__start_subtest ("tailcall_bpf2bpf_freplace" ))test_tailcall_bpf2bpf_freplace (); +if (test__start_subtest ("tailcall_cgrp_storage" )) +test_tailcall_cgrp_storage (); +if (test__start_subtest ("tailcall_cgrp_storage_diff_storage" )) +test_tailcall_cgrp_storage_diff_storage (); +if (test__start_subtest ("tailcall_cgrp_storage_no_storage" )) +test_tailcall_cgrp_storage_no_storage (); +if (test__start_subtest ("tailcall_cgrp_storage_no_storage_bridge" )) +test_tailcall_cgrp_storage_no_storage_bridge ();if (test__start_subtest ("tailcall_failure" ))test_tailcall_failure ();if (test__start_subtest ("tailcall_sleepable" ))
Quoted 1 line
test_tailcall_sleepable();
In the v2 review Leon Hwang asked that these new subtests be placed at the tail of test_tailcalls():
https://lore.kernel.org/bpf/[email protected]/
"These new ones should stay at the tail of test_tailcalls()."
Here they are still registered ahead of tailcall_failure and tailcall_sleepable rather than at the end. Was the intent to move them after the existing subtests?
---
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/26923843925
[email protected]
AI reviewRelated to this patch series, Leon Hwang raised a concern about test placement in the selftest file (tools/testing/selftests/bpf/prog_tests/ tailcalls.c). The new cgroup storage tail-call tests…
Quoted 9 lines
kernel/bpf/core.c +0
-1@@ -2480,8 +2480,12 @@ static bool __bpf_prog_map_compatible(struct bpf_map *map,break ; cookie = aux->cgroup_storage[i] ? aux->cgroup_storage[i]->cookie :0 ; - ret = map->owner->storage_cookie[i] == cookie ||
kernel/bpf/core.c static bool __bpf_prog_map_compatible(struct bpf_map *map, · line 2491
Quoted 10 lines
kernel/bpf/core.c +6
-1- !cookie; +/* +* Tail calls keep using the caller cgroup storage +* context, so prog-array members must use the same +* storage cookie. +*/ + ret = map->owner->storage_cookie[i] == cookie; }if (ret && map->owner->attach_func_proto != aux->attach_func_proto) {
Related to this patch series, Leon Hwang raised a concern about test placement in the selftest file (tools/testing/selftests/bpf/prog_tests/ tailcalls.c). The new cgroup storage tail-call tests should be placed at the tail of test_tailcalls() rather than before tailcall_failure and tailcall_sleepable.
Reference: https://lore.kernel.org/bpf/[email protected]/
Leon's comment from v2: "These new ones should stay at the tail of test_tailcalls()."
Should the test ordering be adjusted in the selftest file to address this feedback?
---
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/26923843925