Linux Trace Kernel
 help / color / mirror / Atom feed
* [PATCH bpf 0/2] bpf: Limit writable registers in uprobe context
@ 2026-11-18  8:44 Jiri Olsa
  2026-11-18  8:44 ` [PATCH bpf 1/2] bpf: Restrict uprobe ctx writes to the registers ptrace can set Jiri Olsa
  2026-11-18  8:44 ` [PATCH bpf 2/2] selftests/bpf: Test which ctx registers a uprobe prog can write Jiri Olsa
  0 siblings, 2 replies; 3+ messages in thread
From: Jiri Olsa @ 2026-11-18  8:44 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Masami Hiramatsu, Oleg Nesterov
  Cc: bpf, x86, linux-riscv, linux-arm-kernel, linux-trace-kernel,
	Martin KaFai Lau, Eduard Zingerman, Song Liu, Yonghong Song,
	Will Deacon, Palmer Dabbelt, Peter Zijlstra, rtm

Hi,
a uprobe BPF program can currently write fields in struct pt_regs that
are loaded directly by the architecture’s return-to-user path. Some of
these fields are restricted by ptrace, but the BPF verifier does not
apply the same restrictions.

This series limits uprobe context writes to registers that ptrace can
set to arbitrary values. It adds architecture-specific writable-register
checks for arm64, riscv, and x86-64; other architectures default to
allowing no writes. Reads are unchanged.

The second patch adds verifier tests for writable and read-only registers
on x86-64, arm64, and riscv.

Patch 1 fixes the issue reported by rtm and is marked for stable consideration.
Patch 2 adds the regression tests.

thanks,
jirka


---
Jiri Olsa (2):
      bpf: Restrict uprobe ctx writes to the registers ptrace can set
      selftests/bpf: Test which ctx registers a uprobe prog can write

 arch/arm64/kernel/probes/uprobes.c                            |   6 ++
 arch/riscv/kernel/probes/uprobes.c                            |   6 ++
 arch/x86/kernel/uprobes.c                                     |  15 ++++
 include/linux/uprobes.h                                       |   5 ++
 kernel/events/uprobes.c                                       |   9 +++
 kernel/trace/bpf_trace.c                                      |  10 ++-
 tools/testing/selftests/bpf/prog_tests/verifier.c             |   2 +
 tools/testing/selftests/bpf/progs/verifier_uprobe_write_ctx.c | 196 +++++++++++++++++++++++++++++++++++++++++++++++++
 8 files changed, 248 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/bpf/progs/verifier_uprobe_write_ctx.c

^ permalink raw reply	[flat|nested] 3+ messages in thread

* [PATCH bpf 1/2] bpf: Restrict uprobe ctx writes to the registers ptrace can set
  2026-11-18  8:44 [PATCH bpf 0/2] bpf: Limit writable registers in uprobe context Jiri Olsa
@ 2026-11-18  8:44 ` Jiri Olsa
  2026-11-18  8:44 ` [PATCH bpf 2/2] selftests/bpf: Test which ctx registers a uprobe prog can write Jiri Olsa
  1 sibling, 0 replies; 3+ messages in thread
From: Jiri Olsa @ 2026-11-18  8:44 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Masami Hiramatsu, Oleg Nesterov
  Cc: stable, rtm, bpf, x86, linux-riscv, linux-arm-kernel,
	linux-trace-kernel, Martin KaFai Lau, Eduard Zingerman, Song Liu,
	Yonghong Song, Will Deacon, Palmer Dabbelt, Peter Zijlstra

