Fix effective prog array indexing with BPF_F_PREORDER
Subsystems (3)
v2 cover Fix effective prog array indexing with BPF_F_PREORDER
Hi,
This patchset fixes a cgroup effective-array indexing bug where replace_effective_prog() and purge_effective_progs() used a linear hlist position that doesn't match the array layout when BPF_F_PREORDER programs are present, corrupting the array on link update and risking a use-after-free in the detach fallback. It computes the slot via a shared effective_prog_pos() helper and adds a cgroup_preorder selftest.
Changelog
v1 -> v2:
- Also fix purge_effective_progs(), in addition to replace_effective_prog() (Sashiko).
- selftest: Set err on bpf_link_create() failure so the failure is reported to the caller (Sashiko).
---
Amery Hung (2):
bpf: Fix effective prog array index with BPF_F_PREORDER selftests/bpf: Test cgroup link replace with BPF_F_PREORDER
kernel/bpf/cgroup.c | 108 ++++++++++-------- .../bpf/prog_tests/cgroup_preorder.c | 77 +++++++++++++ 2 files changed, 139 insertions(+), 46 deletions(-)
Signature · 1 line
2.53.0-Meta
PATCH v2 1/2 bpf: Fix effective prog array index with BPF_F_PREORDER
replace_effective_prog() and purge_effective_progs() located the slot in the effective array by walking the program hlist and counting entries linearly. That count does not match the array layout: compute_effective_ progs() places BPF_F_PREORDER programs at the front (ancestor cgroup first, attach order within a cgroup) and the rest after them (descendant cgroup first). So when a preorder program is present, the linear hlist position no longer equals the program's index in the effective array.
For replace_effective_prog() (bpf_link_update()) this overwrote the wrong slot, corrupting the effective order. For purge_effective_progs(), it could dummy out a slot belonging to a different program and leave the detached program in the array while bpf_prog_put() drops its reference, i.e. a use-after-free.
Fix both by replaying compute_effective_progs()'s placement (including the per-cgroup preorder reversal) in a shared effective_prog_pos() helper. Identify the entry by its struct bpf_prog_list pointer rather than by (prog, link) value, so the lookup resolves to exactly the attachment the syscall selected even when the same bpf_prog is attached to several cgroups in the hierarchy.
--- kernel/bpf/cgroup.c | 108 +++++++++++++++++++++++++------------------- 1 file changed, 62 insertions(+), 46 deletions(-)
kernel/bpf/cgroup.c +62 -46
@@ -939,19 +939,65 @@ static int cgroup_bpf_attach(struct cgroup *cgrp,return ret; } +static int effective_prog_pos (struct cgroup *cgrp, +enum cgroup_bpf_attach_type atype, +struct bpf_prog_list *target_pl) +{ +int cnt =0 , preorder_cnt =0 , fstart, bstart, init_bstart, pos =-1 ; +struct bpf_prog_list *pl; +struct cgroup *p = cgrp; + +/* count effective programs to find where the preorder region ends */ +do { +if (cnt ==0 || (p->bpf.flags[atype] &BPF_F_ALLOW_MULTI )) + cnt +=prog_list_length (&p->bpf.progs[atype], &preorder_cnt); + p =cgroup_parent (p); + }while (p); + +/* replay compute_effective_progs() placement and record target's slot */ + cnt =0 ; + p = cgrp; + fstart = preorder_cnt; + bstart = preorder_cnt -1 ; +do { +if (cnt >0 && !(p->bpf.flags[atype] &BPF_F_ALLOW_MULTI )) +continue ; + + init_bstart = bstart; +hlist_for_each_entry (pl, &p->bpf.progs[atype], node) { +if (!prog_list_prog (pl)) +continue ; + +if (pl->flags &BPF_F_PREORDER ) { +if (pl == target_pl) + pos = bstart; + bstart--; + }else { +if (pl == target_pl) + pos = fstart; + fstart++; + } + cnt++; + } + +/* reverse pre-ordering progs at this cgroup level */ +if (pos >= bstart +1 && pos <= init_bstart) + pos = bstart +1 + init_bstart - pos; + }while ((p =cgroup_parent (p))); + +return pos; +} +/* Swap updated BPF program for given link in effective program arrays across * all descendant cgroups. This function is guaranteed to succeed. */ static void replace_effective_prog (struct cgroup *cgrp,enum cgroup_bpf_attach_type atype, -struct bpf_cgroup_link *link) +struct bpf_prog_list *pl) {struct bpf_prog_array_item *item;struct cgroup_subsys_state *css;struct bpf_prog_array *progs; -struct bpf_prog_list *pl; -struct hlist_head *head; -struct cgroup *cg;int pos;css_for_each_descendant_pre (css, &cgrp->self) {
@@ -960,27 +1006,15 @@ static void replace_effective_prog(struct cgroup *cgrp,if (percpu_ref_is_zero (&desc->bpf.refcnt))continue ; -/* find position of link in effective progs array */ -for (pos =0 , cg = desc; cg; cg =cgroup_parent (cg)) { -if (pos && !(cg->bpf.flags[atype] &BPF_F_ALLOW_MULTI )) -continue ; + pos =effective_prog_pos (desc, atype, pl); +if (WARN_ON_ONCE (pos <0 )) +continue ; - head = &cg->bpf.progs[atype]; -hlist_for_each_entry (pl, head, node) { -if (!prog_list_prog (pl)) -continue ; -if (pl->link == link) - goto found; - pos++; - } - } -found: -BUG_ON (!cg); progs =rcu_dereference_protected ( desc->bpf.effective[atype],lockdep_is_held (&cgroup_mutex)); item = &progs->items[pos]; -WRITE_ONCE (item->prog, link->link.prog); +WRITE_ONCE (item->prog, pl->link->link.prog); } }
@@ -1024,7 +1058,7 @@ static int __cgroup_bpf_replace(struct cgroup *cgrp, cgrp->bpf.revisions[atype] +=1 ; old_prog =xchg (&link->link.prog, new_prog); -replace_effective_prog (cgrp, atype, link); +replace_effective_prog (cgrp, atype, pl);bpf_prog_put (old_prog);return 0 ; }
@@ -1091,19 +1125,14 @@ static struct bpf_prog_list *find_detach_entry(struct hlist_head *progs,* recomputing the array in place. * * @cgrp: The cgroup which descendants to travers -* @prog: A program to detach or NULL -* @link: A link to detach or NULL +* @pl: The prog_list entry being detached * @atype: Type of detach operation */ -static void purge_effective_progs (struct cgroup *cgrp,struct bpf_prog *prog, -struct bpf_cgroup_link *link, +static void purge_effective_progs (struct cgroup *cgrp,struct bpf_prog_list *pl,enum cgroup_bpf_attach_type atype) {struct cgroup_subsys_state *css;struct bpf_prog_array *progs; -struct bpf_prog_list *pl; -struct hlist_head *head; -struct cgroup *cg;int pos;/* recompute effective prog array in place */
@@ -1113,24 +1142,11 @@ static void purge_effective_progs(struct cgroup *cgrp, struct bpf_prog *prog,if (percpu_ref_is_zero (&desc->bpf.refcnt))continue ; -/* find position of link or prog in effective progs array */ -for (pos =0 , cg = desc; cg; cg =cgroup_parent (cg)) { -if (pos && !(cg->bpf.flags[atype] &BPF_F_ALLOW_MULTI )) -continue ; - - head = &cg->bpf.progs[atype]; -hlist_for_each_entry (pl, head, node) { -if (!prog_list_prog (pl)) -continue ; -if (pl->prog == prog && pl->link == link) - goto found; - pos++; - } - } - + pos =effective_prog_pos (desc, atype, pl);/* no link or prog match, skip the cgroup of this layer */ -continue ; -found: +if (pos <0 ) +continue ; + progs =rcu_dereference_protected ( desc->bpf.effective[atype],lockdep_is_held (&cgroup_mutex));
@@ -1196,7 +1212,7 @@ static int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,/* if update effective array failed replace the prog with a dummy prog*/ pl->prog = old_prog; pl->link = link; -purge_effective_progs (cgrp, old_prog, link, atype); +purge_effective_progs (cgrp, pl, atype); }/* now can actually delete it from this cgroup list */
Signature · 1 line
2.53.0-Meta
[email protected]
AI reviewRe: [PATCH bpf v2 1/2] bpf: Fix effective prog array index with BPF_F_PREORDER
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [Critical] This problem wasn't introduced by this patch, but replace_effective_prog() erroneously uses the logical index returned by effective_prog_pos() as a direct physical index into the effective BPF program array. If previous detach operations failed to reallocate the array and left dummy_bpf_prog elements in place, the physical index does not match the logical index. This causes bpf_link_update() to overwrite the wrong program slot (e.g., the dummy) leaving the original program untouched in the active array while its reference is dropped by __cgroup_bpf_replace(). Once the RCU grace period expires, this leads to a Use-After-Free when the kernel executes the freed program. --
commit f837441f68b1fdb520696422a141ec421e2d50ae
Author: Amery Hung <[email protected]>
bpf: Fix effective prog array index with BPF_F_PREORDER
This commit introduces a shared helper effective_prog_pos() to accurately determine a program's position in the effective array by replaying the placement logic. This fixes an issue where preorder programs caused replace_effective_prog() and purge_effective_progs() to access incorrect slots, corrupting the array or causing a use-after-free.
Quoted 4 lines
kernel/bpf/cgroup.c +0
-0
[ ... ]
Quoted 20 lines
kernel/bpf/cgroup.c +0
-16@@ -960,27 +1006,15 @@ static void replace_effective_prog(struct cgroup *cgrp,if (percpu_ref_is_zero (&desc->bpf.refcnt))continue ; -/* find position of link in effective progs array */ -for (pos =0 , cg = desc; cg; cg =cgroup_parent (cg)) { -if (pos && !(cg->bpf.flags[atype] &BPF_F_ALLOW_MULTI )) -continue ; - - head = &cg->bpf.progs[atype]; -hlist_for_each_entry (pl, head, node) { -if (!prog_list_prog (pl)) -continue ; -if (pl->link == link) - goto found; - pos++; - } - } -found: -BUG_ON (!cg);
kernel/bpf/cgroup.c static void replace_effective_prog(struct cgroup *cgrp, · line 1017
Quoted 10 lines
kernel/bpf/cgroup.c +4
-1+ pos =effective_prog_pos (desc, atype, pl); +if (WARN_ON_ONCE (pos <0 )) +continue ; progs =rcu_dereference_protected ( desc->bpf.effective[atype],lockdep_is_held (&cgroup_mutex)); item = &progs->items[pos]; -WRITE_ONCE (item->prog, link->link.prog); +WRITE_ONCE (item->prog, pl->link->link.prog);
[Severity: Critical]
This isn't a bug introduced by this patch, but does replace_effective_prog() erroneously use the logical index returned by effective_prog_pos() as a direct physical index into the effective BPF program array?
If previous detach operations failed to reallocate the array and left dummy_bpf_prog elements in place, the physical index would not match the logical index. This could cause bpf_link_update() to overwrite the wrong program slot (e.g., the dummy), leaving the original program untouched in the active array while its reference is dropped by __cgroup_bpf_replace().
Once the RCU grace period expires, could this lead to a Use-After-Free when the kernel executes the freed program? Should this instead use bpf_prog_array_update_at(progs, pos, pl->link->link.prog) to correctly handle the presence of dummy programs?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Yonghong Song
reviewerRe: [PATCH bpf v2 1/2] bpf: Fix effective prog array index with BPF_F_PREORDER
Quoted 64 lines · On 6/18/26 11:46 PM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [Critical] This problem wasn't introduced by this patch, butreplace_effective_prog()erroneously uses the logical index returned byeffective_prog_pos()as a direct physical index into the effective BPF program array. If previous detach operations failed to reallocate the array and leftdummy_bpf_progelements in place, the physical index does not match the logical index. This causesbpf_link_update()to overwrite the wrong program slot (e.g., the dummy) leaving the original program untouched in the active array while its reference is dropped by__cgroup_bpf_replace(). Once the RCU grace period expires, this leads to a Use-After-Free when the kernel executes the freed program. --commit
f837441f68b1fdb520696422a141ec421e2d50ae
Author: Amery Hung <[email protected]>bpf: Fix effective prog array index with
BPF_F_PREORDERThis commit introduces a shared helper
effective_prog_pos()to accurately determine a program's position in the effective array by replaying the placement logic. This fixes an issue where preorder programs causedreplace_effective_prog()andpurge_effective_progs()to access incorrect slots, corrupting the array or causing a use-after-free.Quoted 4 lines
kernel/bpf/cgroup.c +0
-0[ ... ]
Quoted 20 lines
kernel/bpf/cgroup.c +0
-16@@ -960,27 +1006,15 @@ static void replace_effective_prog(struct cgroup *cgrp,if (percpu_ref_is_zero (&desc->bpf.refcnt))continue ; -/* find position of link in effective progs array */ -for (pos =0 , cg = desc; cg; cg =cgroup_parent (cg)) { -if (pos && !(cg->bpf.flags[atype] &BPF_F_ALLOW_MULTI )) -continue ; - - head = &cg->bpf.progs[atype]; -hlist_for_each_entry (pl, head, node) { -if (!prog_list_prog (pl)) -continue ; -if (pl->link == link) - goto found; - pos++; - } - } -found: -BUG_ON (!cg);kernel/bpf/cgroup.c static void replace_effective_prog(struct cgroup *cgrp, · line 1017
Quoted 10 lines
kernel/bpf/cgroup.c +4
-1+ pos =effective_prog_pos (desc, atype, pl); +if (WARN_ON_ONCE (pos <0 )) +continue ; progs =rcu_dereference_protected ( desc->bpf.effective[atype],lockdep_is_held (&cgroup_mutex)); item = &progs->items[pos]; -WRITE_ONCE (item->prog, link->link.prog); +WRITE_ONCE (item->prog, pl->link->link.prog);[Severity: Critical]
This isn't a bug introduced by this patch, but doesreplace_effective_prog()erroneously use the logical index returned byeffective_prog_pos()as a direct physical index into the effective BPF program array?If previous detach operations failed to reallocate the array and left
dummy_bpf_progelements in place, the physical index would not match the logical index. This could causebpf_link_update()to overwrite the wrong program slot (e.g., the dummy), leaving the original program untouched in the active array while its reference is dropped by__cgroup_bpf_replace().
Quoted 4 lines
Once the RCU grace period expires, could this lead to a Use-After-Free when the kernel executes the freed program? Should this instead use
bpf_prog_array_update_at(progs, pos, pl->link->link.prog)to correctly handle the presence of dummy programs?
Indeed this is a prefixing bug and can be fixed in another patch. If I undersand correctly, the logic like below:
__cgroup_bpf_detach
update_effective_progs
failed doe to out-of-memory:
purge_effective_progs
...
bpf_prog_array_delete_safe_at(...)
/* dummy prog is in the effective array */
__cgroup_bpf_replace
replace_effective_prog
...
item = &progs->items[pos];
WRITE_ONCE(item->prog, pl->link->link.prog);
/* dummy prog in effective array, but pos may ignore dummy prog during accouting. */So for in replace_effective_prog(), bpf_prog_array_update_at() is the right way to fix.
Re: [PATCH bpf v2 1/2] bpf: Fix effective prog array index with BPF_F_PREORDER
In reply to Amery HungQuoted 21 lines · Amery Hung
replace_effective_prog()andpurge_effective_progs()located the slot in the effective array by walking the program hlist and counting entries linearly. That count does not match the array layout:compute_effective_progs()placesBPF_F_PREORDERprograms at the front (ancestor cgroup first, attach order within a cgroup) and the rest after them (descendant cgroup first). So when a preorder program is present, the linear hlist position no longer equals the program's index in the effective array.For
replace_effective_prog()(bpf_link_update()) this overwrote the wrong slot, corrupting the effective order. Forpurge_effective_progs(), it could dummy out a slot belonging to a different program and leave the detached program in the array whilebpf_prog_put()drops its reference, i.e. a use-after-free.Fix both by replaying compute_effective_progs()'s placement (including the per-cgroup preorder reversal) in a shared
effective_prog_pos()helper. Identify the entry by its structbpf_prog_listpointer rather than by (prog, link) value, so the lookup resolves to exactly the attachment the syscall selected even when the samebpf_progis attached to several cgroups in the hierarchy.
Quoted 2 lines
Fixes 4b82b181a26c ("bpf: Allow pre-ordering for bpf cgroup progs")Signed-off-by Amery Hung <[email protected]>
LGTM with a nit below.
Quoted 46 lines
--- kernel/bpf/cgroup.c | 108 +++++++++++++++++++++++++------------------- 1 file changed, 62 insertions(+), 46 deletions(-)kernel/bpf/cgroup.c +34
-0@@ -939,19 +939,65 @@ static int cgroup_bpf_attach(struct cgroup *cgrp,return ret; } +static int effective_prog_pos (struct cgroup *cgrp, +enum cgroup_bpf_attach_type atype, +struct bpf_prog_list *target_pl) +{ +int cnt =0 , preorder_cnt =0 , fstart, bstart, init_bstart, pos =-1 ; +struct bpf_prog_list *pl; +struct cgroup *p = cgrp; + +/* count effective programs to find where the preorder region ends */ +do { +if (cnt ==0 || (p->bpf.flags[atype] &BPF_F_ALLOW_MULTI )) + cnt +=prog_list_length (&p->bpf.progs[atype], &preorder_cnt); + p =cgroup_parent (p); + }while (p); + +/* replay compute_effective_progs() placement and record target's slot */ + cnt =0 ; + p = cgrp; + fstart = preorder_cnt; + bstart = preorder_cnt -1 ; + do { + if (cnt > 0 && !(p->bpf.flags[atype] & BPF_F_ALLOW_MULTI)) + continue; + + init_bstart = bstart; + hlist_for_each_entry(pl, &p->bpf.progs[atype], node) { + if (!prog_list_prog(pl)) + continue; + + if (pl->flags & BPF_F_PREORDER) { + if (pl == target_pl) + pos = bstart; + bstart--; + } else {
kernel/bpf/cgroup.c static int cgroup_bpf_attach(struct cgroup *cgrp, · line 985
Quoted 10 lines
kernel/bpf/cgroup.c +10
-0+if (pl == target_pl) + pos = fstart; + fstart++; + } + cnt++; + } + +/* reverse pre-ordering progs at this cgroup level */ +if (pos >= bstart +1 && pos <= init_bstart) + pos = bstart +1 + init_bstart - pos;
Here, if pos is not -1, we could break out of loop since each pl is unique. But since this is not in a performance critical path, probably the current implementation is okay.
Quoted 85 lines
kernel/bpf/cgroup.c +13
-28+ }while ((p =cgroup_parent (p))); + +return pos; +} +/* Swap updated BPF program for given link in effective program arrays across * all descendant cgroups. This function is guaranteed to succeed. */ static void replace_effective_prog (struct cgroup *cgrp,enum cgroup_bpf_attach_type atype, -struct bpf_cgroup_link *link) +struct bpf_prog_list *pl) {struct bpf_prog_array_item *item;struct cgroup_subsys_state *css;struct bpf_prog_array *progs; -struct bpf_prog_list *pl; -struct hlist_head *head; -struct cgroup *cg;int pos;css_for_each_descendant_pre (css, &cgrp->self) {@@ -960,27 +1006,15 @@ static void replace_effective_prog(struct cgroup *cgrp,if (percpu_ref_is_zero (&desc->bpf.refcnt))continue ; -/* find position of link in effective progs array */ -for (pos =0 , cg = desc; cg; cg =cgroup_parent (cg)) { -if (pos && !(cg->bpf.flags[atype] &BPF_F_ALLOW_MULTI )) -continue ; + pos =effective_prog_pos (desc, atype, pl); +if (WARN_ON_ONCE (pos <0 )) +continue ; - head = &cg->bpf.progs[atype]; -hlist_for_each_entry (pl, head, node) { -if (!prog_list_prog (pl)) -continue ; -if (pl->link == link) - goto found; - pos++; - } - } -found: -BUG_ON (!cg); progs =rcu_dereference_protected ( desc->bpf.effective[atype],lockdep_is_held (&cgroup_mutex)); item = &progs->items[pos]; -WRITE_ONCE (item->prog, link->link.prog); +WRITE_ONCE (item->prog, pl->link->link.prog); } }@@ -1024,7 +1058,7 @@ static int __cgroup_bpf_replace(struct cgroup *cgrp, cgrp->bpf.revisions[atype] +=1 ; old_prog =xchg (&link->link.prog, new_prog); -replace_effective_prog (cgrp, atype, link); +replace_effective_prog (cgrp, atype, pl);bpf_prog_put (old_prog);return 0 ; }@@ -1091,19 +1125,14 @@ static struct bpf_prog_list *find_detach_entry(struct hlist_head *progs,* recomputing the array in place. * * @cgrp: The cgroup which descendants to travers -* @prog: A program to detach or NULL -* @link: A link to detach or NULL +* @pl: The prog_list entry being detached * @atype: Type of detach operation */ -static void purge_effective_progs (struct cgroup *cgrp,struct bpf_prog *prog, -struct bpf_cgroup_link *link, +static void purge_effective_progs (struct cgroup *cgrp,struct bpf_prog_list *pl,enum cgroup_bpf_attach_type atype) {struct cgroup_subsys_state *css;struct bpf_prog_array *progs; -struct bpf_prog_list *pl; -struct hlist_head *head; -struct cgroup *cg;int pos;/* recompute effective prog array in place */
[...]
PATCH v2 2/2 selftests/bpf: Test cgroup link replace with BPF_F_PREORDER
In reply to Amery HungAdd a cgroup_preorder case that attaches a normal and a BPF_F_PREORDER program to a cgroup (effective order [2, 1]), then replaces the normal link's program via bpf_link_update() and checks the effective order becomes [2, 3] — i.e. only the non-preorder slot changes. Without the replace_effective_prog() fix the array is corrupted and the order is wrong.
--- .../bpf/prog_tests/cgroup_preorder.c | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+)
tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c +77 -0
@@ -102,6 +102,82 @@ static int run_getsockopt_test(int cg_parent, int cg_child, int sock_fd, bool alreturn err; } +/* +* Replacing a link's program (bpf_link_update) must target the correct slot in +* the effective array even when a BPF_F_PREORDER program is attached to the +* same cgroup. All programs here are attached to a single cgroup; "parent" is +* reused only as a third distinct program. +* +* Attach child(1) normally and child_2(2) with BPF_F_PREORDER, so the effective +* order is [2, 1]. Then replace child(1)'s program with parent(3): only the +* non-preorder slot changes, giving [2, 3]. +*/ +static int run_link_replace_test (int cgroup_fd,int sock_fd) +{ +LIBBPF_OPTS (bpf_link_create_opts, create_opts); +int err =0 , normal_link =-1 , preorder_link =-1 ; +struct cgroup_preorder *skel =NULL ; +enum bpf_attach_type atype; +__u8 *result, buf =0x00 ; +socklen_t optlen =1 ; + + skel =cgroup_preorder__open_and_load (); +if (!ASSERT_OK_PTR (skel,"cgroup_preorder__open_and_load" )) +return -1 ; + + err =setsockopt (sock_fd,SOL_IP ,IP_TOS , &buf,1 ); +if (!ASSERT_OK (err,"setsockopt" )) + goto close_skel; + + atype =bpf_program__expected_attach_type (skel->progs.child); + + create_opts.flags =0 ; + normal_link =bpf_link_create (bpf_program__fd (skel->progs.child), + cgroup_fd, atype, &create_opts); +if (!ASSERT_GE (normal_link,0 ,"create_normal_link" )) { + err = normal_link; + goto close_skel; + } + + create_opts.flags =BPF_F_PREORDER ; + preorder_link =bpf_link_create (bpf_program__fd (skel->progs.child_2), + cgroup_fd, atype, &create_opts); +if (!ASSERT_GE (preorder_link,0 ,"create_preorder_link" )) { + err = preorder_link; + goto close_links; + } + + result = skel->bss->result; + skel->bss->idx =0 ; +memset (result,0 ,4 ); + + err =getsockopt (sock_fd,SOL_IP ,IP_TOS , &buf, &optlen); +if (!ASSERT_OK (err,"getsockopt-before" )) + goto close_links; +ASSERT_TRUE (result[0 ] ==2 && result[1 ] ==1 ,"order before update" ); + +/* Replace the normal link's program child(1) -> parent(3). */ + err =bpf_link_update (normal_link,bpf_program__fd (skel->progs.parent),NULL ); +if (!ASSERT_OK (err,"bpf_link_update" )) + goto close_links; + + skel->bss->idx =0 ; +memset (result,0 ,4 ); + + err =getsockopt (sock_fd,SOL_IP ,IP_TOS , &buf, &optlen); +if (!ASSERT_OK (err,"getsockopt-after" )) + goto close_links; +ASSERT_TRUE (result[0 ] ==2 && result[1 ] ==3 ,"order after update" ); + +close_links: +if (preorder_link >=0 ) +close (preorder_link); +close (normal_link); +close_skel: +cgroup_preorder__destroy (skel); +return err; +} +void test_cgroup_preorder (void ) {int cg_parent =-1 , cg_child =-1 , sock_fd =-1 ;
@@ -120,6 +196,7 @@ void test_cgroup_preorder(void)ASSERT_OK (run_getsockopt_test (cg_parent, cg_child, sock_fd, false),"getsockopt_test_1" );ASSERT_OK (run_getsockopt_test (cg_parent, cg_child, sock_fd, true),"getsockopt_test_2" ); +ASSERT_OK (run_link_replace_test (cg_child, sock_fd),"link_replace_test" ); out:close (sock_fd);
Signature · 1 line
2.53.0-Meta
Re: [PATCH bpf v2 2/2] selftests/bpf: Test cgroup link replace with BPF_F_PREORDER
Quoted 8 lines · Amery Hung
Add a
cgroup_preordercase that attaches a normal and aBPF_F_PREORDERprogram to a cgroup (effective order [2, 1]), then replaces the normal link's program viabpf_link_update()and checks the effective order becomes [2, 3] — i.e. only the non-preorder slot changes. Without thereplace_effective_prog()fix the array is corrupted and the order is wrong.Signed-off-by Amery Hung <[email protected]>
This series was applied to bpf/bpf.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf.git (master)
by Alexei Starovoitov <[email protected]>:
Quoted 10 lines · On Thu, 18 Jun 2026 23:35:18 -0700 you wrote:
Hi,
This patchset fixes a cgroup effective-array indexing bug where
replace_effective_prog()andpurge_effective_progs()used a linear hlist position that doesn't match the array layout whenBPF_F_PREORDERprograms are present, corrupting the array on link update and risking a use-after-free in the detach fallback. It computes the slot via a sharedeffective_prog_pos()helper and adds acgroup_preorderselftest.[...]
Here is the summary with links:
- [bpf,v2,1/2] bpf: Fix effective prog array index with BPF_F_PREORDER
https://git.kernel.org/bpf/bpf/c/f08aaee3152d - [bpf,v2,2/2] selftests/bpf: Test cgroup link replace with BPF_F_PREORDER https://git.kernel.org/bpf/bpf/c/a6ff26f360c8
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html