FAILED: patch "[PATCH] perf/core: Fix group leader use-after-free after sibling" failed to apply to 5.10-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 5.10-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-5.10.y
git checkout FETCH_HEAD
git cherry-pick -x 42c5ca1f0a288a52878bd72a5595b08261057438
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026081732-unmixed-crudely-500c@gregkh' --subject-prefix 'PATCH 5.10.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 42c5ca1f0a288a52878bd72a5595b08261057438 Mon Sep 17 00:00:00 2001
From: Aditya Chillara <[email protected]>
Date: Fri, 7 Aug 2026 18:11:52 +0530
Subject: [PATCH] perf/core: Fix group leader use-after-free after sibling
detach
perf_group_detach() handles leader and sibling detach differently. When the group leader is detached, all siblings are promoted to singleton events and their group_leader pointer is reset to themselves. When a sibling is detached, it is removed from the leader's sibling_list, but its group_leader pointer is left pointing at the old leader.
That is harmless when the sibling is being closed and freed immediately, as in the DETACH_DEAD path. It is not safe when the sibling is detached but kept alive, such as during CPU hotplug with DETACH_GROUP. In that case the sibling is removed from the context, while its file descriptor can still keep it alive.
A typical failing sequence is:
- A group contains leader L and sibling S.
- CPU hot-unplug detaches S with DETACH_GROUP, removing it from
L->sibling_list but leaving S->group_leader == L.
- L is later closed and freed.
- A PERF_IOC_FLAG_GROUP ioctl on S follows S->group_leader and dereferences the freed leader.
This was reproduced by running the perf event fuzzer, CPU hotplug, and a stress workload concurrently:
Unable to handle kernel paging request at virtual address 006b6b6b6b6b6cdb CPU: 2 PID: 12489 Comm: perf_fuzzer 6.18.7 PREEMPT pc : perf_ioctl+0x34c/0xc68 x20: ffffff89a3fa2c70 x8 : 6b6b6b6b6b6b6b6b Code: 943c4a0e 340047a0 f9404a94 f9411e88 (f940b908) Call trace: perf_ioctl+0x34c/0xc68 (P) __arm64_sys_ioctl+0xa0/0xf4 invoke_syscall+0x58/0xe4 el0_svc_common+0xa8/0xdc do_el0_svc+0x1c/0x28 el0_svc+0x40/0xc0 el0t_64_sync_handler+0x68/0xdc el0t_64_sync+0x1c4/0x1c8
The fault happened in perf_ioctl(), where perf_event_for_each() follows the stale group_leader pointer and perf_event_for_each_child() then dereferences the freed leader's context.
Fix the use-after-free by promoting the detached sibling to a singleton. Also fix __event_disable() cgroup accounting and event state change.
kernel/events/core.c +37 -30
@@ -2343,6 +2343,34 @@ static inline struct list_head *get_event_list(struct perf_event *event) &event->pmu_ctx->flexible_active; } +/* @sibling must already be unlinked from its old leader's sibling_list. */ +static void perf_promote_sibling_to_leader (struct perf_event *sibling, +struct perf_event_context *ctx, +int group_caps) +{ +/* +* Events that have PERF_EV_CAP_SIBLING require being part of +* a group and cannot exist on their own, schedule them out +* and move them into the ERROR state. Also see +* _perf_event_enable(), it will not be able to recover this +* ERROR state. +*/ +if (sibling->event_caps &PERF_EV_CAP_SIBLING ) +__event_disable (sibling, ctx,PERF_EVENT_STATE_ERROR ); + + sibling->group_leader = sibling; + sibling->group_caps = group_caps; + +if (sibling->attach_state &PERF_ATTACH_CONTEXT ) { +add_event_to_groups (sibling, ctx); + +if (sibling->state ==PERF_EVENT_STATE_ACTIVE ) +list_add_tail (&sibling->active_list,get_event_list (sibling)); + } + +perf_event__header_size (sibling); +} +static void perf_group_detach (struct perf_event *event) {struct perf_event *leader = event->group_leader;
@@ -2366,8 +2394,9 @@ static void perf_group_detach(struct perf_event *event)*/ if (leader != event) {list_del_init (&event->sibling_list); - event->group_leader->nr_siblings--; - event->group_leader->group_generation++; + leader->nr_siblings--; + leader->group_generation++; +perf_promote_sibling_to_leader (event, ctx, event->event_caps); goto out; }
@@ -2377,32 +2406,14 @@ static void perf_group_detach(struct perf_event *event)* to whatever list we are on. */ list_for_each_entry_safe (sibling, tmp, &event->sibling_list, sibling_list) { - -/* -* Events that have PERF_EV_CAP_SIBLING require being part of -* a group and cannot exist on their own, schedule them out -* and move them into the ERROR state. Also see -* _perf_event_enable(), it will not be able to recover this -* ERROR state. -*/ -if (sibling->event_caps &PERF_EV_CAP_SIBLING ) -__event_disable (sibling, ctx,PERF_EVENT_STATE_ERROR ); - - sibling->group_leader = sibling;list_del_init (&sibling->sibling_list);/* Inherit group flags from the previous leader */ - sibling->group_caps = event->group_caps; - -if (sibling->attach_state &PERF_ATTACH_CONTEXT ) { -add_event_to_groups (sibling, event->ctx); - -if (sibling->state ==PERF_EVENT_STATE_ACTIVE ) -list_add_tail (&sibling->active_list,get_event_list (sibling)); - } +perf_promote_sibling_to_leader (sibling, ctx, event->group_caps);WARN_ON_ONCE (sibling->ctx != event->ctx); } + event->nr_siblings =0 ; out:for_each_sibling_event (tmp, leader)
@@ -2592,12 +2603,7 @@ __perf_remove_from_context(struct perf_event *event,if (flags &DETACH_DEAD ) state =PERF_EVENT_STATE_DEAD ; -event_sched_out (event, ctx); - -if (event->state >PERF_EVENT_STATE_OFF ) -perf_cgroup_event_disable (event, ctx); - -perf_event_set_state (event,min (event->state, state)); +__event_disable (event, ctx, state);if (flags &DETACH_GROUP )perf_group_detach (event);
@@ -2666,8 +2672,9 @@ static void __event_disable(struct perf_event *event, enum perf_event_state state) {event_sched_out (event, ctx); -perf_cgroup_event_disable (event, ctx); -perf_event_set_state (event, state); +if (event->state >PERF_EVENT_STATE_OFF ) +perf_cgroup_event_disable (event, ctx); +perf_event_set_state (event,min (event->state, state)); }/*
Sasha Levin
maintainerPATCH 1/3 perf: Fix cgroup state vs ERROR
From: Peter Zijlstra <[email protected]>
[ Upstream commit 61988e36dc5457cdff7ae7927e8d9ad1419ee998 ]
While chasing down a missing perf_cgroup_event_disable() elsewhere, Leo Yan found that both perf_put_aux_event() and perf_remove_sibling_event() were also missing one.
Specifically, the rule is that events that switch to OFF,ERROR need to call perf_cgroup_event_disable().
Unify the disable paths to ensure this.
Stable-dep-of: 42c5ca1f0a28 ("perf/core: Fix group leader use-after-free after sibling detach")
--- kernel/events/core.c | 56 ++++++++++++++++++++++++-------------------- 1 file changed, 30 insertions(+), 26 deletions(-)
kernel/events/core.c +30 -26
@@ -2145,14 +2145,13 @@ perf_aux_output_match(struct perf_event *event, struct perf_event *aux_event) }static void put_event (struct perf_event *event); -static void event_sched_out (struct perf_event *event, -struct perf_cpu_context *cpuctx, -struct perf_event_context *ctx); +static void __event_disable (struct perf_event *event, +struct perf_event_context *ctx, +enum perf_event_state state);static void perf_put_aux_event (struct perf_event *event) {struct perf_event_context *ctx = event->ctx; -struct perf_cpu_context *cpuctx =__get_cpu_context (ctx);struct perf_event *iter;/*
@@ -2181,8 +2180,7 @@ static void perf_put_aux_event(struct perf_event *event)* state so that we don't try to schedule it again. Note * that perf_event_enable() will clear the ERROR status. */ -event_sched_out (iter, cpuctx, ctx); -perf_event_set_state (event,PERF_EVENT_STATE_ERROR ); +__event_disable (iter, ctx,PERF_EVENT_STATE_ERROR ); } }
@@ -2236,21 +2234,6 @@ static inline struct list_head *get_event_list(struct perf_event *event)return event->attr.pinned ? &ctx->pinned_active : &ctx->flexible_active; } -/* -* Events that have PERF_EV_CAP_SIBLING require being part of a group and -* cannot exist on their own, schedule them out and move them into the ERROR -* state. Also see _perf_event_enable(), it will not be able to recover -* this ERROR state. -*/ -static inline void perf_remove_sibling_event (struct perf_event *event) -{ -struct perf_event_context *ctx = event->ctx; -struct perf_cpu_context *cpuctx =__get_cpu_context (ctx); - -event_sched_out (event, cpuctx, ctx); -perf_event_set_state (event,PERF_EVENT_STATE_ERROR ); -} -static void perf_group_detach (struct perf_event *event) {struct perf_event *leader = event->group_leader;
@@ -2286,8 +2269,15 @@ static void perf_group_detach(struct perf_event *event)*/ list_for_each_entry_safe (sibling, tmp, &event->sibling_list, sibling_list) { +/* +* Events that have PERF_EV_CAP_SIBLING require being part of +* a group and cannot exist on their own, schedule them out +* and move them into the ERROR state. Also see +* _perf_event_enable(), it will not be able to recover this +* ERROR state. +*/ if (sibling->event_caps &PERF_EV_CAP_SIBLING ) -perf_remove_sibling_event (sibling); +__event_disable (sibling, ctx,PERF_EVENT_STATE_ERROR ); sibling->group_leader = sibling;list_del_init (&sibling->sibling_list);
@@ -2494,6 +2484,15 @@ static void perf_remove_from_context(struct perf_event *event, unsigned long fla } } +static void __event_disable (struct perf_event *event, +struct perf_event_context *ctx, +enum perf_event_state state) +{ +event_sched_out (event,__get_cpu_context (ctx), ctx); +perf_cgroup_event_disable (event, ctx); +perf_event_set_state (event, state); +} +/* * Cross CPU call to disable a performance event */
@@ -2510,13 +2509,18 @@ static void __perf_event_disable(struct perf_event *event,update_cgrp_time_from_event (event); } +/* +* When disabling a group leader, the whole group becomes ineligible +* to run, so schedule out the full group. +*/ if (event == event->group_leader)group_sched_out (event, cpuctx, ctx); -else -event_sched_out (event, cpuctx, ctx); -perf_event_set_state (event,PERF_EVENT_STATE_OFF ); -perf_cgroup_event_disable (event, ctx); +/* +* But only mark the leader OFF; the siblings will remain +* INACTIVE. +*/ +__event_disable (event, ctx,PERF_EVENT_STATE_OFF ); }/*
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/3 perf: Fix dangling cgroup pointer in cpuctx
From: Yeoreum Yun <[email protected]>
[ Upstream commit 3b7a34aebbdf2a4b7295205bf0c654294283ec82 ]
Commit a3c3c6667("perf/core: Fix child_total_time_enabled accounting bug at task exit") moves the event->state update to before list_del_event(). This makes the event->state test in list_del_event() always false; never calling perf_cgroup_event_disable().
As a result, cpuctx->cgrp won't be cleared properly; causing havoc.
Stable-dep-of: 42c5ca1f0a28 ("perf/core: Fix group leader use-after-free after sibling detach")
--- kernel/events/core.c | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-)
kernel/events/core.c +7 -12
@@ -2117,18 +2117,6 @@ list_del_event(struct perf_event *event, struct perf_event_context *ctx)if (event->group_leader == event)del_event_from_groups (event, ctx); -/* -* If event was in error state, then keep it -* that way, otherwise bogus counts will be -* returned on read(). The only way to get out -* of error state is by explicit re-enabling -* of the event -*/ -if (event->state >PERF_EVENT_STATE_OFF ) { -perf_cgroup_event_disable (event, ctx); -perf_event_set_state (event,PERF_EVENT_STATE_OFF ); - } - ctx->generation++; }
@@ -2422,6 +2410,7 @@ __perf_remove_from_context(struct perf_event *event,struct perf_event_context *ctx, void *info) { + enum perf_event_state state = PERF_EVENT_STATE_OFF;unsigned long flags = (unsigned long )info;if (ctx->is_active &EVENT_TIME ) {
@@ -2430,6 +2419,12 @@ __perf_remove_from_context(struct perf_event *event, }event_sched_out (event, cpuctx, ctx); + +if (event->state >PERF_EVENT_STATE_OFF ) +perf_cgroup_event_disable (event, ctx); + +perf_event_set_state (event,min (event->state, state)); +if (flags &DETACH_GROUP )perf_group_detach (event);list_del_event (event, ctx);
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 3/3 perf/core: Fix group leader use-after-free after sibling detach
In reply to Sasha LevinFrom: Aditya Chillara <[email protected]>
[ Upstream commit 42c5ca1f0a288a52878bd72a5595b08261057438 ]
perf_group_detach() handles leader and sibling detach differently. When the group leader is detached, all siblings are promoted to singleton events and their group_leader pointer is reset to themselves. When a sibling is detached, it is removed from the leader's sibling_list, but its group_leader pointer is left pointing at the old leader.
That is harmless when the sibling is being closed and freed immediately, as in the DETACH_DEAD path. It is not safe when the sibling is detached but kept alive, such as during CPU hotplug with DETACH_GROUP. In that case the sibling is removed from the context, while its file descriptor can still keep it alive.
A typical failing sequence is:
- A group contains leader L and sibling S.
- CPU hot-unplug detaches S with DETACH_GROUP, removing it from
L->sibling_list but leaving S->group_leader == L.
- L is later closed and freed.
- A PERF_IOC_FLAG_GROUP ioctl on S follows S->group_leader and dereferences the freed leader.
This was reproduced by running the perf event fuzzer, CPU hotplug, and a stress workload concurrently:
Unable to handle kernel paging request at virtual address 006b6b6b6b6b6cdb CPU: 2 PID: 12489 Comm: perf_fuzzer 6.18.7 PREEMPT pc : perf_ioctl+0x34c/0xc68 x20: ffffff89a3fa2c70 x8 : 6b6b6b6b6b6b6b6b Code: 943c4a0e 340047a0 f9404a94 f9411e88 (f940b908) Call trace: perf_ioctl+0x34c/0xc68 (P) __arm64_sys_ioctl+0xa0/0xf4 invoke_syscall+0x58/0xe4 el0_svc_common+0xa8/0xdc do_el0_svc+0x1c/0x28 el0_svc+0x40/0xc0 el0t_64_sync_handler+0x68/0xdc el0t_64_sync+0x1c4/0x1c8
The fault happened in perf_ioctl(), where perf_event_for_each() follows the stale group_leader pointer and perf_event_for_each_child() then dereferences the freed leader's context.
Fix the use-after-free by promoting the detached sibling to a singleton. Also fix __event_disable() cgroup accounting and event state change.
--- kernel/events/core.c | 67 ++++++++++++++++++++++++-------------------- 1 file changed, 37 insertions(+), 30 deletions(-)
kernel/events/core.c +37 -30
@@ -2222,6 +2222,34 @@ static inline struct list_head *get_event_list(struct perf_event *event)return event->attr.pinned ? &ctx->pinned_active : &ctx->flexible_active; } +/* @sibling must already be unlinked from its old leader's sibling_list. */ +static void perf_promote_sibling_to_leader (struct perf_event *sibling, +struct perf_event_context *ctx, +int group_caps) +{ +/* +* Events that have PERF_EV_CAP_SIBLING require being part of +* a group and cannot exist on their own, schedule them out +* and move them into the ERROR state. Also see +* _perf_event_enable(), it will not be able to recover this +* ERROR state. +*/ +if (sibling->event_caps &PERF_EV_CAP_SIBLING ) +__event_disable (sibling, ctx,PERF_EVENT_STATE_ERROR ); + + sibling->group_leader = sibling; + sibling->group_caps = group_caps; + +if (sibling->attach_state &PERF_ATTACH_CONTEXT ) { +add_event_to_groups (sibling, ctx); + +if (sibling->state ==PERF_EVENT_STATE_ACTIVE ) +list_add_tail (&sibling->active_list,get_event_list (sibling)); + } + +perf_event__header_size (sibling); +} +static void perf_group_detach (struct perf_event *event) {struct perf_event *leader = event->group_leader;
@@ -2245,8 +2273,9 @@ static void perf_group_detach(struct perf_event *event)*/ if (leader != event) {list_del_init (&event->sibling_list); - event->group_leader->nr_siblings--; - event->group_leader->group_generation++; + leader->nr_siblings--; + leader->group_generation++; +perf_promote_sibling_to_leader (event, ctx, event->event_caps); goto out; }
@@ -2256,32 +2285,14 @@ static void perf_group_detach(struct perf_event *event)* to whatever list we are on. */ list_for_each_entry_safe (sibling, tmp, &event->sibling_list, sibling_list) { - -/* -* Events that have PERF_EV_CAP_SIBLING require being part of -* a group and cannot exist on their own, schedule them out -* and move them into the ERROR state. Also see -* _perf_event_enable(), it will not be able to recover this -* ERROR state. -*/ -if (sibling->event_caps &PERF_EV_CAP_SIBLING ) -__event_disable (sibling, ctx,PERF_EVENT_STATE_ERROR ); - - sibling->group_leader = sibling;list_del_init (&sibling->sibling_list);/* Inherit group flags from the previous leader */ - sibling->group_caps = event->group_caps; - -if (!RB_EMPTY_NODE (&event->group_node)) { -add_event_to_groups (sibling, event->ctx); - -if (sibling->state ==PERF_EVENT_STATE_ACTIVE ) -list_add_tail (&sibling->active_list,get_event_list (sibling)); - } +perf_promote_sibling_to_leader (sibling, ctx, event->group_caps);WARN_ON_ONCE (sibling->ctx != event->ctx); } + event->nr_siblings =0 ; out:for_each_sibling_event (tmp, leader)
@@ -2418,12 +2429,7 @@ __perf_remove_from_context(struct perf_event *event,update_cgrp_time_from_cpuctx (cpuctx, false); } -event_sched_out (event, cpuctx, ctx); - -if (event->state >PERF_EVENT_STATE_OFF ) -perf_cgroup_event_disable (event, ctx); - -perf_event_set_state (event,min (event->state, state)); +__event_disable (event, ctx, state);if (flags &DETACH_GROUP )perf_group_detach (event);
@@ -2484,8 +2490,9 @@ static void __event_disable(struct perf_event *event, enum perf_event_state state) {event_sched_out (event,__get_cpu_context (ctx), ctx); -perf_cgroup_event_disable (event, ctx); -perf_event_set_state (event, state); +if (event->state >PERF_EVENT_STATE_OFF ) +perf_cgroup_event_disable (event, ctx); +perf_event_set_state (event,min (event->state, state)); }/*
Signature · 1 line
2.53.0