Since commit 7384893d970e ("bpf: Allow uprobe program to change context
registers") a uprobe program can write any field of struct pt_regs.
Some of those fields are not plain user registers. The exit to user
space loads them into the CPU:

  arch    field   exit path                        ptrace
  ------  ------  -------------------------------  ------------------
  riscv   status  csrw CSR_STATUS, a0              not in the regset
  arm64   pstate  msr spsr_el1, x22                valid_user_regs()
  x86-64  cs, ss  (cs & 3) == 0: iretq to ring 0   set_segment_reg()
  x86-64  flags   iretq loads IF and IOPL          set_flags()

On riscv a program that sets sstatus.SPP in pt_regs.status makes
ret_from_exception return to user code in supervisor mode. On x86-64 a
program that writes a kernel selector to cs makes iretq return to
ring 0.
ptrace guards these fields, but the bpf verifier does not.

Add arch_uprobe_regs_writable(). Each arch lists the registers that
ptrace can set to any value, and kprobe_prog_is_valid_access() rejects
writes to any other offset when the program is loaded:

  arm64:   x0 to x30, sp, pc
  riscv:   epc, ra to t6
  x86-64:  r15 to di, ip, sp

The default is no writes, so arches without a list (and 32-bit x86)
lose ctx writes for uprobe programs. Reads are not affected.

flags on x86-64 and pstate on arm64 become read-only, including the
condition bits that ptrace would let a debugger change. orig_ax is
read-only too.

Kprobe programs that write ctx were already rejected when they were
attached. Those that write one of these fields now fail to load.

Fixes: 7384893d970e ("bpf: Allow uprobe program to change context registers")
Cc: stable@vger.kernel.org
Reported-by: rtm@csail.mit.edu
Closes: https://lore.kernel.org/bpf/30318.1794850523@30-11-166.wireless.csail.mit.edu/
Suggested-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
---
 arch/arm64/kernel/probes/uprobes.c |  6 ++++++
 arch/riscv/kernel/probes/uprobes.c |  6 ++++++
 arch/x86/kernel/uprobes.c          | 15 +++++++++++++++
 include/linux/uprobes.h            |  5 +++++
 kernel/events/uprobes.c            |  9 +++++++++
 kernel/trace/bpf_trace.c           | 10 +++++++++-
 6 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/arch/arm64/kernel/probes/uprobes.c b/arch/arm64/kernel/probes/uprobes.c
index 2a9b0bc083a3..1e6ac4785a53 100644
--- a/arch/arm64/kernel/probes/uprobes.c
+++ b/arch/arm64/kernel/probes/uprobes.c
@@ -152,6 +152,12 @@ bool arch_uretprobe_is_alive(struct return_instance *ret, enum rp_check ctx,
 		return regs->sp < ret->stack;
 }
 
+bool arch_uprobe_regs_writable(int off, int size)
+{
+	/* From x0 to x30, sp, pc. */
+	return off + size <= offsetof(struct pt_regs, pstate);
+}
+
 unsigned long
 arch_uretprobe_hijack_return_addr(unsigned long trampoline_vaddr,
 				  struct pt_regs *regs)
diff --git a/arch/riscv/kernel/probes/uprobes.c b/arch/riscv/kernel/probes/uprobes.c
index eb177d0ce8ab..dbb153463197 100644
--- a/arch/riscv/kernel/probes/uprobes.c
+++ b/arch/riscv/kernel/probes/uprobes.c
@@ -126,6 +126,12 @@ bool arch_uretprobe_is_alive(struct return_instance *ret, enum rp_check ctx,
 		return regs->sp < ret->stack;
 }
 
+bool arch_uprobe_regs_writable(int off, int size)
+{
+	/* epc, from ra to t6. */
+	return off + size <= offsetof(struct pt_regs, status);
+}
+
 unsigned long
 arch_uretprobe_hijack_return_addr(unsigned long trampoline_vaddr,
 				  struct pt_regs *regs)
diff --git a/arch/x86/kernel/uprobes.c b/arch/x86/kernel/uprobes.c
index 0f60c0d076b6..fc07bcd0f462 100644
--- a/arch/x86/kernel/uprobes.c
+++ b/arch/x86/kernel/uprobes.c
@@ -1888,6 +1888,21 @@ bool arch_uretprobe_is_alive(struct return_instance *ret, enum rp_check ctx,
 		return regs->sp <= ret->stack;
 }
 
+bool arch_uprobe_regs_writable(int off, int size)
+{
+	int end = off + size;
+
+	/* The 32-bit pt_regs has segments in front of orig_ax. */
+	if (!IS_ENABLED(CONFIG_X86_64))
+		return false;
+	/* From r15 to di. Not orig_ax, cs, flags, ss. */
+	if (end <= offsetof(struct pt_regs, orig_ax))
+		return true;
+	if (off >= offsetof(struct pt_regs, ip) && end <= offsetofend(struct pt_regs, ip))
+		return true;
+	return off >= offsetof(struct pt_regs, sp) && end <= offsetofend(struct pt_regs, sp);
+}
+
 /*
  * Heuristic-based check if uprobe is installed at the function entry.
  *
diff --git a/include/linux/uprobes.h b/include/linux/uprobes.h
index d34dbc0fbbfe..43b250bff162 100644
--- a/include/linux/uprobes.h
+++ b/include/linux/uprobes.h
@@ -239,6 +239,7 @@ extern void uprobe_copy_from_page(struct page *page, unsigned long vaddr, void *
 extern void handle_syscall_uprobe(struct pt_regs *regs, unsigned long bp_vaddr);
 extern void arch_uprobe_optimize(struct arch_uprobe *auprobe, unsigned long vaddr);
 extern unsigned long arch_uprobe_get_xol_area(void);
+extern bool arch_uprobe_regs_writable(int off, int size);
 #else /* !CONFIG_UPROBES */
 struct uprobes_state {
 };
@@ -300,5 +301,9 @@ static inline void uprobe_copy_process(struct task_struct *t, u64 flags)
 static inline void uprobe_clear_state(struct mm_struct *mm)
 {
 }
+static inline bool arch_uprobe_regs_writable(int off, int size)
+{
+	return false;
+}
 #endif /* !CONFIG_UPROBES */
 #endif	/* _LINUX_UPROBES_H */
diff --git a/kernel/events/uprobes.c b/kernel/events/uprobes.c
index caf444762a27..c47b1ee266d5 100644
--- a/kernel/events/uprobes.c
+++ b/kernel/events/uprobes.c
@@ -2703,6 +2703,15 @@ void __weak arch_uprobe_optimize(struct arch_uprobe *auprobe, unsigned long vadd
 {
 }
 
+/*
+ * Can a bpf prog write these bytes of pt_regs? An arch opts in and lists the
+ * registers that ptrace can set to any value.
+ */
+bool __weak arch_uprobe_regs_writable(int off, int size)
+{
+	return false;
+}
+
 /*
  * Run handler and ask thread to singlestep.
  * Ensure all non-fatal signals cannot interrupt thread while it singlesteps.
diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c
index 2aec56d7f3d3..636c9849e07f 100644
--- a/kernel/trace/bpf_trace.c
+++ b/kernel/trace/bpf_trace.c
@@ -1397,8 +1397,16 @@ static bool kprobe_prog_is_valid_access(int off, int size, enum bpf_access_type
 	if (off + size > sizeof(struct pt_regs))
 		return false;
 
-	if (type == BPF_WRITE)
+	if (type == BPF_WRITE) {
+		/*
+		 * pt_regs also holds what the kernel restores on the way to
+		 * user space: cs and flags on x86, pstate on arm64, status on
+		 * riscv. A prog can write the registers of the task only.
+		 */
+		if (!arch_uprobe_regs_writable(off, size))
+			return false;
 		prog->aux->kprobe_write_ctx = true;
+	}
 
 	return true;
 }
