* [PATCH v5 0/2] perf/core: Fix sigtrap task_work races
@ 2026-11-19 9:50 Tengda Wu
2026-11-19 9:51 ` [PATCH v5 1/2] perf/core: Prevent duplicate sigtrap task work enqueue Tengda Wu
2026-11-19 9:51 ` [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events Tengda Wu
0 siblings, 2 replies; 12+ messages in thread
From: Tengda Wu @ 2026-11-19 9:50 UTC (permalink / raw)
To: Peter Zijlstra, Sebastian Andrzej Siewior
Cc: Ingo Molnar, Arnaldo Carvalho de Melo, Namhyung Kim, Mark Rutland,
Alexander Shishkin, Jiri Olsa, Ian Rogers, Adrian Hunter,
James Clark, linux-perf-users, linux-kernel, Tengda Wu
Two fixes for sigtrap task_work handling since the switch to always
enqueue SIGTRAP via task_work.
The warning splats and PoCs for both patches are too long to inline
in the commit messages, so they are provided as separate replies at
the following links:
Patch 1: https://lore.kernel.org/all/29aa123c-36a2-460f-b76b-a8dfe1eb542f@huaweicloud.com/
Patch 2: https://lore.kernel.org/all/d1b24bbf-9111-4766-87c8-ff97adcac727@huaweicloud.com/
Patch 1 fixes a re-entrancy race in __perf_event_overflow(): pending_work
was set only after task_work_add(), so an NMI could re-enter and enqueue
the same pending_task twice, creating a cycle in the task work list and
unbalancing the event refcount. Claim pending_work before enqueuing, and
clear it if the enqueue fails.
Patch 2 fixes a WARN_ON_ONCE() in perf_sigtrap() triggered by the context
fast-swap path swapping ctx->task while a sigtrap event has pending task
work. SIGTRAP is targeted at ctx->task, so exclude sigtrap events from
fast-swap alongside inherit+sample-read events.
Changelog
=========
v4 -> v5:
- v4: https://lore.kernel.org/all/cover.1794914794.git.wutengda@huaweicloud.com/
- Roll back patch 2 to v3 to avoid the fast swap isolation omission in
the nr_no_switch_fast 1->0 scenario. (Shashiko)
v3 -> v4:
- v3: https://lore.kernel.org/all/cover.1793870900.git.wutengda@huaweicloud.com/
- Patch 1: Use acquire/release pairs for pending_work updates (Sebastian)
- Patch 2: Remove redundant nr_no_switch_fast updates (Sebastian)
v2 -> v3:
- v2: https://lore.kernel.org/all/20261102021355.650671-1-wutengda@huaweicloud.com/
- Added Patch 2 to fix WARN_ON_ONCE() in perf_sigtrap()
v1 -> v2:
- v1: https://lore.kernel.org/all/20261031114520.642476-1-wutengda@huaweicloud.com/
- Drop the redundant event->pending_work assignment. (Sashiko)
Tengda Wu (2):
perf/core: Prevent duplicate sigtrap task work enqueue
perf/core: Disable context fast-swap for sigtrap events
include/linux/perf_event.h | 6 ++---
kernel/events/core.c | 48 ++++++++++++++++++++++++++------------
2 files changed, 35 insertions(+), 19 deletions(-)
--
2.34.1
^ permalink raw reply [flat|nested] 12+ messages in thread* [PATCH v5 1/2] perf/core: Prevent duplicate sigtrap task work enqueue 2026-11-19 9:50 [PATCH v5 0/2] perf/core: Fix sigtrap task_work races Tengda Wu @ 2026-11-19 9:51 ` Tengda Wu 2026-11-19 9:59 ` sashiko-bot 2026-11-19 12:09 ` Sebastian Andrzej Siewior 2026-11-19 9:51 ` [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events Tengda Wu 1 sibling, 2 replies; 12+ messages in thread From: Tengda Wu @ 2026-11-19 9:51 UTC (permalink / raw) To: Peter Zijlstra, Sebastian Andrzej Siewior Cc: Ingo Molnar, Arnaldo Carvalho de Melo, Namhyung Kim, Mark Rutland, Alexander Shishkin, Jiri Olsa, Ian Rogers, Adrian Hunter, James Clark, linux-perf-users, linux-kernel, Tengda Wu The sigtrap handling in __perf_event_overflow() checks event->pending_work before calling task_work_add(), but only sets pending_work after the task work has been queued. This leaves a window where an NMI can interrupt task_work_add() and re-enter __perf_event_overflow() for the same event. Since pending_work is still zero, the nested invocation can enqueue the same pending_task again. The re-entrant call path looks like this: __perf_event_overflow() task_work_add() kasan_record_aux_stack() <NMI> __perf_event_overflow() task_work_add() The nested invocation may enqueue pending_task before the outer invocation does. When the outer invocation resumes, it inserts the same task work entry again, potentially creating a cycle in the task work list. As a result, perf_pending_task() may be executed repeatedly, leading to unbalanced event reference counting. Fix this by atomically claiming pending_work with cmpxchg_acquire() before calling task_work_add(). This ensures that only one invocation can enqueue the task work, even when another overflow occurs re-entrantly from an NMI. If task_work_add() fails, clear the claim with smp_store_release() to allow a subsequent overflow to retry. In perf_pending_task(), defer clearing pending_work until after perf_sigtrap() has completed. Use smp_store_release() to ensure that a subsequent overflow cannot re-queue the task work before the previous invocation has finished handling it. Also use smp_load_acquire() when checking pending_work in the exclude_kernel warning path to ensure the read is properly ordered. Fixes: c5d93d23a260 ("perf: Enqueue SIGTRAP always via task_work.") Signed-off-by: Tengda Wu <wutengda@huaweicloud.com> --- kernel/events/core.c | 39 ++++++++++++++++++++++++++------------- 1 file changed, 26 insertions(+), 13 deletions(-) diff --git a/kernel/events/core.c b/kernel/events/core.c index 614f9f0e6500..857230b023ae 100644 --- a/kernel/events/core.c +++ b/kernel/events/core.c @@ -7775,10 +7775,14 @@ static void perf_pending_task(struct callback_head *head) */ rctx = perf_swevent_get_recursion_context(); - if (event->pending_work) { - event->pending_work = 0; + if (smp_load_acquire(&event->pending_work)) { perf_sigtrap(event); local_dec(&event->ctx->nr_no_switch_fast); + /* + * Ensure the pending work is fully handled before allowing + * another overflow to queue it. See __perf_event_overflow(). + */ + smp_store_release(&event->pending_work, 0); } put_event(event); @@ -10950,16 +10954,25 @@ static int __perf_event_overflow(struct perf_event *event, notify_mode = in_nmi() ? TWA_NMI_CURRENT : TWA_RESUME; - if (!event->pending_work && - !task_work_add(current, &event->pending_task, notify_mode)) { - event->pending_work = pending_id; - local_inc(&event->ctx->nr_no_switch_fast); - WARN_ON_ONCE(!atomic_long_inc_not_zero(&event->refcount)); - - event->pending_addr = 0; - if (valid_sample && (data->sample_flags & PERF_SAMPLE_ADDR)) - event->pending_addr = data->addr; - + /* + * Claim pending_work before queueing the task work to prevent + * another overflow from queueing it concurrently. + */ + if (cmpxchg_acquire(&event->pending_work, 0, pending_id) == 0) { + if (!task_work_add(current, &event->pending_task, notify_mode)) { + local_inc(&event->ctx->nr_no_switch_fast); + WARN_ON_ONCE(!atomic_long_inc_not_zero(&event->refcount)); + + event->pending_addr = 0; + if (valid_sample && (data->sample_flags & PERF_SAMPLE_ADDR)) + event->pending_addr = data->addr; + } else { + /* + * Publish the failed queueing attempt so + * a subsequent overflow can retry. + */ + smp_store_release(&event->pending_work, 0); + } } else if (event->attr.exclude_kernel && valid_sample) { /* * Should not be able to return to user space without @@ -10973,7 +10986,7 @@ static int __perf_event_overflow(struct perf_event *event, * To approximate progress (with false negatives), * check 32-bit hash of the current IP. */ - WARN_ON_ONCE(event->pending_work != pending_id); + WARN_ON_ONCE(smp_load_acquire(&event->pending_work) != pending_id); } } -- 2.34.1 ^ permalink raw reply related [flat|nested] 12+ messages in thread
* Re: [PATCH v5 1/2] perf/core: Prevent duplicate sigtrap task work enqueue 2026-11-19 9:51 ` [PATCH v5 1/2] perf/core: Prevent duplicate sigtrap task work enqueue Tengda Wu @ 2026-11-19 9:59 ` sashiko-bot 2026-11-19 12:09 ` Sebastian Andrzej Siewior 1 sibling, 0 replies; 12+ messages in thread From: sashiko-bot @ 2026-11-19 9:59 UTC (permalink / raw) To: Tengda Wu; +Cc: linux-perf-users > The sigtrap handling in __perf_event_overflow() checks > event->pending_work before calling task_work_add(), but only sets > pending_work after the task work has been queued. > > This leaves a window where an NMI can interrupt task_work_add() > and re-enter __perf_event_overflow() for the same event. Since > pending_work is still zero, the nested invocation can enqueue > the same pending_task again. > > The re-entrant call path looks like this: > > __perf_event_overflow() > task_work_add() > kasan_record_aux_stack() > <NMI> > [ ... ] > the exclude_kernel warning path to ensure the read is properly > ordered. > > Fixes: c5d93d23a260 ("perf: Enqueue SIGTRAP always via task_work.") > Signed-off-by: Tengda Wu <wutengda@huaweicloud.com> Sashiko has reviewed this patch and found no issues. -- Sashiko AI review · https://sashiko.dev/#/patchset/cover.1795053619.git.wutengda@huaweicloud.com?part=1 ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v5 1/2] perf/core: Prevent duplicate sigtrap task work enqueue 2026-11-19 9:51 ` [PATCH v5 1/2] perf/core: Prevent duplicate sigtrap task work enqueue Tengda Wu 2026-11-19 9:59 ` sashiko-bot @ 2026-11-19 12:09 ` Sebastian Andrzej Siewior 1 sibling, 0 replies; 12+ messages in thread From: Sebastian Andrzej Siewior @ 2026-11-19 12:09 UTC (permalink / raw) To: Tengda Wu Cc: Peter Zijlstra, Ingo Molnar, Arnaldo Carvalho de Melo, Namhyung Kim, Mark Rutland, Alexander Shishkin, Jiri Olsa, Ian Rogers, Adrian Hunter, James Clark, linux-perf-users, linux-kernel On 2026-11-19 09:51:00 [+0000], Tengda Wu wrote: > The sigtrap handling in __perf_event_overflow() checks > event->pending_work before calling task_work_add(), but only sets > pending_work after the task work has been queued. > > This leaves a window where an NMI can interrupt task_work_add() > and re-enter __perf_event_overflow() for the same event. Since > pending_work is still zero, the nested invocation can enqueue > the same pending_task again. > > The re-entrant call path looks like this: > > __perf_event_overflow() > task_work_add() > kasan_record_aux_stack() > <NMI> > __perf_event_overflow() > task_work_add() > > The nested invocation may enqueue pending_task before the > outer invocation does. When the outer invocation resumes, it > inserts the same task work entry again, potentially creating > a cycle in the task work list. > > As a result, perf_pending_task() may be executed repeatedly, > leading to unbalanced event reference counting. The repeated task_work_add() will corrupt the list. > Fix this by atomically claiming pending_work with > cmpxchg_acquire() before calling task_work_add(). This ensures > that only one invocation can enqueue the task work, even when > another overflow occurs re-entrantly from an NMI. > > If task_work_add() fails, clear the claim with > smp_store_release() to allow a subsequent overflow to retry. "to revert to previous state". > In perf_pending_task(), defer clearing pending_work until > after perf_sigtrap() has completed. Use smp_store_release() > to ensure that a subsequent overflow cannot re-queue the task > work before the previous invocation has finished handling it. > > Also use smp_load_acquire() when checking pending_work in > the exclude_kernel warning path to ensure the read is properly > ordered. > > Fixes: c5d93d23a260 ("perf: Enqueue SIGTRAP always via task_work.") > Signed-off-by: Tengda Wu <wutengda@huaweicloud.com> Reviewed-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> Sebastian ^ permalink raw reply [flat|nested] 12+ messages in thread
* [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events 2026-11-19 9:50 [PATCH v5 0/2] perf/core: Fix sigtrap task_work races Tengda Wu 2026-11-19 9:51 ` [PATCH v5 1/2] perf/core: Prevent duplicate sigtrap task work enqueue Tengda Wu @ 2026-11-19 9:51 ` Tengda Wu 2026-11-19 10:03 ` sashiko-bot 2026-11-19 12:11 ` Sebastian Andrzej Siewior 1 sibling, 2 replies; 12+ messages in thread From: Tengda Wu @ 2026-11-19 9:51 UTC (permalink / raw) To: Peter Zijlstra, Sebastian Andrzej Siewior Cc: Ingo Molnar, Arnaldo Carvalho de Melo, Namhyung Kim, Mark Rutland, Alexander Shishkin, Jiri Olsa, Ian Rogers, Adrian Hunter, James Clark, linux-perf-users, linux-kernel, Tengda Wu perf_sigtrap() contains: WARN_ON_ONCE(event->ctx->task != current) The warning assumes that an event's ctx->task always matches the task that ends up running the pending task_work. That assumption can be broken by the context fast-swap path. The failure sequence is: 1. A -> B switch, perf_event_context_sched_out() takes the fast path and does WRITE_ONCE(ctx->task, next) / WRITE_ONCE(next_ctx->task, task). An NMI then hits while the context is swapped, and __perf_event_overflow() queues pending task_work on the *current* task (A), even though the event now belongs to B's swapped-in context view. 2. B -> A switch. Because A now has pending task_work, nr_no_switch_fast is non-zero, so the slow path is taken and ctx->task is *not* swapped back. 3. A returns to user mode, task_work runs perf_pending_task() -> perf_sigtrap(), and event->ctx->task no longer equals current, tripping the WARN_ON_ONCE(). The context fast-swap path was already excluded for events that need stable task association (inherit + sample read). sigtrap events have the same requirement: the SIGTRAP is targeted at ctx->task and must not be delivered after ctx->task has been swapped to another task. Fix this by also excluding events with attr->sigtrap from the fast-swap path, i.e. bump nr_no_switch_fast for sigtrap events in list_add_event()/list_del_event(), and update the comment describing the invariant accordingly. Fixes: c5d93d23a260 ("perf: Enqueue SIGTRAP always via task_work.") Signed-off-by: Tengda Wu <wutengda@huaweicloud.com> --- include/linux/perf_event.h | 6 ++---- kernel/events/core.c | 9 +++++++-- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h index e1e11500df09..d2eb22cc5b71 100644 --- a/include/linux/perf_event.h +++ b/include/linux/perf_event.h @@ -1067,10 +1067,8 @@ struct perf_event_context { * should be avoided. * * Sum (event->pending_work + events with - * (attr->inherit && (attr->sample_type & PERF_SAMPLE_READ))) - * - * The SIGTRAP is targeted at ctx->task, as such it won't do changing - * that until the signal is delivered. + * (attr->inherit && (attr->sample_type & PERF_SAMPLE_READ)) + + * events with attr->sigtrap) */ local_t nr_no_switch_fast; }; diff --git a/kernel/events/core.c b/kernel/events/core.c index 857230b023ae..094b42ed6462 100644 --- a/kernel/events/core.c +++ b/kernel/events/core.c @@ -2009,7 +2009,7 @@ list_add_event(struct perf_event *event, struct perf_event_context *ctx) ctx->nr_user++; if (event->attr.inherit_stat) ctx->nr_stat++; - if (has_inherit_and_sample_read(&event->attr)) + if (has_inherit_and_sample_read(&event->attr) || event->attr.sigtrap) local_inc(&ctx->nr_no_switch_fast); if (event->state > PERF_EVENT_STATE_OFF) @@ -2235,7 +2235,7 @@ list_del_event(struct perf_event *event, struct perf_event_context *ctx) ctx->nr_user--; if (event->attr.inherit_stat) ctx->nr_stat--; - if (has_inherit_and_sample_read(&event->attr)) + if (has_inherit_and_sample_read(&event->attr) || event->attr.sigtrap) local_dec(&ctx->nr_no_switch_fast); list_del_rcu(&event->event_entry); @@ -3841,6 +3841,11 @@ perf_event_context_sched_out(struct task_struct *task, struct task_struct *next) * SAMPLE_READ events they should be switched * out using the slow path so that they are * treated as if they were distinct contexts. + * + * A context holding a sigtrap event must also + * take the slow path, even when nothing is + * pending, since the sigtrap delivery relies on + * the ctx->task relation as well. */ raw_spin_unlock(&next_ctx->lock); rcu_read_unlock(); -- 2.34.1 ^ permalink raw reply related [flat|nested] 12+ messages in thread
* Re: [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events 2026-11-19 9:51 ` [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events Tengda Wu @ 2026-11-19 10:03 ` sashiko-bot 2026-11-19 11:39 ` Tengda Wu 2026-11-19 12:11 ` Sebastian Andrzej Siewior 1 sibling, 1 reply; 12+ messages in thread From: sashiko-bot @ 2026-11-19 10:03 UTC (permalink / raw) To: Tengda Wu; +Cc: linux-perf-users Thank you for your contribution! Sashiko AI review found 1 potential issue to consider: - [Medium] perf/core: non-SMP-atomic local_t race on ctx->nr_no_switch_fast -- commit 5e829db733e2fe49cdac7cb99bb9428db1c83359 Author: Tengda Wu <wutengda@huaweicloud.com> perf/core: Disable context fast-swap for sigtrap events This commit excludes sigtrap events from the context fast-swap path by incrementing and decrementing ctx->nr_no_switch_fast when adding and removing events with attr.sigtrap set. > diff --git a/kernel/events/core.c b/kernel/events/core.c > index da86bc6e8be94..483ba8704d418 100644 > --- a/kernel/events/core.c > +++ b/kernel/events/core.c > @@ -1999,7 +1999,7 @@ list_add_event(struct perf_event *event, struct perf_event_context *ctx) > ctx->nr_user++; > if (event->attr.inherit_stat) > ctx->nr_stat++; > - if (has_inherit_and_sample_read(&event->attr)) > + if (has_inherit_and_sample_read(&event->attr) || event->attr.sigtrap) > local_inc(&ctx->nr_no_switch_fast); > > if (event->state > PERF_EVENT_STATE_OFF) > @@ -2225,7 +2225,7 @@ list_del_event(struct perf_event *event, struct perf_event_context *ctx) > ctx->nr_user--; > if (event->attr.inherit_stat) > ctx->nr_stat--; > - if (has_inherit_and_sample_read(&event->attr)) > + if (has_inherit_and_sample_read(&event->attr) || event->attr.sigtrap) > local_dec(&ctx->nr_no_switch_fast); [Severity: Medium] Can concurrent local_inc() and local_dec() calls on ctx->nr_no_switch_fast from different CPUs race and lose updates? ctx->nr_no_switch_fast is a local_t, so local_inc() and local_dec() are only atomic on a single CPU (for example, unlocked inc/dec on x86). When installing a disabled sigtrap event into a non-empty task context, perf_install_in_context() runs add_event_to_ctx() directly on the installer CPU under ctx->lock without an IPI, while an already-active sigtrap event in that context can update ctx->nr_no_switch_fast on the target task's CPU without holding ctx->lock: CPU0 CPU1 (running ctx->task) perf_install_in_context() raw_spin_lock(&ctx->lock) add_event_to_ctx() list_add_event() local_inc(&ctx->nr_no_switch_fast) __perf_event_overflow() local_inc(&ctx->nr_no_switch_fast) <-- non-SMP-atomic RMW race ... perf_pending_task() local_dec(&ctx->nr_no_switch_fast) A similar cross-CPU race is possible between list_del_event() in perf_remove_from_context() (when !ctx->is_active) and perf_pending_task(). A lost increment allows ctx->nr_no_switch_fast to drop to 0 while a sigtrap event or pending task_work is still present, re-enabling the context fast-swap path and hitting WARN_ON_ONCE(event->ctx->task != current) in perf_sigtrap(). -- Sashiko AI review · https://sashiko.dev/#/patchset/cover.1795053619.git.wutengda@huaweicloud.com?part=2 ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events 2026-11-19 10:03 ` sashiko-bot @ 2026-11-19 11:39 ` Tengda Wu 0 siblings, 0 replies; 12+ messages in thread From: Tengda Wu @ 2026-11-19 11:39 UTC (permalink / raw) To: sashiko-reviews; +Cc: linux-perf-users On 2026/11/19 18:03, sashiko-bot@kernel.org wrote: > Thank you for your contribution! Sashiko AI review found 1 potential > issue to consider: > - [Medium] perf/core: non-SMP-atomic local_t race on > ctx->nr_no_switch_fast > -- > > commit 5e829db733e2fe49cdac7cb99bb9428db1c83359 > Author: Tengda Wu <wutengda@huaweicloud.com> > > perf/core: Disable context fast-swap for sigtrap events > > This commit excludes sigtrap events from the context fast-swap path by > incrementing and decrementing ctx->nr_no_switch_fast when adding and > removing events with attr.sigtrap set. > >> diff --git a/kernel/events/core.c b/kernel/events/core.c >> index da86bc6e8be94..483ba8704d418 100644 >> --- a/kernel/events/core.c >> +++ b/kernel/events/core.c >> @@ -1999,7 +1999,7 @@ list_add_event(struct perf_event *event, struct perf_event_context *ctx) >> ctx->nr_user++; >> if (event->attr.inherit_stat) >> ctx->nr_stat++; >> - if (has_inherit_and_sample_read(&event->attr)) >> + if (has_inherit_and_sample_read(&event->attr) || event->attr.sigtrap) >> local_inc(&ctx->nr_no_switch_fast); >> >> if (event->state > PERF_EVENT_STATE_OFF) >> @@ -2225,7 +2225,7 @@ list_del_event(struct perf_event *event, struct perf_event_context *ctx) >> ctx->nr_user--; >> if (event->attr.inherit_stat) >> ctx->nr_stat--; >> - if (has_inherit_and_sample_read(&event->attr)) >> + if (has_inherit_and_sample_read(&event->attr) || event->attr.sigtrap) >> local_dec(&ctx->nr_no_switch_fast); > > [Severity: Medium] > Can concurrent local_inc() and local_dec() calls on ctx->nr_no_switch_fast > from different CPUs race and lose updates? > > ctx->nr_no_switch_fast is a local_t, so local_inc() and local_dec() are > only atomic on a single CPU (for example, unlocked inc/dec on x86). When > installing a disabled sigtrap event into a non-empty task context, > perf_install_in_context() runs add_event_to_ctx() directly on the > installer CPU under ctx->lock without an IPI, while an already-active > sigtrap event in that context can update ctx->nr_no_switch_fast on the > target task's CPU without holding ctx->lock: > > CPU0 CPU1 (running ctx->task) > perf_install_in_context() > raw_spin_lock(&ctx->lock) > add_event_to_ctx() > list_add_event() > local_inc(&ctx->nr_no_switch_fast) > __perf_event_overflow() > local_inc(&ctx->nr_no_switch_fast) > <-- non-SMP-atomic RMW race > ... > perf_pending_task() > local_dec(&ctx->nr_no_switch_fast) > > A similar cross-CPU race is possible between list_del_event() in > perf_remove_from_context() (when !ctx->is_active) and perf_pending_task(). > A lost increment allows ctx->nr_no_switch_fast to drop to 0 while a > sigtrap event or pending task_work is still present, re-enabling the > context fast-swap path and hitting WARN_ON_ONCE(event->ctx->task != > current) in perf_sigtrap(). > Same as this: https://lore.kernel.org/all/b5d10cd7-e3af-4e07-a19b-44544077db59@huaweicloud.com/ It is a pre-existing issue, so a separate patch will be submitted and it will not be fixed within this patch series. Thanks, Tengda ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events 2026-11-19 9:51 ` [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events Tengda Wu 2026-11-19 10:03 ` sashiko-bot @ 2026-11-19 12:11 ` Sebastian Andrzej Siewior 2026-11-19 12:17 ` Tengda Wu 1 sibling, 1 reply; 12+ messages in thread From: Sebastian Andrzej Siewior @ 2026-11-19 12:11 UTC (permalink / raw) To: Tengda Wu Cc: Peter Zijlstra, Ingo Molnar, Arnaldo Carvalho de Melo, Namhyung Kim, Mark Rutland, Alexander Shishkin, Jiri Olsa, Ian Rogers, Adrian Hunter, James Clark, linux-perf-users, linux-kernel On 2026-11-19 09:51:01 [+0000], Tengda Wu wrote: > perf_sigtrap() contains: > > WARN_ON_ONCE(event->ctx->task != current) > > The warning assumes that an event's ctx->task always matches the task > that ends up running the pending task_work. That assumption can be > broken by the context fast-swap path. > > The failure sequence is: > > 1. A -> B switch, perf_event_context_sched_out() takes the fast path > and does WRITE_ONCE(ctx->task, next) / WRITE_ONCE(next_ctx->task, task). > An NMI then hits while the context is swapped, and > __perf_event_overflow() queues pending task_work on the *current* > task (A), even though the event now belongs to B's swapped-in > context view. > > 2. B -> A switch. Because A now has pending task_work, > nr_no_switch_fast is non-zero, so the slow path is taken and > ctx->task is *not* swapped back. > > 3. A returns to user mode, task_work runs perf_pending_task() -> > perf_sigtrap(), and event->ctx->task no longer equals current, > tripping the WARN_ON_ONCE(). > > The context fast-swap path was already excluded for events that need > stable task association (inherit + sample read). sigtrap events have > the same requirement: the SIGTRAP is targeted at ctx->task and must not > be delivered after ctx->task has been swapped to another task. > > Fix this by also excluding events with attr->sigtrap from the fast-swap > path, i.e. bump nr_no_switch_fast for sigtrap events in > list_add_event()/list_del_event(), and update the comment describing > the invariant accordingly. > > Fixes: c5d93d23a260 ("perf: Enqueue SIGTRAP always via task_work.") > Signed-off-by: Tengda Wu <wutengda@huaweicloud.com> This makes sense. How did you run into this? Is it possible to make a testcase out of it? Reviewed-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> Sebastian ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events 2026-11-19 12:11 ` Sebastian Andrzej Siewior @ 2026-11-19 12:17 ` Tengda Wu 2026-11-19 13:07 ` Sebastian Andrzej Siewior 0 siblings, 1 reply; 12+ messages in thread From: Tengda Wu @ 2026-11-19 12:17 UTC (permalink / raw) To: Sebastian Andrzej Siewior Cc: Peter Zijlstra, Ingo Molnar, Arnaldo Carvalho de Melo, Namhyung Kim, Mark Rutland, Alexander Shishkin, Jiri Olsa, Ian Rogers, Adrian Hunter, James Clark, linux-perf-users, linux-kernel On 2026/11/19 20:11, Sebastian Andrzej Siewior wrote: > On 2026-11-19 09:51:01 [+0000], Tengda Wu wrote: >> perf_sigtrap() contains: >> >> WARN_ON_ONCE(event->ctx->task != current) >> >> The warning assumes that an event's ctx->task always matches the task >> that ends up running the pending task_work. That assumption can be >> broken by the context fast-swap path. >> >> The failure sequence is: >> >> 1. A -> B switch, perf_event_context_sched_out() takes the fast path >> and does WRITE_ONCE(ctx->task, next) / WRITE_ONCE(next_ctx->task, task). >> An NMI then hits while the context is swapped, and >> __perf_event_overflow() queues pending task_work on the *current* >> task (A), even though the event now belongs to B's swapped-in >> context view. >> >> 2. B -> A switch. Because A now has pending task_work, >> nr_no_switch_fast is non-zero, so the slow path is taken and >> ctx->task is *not* swapped back. >> >> 3. A returns to user mode, task_work runs perf_pending_task() -> >> perf_sigtrap(), and event->ctx->task no longer equals current, >> tripping the WARN_ON_ONCE(). >> >> The context fast-swap path was already excluded for events that need >> stable task association (inherit + sample read). sigtrap events have >> the same requirement: the SIGTRAP is targeted at ctx->task and must not >> be delivered after ctx->task has been swapped to another task. >> >> Fix this by also excluding events with attr->sigtrap from the fast-swap >> path, i.e. bump nr_no_switch_fast for sigtrap events in >> list_add_event()/list_del_event(), and update the comment describing >> the invariant accordingly. >> >> Fixes: c5d93d23a260 ("perf: Enqueue SIGTRAP always via task_work.") >> Signed-off-by: Tengda Wu <wutengda@huaweicloud.com> > > This makes sense. How did you run into this? Is it possible to make a > testcase out of it? > > Reviewed-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de> > > Sebastian There is a test case, see this: https://lore.kernel.org/all/d1b24bbf-9111-4766-87c8-ff97adcac727@huaweicloud.com/ Thanks, Tengda ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events 2026-11-19 12:17 ` Tengda Wu @ 2026-11-19 13:07 ` Sebastian Andrzej Siewior 2026-11-19 13:19 ` Tengda Wu 0 siblings, 1 reply; 12+ messages in thread From: Sebastian Andrzej Siewior @ 2026-11-19 13:07 UTC (permalink / raw) To: Tengda Wu Cc: Peter Zijlstra, Ingo Molnar, Arnaldo Carvalho de Melo, Namhyung Kim, Mark Rutland, Alexander Shishkin, Jiri Olsa, Ian Rogers, Adrian Hunter, James Clark, linux-perf-users, linux-kernel On 2026-11-19 20:17:20 [+0800], Tengda Wu wrote: > There is a test case, see this: > https://lore.kernel.org/all/d1b24bbf-9111-4766-87c8-ff97adcac727@huaweicloud.com/ Now I remember. Would it make sense to include it to tools/testing/selftests/perf_events/sigtrap_threads.c ? > Thanks, > Tengda Sebastian ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events 2026-11-19 13:07 ` Sebastian Andrzej Siewior @ 2026-11-19 13:19 ` Tengda Wu 2026-11-19 13:48 ` Sebastian Andrzej Siewior 0 siblings, 1 reply; 12+ messages in thread From: Tengda Wu @ 2026-11-19 13:19 UTC (permalink / raw) To: Sebastian Andrzej Siewior Cc: Peter Zijlstra, Ingo Molnar, Arnaldo Carvalho de Melo, Namhyung Kim, Mark Rutland, Alexander Shishkin, Jiri Olsa, Ian Rogers, Adrian Hunter, James Clark, linux-perf-users, linux-kernel On 2026/11/19 21:07, Sebastian Andrzej Siewior wrote: > On 2026-11-19 20:17:20 [+0800], Tengda Wu wrote: >> There is a test case, see this: >> https://lore.kernel.org/all/d1b24bbf-9111-4766-87c8-ff97adcac727@huaweicloud.com/ > > Now I remember. Would it make sense to include it to > tools/testing/selftests/perf_events/sigtrap_threads.c > > ? > Well, because the trigger window is very short, it is not easy to reproduce. The test case I provided above must be stress-tested through multiple rounds of a while loop. Is it inappropriate to put this kind of test, which requires a while loop and has a certain degree of randomness, into deterministic test cases like sigtrap_threads.c? Thanks, Tengda ^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events 2026-11-19 13:19 ` Tengda Wu @ 2026-11-19 13:48 ` Sebastian Andrzej Siewior 0 siblings, 0 replies; 12+ messages in thread From: Sebastian Andrzej Siewior @ 2026-11-19 13:48 UTC (permalink / raw) To: Tengda Wu Cc: Peter Zijlstra, Ingo Molnar, Arnaldo Carvalho de Melo, Namhyung Kim, Mark Rutland, Alexander Shishkin, Jiri Olsa, Ian Rogers, Adrian Hunter, James Clark, linux-perf-users, linux-kernel On 2026-11-19 21:19:59 [+0800], Tengda Wu wrote: > Well, because the trigger window is very short, it is not easy to reproduce. > The test case I provided above must be stress-tested through multiple > rounds of a while loop. Is it inappropriate to put this kind of test, > which requires a while loop and has a certain degree of randomness, into > deterministic test cases like sigtrap_threads.c? Then maybe not. I would have to run it myself to be able to judge it. However this thread has a reference to the test case should someone need it in a few years… > Thanks, > Tengda Sebastian ^ permalink raw reply [flat|nested] 12+ messages in thread
end of thread, other threads:[~2026-11-19 13:48 UTC | newest] Thread overview: 12+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2026-11-19 9:50 [PATCH v5 0/2] perf/core: Fix sigtrap task_work races Tengda Wu 2026-11-19 9:51 ` [PATCH v5 1/2] perf/core: Prevent duplicate sigtrap task work enqueue Tengda Wu 2026-11-19 9:59 ` sashiko-bot 2026-11-19 12:09 ` Sebastian Andrzej Siewior 2026-11-19 9:51 ` [PATCH v5 2/2] perf/core: Disable context fast-swap for sigtrap events Tengda Wu 2026-11-19 10:03 ` sashiko-bot 2026-11-19 11:39 ` Tengda Wu 2026-11-19 12:11 ` Sebastian Andrzej Siewior 2026-11-19 12:17 ` Tengda Wu 2026-11-19 13:07 ` Sebastian Andrzej Siewior 2026-11-19 13:19 ` Tengda Wu 2026-11-19 13:48 ` Sebastian Andrzej Siewior
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox