From: sashiko-bot@kernel.org
To: "Steven Rostedt" <rostedt@goodmis.org>,
"Linux Trace Kernel" <linux-trace-kernel@vger.kernel.org>
Subject: Re: [PATCH v3] tracing/probes: Zero out faulted dereferenced fields
Date: Thu, 19 Nov 2026 20:50:02 +0000 [thread overview]
Message-ID: <sashiko-outbox-224053@kernel.org> (raw)
In-Reply-To: <20261119152922.5a66f10e@gandalf.local.home>
Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [Medium] tracing/probes: stage 3 in process_fetch_insn_bottom()
dereferences NULL val
- [Medium] tracing/probes: FETCH_OP_LP_ARRAY in
process_fetch_insn_bottom() advances NULL
- [Medium] tracing/probes: FETCH_OP_CPU_PTR in
process_fetch_insn_bottom() shifts NULL
- [Low] tracing/probes: trace_uprobe probe_mem_read() leaves partial
bytes on fault
--
commit 754d85e0c0dcb5af755f3a74bd787872a07c54fd
Author: Steven Rostedt <rostedt@goodmis.org>
tracing/probes: Zero out faulted dereferenced fields
This commit zeroes the destination buffer in probe_mem_read() and
probe_mem_read_user() on read failure, and updates
process_fetch_insn_bottom() to skip NULL dereferences and continue to
stage 3 so faulted fields are zeroed in the trace event.
> diff --git a/kernel/trace/trace_probe_kernel.h b/kernel/trace/trace_probe_kernel.h
> index 4eb4acfa09ba1..00542a162d307 100644
> --- a/kernel/trace/trace_probe_kernel.h
> +++ b/kernel/trace/trace_probe_kernel.h
> @@ -102,18 +102,27 @@ static nokprobe_inline int
> probe_mem_read_user(void *dest, void *src, size_t size)
> {
> const void __user *uaddr = (__force const void __user *)src;
> + int ret;
>
> - return copy_from_user_nofault(dest, uaddr, size);
> + ret = copy_from_user_nofault(dest, uaddr, size);
> + if (ret < 0)
> + memset(dest, 0, size);
> + return ret;
> }
>
> static nokprobe_inline int
> probe_mem_read(void *dest, void *src, size_t size)
> {
> + int ret;
> +
> #ifdef CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE
> if ((unsigned long)src < TASK_SIZE)
> return probe_mem_read_user(dest, src, size);
> #endif
> - return copy_from_kernel_nofault(dest, src, size);
> + ret = copy_from_kernel_nofault(dest, src, size);
> + if (ret < 0)
> + memset(dest, 0, size);
> + return ret;
> }
[Severity: Low]
Does probe_mem_read() in kernel/trace/trace_uprobe.c need the same
memset(dest, 0, size) on error?
kernel/trace/trace_uprobe.c:probe_mem_read() {
void __user *vaddr = (void __force __user *)src;
return copy_from_user(dest, vaddr, size) ? -EFAULT : 0;
}
trace_uprobe.c includes trace_probe_tmpl.h, where
process_fetch_insn_bottom() now ignores the return value of
probe_mem_read() in stage 2 and relies on it to zero dest on failure.
When an unaligned multi-byte read faults across a page boundary,
copy_from_user() only zeroes the uncopied trailing bytes, leaving the
initial bytes from the first page in val and causing stage 2 to
dereference a truncated non-zero address.
> diff --git a/kernel/trace/trace_probe_tmpl.h b/kernel/trace/trace_probe_tmpl.h
> index 8db12f758fdae..8be14c00d66f9 100644
> --- a/kernel/trace/trace_probe_tmpl.h
> +++ b/kernel/trace/trace_probe_tmpl.h
> @@ -127,7 +127,7 @@ 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;
>
> @@ -135,25 +135,28 @@ 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)
> + 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)
> + 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;
> break;
[Severity: Medium]
Should FETCH_OP_CPU_PTR also check if (val) before calling
this_cpu_ptr()?
Now that stage 2 continues after a failed or NULL dereference, an inner
dereference in an expression such as this_cpu_ptr(+8($arg1)) or
this_cpu_read(+8($arg1)) can reach FETCH_OP_CPU_PTR with val == 0.
On SMP kernels, this_cpu_ptr((void __percpu *)0) evaluates to
__my_cpu_offset, so subsequent instructions will record or dereference
the current CPU's per-CPU base address + offset instead of zero.
> default:
> lval = llval;
> goto out;
> }
> - if (ret)
> - return ret;
> llval = lval;
> code++;
> } while (1);
> @@ -161,19 +164,22 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
>
> s3 = code;
> stage3:
> + /* Prevent dereferencing NULL val 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:
> @@ -181,27 +187,30 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,
> }
> }
>
> + /* Prevent dereferencing NULL val pointer */
> + 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);
> + 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);
> + 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 + offset, dest, base);
> + ret = fetch_store_symstring(val + offset, dest, base);
> break;
> default:
> return -EILSEQ;
[Severity: Medium]
Does setting offset to 0 in stage 3 still dereference address 0 when val
is NULL?
finalize_fetch_insn() converts the final FETCH_OP_DEREF or
FETCH_OP_UDEREF of a dereference chain (such as ->pgd in prev->mm->pgd)
into FETCH_OP_ST_MEM, FETCH_OP_ST_UMEM, FETCH_OP_ST_STRING or
FETCH_OP_ST_USTRING in stage 3. When val is 0, val + offset is 0, and
stage 3 still calls probe_mem_read(), fetch_store_strlen(),
fetch_store_string() and their user counterparts with address 0.
On CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE architectures, 0 <
TASK_SIZE is true, so probe_mem_read(), fetch_store_strlen() and
fetch_store_string() redirect the NULL kernel pointer read to current's
user virtual address 0, faulting on every NULL pointer or reading user
page 0 if mapped. On s390, where address 0 is mapped to struct lowcore,
copy_from_kernel_nofault() succeeds and copies lowcore bytes into the
trace buffer instead of zeroing dest.
[Severity: Medium]
What happens in the FETCH_OP_LP_ARRAY loop below stage 3 when val or
lval is 0?
kernel/trace/trace_probe_tmpl.h:process_fetch_insn_bottom() {
...
if (code->op == FETCH_OP_LP_ARRAY) {
if (ret < 0)
ret = 0;
total += ret;
if (++i < code->param) {
code = s3;
if (s3->op != FETCH_OP_ST_STRING &&
s3->op != FETCH_OP_ST_USTRING) {
dest += s3->size;
val += s3->size;
goto stage3;
}
code--;
val = lval + sizeof(char *);
...
}
Because stage 2 no longer returns early on a dereference fault, a NULL or
faulted array base pointer now enters the FETCH_OP_LP_ARRAY loop with
val == 0 (or lval == 0). On the next iteration, val += s3->size or
val = lval + sizeof(char *) turns 0 into a non-zero value (such as 8), so
val ? code->offset : 0 and if (val) treat it as a valid pointer and
dereference i * elem_size + code->offset for the remaining array
elements.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261119152922.5a66f10e@gandalf.local.home?part=1
next prev parent reply other threads:[~2026-11-19 20:50 UTC|newest]
Thread overview: 4+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-19 20:29 [PATCH v3] tracing/probes: Zero out faulted dereferenced fields Steven Rostedt
2026-11-19 20:50 ` sashiko-bot [this message]
2026-11-19 21:19 ` Steven Rostedt
2026-11-20 0:10 ` Masami Hiramatsu (Google)
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-224053@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=linux-trace-kernel@vger.kernel.org \
--cc=rostedt@goodmis.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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox