From: sashiko-bot@kernel.org
To: "Masami Hiramatsu (Google)" <mhiramat@kernel.org>
Cc: linux-trace-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org
Subject: Re: [PATCH v20 08/11] tracing/wprobe: Add set_wprobe and clear_wprobe event triggers
Date: Mon, 16 Nov 2026 06:20:28 +0000 [thread overview]
Message-ID: <sashiko-outbox-216266@kernel.org> (raw)
In-Reply-To: <179480684514.38065.14028970872476288842.stgit@devnote2>
Thank you for your contribution! Sashiko AI review found 9 potential
issues to consider:
- [Medium] tracing/wprobe: stale work_pending after cancel_work_sync()
wedges triggers
- [Medium] tracing/wprobe: race and UAF on bp_event in
wprobe_trigger_free() teardown
- [Medium] tracing/wprobe: broken trace_probe_is_enabled() check in
trigger parse
- [Medium] tracing/wprobe: TASK_SIZE in trace_wprobe_is_valid_addr()
allows user addr
- [Medium] tracing/wprobe: unrestored tw->addr after set_wprobe breaks
show and match
- [Medium] tracing/wprobe: stale breakpoint hits fire triggers in
wprobe_trace_handler()
- [Medium] tracing/wprobe: self-deadlock on tw->lock in wprobe_trigger()
- [Low] tracing/wprobe: in-place NUL mutation of glob truncates trigger
error_log
- [Low] tracing/wprobe: unlocked double read of tw->addr in
trace_wprobe_show()
--
commit 86f0de972cafa3458ae22f00d7d3014fc1fc6164
Author: Masami Hiramatsu (Google) <mhiramat@kernel.org>
tracing/wprobe: Add set_wprobe and clear_wprobe event triggers
This commit adds set_wprobe and clear_wprobe event triggers to dynamically
configure and clear hardware watchpoint addresses from trace event fields.
Link: https://lore.kernel.org/all/59637b96946653393a7ad3c7de094094796b39c2.1785067572.git.wangjinchao600@gmail.com/
> diff --git a/kernel/trace/trace_wprobe.c b/kernel/trace/trace_wprobe.c
> index 644183cf5155e..d2b41aa69cfdf 100644
> --- a/kernel/trace/trace_wprobe.c
> +++ b/kernel/trace/trace_wprobe.c
[ ... ]
> @@ -217,28 +241,143 @@ static int __register_trace_wprobe(struct trace_wprobe *tw)
> attr.bp_len = tw->len;
> attr.bp_type = tw->type;
>
> - tw->bp_event = register_wide_hw_breakpoint(&attr, wprobe_perf_handler, tw);
> + cpus_read_lock();
> + tw->bp_event = register_wide_hw_breakpoint_cpuslocked(&attr,
> + wprobe_perf_handler,
> + tw);
> if (IS_ERR_PCPU(tw->bp_event)) {
> int ret = PTR_ERR_PCPU(tw->bp_event);
>
> tw->bp_event = NULL;
> + cpus_read_unlock();
> return ret;
> }
>
> + mutex_lock(&wprobe_mutex);
> + list_add(&tw->active_list, &active_wprobes);
> + mutex_unlock(&wprobe_mutex);
> + cpus_read_unlock();
> +
> return 0;
> }
>
> static void __unregister_trace_wprobe(struct trace_wprobe *tw)
> {
> if (tw->bp_event) {
> + mutex_lock(&wprobe_mutex);
> + list_del_init(&tw->active_list);
> + mutex_unlock(&wprobe_mutex);
> +
> + irq_work_sync(&tw->irq_work);
> + cancel_work_sync(&tw->work);
> unregister_wide_hw_breakpoint(tw->bp_event);
> tw->bp_event = NULL;
> }
> }
[Severity: Medium]
Does cancelling tw->work in __unregister_trace_wprobe() leave
tw->work_pending stuck at 1?
wprobe_trigger() sets tw->work_pending to 1 before queueing tw->irq_work,
and only wprobe_work_func() resets it to 0. If __unregister_trace_wprobe()
runs after wprobe_irq_work_func() schedules tw->work but before
wprobe_work_func() executes, cancel_work_sync(&tw->work) cancels the work
item without clearing tw->work_pending. Every later trigger evaluation on
that wprobe then sees atomic_read(&tw->work_pending) != 0 in
__wprobe_count_func(), increments tw->missed, and drops all future updates.
[ ... ]
> @@ -788,6 +945,10 @@ static int trace_wprobe_show(struct seq_file *m, struct dyn_event *ev)
> tw->offset, len);
> else
> seq_printf(m, " %s@%s:%d", type_str, tw->symbol, len);
> +#ifdef CONFIG_WPROBE_TRIGGERS
> + } else if (tw->addr == WPROBE_DEFAULT_CLEAR_ADDRESS) {\
> + seq_printf(m, " %s@-1:%d", type_str, len);
> +#endif
> } else {
> seq_printf(m, " %s@0x%lx:%d", type_str, tw->addr, len);
> }
[Severity: Low]
Can trace_wprobe_show() print the raw address of
wprobe_trigger_clear_target instead of -1?
wprobe_trigger() updates tw->addr concurrently under tw->lock without
holding dyn_event_ops_mutex. Because trace_wprobe_show() reads tw->addr a
second time in the else branch instead of reading it once with READ_ONCE()
into a local variable, a concurrent clear_wprobe trigger setting tw->addr
to WPROBE_DEFAULT_CLEAR_ADDRESS between the comparison and seq_printf()
causes dynamic_events to print the address of wprobe_trigger_clear_target.
> @@ -800,9 +961,635 @@ static int trace_wprobe_show(struct seq_file *m, struct dyn_event *ev)
[ ... ]
> +static bool __wprobe_count_func(struct event_trigger_data *data,
> + unsigned long addr)
> +{
> + struct wprobe_trigger_data *wprobe_data = data->private_data;
> + struct trace_wprobe *tw = wprobe_data->tw;
> + unsigned long cur_addr;
> +
> + if (atomic_read(&tw->work_pending))
> + return false;
> +
> + cur_addr = READ_ONCE(tw->addr);
> +
> + if (!wprobe_data->clear) {
> + if (cur_addr != WPROBE_DEFAULT_CLEAR_ADDRESS)
> + return false;
> + if (!trace_wprobe_is_valid_addr(addr, tw->len))
> + return false;
[Severity: Medium]
Can trace_wprobe_is_valid_addr() allow a set_wprobe trigger to install a
user-space watchpoint address when a 32-bit compat task is running?
kernel/trace/trace_wprobe.c:trace_wprobe_is_valid_addr() {
if (addr < TASK_SIZE)
return false;
...
}
On 64-bit architectures with 32-bit compatibility mode (such as x86_64 with
CONFIG_IA32_EMULATION), TASK_SIZE depends on the current task's personality
and evaluates to IA32_PAGE_OFFSET (~4 GiB) when a 32-bit compat task is
running. Because modify_local_hw_breakpoint_addr() bypasses
arch_check_bp_in_kernelspace() (which checks TASK_SIZE_MAX), a set_wprobe
trigger firing in the context of a 32-bit compat task accepts any aligned
64-bit user-space address in [IA32_PAGE_OFFSET, TASK_SIZE_MAX) and programs
it into the CPU-wide hardware debug registers. Using TASK_SIZE_MAX (or
arch_check_bp_in_kernelspace()) avoids depending on current.
[ ... ]
> +static void wprobe_trigger(struct event_trigger_data *data,
> + struct trace_buffer *buffer, void *rec,
> + struct ring_buffer_event *event)
> +{
> + struct wprobe_trigger_data *wprobe_data = data->private_data;
> + struct trace_wprobe *tw = wprobe_data->tw;
> + unsigned long target_addr, addr = 0, flags;
> +
> + if (in_nmi())
> + return;
> +
> + if (wprobe_data->field) {
> + if (!rec)
> + return;
> + addr = *(unsigned long *)((char *)rec + wprobe_data->offset);
> + addr += wprobe_data->adjust;
> + }
> +
> + raw_spin_lock_irqsave(&tw->lock, flags);
> +
> + if (!__wprobe_count_func(data, addr)) {
> + atomic_inc(&tw->missed);
> + goto out;
> + }
> +
> + /*
> + * For counted triggers, verify data->count is still available under
> + * tw->lock to prevent concurrent executions from exceeding the limit.
> + */
> + if ((data->flags & EVENT_TRIGGER_FL_COUNT) && !data->count)
> + goto out;
> +
> + target_addr = wprobe_data->clear ? WPROBE_DEFAULT_CLEAR_ADDRESS : addr;
> +
> + /*
> + * Try updating the hardware breakpoint on the local CPU first.
> + * If this fails, skip updating tw->addr and do not queue irq_work.
> + * Note that this wprobe will not be traced until tw_addr is updated.
> + * (e.g. NMI happens on this CPU.)
> + */
> + if (trace_wprobe_update_local(tw, target_addr)) {
> + atomic_inc(&tw->missed);
> + goto out;
> + }
> +
> + /*
> + * Decrement data->count here under tw->lock only after the local
> + * hardware breakpoint has been successfully updated. This avoids:
> + * 1) Consuming count on trigger attempts that failed/missed.
> + * 2) Race windows where concurrent CPUs decrement count and underflow
> + * to -1 (unlimited).
> + */
> + if (data->flags & EVENT_TRIGGER_FL_COUNT) {
> + if (data->count > 0)
> + (data->count)--;
> + }
> +
> + WRITE_ONCE(tw->addr, target_addr);
> + if (!wprobe_data->clear)
> + clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &wprobe_data->file->flags);
> + else
> + set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &wprobe_data->file->flags);
> +
> + /*
> + * For other CPUs, kick irq_work to asynchronously propagate
> + * the new address.
> + */
> + if (num_online_cpus() > 1) {
> + atomic_set(&tw->work_pending, 1);
> + irq_work_queue(&tw->irq_work);
> + }
> +
> +out:
> + raw_spin_unlock_irqrestore(&tw->lock, flags);
> +}
[Severity: Medium]
Can wprobe_trigger() self-deadlock on tw->lock if a nested event fires
while tw->lock is held?
wprobe_trigger()
raw_spin_lock_irqsave(&tw->lock, flags)
irq_work_queue(&tw->irq_work)
...
native_write_msr()
trace_write_msr()
...
wprobe_trigger()
raw_spin_lock_irqsave(&tw->lock, flags) <-- spins forever
While wprobe_trigger() holds tw->lock, irq_work_queue() on x86 with x2APIC
raises a self-IPI via native_write_msr(), firing the msr:write_msr
tracepoint, and functions called by trace_wprobe_update_local() (such as
modify_local_hw_breakpoint_addr()) can also be traced by fprobe events. If
a wprobe trigger targeting the same trace_wprobe is attached to one of
those nested events, the inner wprobe_trigger() runs on the same CPU with
in_nmi() == false and spins forever on tw->lock.
[Severity: Medium]
Can a stale breakpoint hit on a remote CPU fire unconditional triggers
attached to the wprobe event after clear_wprobe or set_wprobe updates
tw->addr?
CPU0 CPU1
wprobe_trigger()
WRITE_ONCE(tw->addr,
WPROBE_DEFAULT_CLEAR_ADDRESS)
set_bit(SOFT_DISABLED_BIT, ...)
irq_work_queue(&tw->irq_work)
wprobe_perf_handler()
wprobe_trace_handler(tw, old_addr, ...)
trace_trigger_soft_disabled(trace_file)
event_triggers_call(...)
if (READ_ONCE(tw->addr) != addr)
return;
kernel/trace/trace_wprobe.c:wprobe_trace_handler() {
...
if (trace_trigger_soft_disabled(trace_file))
return;
if (READ_ONCE(tw->addr) != addr)
return;
...
}
Because remote CPUs update their hardware debug registers asynchronously via
tw->work, a remote CPU can still take a breakpoint exception for the old
address after tw->addr has changed. In wprobe_trace_handler(),
trace_trigger_soft_disabled() runs before the READ_ONCE(tw->addr) != addr
check, which invokes __trace_trigger_soft_disabled() ->
event_triggers_call() and fires any unconditional triggers (such as
traceoff, snapshot, or stacktrace) attached to the wprobe event. Checking
READ_ONCE(tw->addr) != addr before trace_trigger_soft_disabled() avoids
firing triggers on stale hits.
[ ... ]
> +static void release_private_wprobe_trigger_data(struct event_trigger_data *data)
> +{
> + struct wprobe_trigger_data *wprobe_data = data->private_data;
> +
> + /* The file may already be freed here, only the call is kept alive */
> + trace_event_put_ref(trace_probe_event_call(&wprobe_data->tw->tp));
> + free_wprobe_trigger_data(wprobe_data);
> +}
[ ... ]
> +static void wprobe_trigger_free(struct event_trigger_data *data)
> +{
> + struct wprobe_trigger_data *wprobe_data = data->private_data;
> +
> + if (WARN_ON_ONCE(data->ref <= 0))
> + return;
> +
> + data->ref--;
> + if (!data->ref) {
> + /* Remove the SOFT_MODE flag */
> + trace_event_enable_disable(wprobe_data->file, 0, 1);
> + data->private_data_free = release_private_wprobe_trigger_data;
> + trigger_data_free(data);
> + }
> +}
[Severity: Medium]
Can wprobe_trigger_free() unregister and free tw->bp_event while an
in-flight wprobe_trigger() is still using it?
CPU0 CPU1
clear_event_triggers()
list_del_rcu(&data->list)
wprobe_trigger_free(data)
trace_event_enable_disable()
...
__unregister_trace_wprobe(tw)
unregister_wide_hw_breakpoint(
tw->bp_event)
wprobe_trigger()
trace_wprobe_update_local(tw, ...)
bp = *this_cpu_ptr(tw->bp_event)
modify_local_hw_breakpoint_addr(bp, ...)
<-- use-after-free
tw->bp_event = NULL
trigger_data_free(data)
/* tracepoint_synchronize_unregister() happens later in kthread */
When a trace instance is removed, clear_event_triggers() calls
data->cmd_ops->free(data) immediately after list_del_rcu() without waiting
for tracepoint_synchronize_unregister(). Because wprobe_trigger_free()
calls trace_event_enable_disable() before trigger_data_free() waits for
in-flight tracepoints, __unregister_trace_wprobe() frees the per-CPU
perf_event breakpoints and tw->bp_event before clearing tw->bp_event = NULL
and without synchronizing with tw->lock, while a concurrent wprobe_trigger()
on another CPU dereferences tw->bp_event and queues tw->irq_work after
irq_work_sync() has already returned.
Conversely, when a user removes a trigger via wprobe_unregister_trigger(),
tracepoint_synchronize_unregister() has already completed, but deferring
trace_event_put_ref() to release_private_wprobe_trigger_data() on
trigger_kthread means an immediate dynamic_events removal of the wprobe can
race with the kthread and fail with -EBUSY.
> +static int wprobe_trigger_cmd_parse(struct event_command *cmd_ops,
> + struct trace_event_file *file,
> + char *glob, char *cmd,
> + char *param_and_filter)
> +{
> + /*
> + * set_wprobe:EVENT:FIELD[+OFFS]
> + * clear_wprobe:EVENT[:FIELD[+OFFS]]
> + */
> + struct wprobe_trigger_data *wprobe_data = NULL;
> + struct event_trigger_data *trigger_data = NULL;
> + struct trace_event_file *wprobe_file;
> + struct trace_array *tr = file->tr;
> + char *event_str, *field_str, *comment;
> + struct ftrace_event_field *field;
> + struct trace_event_call *event;
> + bool remove, clear = false;
> + unsigned long orig_addr = 0;
> + struct trace_wprobe *tw;
> + char *param, *filter;
> + int ret;
> +
> + remove = event_trigger_check_remove(glob);
> +
> + if (!strcmp(cmd, CLEAR_WPROBE_STR))
> + clear = true;
> +
> + if (param_and_filter) {
> + /* Recover original trigger string to show the error log correctly. */
> + if (*(param_and_filter - 1) == '\0')
> + *(param_and_filter - 1) = ':';
> + comment = strchr(param_and_filter, '#');
> + if (comment)
> + *comment = '\0';
> + }
> +
> + if (event_trigger_empty_param(param_and_filter)) {
> + wprobe_trigger_log_err(file, glob, strlen(cmd) + 1, WPROBE_NOT_FOUND);
> + return -EINVAL;
> + }
> +
> + ret = event_trigger_separate_filter(param_and_filter, ¶m, &filter, true);
> + if (ret)
> + return ret;
> +
> + if (file->event_call->flags & TRACE_EVENT_FL_KPROBE) {
> + wprobe_trigger_log_err(file, glob, 0, WPROBE_ON_KPROBE);
> + return -EOPNOTSUPP;
> + }
> +
> + event_str = strsep(¶m, ":");
[Severity: Low]
Does mutating param_and_filter in place truncate the command string logged
by wprobe_trigger_log_err()?
param_and_filter points into the glob buffer. Although the code restores
the colon at *(param_and_filter - 1), subsequent calls to
event_trigger_separate_filter(), strsep(¶m, ":"), and *offs = '\0'
insert NUL terminators directly into glob. Any later
wprobe_trigger_log_err(file, glob, ...) call for a bad field, offset, or
count logs only the truncated prefix of glob while passing an error caret
offset past the end of the logged string. Also, when param_and_filter is
NULL (for example, writing "set_wprobe" with no colon), strlen(cmd) + 1
points one byte past the NUL terminator of glob.
> + /* Find target wprobe */
> + tw = find_trace_wprobe(event_str, WPROBE_EVENT_SYSTEM);
> + if (!tw) {
> + wprobe_trigger_log_err(file, glob, event_str - glob, WPROBE_NOT_FOUND);
> + return -ENOENT;
> + }
> + /* The target wprobe must not be used (unless clear) */
> + if (!remove && !clear && trace_probe_is_enabled(&tw->tp)) {
> + wprobe_trigger_log_err(file, glob, event_str - glob, WPROBE_BUSY);
> + return -EBUSY;
> + }
[Severity: Medium]
Does checking trace_probe_is_enabled(&tw->tp) here conflate manual enabling
with trigger soft-enabling?
Both set_wprobe and clear_wprobe call trace_event_enable_disable(wprobe_file,
1, 1), which sets TP_FLAG_TRACE on tw->tp and makes
trace_probe_is_enabled(&tw->tp) return true. As a result, registering
clear_wprobe before set_wprobe, re-adding set_wprobe after removing it while
clear_wprobe is still attached, or attaching set_wprobe to a second event
all fail with -EBUSY. When clear_wprobe is registered first, tw->addr is
also not initialized to WPROBE_DEFAULT_CLEAR_ADDRESS because that assignment
is gated on !clear.
Conversely, because clear_wprobe skips this busy check, it can be attached
to a wprobe that was manually enabled by the user (where sm_ref == 0); when
clear_wprobe fires or is later removed, it soft-disables or unregisters the
manually enabled wprobe.
[ ... ]
> + if (!clear) {
> + orig_addr = tw->addr;
> + WRITE_ONCE(tw->addr, WPROBE_DEFAULT_CLEAR_ADDRESS);
> + }
> +
> + ret = trace_event_enable_disable(wprobe_file, 1, 1);
[Severity: Medium]
Does overwriting tw->addr without restoring it on trigger teardown break
trace_wprobe_show() and dynamic_events deletion?
When set_wprobe is registered and fires, tw->addr is overwritten first with
WPROBE_DEFAULT_CLEAR_ADDRESS and then with the runtime target address, and
removing the trigger leaves tw->addr at that runtime value. For a wprobe
created with rw@-1:8, removing set_wprobe after it fires causes
trace_wprobe_show() to print the runtime address instead of -1, and
deleting the wprobe with "!w:watch rw@-1:8 ..." fails in
trace_wprobe_match_command_head() because tw->addr no longer equals
WPROBE_DEFAULT_CLEAR_ADDRESS. For a symbol-based wprobe, tw->symbol remains
set while tw->addr is left clobbered, so trace_wprobe_show() still shows
@symbol while re-enabling the wprobe watches the wrong address.
--
Sashiko AI review · https://sashiko.dev/#/patchset/179480675130.38065.3086970856119381693.stgit@devnote2?part=8
next prev parent reply other threads:[~2026-11-16 6:20 UTC|newest]
Thread overview: 23+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-16 5:25 [PATCH v20 00/11] tracing: wprobe: x86: Add wprobe for watchpoint Masami Hiramatsu (Google)
2026-11-16 5:26 ` [PATCH v20 01/11] x86/hw_breakpoints: Add arch_modify_local_hw_breakpoint_addr() API Masami Hiramatsu (Google)
2026-11-16 5:47 ` sashiko-bot
2026-11-16 5:26 ` [PATCH v20 02/11] HWBP: Add modify_local_hw_breakpoint_addr() API Masami Hiramatsu (Google)
2026-11-16 5:57 ` sashiko-bot
2026-11-16 5:26 ` [PATCH v20 03/11] perf/hw_breakpoint: Add register_wide_hw_breakpoint_cpuslocked() API Masami Hiramatsu (Google)
2026-11-16 5:44 ` sashiko-bot
2026-11-16 5:26 ` [PATCH v20 04/11] tracing/wprobe: Add wprobe (watchpoint probe) trace event support Masami Hiramatsu (Google)
2026-11-16 5:56 ` sashiko-bot
2026-11-16 5:26 ` [PATCH v20 05/11] x86: hw_breakpoint: Add a kconfig to clarify when a breakpoint fires Masami Hiramatsu (Google)
2026-11-16 5:34 ` sashiko-bot
2026-11-16 5:27 ` [PATCH v20 06/11] selftests: tracing: Add a basic testcase for wprobe Masami Hiramatsu (Google)
2026-11-16 5:34 ` sashiko-bot
2026-11-16 5:27 ` [PATCH v20 07/11] selftests: tracing: Add syntax " Masami Hiramatsu (Google)
2026-11-16 5:42 ` sashiko-bot
2026-11-16 5:27 ` [PATCH v20 08/11] tracing/wprobe: Add set_wprobe and clear_wprobe event triggers Masami Hiramatsu (Google)
2026-11-16 6:20 ` sashiko-bot [this message]
2026-11-16 5:27 ` [PATCH v20 09/11] selftests: tracing: Add wprobe trigger testcases Masami Hiramatsu (Google)
2026-11-16 5:52 ` sashiko-bot
2026-11-16 5:27 ` [PATCH v20 10/11] tracing/wprobe: Support BTF typecast in fetchargs Masami Hiramatsu (Google)
2026-11-16 5:52 ` sashiko-bot
2026-11-16 5:27 ` [PATCH v20 11/11] tracing/wprobe: Support BTF struct offset resolution in set_wprobe trigger Masami Hiramatsu (Google)
2026-11-16 5:50 ` sashiko-bot
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-216266@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=linux-perf-users@vger.kernel.org \
--cc=linux-trace-kernel@vger.kernel.org \
--cc=mhiramat@kernel.org \
--cc=sashiko-reviews@lists.linux.dev \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.