Linux Trace Kernel
 help / color / mirror / Atom feed
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

  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