-- 
2.43.0


^ permalink raw reply related	[flat|nested] 3+ messages in thread

* [PATCH bpf 2/2] selftests/bpf: Test which ctx registers a uprobe prog can write
  2026-11-18  8:44 [PATCH bpf 0/2] bpf: Limit writable registers in uprobe context Jiri Olsa
  2026-11-18  8:44 ` [PATCH bpf 1/2] bpf: Restrict uprobe ctx writes to the registers ptrace can set Jiri Olsa
@ 2026-11-18  8:44 ` Jiri Olsa
  1 sibling, 0 replies; 3+ messages in thread
From: Jiri Olsa @ 2026-11-18  8:44 UTC (permalink / raw)
  To: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
	Masami Hiramatsu, Oleg Nesterov
  Cc: bpf, x86, linux-riscv, linux-arm-kernel, linux-trace-kernel,
	Martin KaFai Lau, Eduard Zingerman, Song Liu, Yonghong Song,
	Will Deacon, Palmer Dabbelt, Peter Zijlstra, rtm

A uprobe program can write only the pt_regs fields that ptrace can set
to any value. Add verifier tests for x86-64, arm64 and riscv:

  - writes to the general registers, the stack pointer and the
    instruction pointer load
  - writes to cs, ss, flags and orig_ax on x86-64, to pstate and
    orig_x0 on arm64, and to status, badaddr and cause on riscv fail
    with "invalid bpf_context access"
  - a 4-byte write to the low half of a read-only field fails too
  - reading a read-only field still works
  - on x86-64, a kprobe program that writes ctx->flags fails to load

