* [PATCH v4] tracing/probes: Zero out faulted dereferenced fields
@ 2026-11-20 19:30 Steven Rostedt
2026-11-20 19:52 ` sashiko-bot
0 siblings, 1 reply; 3+ messages in thread
From: Steven Rostedt @ 2026-11-20 19:30 UTC (permalink / raw)
To: LKML, Linux Trace Kernel; +Cc: Masami Hiramatsu, Mathieu Desnoyers
From: Steven Rostedt <rostedt@goodmis.org>
While looking at tasks global descriptor tables, I discovered the
following anomaly:
~# echo 't:sched sched_switch prev=prev mm=(task_struct)prev->mm ppgd=(task_struct)prev->mm->pgd' > /sys/kernel/tracing/dynamic_events
The above creates a tprobe on the sched_switch tracepoint and records the
previous task_struct pointer, it's mm_struct and the pgd the mm_struct
points to.
~# trace-cmd start -e tracepoints:sched
bash-1050 [000] d..3. 90.829478: sched: (__probestub_sched_switch+0x0/0x10) prev=0xffff88d30b623600 mm=0xffff88d30108c600 ppgd=0xffff88d33352b000
<idle>-0 [002] d..3. 90.836024: sched: (__probestub_sched_switch+0x0/0x10) prev=0xffff88d301870000 mm=0x0 ppgd=0x0
rcu_preempt-15 [002] d..3. 90.836031: sched: (__probestub_sched_switch+0x0/0x10) prev=0xffff88d3013ad100 mm=0x0 ppgd=0xffff88d33352b000
The first event has is a user task that has both a valid mm_struct and a pgd.
The second event is a kernel task where the mm_struct is NULL and so is the
dereferenced pgd pointer.
The third event is where things looked strange. The mm_struct is NULL but
the dereferenced pgd has a value! That is: NULL->pgd produced something
other than zero.
The reason for this is that the probe_mem_read() and probe_mem_read_user()
do not write to the destination on failure. The process_fetch_insn_bottom()
loop does not check the return value of the dereference (as it is the last
one), and does not update the event. That leaves the value for that failed
field to be whatever was in the ring buffer at that time.
Have both probe_mem_read() and probe_mem_read_user() set the destination to
zero on failure to read the address.
Now all pgd are zero when mm is zero.
Also update the stage 2 of process_fetch_insn_bottom() to not return on
fault but to just set the value to zero and also do not even bother
dereferencing the address if the value is already zero. This allows the
code to continue and fill in the zero into the memory location on the
ring buffer.
Cc: stable@vger.kernel.org
Fixes: 533059281ee59 ("tracing: probeevent: Introduce new argument fetching code")
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
---
Changes since v3: https://patch.msgid.link/20261119152922.5a66f10e@gandalf.local.home
- Better handle offsets when val is a NULL pointer to always dereference
NULL. (Sashiko)
- Wrapped the probe_mem_read/_user() in a function to use that does the
memory clearing on failure so that other code (like trace_uprobe.c) that
defines probe_mem_read() can also work with it. (Sashiko)
kernel/trace/trace_probe_tmpl.h | 80 +++++++++++++++++++++++++--------
1 file changed, 61 insertions(+), 19 deletions(-)
diff --git a/kernel/trace/trace_probe_tmpl.h b/kernel/trace/trace_probe_tmpl.h
index 8acc0f0ebd7a..6e137772d2b6 100644
--- a/kernel/trace/trace_probe_tmpl.h
+++ b/kernel/trace/trace_probe_tmpl.h
@@ -133,13 +133,37 @@ process_common_fetch_insn(struct fetch_insn *code, unsigned long *val)
return 0;
}
+/* On failure, zero out the destination */
+static nokprobe_inline int
+do_probe_mem_read_user(void *dest, void *src, size_t size)
+{
+ int ret;
+
+ ret = probe_mem_read_user(dest, src, size);
+ if (ret < 0)
+ memset(dest, 0, size);
+ return ret;
+}
+
+/* On failure, zero out the destination */
+static nokprobe_inline int
+do_probe_mem_read(void *dest, void *src, size_t size)
+{
+ int ret;
+
+ ret = probe_mem_read(dest, src, size);
+ if (ret < 0)
+ memset(dest, 0, size);
+ return ret;
+}
+
/* From the 2nd stage, routine is same */
static nokprobe_inline int
process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
void *dest, void *base)
{
struct fetch_insn *s3 = NULL;
- int total = 0, ret = 0, i = 0;
+ int total = 0, ret = 0, i = 0, offset;
u32 loc = 0;
unsigned long lval, llval = val;
@@ -147,25 +171,30 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
/* 2nd stage: dereference memory if needed */
do {
lval = val;
+ /* Prevent dereferencing NULL val pointer */
+ offset = val ? code->offset : 0;
switch (code->op) {
case FETCH_OP_DEREF:
- ret = probe_mem_read(&val, (void *)val + code->offset,
- sizeof(val));
+ /* Do not dereference NULL pointers */
+ if (val)
+ do_probe_mem_read(&val, (void *)val + offset,
+ sizeof(val));
break;
case FETCH_OP_UDEREF:
- ret = probe_mem_read_user(&val,
- (void *)val + code->offset, sizeof(val));
+ /* Do not dereference NULL pointers */
+ if (val)
+ do_probe_mem_read_user(&val, (void *)val + offset,
+ sizeof(val));
break;
case FETCH_OP_CPU_PTR:
- val = (unsigned long)this_cpu_ptr((void __percpu *)val);
- ret = 0;
+ /* Do not dereference NULL pointers */
+ if (val)
+ val = (unsigned long)this_cpu_ptr((void __percpu *)val);
break;
default:
lval = llval;
goto out;
}
- if (ret)
- return ret;
llval = lval;
code++;
} while (1);
@@ -173,19 +202,25 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
s3 = code;
stage3:
+ /*
+ * Once val is zero, it is pointing to NULL. Any new dereference is
+ * also treated as a NULL pointer.
+ */
+ offset = val ? code->offset : 0;
+
/* 3rd stage: store value to buffer */
if (unlikely(!dest)) {
switch (code->op) {
case FETCH_OP_ST_STRING:
- ret = fetch_store_strlen(val + code->offset);
+ ret = fetch_store_strlen(val + offset);
code++;
goto array;
case FETCH_OP_ST_USTRING:
- ret = fetch_store_strlen_user(val + code->offset);
+ ret = fetch_store_strlen_user(val + offset);
code++;
goto array;
case FETCH_OP_ST_SYMSTR:
- ret = fetch_store_symstrlen(val + code->offset);
+ ret = fetch_store_symstrlen(val + offset);
code++;
goto array;
default:
@@ -193,27 +228,30 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
}
}
+ /* When val is NULL, so should the val + offset */
+ offset = val ? code->offset : 0;
+
switch (code->op) {
case FETCH_OP_ST_RAW:
fetch_store_raw(val, code, dest);
break;
case FETCH_OP_ST_MEM:
- probe_mem_read(dest, (void *)val + code->offset, code->size);
+ do_probe_mem_read(dest, (void *)val + offset, code->size);
break;
case FETCH_OP_ST_UMEM:
- probe_mem_read_user(dest, (void *)val + code->offset, code->size);
+ do_probe_mem_read_user(dest, (void *)val + offset, code->size);
break;
case FETCH_OP_ST_STRING:
loc = *(u32 *)dest;
- ret = fetch_store_string(val + code->offset, dest, base);
+ ret = fetch_store_string(val + offset, dest, base);
break;
case FETCH_OP_ST_USTRING:
loc = *(u32 *)dest;
- ret = fetch_store_string_user(val + code->offset, dest, base);
+ ret = fetch_store_string_user(val + offset, dest, base);
break;
case FETCH_OP_ST_SYMSTR:
loc = *(u32 *)dest;
- ret = fetch_store_symstring(val + code->offset, dest, base);
+ ret = fetch_store_symstring(val + offset, dest, base);
break;
default:
return -EILSEQ;
@@ -237,11 +275,15 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
if (s3->op != FETCH_OP_ST_STRING &&
s3->op != FETCH_OP_ST_USTRING) {
dest += s3->size;
- val += s3->size;
+ /* Only update a non NULL val */
+ if (val)
+ val += s3->size;
goto stage3;
}
code--;
- val = lval + sizeof(char *);
+ /* Only update a non NULL val */
+ if (val)
+ val = lval + sizeof(char *);
if (dest) {
dest += sizeof(u32);
*(u32 *)dest = update_data_loc(loc, ret);
--
2.53.0
^ permalink raw reply related [flat|nested] 3+ messages in thread* Re: [PATCH v4] tracing/probes: Zero out faulted dereferenced fields
2026-11-20 19:30 [PATCH v4] tracing/probes: Zero out faulted dereferenced fields Steven Rostedt
@ 2026-11-20 19:52 ` sashiko-bot
2026-11-20 20:10 ` Steven Rostedt
0 siblings, 1 reply; 3+ messages in thread
From: sashiko-bot @ 2026-11-20 19:52 UTC (permalink / raw)
To: Steven Rostedt, Linux Trace Kernel
Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [Medium] tracing/probes: process_fetch_insn_bottom() string array loop
checks val
--
commit 1bda61677a4b06fd01938014840ab606ebd55bfe
Author: Steven Rostedt <rostedt@goodmis.org>
tracing/probes: Zero out faulted dereferenced fields
This commit wraps probe_mem_read() and probe_mem_read_user() to zero out
the destination on failure, and continues through stage 2 of
process_fetch_insn_bottom() with a zero value rather than returning early
when a pointer dereference is NULL or faults.
> diff --git a/kernel/trace/trace_probe_tmpl.h b/kernel/trace/trace_probe_tmpl.h
> index 8db12f758fdae..4eb0ebe5767cd 100644
> --- a/kernel/trace/trace_probe_tmpl.h
> +++ b/kernel/trace/trace_probe_tmpl.h
[ ... ]
> @@ -225,11 +263,15 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
> if (s3->op != FETCH_OP_ST_STRING &&
> s3->op != FETCH_OP_ST_USTRING) {
> dest += s3->size;
> - val += s3->size;
> + /* Only update a non NULL val */
> + if (val)
> + val += s3->size;
> goto stage3;
> }
> code--;
> - val = lval + sizeof(char *);
> + /* Only update a non NULL val */
> + if (val)
> + val = lval + sizeof(char *);
[Severity: Medium]
Should this check if (lval) instead of if (val) when advancing through a
string pointer array?
For FETCH_OP_ST_STRING and FETCH_OP_ST_USTRING arrays, stage 2 saves the
current array slot address in lval and dereferences that slot into val.
If the array pointer lval is valid but element i is NULL (or reading it
faulted), val is 0 while lval is non-zero. Checking if (val) leaves val
as 0 instead of advancing to lval + sizeof(char *), so jumping back to
stage2 overwrites lval with 0 and causes all remaining string elements in
the array to be skipped and recorded as faulted.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261120143002.18b364b3@gandalf.local.home?part=1
^ permalink raw reply [flat|nested] 3+ messages in thread* Re: [PATCH v4] tracing/probes: Zero out faulted dereferenced fields
2026-11-20 19:52 ` sashiko-bot
@ 2026-11-20 20:10 ` Steven Rostedt
0 siblings, 0 replies; 3+ messages in thread
From: Steven Rostedt @ 2026-11-20 20:10 UTC (permalink / raw)
To: sashiko-bot; +Cc: sashiko-reviews, Linux Trace Kernel
On Fri, 20 Nov 2026 19:52:53 +0000
sashiko-bot@kernel.org wrote:
> > - val = lval + sizeof(char *);
> > + /* Only update a non NULL val */
> > + if (val)
> > + val = lval + sizeof(char *);
>
> [Severity: Medium]
> Should this check if (lval) instead of if (val) when advancing through a
> string pointer array?
>
> For FETCH_OP_ST_STRING and FETCH_OP_ST_USTRING arrays, stage 2 saves the
> current array slot address in lval and dereferences that slot into val.
> If the array pointer lval is valid but element i is NULL (or reading it
> faulted), val is 0 while lval is non-zero. Checking if (val) leaves val
> as 0 instead of advancing to lval + sizeof(char *), so jumping back to
> stage2 overwrites lval with 0 and causes all remaining string elements in
> the array to be skipped and recorded as faulted.
Hmm, I'm not sure if it makes much of a difference. If val were to fault,
it is very likely that lval would fault too. But perhaps it should be:
val = lval ? lval + sizeof(char *) : 0;
I'll send a v5.
-- Steve
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2026-11-20 20:10 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-20 19:30 [PATCH v4] tracing/probes: Zero out faulted dereferenced fields Steven Rostedt
2026-11-20 19:52 ` sashiko-bot
2026-11-20 20:10 ` Steven Rostedt
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.