Other arches get one test that just loads.

Signed-off-by: Jiri Olsa <jolsa@kernel.org>
---
 .../selftests/bpf/prog_tests/verifier.c       |   2 +
 .../bpf/progs/verifier_uprobe_write_ctx.c     | 196 ++++++++++++++++++
 2 files changed, 198 insertions(+)
 create mode 100644 tools/testing/selftests/bpf/progs/verifier_uprobe_write_ctx.c

diff --git a/tools/testing/selftests/bpf/prog_tests/verifier.c b/tools/testing/selftests/bpf/prog_tests/verifier.c
index 6a494c381266..5a31f04677e0 100644
--- a/tools/testing/selftests/bpf/prog_tests/verifier.c
+++ b/tools/testing/selftests/bpf/prog_tests/verifier.c
@@ -131,6 +131,7 @@
 #include "verifier_unpriv.skel.h"
 #include "verifier_unwind.skel.h"
 #include "verifier_unpriv_perf.skel.h"
+#include "verifier_uprobe_write_ctx.skel.h"
 #include "verifier_value_adj_spill.skel.h"
 #include "verifier_value.skel.h"
 #include "verifier_value_illegal_alu.skel.h"
@@ -321,6 +322,7 @@ void test_verifier_uninit(void)               { RUN(verifier_uninit); }
 void test_verifier_unpriv(void)               { RUN(verifier_unpriv); }
 void test_verifier_unwind(void)               { RUN(verifier_unwind); }
 void test_verifier_unpriv_perf(void)          { RUN(verifier_unpriv_perf); }
+void test_verifier_uprobe_write_ctx(void)     { RUN(verifier_uprobe_write_ctx); }
 void test_verifier_value_adj_spill(void)      { RUN(verifier_value_adj_spill); }
 void test_verifier_value(void)                { RUN(verifier_value); }
 void test_verifier_value_illegal_alu(void)    { RUN(verifier_value_illegal_alu); }
diff --git a/tools/testing/selftests/bpf/progs/verifier_uprobe_write_ctx.c b/tools/testing/selftests/bpf/progs/verifier_uprobe_write_ctx.c
new file mode 100644
index 000000000000..f5ed453b1798
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/verifier_uprobe_write_ctx.c
@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+#include "bpf_misc.h"
+
+/*
+ * A uprobe prog can write only the registers that ptrace can set to any
+ * value. The fields the kernel restores on the way to user space (segments,
+ * flags, privilege state) are read-only.
+ */
+
+#define WRITE_CTX(name, field, sz)					\
+__naked void name(void)							\
+{									\
+	asm volatile ("							\
+	r2 = 0;								\
+	*(" #sz " *)(r1 + %[off]) = r2;					\
+	r0 = 0;								\
+	exit;								\
+"	:								\
+	: __imm_const(off, offsetof(struct pt_regs, field))		\
+	: __clobber_all);						\
+}
+
+#define READ_CTX(name, field)						\
+__naked void name(void)							\
+{									\
+	asm volatile ("							\
+	r0 = *(u64 *)(r1 + %[off]);					\
+	r0 = 0;								\
+	exit;								\
+"	:								\
+	: __imm_const(off, offsetof(struct pt_regs, field))		\
+	: __clobber_all);						\
+}
+
+#if defined(__TARGET_ARCH_x86)
+
+SEC("uprobe")
+__description("uprobe: write ctx->ax")
+__success
+WRITE_CTX(write_ax, ax, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->r15")
+__success
+WRITE_CTX(write_r15, r15, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->di")
+__success
+WRITE_CTX(write_di, di, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->ip")
+__success
+WRITE_CTX(write_ip, ip, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->sp")
+__success
+WRITE_CTX(write_sp, sp, u64)
+
+SEC("uprobe")
+__description("uprobe: write lower half of ctx->ax")
+__success
+WRITE_CTX(write_ax_u32, ax, u32)
+
+SEC("uprobe")
+__description("uprobe: write ctx->orig_ax")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_orig_ax, orig_ax, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->cs")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_cs, cs, u64)
+
+SEC("uprobe")
+__description("uprobe: write lower half of ctx->cs")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_cs_u32, cs, u32)
+
+SEC("uprobe")
+__description("uprobe: write ctx->flags")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_flags, flags, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->ss")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_ss, ss, u64)
+
+SEC("uprobe")
+__description("uprobe: read ctx->flags")
+__success
+READ_CTX(read_flags, flags)
+
+SEC("kprobe")
+__description("kprobe: write ctx->flags")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(kprobe_write_flags, flags, u64)
+
+#elif defined(__TARGET_ARCH_arm64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->regs[0]")
+__success
+WRITE_CTX(write_x0, regs[0], u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->regs[30]")
+__success
+WRITE_CTX(write_x30, regs[30], u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->sp")
+__success
+WRITE_CTX(write_sp, sp, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->pc")
+__success
+WRITE_CTX(write_pc, pc, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->pstate")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_pstate, pstate, u64)
+
+SEC("uprobe")
+__description("uprobe: write lower half of ctx->pstate")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_pstate_u32, pstate, u32)
+
+SEC("uprobe")
+__description("uprobe: write ctx->orig_x0")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_orig_x0, orig_x0, u64)
+
+SEC("uprobe")
+__description("uprobe: read ctx->pstate")
+__success
+READ_CTX(read_pstate, pstate)
+
+#elif defined(__TARGET_ARCH_riscv)
+
+SEC("uprobe")
+__description("uprobe: write ctx->epc")
+__success
+WRITE_CTX(write_epc, epc, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->a0")
+__success
+WRITE_CTX(write_a0, a0, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->t6")
+__success
+WRITE_CTX(write_t6, t6, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->status")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_status, status, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->badaddr")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_badaddr, badaddr, u64)
+
+SEC("uprobe")
+__description("uprobe: write ctx->cause")
+__failure __msg("invalid bpf_context access")
+WRITE_CTX(write_cause, cause, u64)
+
+SEC("uprobe")
+__description("uprobe: read ctx->status")
+__success
+READ_CTX(read_status, status)
+
+#else
+
+SEC("uprobe")
+__description("uprobe: ctx writes not checked on this arch")
+__success
+__naked void unsupported(void)
+{
+	asm volatile ("r0 = 0; exit;" ::: __clobber_all);
+}
+
+#endif
+
+char _license[] SEC("license") = "GPL";
-- 
2.43.0


^ permalink raw reply related	[flat|nested] 3+ messages in thread

end of thread, other threads:[~2026-11-18  8:45 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-18  8:44 [PATCH bpf 0/2] bpf: Limit writable registers in uprobe context Jiri Olsa
2026-11-18  8:44 ` [PATCH bpf 1/2] bpf: Restrict uprobe ctx writes to the registers ptrace can set Jiri Olsa
2026-11-18  8:44 ` [PATCH bpf 2/2] selftests/bpf: Test which ctx registers a uprobe prog can write Jiri Olsa

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox