Skip to contentSkip to conversation

uprobes/x86: Fix red zone issue for optimized uprobes

PATCH Superseded Jiri Olsa 7 participants 44 messages May 21 – May 26

Subsystems (11)
x86 Kselftest BPF perf events +7 more subsystems

v3 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Jiri Olsa

author reviewer
#0 lore raw

v3 cover uprobes/x86: Fix red zone issue for optimized uprobes

hi,
Andrii reported an issue with optimized uprobes [1] that can clobber redzone area with call instruction storing return address on stack where user code may keep temporary data without adjusting rsp.

Fixing this by moving the optimized uprobes on top of 10-bytes nop instruction, so we can squeeze another instruction to escape the redzone area before doing the call.

Note we need upstream update first for patch 3 (github.com/libbpf/usdt), if we decide to take this change.

thanks,
jirka

v1: https://lore.kernel.org/bpf/[email protected]/
v2: https://lore.kernel.org/bpf/[email protected]/

v3 changes:
- use nop10 update suggested by Peter in [2]
- remove struct uprobe_trampoline object, use vma objects directly instead
- selftests fixes [sashiko]
- ack from Andrii

v2 changes:
- several selftest fixes [sashiko]
- consolidate is_lea_insn and is_call_insn insto single check [Jakub Sitnicki]
- use proper mm_struct object in __in_uprobe_trampoline check [sashiko]
- allow to copy uprobe trampolines vma objects on fork [sashiko]
- change uprobe syscall detection error from -ENXIO to -EPROTO [Andrii]
- added fork/clone tests
- I kept the selftest changes and nop5->nop10 changes in separate commits for easier review, we can squash them later if we want to keep bisect working properly

[1] https://lore.kernel.org/bpf/[email protected]/
[2] https://lore.kernel.org/bpf/[email protected]/#t
---
Andrii Nakryiko (1):
selftests/bpf: Add tests for uprobe nop10 red zone clobbering

Jiri Olsa (11):
uprobes/x86: Use proper mm_struct in __in_uprobe_trampoline uprobes/x86: Remove struct uprobe_trampoline object uprobes/x86: Allow to copy uprobe trampolines on fork uprobes/x86: Move optimized uprobe from nop5 to nop10
libbpf: Change has_nop_combo to work on top of nop10
libbpf: Detect uprobe syscall with new error selftests/bpf: Emit nop,nop10 instructions combo for x86_64 arch selftests/bpf: Change uprobe syscall tests to use nop10 selftests/bpf: Change uprobe/usdt trigger bench code to use nop10 selftests/bpf: Add reattach tests for uprobe syscall selftests/bpf: Add tests for forked/cloned optimized uprobes

 arch/x86/kernel/uprobes.c                               | 393 ++++++++++++++++++++++++++++++++++++++++++++----------------------------
 include/linux/uprobes.h                                 |   5 -
 kernel/events/uprobes.c                                 |  10 --
 kernel/fork.c                                           |   1 -
 tools/lib/bpf/features.c                                |   4 +-
 tools/lib/bpf/usdt.c                                    |  16 +--
 tools/testing/selftests/bpf/bench.c                     |  20 ++--
 tools/testing/selftests/bpf/benchs/bench_trigger.c      |  38 +++----
 tools/testing/selftests/bpf/benchs/run_bench_uprobes.sh |   2 +-
 tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c | 307 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 tools/testing/selftests/bpf/prog_tests/usdt.c           |  74 ++++++++++++--
 tools/testing/selftests/bpf/progs/test_usdt.c           |  25 +++++
 tools/testing/selftests/bpf/usdt.h                      |   2 +-
 tools/testing/selftests/bpf/usdt_2.c                    |  15 ++-
 14 files changed, 670 insertions(+), 242 deletions(-)
author reviewer
#1 lore raw

PATCH v3 1/12 uprobes/x86: Use proper mm_struct in __in_uprobe_trampoline

In the unregister path we use __in_uprobe_trampoline check with current->mm for the VMA lookup, which is wrong, because we are in the tracer context, not the traced process.

Add mm_struct pointer argument to __in_uprobe_trampoline and changing related callers to pass proper mm_struct pointer.

Fixes ba2bfc97b462 ("uprobes/x86: Add support to optimize uprobes")
---
 arch/x86/kernel/uprobes.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)
arch/x86/kernel/uprobes.c +7 -7
index ebb1baf1eb1d..2be6707e3320 100644
@@ -761,9 +761,9 @@ void arch_uprobe_clear_state(struct mm_struct *mm)
 		destroy_uprobe_trampoline(tramp);
 }
 
-static bool __in_uprobe_trampoline(unsigned long ip)
+static bool __in_uprobe_trampoline(struct mm_struct *mm, unsigned long ip)
 {
-	struct vm_area_struct *vma = vma_lookup(current->mm, ip);
+	struct vm_area_struct *vma = vma_lookup(mm, ip);
 
 	return vma && vma_is_special_mapping(vma, &tramp_mapping);
 }
@@ -776,14 +776,14 @@ static bool in_uprobe_trampoline(unsigned long ip)
 
 	rcu_read_lock();
 	if (mmap_lock_speculate_try_begin(mm, &seq)) {
-		found = __in_uprobe_trampoline(ip);
+		found = __in_uprobe_trampoline(mm, ip);
 		retry = mmap_lock_speculate_retry(mm, seq);
 	}
 	rcu_read_unlock();
 
 	if (retry) {
 		mmap_read_lock(mm);
-		found = __in_uprobe_trampoline(ip);
+		found = __in_uprobe_trampoline(mm, ip);
 		mmap_read_unlock(mm);
 	}
 	return found;
@@ -1044,7 +1044,7 @@ static int copy_from_vaddr(struct mm_struct *mm, unsigned long vaddr, void *dst,
 	return 0;
 }
 
-static bool __is_optimized(uprobe_opcode_t *insn, unsigned long vaddr)
+static bool __is_optimized(struct mm_struct *mm, uprobe_opcode_t *insn, unsigned long vaddr)
 {
 	struct __packed __arch_relative_insn {
 		u8 op;
@@ -1053,7 +1053,7 @@ static bool __is_optimized(uprobe_opcode_t *insn, unsigned long vaddr)
 
 	if (!is_call_insn(insn))
 		return false;
-	return __in_uprobe_trampoline(vaddr + 5 + call->raddr);
+	return __in_uprobe_trampoline(mm, vaddr + 5 + call->raddr);
 }
 
 static int is_optimized(struct mm_struct *mm, unsigned long vaddr)
@@ -1064,7 +1064,7 @@ static int is_optimized(struct mm_struct *mm, unsigned long vaddr)
 	err = copy_from_vaddr(mm, vaddr, &insn, 5);
 	if (err)
 		return err;
-	return __is_optimized((uprobe_opcode_t *)&insn, vaddr);
+	return __is_optimized(mm, (uprobe_opcode_t *)&insn, vaddr);
 }
 
 static bool should_optimize(struct arch_uprobe *auprobe)
Signature · 1 line
2.53.0
Acked-by on v3 1/12
#2 lore raw

Re: [PATCHv3 01/12] uprobes/x86: Use proper mm_struct in __in_uprobe_trampoline

Quoted 5 lines · Jiri Olsa

In the unregister path we use __in_uprobe_trampoline check with current->mm for the VMA lookup, which is wrong, because we are in the tracer context, not the traced process.

Quoted 9 lines

Add mm_struct pointer argument to __in_uprobe_trampoline and changing related callers to pass proper mm_struct pointer.

Fixes ba2bfc97b462 ("uprobes/x86: Add support to optimize uprobes")
---
 arch/x86/kernel/uprobes.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

lgtm, thanks!

[...]

author reviewer
#3 lore raw

PATCH v3 2/12 uprobes/x86: Remove struct uprobe_trampoline object

In reply to Jiri Olsa

Removing struct uprobe_trampoline object and it's tracking code, because it's not needed. We can do same thing directly on top of struct vm_area_struct objects.

This makes the code simpler and allows easy propagation of the trampoline vma object into child process in following change.

Note the original code called destroy_uprobe_trampoline if the optimiation failed, but it only freed the struct uprobe_trampoline object, not the vma.

---
 arch/x86/kernel/uprobes.c | 102 ++++++++------------------------------
 include/linux/uprobes.h   |   5 --
 kernel/events/uprobes.c   |  10 ----
 kernel/fork.c             |   1 -
 4 files changed, 20 insertions(+), 98 deletions(-)
arch/x86/kernel/uprobes.c +20 -82
index 2be6707e3320..6824376e253d 100644
@@ -631,11 +631,6 @@ static struct vm_special_mapping tramp_mapping = {
 	.pages  = tramp_mapping_pages,
 };
 
-struct uprobe_trampoline {
-	struct hlist_node	node;
-	unsigned long		vaddr;
-};
-
 static bool is_reachable_by_call(unsigned long vtramp, unsigned long vaddr)
 {
 	long delta = (long)(vaddr + 5 - vtramp);
@@ -682,83 +677,32 @@ static unsigned long find_nearest_trampoline(unsigned long vaddr)
 	return high_tramp;
 }
 
-static struct uprobe_trampoline *create_uprobe_trampoline(unsigned long vaddr)
+static struct vm_area_struct *get_uprobe_trampoline(unsigned long vaddr)
 {
 	struct pt_regs *regs = task_pt_regs(current);
-	struct mm_struct *mm = current->mm;
-	struct uprobe_trampoline *tramp;
+	VMA_ITERATOR(vmi, current->mm, 0);
 	struct vm_area_struct *vma;
 
 	if (!user_64bit_mode(regs))
-		return NULL;
-
-	vaddr = find_nearest_trampoline(vaddr);
-	if (IS_ERR_VALUE(vaddr))
-		return NULL;
-
-	tramp = kzalloc_obj(*tramp);
-	if (unlikely(!tramp))
-		return NULL;
-
-	tramp->vaddr = vaddr;
-	vma = _install_special_mapping(mm, tramp->vaddr, PAGE_SIZE,
-				VM_READ|VM_EXEC|VM_MAYEXEC|VM_MAYREAD|VM_DONTCOPY|VM_IO,
-				&tramp_mapping);
-	if (IS_ERR(vma)) {
-		kfree(tramp);
-		return NULL;
-	}
-	return tramp;
-}
-
-static struct uprobe_trampoline *get_uprobe_trampoline(unsigned long vaddr, bool *new)
-{
-	struct uprobes_state *state = &current->mm->uprobes_state;
-	struct uprobe_trampoline *tramp = NULL;
+		return ERR_PTR(-EINVAL);
 
 	if (vaddr > TASK_SIZE || vaddr < PAGE_SIZE)
-		return NULL;
+		return ERR_PTR(-EINVAL);
 
-	hlist_for_each_entry(tramp, &state->head_tramps, node) {
-		if (is_reachable_by_call(tramp->vaddr, vaddr)) {
-			*new = false;
-			return tramp;
-		}
+	for_each_vma(vmi, vma) {
+		if (!vma_is_special_mapping(vma, &tramp_mapping))
+			continue;
+		if (is_reachable_by_call(vma->vm_start, vaddr))
+			return vma;
 	}
 
-	tramp = create_uprobe_trampoline(vaddr);
-	if (!tramp)
-		return NULL;
-
-	*new = true;
-	hlist_add_head(&tramp->node, &state->head_tramps);
-	return tramp;
-}
-
-static void destroy_uprobe_trampoline(struct uprobe_trampoline *tramp)
-{
-	/*
-	 * We do not unmap and release uprobe trampoline page itself,
-	 * because there's no easy way to make sure none of the threads
-	 * is still inside the trampoline.
-	 */
-	hlist_del(&tramp->node);
-	kfree(tramp);
-}
-
-void arch_uprobe_init_state(struct mm_struct *mm)
-{
-	INIT_HLIST_HEAD(&mm->uprobes_state.head_tramps);
-}
-
-void arch_uprobe_clear_state(struct mm_struct *mm)
-{
-	struct uprobes_state *state = &mm->uprobes_state;
-	struct uprobe_trampoline *tramp;
-	struct hlist_node *n;
+	vaddr = find_nearest_trampoline(vaddr);
+	if (IS_ERR_VALUE(vaddr))
+		return ERR_PTR(vaddr);
 
-	hlist_for_each_entry_safe(tramp, n, &state->head_tramps, node)
-		destroy_uprobe_trampoline(tramp);
+	return _install_special_mapping(current->mm, vaddr, PAGE_SIZE,
+				VM_READ|VM_EXEC|VM_MAYEXEC|VM_MAYREAD|VM_DONTCOPY|VM_IO,
+				&tramp_mapping);
 }
 
 static bool __in_uprobe_trampoline(struct mm_struct *mm, unsigned long ip)
@@ -1111,21 +1055,15 @@ int set_orig_insn(struct arch_uprobe *auprobe, struct vm_area_struct *vma,
 static int __arch_uprobe_optimize(struct arch_uprobe *auprobe, struct mm_struct *mm,
 				  unsigned long vaddr)
 {
-	struct uprobe_trampoline *tramp;
-	struct vm_area_struct *vma;
-	bool new = false;
-	int err = 0;
+	struct vm_area_struct *vma, *tramp;
 
 	vma = find_vma(mm, vaddr);
 	if (!vma)
 		return -EINVAL;
-	tramp = get_uprobe_trampoline(vaddr, &new);
-	if (!tramp)
-		return -EINVAL;
-	err = swbp_optimize(auprobe, vma, vaddr, tramp->vaddr);
-	if (WARN_ON_ONCE(err) && new)
-		destroy_uprobe_trampoline(tramp);
-	return err;
+	tramp = get_uprobe_trampoline(vaddr);
+	if (IS_ERR(tramp))
+		return PTR_ERR(tramp);
+	return WARN_ON_ONCE(swbp_optimize(auprobe, vma, vaddr, tramp->vm_start));
 }
 
 void arch_uprobe_optimize(struct arch_uprobe *auprobe, unsigned long vaddr)
include/linux/uprobes.h +0 -5
index f548fea2adec..18be159bbc34 100644
@@ -186,9 +186,6 @@ struct xol_area;
 
 struct uprobes_state {
 	struct xol_area		*xol_area;
-#ifdef CONFIG_X86_64
-	struct hlist_head	head_tramps;
-#endif
 };
 
 typedef int (*uprobe_write_verify_t)(struct page *page, unsigned long vaddr,
@@ -238,8 +235,6 @@ extern void uprobe_handle_trampoline(struct pt_regs *regs);
 extern void *arch_uretprobe_trampoline(unsigned long *psize);
 extern unsigned long uprobe_get_trampoline_vaddr(void);
 extern void uprobe_copy_from_page(struct page *page, unsigned long vaddr, void *dst, int len);
-extern void arch_uprobe_clear_state(struct mm_struct *mm);
-extern void arch_uprobe_init_state(struct mm_struct *mm);
 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);
kernel/events/uprobes.c +0 -10
index 4084e926e284..b5c516168f84 100644
@@ -1806,14 +1806,6 @@ static struct xol_area *get_xol_area(void)
 	return area;
 }
 
-void __weak arch_uprobe_clear_state(struct mm_struct *mm)
-{
-}
-
-void __weak arch_uprobe_init_state(struct mm_struct *mm)
-{
-}
-
 /*
  * uprobe_clear_state - Free the area allocated for slots.
  */
@@ -1825,8 +1817,6 @@ void uprobe_clear_state(struct mm_struct *mm)
 	delayed_uprobe_remove(NULL, mm);
 	mutex_unlock(&delayed_uprobe_lock);
 
-	arch_uprobe_clear_state(mm);
-
 	if (!area)
 		return;
 
kernel/fork.c +0 -1
index 5f3fdfdb14c7..9c6baabdc961 100644
@@ -1059,7 +1059,6 @@ static void mm_init_uprobes_state(struct mm_struct *mm)
 {
 #ifdef CONFIG_UPROBES
 	mm->uprobes_state.xol_area = NULL;
-	arch_uprobe_init_state(mm);
 #endif
 }
 
Signature · 1 line
2.53.0
#4 lore raw

Re: [PATCHv3 02/12] uprobes/x86: Remove struct uprobe_trampoline object

This looks like a bug fix for a VMA resource leak. The commit message notes that when uprobe optimization failed, the original code only freed the struct uprobe_trampoline object but leaked the VMA…
Quoted 10 lines

commit 35d93b034b144060a547b507cfb4268692c328c2

Author: Jiri Olsa <[email protected]>
Date:   Thu May 21 14:44:01 2026 +0200

uprobes/x86: Remove struct uprobe_trampoline object

Removing struct uprobe_trampoline object and it's tracking code, because it's not needed. We can do same thing directly on top of struct vm_area_struct objects.

Quoted 8 lines

This makes the code simpler and allows easy propagation of the trampoline vma object into child process in following change.

Note the original code called destroy_uprobe_trampoline if the optimiation failed, but it only freed the struct uprobe_trampoline object, not the vma.

This looks like a bug fix for a VMA resource leak. The commit message notes that when uprobe optimization failed, the original code only freed the struct uprobe_trampoline object but leaked the VMA created by _install_special_mapping. Should this include:

Fixes ba2bfc97b462 ("uprobes/x86: Add support to optimize uprobes")

---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md

CI run summary: https://github.com/kernel-patches/bpf/actions/runs/26227520868

#5 lore raw

Re: [PATCHv3 02/12] uprobes/x86: Remove struct uprobe_trampoline object

Quoted 17 lines · On Thu, May 21, 2026 at 01:26:09PM +0000, [email protected] wrote:
Quoted 17 lines

commit 35d93b034b144060a547b507cfb4268692c328c2

Author: Jiri Olsa <[email protected]>
Date:   Thu May 21 14:44:01 2026 +0200

uprobes/x86: Remove struct uprobe_trampoline object

Removing struct uprobe_trampoline object and it's tracking code, because it's not needed. We can do same thing directly on top of struct vm_area_struct objects.

This makes the code simpler and allows easy propagation of the trampoline vma object into child process in following change.

Note the original code called destroy_uprobe_trampoline if the optimiation failed, but it only freed the struct uprobe_trampoline object, not the vma.

Quoted 8 lines
Quoted 1 line

This looks like a bug fix for a VMA resource leak. The commit message notes that when uprobe optimization failed, the original code only freed the struct uprobe_trampoline object but leaked the VMA created by _install_special_mapping. Should this include:

Fixes ba2bfc97b462 ("uprobes/x86: Add support to optimize uprobes")

no, the logic stays, we just removed one layer.. but we need separate fix for the possible vma leak, will include it in the next version

jirka

Acked-by on v3 2/12
#6 lore raw

Re: [PATCHv3 02/12] uprobes/x86: Remove struct uprobe_trampoline object

In reply to Jiri Olsa
Quoted 12 lines · Jiri Olsa

Removing struct uprobe_trampoline object and it's tracking code, because it's not needed. We can do same thing directly on top of struct vm_area_struct objects.

This makes the code simpler and allows easy propagation of the trampoline vma object into child process in following change.

Note the original code called destroy_uprobe_trampoline if the optimiation failed, but it only freed the struct uprobe_trampoline object, not the vma.

Quoted 8 lines
---
 arch/x86/kernel/uprobes.c | 102 ++++++++------------------------------
 include/linux/uprobes.h   |   5 --
 kernel/events/uprobes.c   |  10 ----
 kernel/fork.c             |   1 -
 4 files changed, 20 insertions(+), 98 deletions(-)

nice cleanup

[...]

author reviewer
#7 lore raw

PATCH v3 3/12 uprobes/x86: Allow to copy uprobe trampolines on fork

In reply to Jiri Olsa

When we do fork or clone without CLONE_VM the new process won't have uprobe trampoline vma objects and at the same time it will have optimized code calling that trampoline and crash.

Fixing this by allowing vma uprobe trampoline objects to be copied on fork to the new process.

Fixes ba2bfc97b462 ("uprobes/x86: Add support to optimize uprobes")
---
 arch/x86/kernel/uprobes.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kernel/uprobes.c +1 -1
index 6824376e253d..11ec6b89b135 100644
@@ -701,7 +701,7 @@ static struct vm_area_struct *get_uprobe_trampoline(unsigned long vaddr)
 		return ERR_PTR(vaddr);
 
 	return _install_special_mapping(current->mm, vaddr, PAGE_SIZE,
-				VM_READ|VM_EXEC|VM_MAYEXEC|VM_MAYREAD|VM_DONTCOPY|VM_IO,
+				VM_READ|VM_EXEC|VM_MAYEXEC|VM_MAYREAD|VM_IO,
 				&tramp_mapping);
 }
 
Signature · 1 line
2.53.0
#8 lore raw

Re: [PATCHv3 03/12] uprobes/x86: Allow to copy uprobe trampolines on fork

Quoted 19 lines · Jiri Olsa

When we do fork or clone without CLONE_VM the new process won't have uprobe trampoline vma objects and at the same time it will have optimized code calling that trampoline and crash.

Fixing this by allowing vma uprobe trampoline objects to be copied on fork to the new process.

Fixes ba2bfc97b462 ("uprobes/x86: Add support to optimize uprobes")
---
 arch/x86/kernel/uprobes.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kernel/uprobes.c +0 -0
index 6824376e253d..11ec6b89b135 100644

arch/x86/kernel/uprobes.c static struct vm_area_struct *get_uprobe_trampoline(unsigned long vaddr) · line 704

Quoted 5 lines
arch/x86/kernel/uprobes.c +1 -1
@@ -701,7 +701,7 @@ static struct vm_area_struct *get_uprobe_trampoline(unsigned long vaddr)
                return ERR_PTR(vaddr);
 
        return _install_special_mapping(current->mm, vaddr, PAGE_SIZE,
-                               VM_READ|VM_EXEC|VM_MAYEXEC|VM_MAYREAD|VM_DONTCOPY|VM_IO,
+                               VM_READ|VM_EXEC|VM_MAYEXEC|VM_MAYREAD|VM_IO,

so on fork we'll get sys_uprobe invocations which will go into uprobe trampoline and syscall will just keep returning -EPROTO, is that right?

what would happen in the similar situation for process with int3 uprobe being forked/cloned? Will it inherit int3 as well, and then will keep hitting interrupts that would just do nothing?

is there a way to restore original memory page for clones? this behavior (unless I'm misunderstanding) seems suboptimal performance-wise

Quoted 7 lines
arch/x86/kernel/uprobes.c +0 -1
                                &tramp_mapping);
 }
 
 
--

2.53.0

#9 lore raw

Re: [PATCHv3 03/12] uprobes/x86: Allow to copy uprobe trampolines on fork

Quoted 22 lines · Andrii Nakryiko
Quoted 21 lines · Jiri Olsa

When we do fork or clone without CLONE_VM the new process won't have uprobe trampoline vma objects and at the same time it will have optimized code calling that trampoline and crash.

Fixing this by allowing vma uprobe trampoline objects to be copied on fork to the new process.

Fixes ba2bfc97b462 ("uprobes/x86: Add support to optimize uprobes")
---
 arch/x86/kernel/uprobes.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kernel/uprobes.c +0 -0
index 6824376e253d..11ec6b89b135 100644
@@ -701,7 +701,7 @@ static struct vm_area_struct *get_uprobe_trampoline(unsigned long vaddr)
                return ERR_PTR(vaddr);
 
Quoted 7 lines

arch/x86/kernel/uprobes.c static struct vm_area_struct *get_uprobe_trampoline(unsigned long vaddr) · line 704

Quoted 3 lines
arch/x86/kernel/uprobes.c +1 -1
        return _install_special_mapping(current->mm, vaddr, PAGE_SIZE,
-                               VM_READ|VM_EXEC|VM_MAYEXEC|VM_MAYREAD|VM_DONTCOPY|VM_IO,
+                               VM_READ|VM_EXEC|VM_MAYEXEC|VM_MAYREAD|VM_IO,

so on fork we'll get sys_uprobe invocations which will go into uprobe trampoline and syscall will just keep returning -EPROTO, is that right?

so the child gets the inherited optimized call path.and now also the trampoline, which executes the uprobe syscall and so if there's related uprobe it will be processed

-EPROTO is returned for uprobe syscall executed out of uprobe trampoline

Quoted 8 lines

what would happen in the similar situation for process with int3 uprobe being forked/cloned? Will it inherit int3 as well, and then will keep hitting interrupts that would just do nothing?

is there a way to restore original memory page for clones? this behavior (unless I'm misunderstanding) seems suboptimal performance-wise

the standard uprobes seem to handle this situation by removing the brekpoint from current->mm, if the uprobe->handler returns UPROBE_HANDLER_REMOVE (for all uprobe consumers) .. and the uprobe->handler does current->mm filter first in uprobe_perf_func and returns UPROBE_HANDLER_REMOVE in case it does not match

this works also for optimized uprobes on top of standard uprobes

but we don't do that for uprobe_multi and I think we could do something similar, the code is there, perhaps we just need to add the filter

jirka

author reviewer
#10 lore raw

PATCH v3 4/12 uprobes/x86: Move optimized uprobe from nop5 to nop10

In reply to Jiri Olsa

Andrii reported an issue with optimized uprobes [1] that can clobber redzone area with call instruction storing return address on stack where user code may keep temporary data without adjusting rsp.

Fixing this by moving the optimized uprobes on top of 10-bytes nop instruction, so we can squeeze another instruction to escape the redzone area before doing the call, like:

lea -0x80(%rsp), %rsp
call tramp

Note the lea instruction is used to adjust the rsp register without changing the flags.

We use nop10 and following transofrmation to optimized instructions above and back as suggested by Peterz [2].

Optimize path (int3_update_optimize):

1) Initial state after set_swbp() installed the uprobe:

      cc 2e 0f 1f 84 00 00 00 00 00

     From offset 0 this is INT3 followed by the tail of the original
     10-byte NOP.

2) Trap the call slot before rewriting the NOP tail:
cc 2e 0f 1f 84 [cc] 00 00 00 00

From offset 0 this traps on the uprobe INT3. A thread reaching offset 5 traps on the temporary INT3 instead of seeing a partially patched call.

3) Rewrite the LEA tail and call displacement, keeping both INT3 bytes:
cc [8d 64 24 80] cc [d0 d1 d2 d3]

From offset 0 and offset 5 this still traps. The bytes between them are not executable entry points while both traps are in place.

4) Restore the call opcode at offset 5:
cc 8d 64 24 80 [e8] d0 d1 d2 d3

From offset 0 this still traps. From offset 5 the instruction is the final CALL to the uprobe trampoline.

5) Publish the first LEA byte:

      [48] 8d 64 24 80 e8 d0 d1 d2 d3

     From offset 0 this is:
        lea -0x80(%rsp), %rsp
        call <uprobe-trampoline>

Unoptimize path (int3_update_unoptimize):

1) Initial optimized state:
48 8d 64 24 80 e8 d0 d1 d2 d3
Same as 5) above.

2) Trap new entries before restoring the NOP bytes:
[cc] 8d 64 24 80 e8 d0 d1 d2 d3

From offset 0 this traps. A thread that had already executed the LEA can still reach the intact CALL at offset 5.

3) Restore bytes 1..4 of the original NOP while keeping byte 0 trapped and byte 5 as CALL.
cc [2e 0f 1f 84] e8 d0 d1 d2 d3

From offset 0 this still traps. Offset 5 is still the CALL for any thread that was already past the first LEA byte.

4) Publish the first byte of the original NOP:
[66] 2e 0f 1f 84 e8 d0 d1 d2 d3

From offset 0 this is the restored 10-byte NOP; the CALL opcode and displacement are now only NOP operands. Offset 5 still decodes as CALL for a thread that was already there.

Note as explained in [2] we need to use following nop10:
PF1 PF2 ESC NOPL MOD SIB DISP32
NOP10: 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 -- cs nopw 0x00000000(%rax,%rax,1)

which means we need to allow 0x2e prefix which maps to INAT_PFX_CS attribute in is_prefix_bad function.

The optimized uprobe performance stays the same:

        uprobe-nop     :    3.129 ± 0.013M/s
        uprobe-push    :    3.045 ± 0.006M/s
        uprobe-ret     :    1.095 ± 0.004M/s
  -->   uprobe-nop10   :    7.170 ± 0.020M/s
        uretprobe-nop  :    2.143 ± 0.021M/s
        uretprobe-push :    2.090 ± 0.000M/s
        uretprobe-ret  :    0.942 ± 0.000M/s
  -->   uretprobe-nop10:    3.381 ± 0.003M/s
        usdt-nop       :    3.245 ± 0.004M/s
  -->   usdt-nop10     :    7.256 ± 0.023M/s

[1] https://lore.kernel.org/bpf/[email protected]/
[2] https://lore.kernel.org/bpf/[email protected]/#t

Fixes ba2bfc97b462 ("uprobes/x86: Add support to optimize uprobes")
Assisted-by Codex:GPT-5.5
---
 arch/x86/kernel/uprobes.c | 281 +++++++++++++++++++++++++++++---------
 1 file changed, 217 insertions(+), 64 deletions(-)
arch/x86/kernel/uprobes.c +217 -64
index 11ec6b89b135..16d9c584b995 100644
@@ -266,7 +266,6 @@ static bool is_prefix_bad(struct insn *insn)
 		attr = inat_get_opcode_attribute(p);
 		switch (attr) {
 		case INAT_MAKE_PREFIX(INAT_PFX_ES):
-		case INAT_MAKE_PREFIX(INAT_PFX_CS):
 		case INAT_MAKE_PREFIX(INAT_PFX_DS):
 		case INAT_MAKE_PREFIX(INAT_PFX_SS):
 		case INAT_MAKE_PREFIX(INAT_PFX_LOCK):
@@ -631,9 +630,29 @@ static struct vm_special_mapping tramp_mapping = {
 	.pages  = tramp_mapping_pages,
 };
 
+
+#define LEA_INSN_SIZE		5
+#define OPT_INSN_SIZE		(LEA_INSN_SIZE + CALL_INSN_SIZE)
+#define REDZONE_SIZE		0x80
+
+static const u8 lea_rsp[] = { 0x48, 0x8d, 0x64, 0x24, 0x80 };
+
+static bool is_opt_insns(const uprobe_opcode_t *insn)
+{
+	return !memcmp(insn, lea_rsp, LEA_INSN_SIZE) &&
+	       insn[LEA_INSN_SIZE] == CALL_INSN_OPCODE;
+}
+
+static bool is_swbp_opt_insns(uprobe_opcode_t *insn)
+{
+	return is_swbp_insn(&insn[0]) &&
+	       !memcmp(&insn[1], &lea_rsp[1], LEA_INSN_SIZE - 1) &&
+	       insn[LEA_INSN_SIZE] == CALL_INSN_OPCODE;
+}
+
 static bool is_reachable_by_call(unsigned long vtramp, unsigned long vaddr)
 {
-	long delta = (long)(vaddr + 5 - vtramp);
+	long delta = (long)(vaddr + OPT_INSN_SIZE - vtramp);
 
 	return delta >= INT_MIN && delta <= INT_MAX;
 }
@@ -646,7 +665,7 @@ static unsigned long find_nearest_trampoline(unsigned long vaddr)
 	};
 	unsigned long low_limit, high_limit;
 	unsigned long low_tramp, high_tramp;
-	unsigned long call_end = vaddr + 5;
+	unsigned long call_end = vaddr + OPT_INSN_SIZE;
 
 	if (check_add_overflow(call_end, INT_MIN, &low_limit))
 		low_limit = PAGE_SIZE;
@@ -754,7 +773,7 @@ SYSCALL_DEFINE0(uprobe)
 
 	/* Allow execution only from uprobe trampolines. */
 	if (!in_uprobe_trampoline(regs->ip))
-		return -ENXIO;
+		return -EPROTO;
 
 	err = copy_from_user(&args, (void __user *)regs->sp, sizeof(args));
 	if (err)
@@ -770,8 +789,8 @@ SYSCALL_DEFINE0(uprobe)
 	regs->ax  = args.ax;
 	regs->r11 = args.r11;
 	regs->cx  = args.cx;
-	regs->ip  = args.retaddr - 5;
-	regs->sp += sizeof(args);
+	regs->ip  = args.retaddr - OPT_INSN_SIZE;
+	regs->sp += sizeof(args) + REDZONE_SIZE;
 	regs->orig_ax = -1;
 
 	sp = regs->sp;
@@ -788,12 +807,12 @@ SYSCALL_DEFINE0(uprobe)
 	 */
 	if (regs->sp != sp) {
 		/* skip the trampoline call */
-		if (args.retaddr - 5 == regs->ip)
-			regs->ip += 5;
+		if (args.retaddr - OPT_INSN_SIZE == regs->ip)
+			regs->ip += OPT_INSN_SIZE;
 		return regs->ax;
 	}
 
-	regs->sp -= sizeof(args);
+	regs->sp -= sizeof(args) + REDZONE_SIZE;
 
 	/* for the case uprobe_consumer has changed ax/r11/cx */
 	args.ax  = regs->ax;
@@ -801,7 +820,7 @@ SYSCALL_DEFINE0(uprobe)
 	args.cx  = regs->cx;
 
 	/* keep return address unless we are instructed otherwise */
-	if (args.retaddr - 5 != regs->ip)
+	if (args.retaddr - OPT_INSN_SIZE != regs->ip)
 		args.retaddr = regs->ip;
 
 	if (shstk_push(args.retaddr) == -EFAULT)
@@ -835,7 +854,7 @@ asm (
 	"pop %rax\n"
 	"pop %r11\n"
 	"pop %rcx\n"
-	"ret\n"
+	"ret $" __stringify(REDZONE_SIZE) "\n"
 	"int3\n"
 	".balign " __stringify(PAGE_SIZE) "\n"
 	".popsection\n"
@@ -853,7 +872,9 @@ late_initcall(arch_uprobes_init);
 
 enum {
 	EXPECT_SWBP,
-	EXPECT_CALL,
+	EXPECT_DUAL_SWBP,
+	EXPECT_OPTIMIZED,
+	EXPECT_SWBP_OPTIMIZED,
 };
 
 struct write_opcode_ctx {
@@ -861,30 +882,34 @@ struct write_opcode_ctx {
 	int expect;
 };
 
-static int is_call_insn(uprobe_opcode_t *insn)
-{
-	return *insn == CALL_INSN_OPCODE;
-}
-
 /*
- * Verification callback used by int3_update uprobe_write calls to make sure
- * the underlying instruction is as expected - either int3 or call.
+ * Verification callback used by uprobe_write calls to make sure the underlying
+ * instruction is in the expected stage of the INT3 update sequence.
  */
 static int verify_insn(struct page *page, unsigned long vaddr, uprobe_opcode_t *new_opcode,
 		       int nbytes, void *data)
 {
 	struct write_opcode_ctx *ctx = data;
-	uprobe_opcode_t old_opcode[5];
+	uprobe_opcode_t old_opcode[OPT_INSN_SIZE];
 
-	uprobe_copy_from_page(page, ctx->base, (uprobe_opcode_t *) &old_opcode, 5);
+	uprobe_copy_from_page(page, ctx->base, old_opcode, OPT_INSN_SIZE);
 
 	switch (ctx->expect) {
 	case EXPECT_SWBP:
 		if (is_swbp_insn(&old_opcode[0]))
 			return 1;
 		break;
-	case EXPECT_CALL:
-		if (is_call_insn(&old_opcode[0]))
+	case EXPECT_DUAL_SWBP:
+		if (is_swbp_insn(&old_opcode[0]) &&
+		    is_swbp_insn(&old_opcode[LEA_INSN_SIZE]))
+			return 1;
+		break;
+	case EXPECT_OPTIMIZED:
+		if (is_opt_insns(&old_opcode[0]))
+			return 1;
+		break;
+	case EXPECT_SWBP_OPTIMIZED:
+		if (is_swbp_opt_insns(&old_opcode[0]))
 			return 1;
 		break;
 	}
@@ -893,48 +918,134 @@ static int verify_insn(struct page *page, unsigned long vaddr, uprobe_opcode_t *
 }
 
 /*
- * Modify multi-byte instructions by using INT3 breakpoints on SMP.
+ * Modify the optimized instruction by using INT3 breakpoints on SMP.
  * We completely avoid using stop_machine() here, and achieve the
  * synchronization using INT3 breakpoints and SMP cross-calls.
  * (borrowed comment from smp_text_poke_batch_finish)
  *
- * The way it is done:
- *   - Add an INT3 trap to the address that will be patched
- *   - SMP sync all CPUs
- *   - Update all but the first byte of the patched range
- *   - SMP sync all CPUs
- *   - Replace the first byte (INT3) by the first byte of the replacing opcode
- *   - SMP sync all CPUs
+ * The way it is done for optimization (int3_update_optimize):
+ *   1) Start with the uprobe INT3 trap already installed
+ *   2) Add an INT3 trap to the call slot
+ *   3) Update everything but the first byte and the call opcode
+ *   4) Replace the call slot INT3 by the call opcode
+ *   5) Replace the first INT3 by the first byte of the LEA instruction
+ *
+ * The way it is done for unoptimization (int3_update_unoptimize):
+ *   1) Start with the optimized uprobe lea/call instructions
+ *   2) Add an INT3 trap to the address that will be patched
+ *   3) Restore the NOP bytes before the call opcode
+ *   4) Replace the first INT3 by the first byte of the NOP instruction
+ *
+ * Note that unoptimization deliberately keeps the call opcode and displacement
+ * in bytes 5..9. Those bytes become operands of the restored 10-byte NOP.
  */
-static int int3_update(struct arch_uprobe *auprobe, struct vm_area_struct *vma,
-		       unsigned long vaddr, char *insn, bool optimize)
+static int int3_update_optimize(struct arch_uprobe *auprobe, struct vm_area_struct *vma,
+				unsigned long vaddr, uprobe_opcode_t *insn)
 {
 	uprobe_opcode_t int3 = UPROBE_SWBP_INSN;
+	uprobe_opcode_t opt_int3[OPT_INSN_SIZE];
 	struct write_opcode_ctx ctx = {
 		.base = vaddr,
 	};
 	int err;
 
 	/*
-	 * Write int3 trap.
+	 * 1) Initial state after set_swbp() installed the uprobe:
+	 *    cc 2e 0f 1f 84 00 00 00 00 00
+	 */
+	smp_text_poke_sync_each_cpu();
+
+	/*
+	 * 2) Trap the call slot before rewriting the NOP tail:
+	 *    cc 2e 0f 1f 84 [cc] 00 00 00 00
+	 */
+	ctx.expect = EXPECT_SWBP;
+	err = uprobe_write(auprobe, vma, vaddr + LEA_INSN_SIZE, &int3, 1, verify_insn,
+			   true /* is_register */, false /* do_update_ref_ctr */,
+			   &ctx);
+	if (err)
+		return err;
+
+	smp_text_poke_sync_each_cpu();
+
+	memcpy(opt_int3, insn, OPT_INSN_SIZE);
+	opt_int3[LEA_INSN_SIZE] = UPROBE_SWBP_INSN;
+
+	/*
+	 * 3) Rewrite the LEA tail and call displacement, keeping both INT3 bytes:
+	 *    cc [8d 64 24 80] cc [d0 d1 d2 d3]
+	 */
+	ctx.expect = EXPECT_DUAL_SWBP;
+	err = uprobe_write(auprobe, vma, vaddr + 1, opt_int3 + 1,
+			   OPT_INSN_SIZE - 1, verify_insn,
+			   true /* is_register */, false /* do_update_ref_ctr */,
+			   &ctx);
+	if (err)
+		goto error;
+
+	smp_text_poke_sync_each_cpu();
+
+	/*
+	 * 4) Restore the call opcode at offset 5.
+	 *    cc 8d 64 24 80 [e8] d0 d1 d2 d3
+	 */
+	err = uprobe_write(auprobe, vma, vaddr + LEA_INSN_SIZE,
+			   insn + LEA_INSN_SIZE, 1, verify_insn,
+			   true /* is_register */, false /* do_update_ref_ctr */,
+			   &ctx);
+	if (err)
+		goto error;
+
+	smp_text_poke_sync_each_cpu();
+
+	/*
+	 * 5) Publish the first LEA byte:
+	 *    [48] 8d 64 24 80 e8 d0 d1 d2 d3
 	 *
-	 * The swbp_optimize path comes with breakpoint already installed,
-	 * so we can skip this step for optimize == true.
+	 *    From offset 0 this is:
+	 *      lea -0x80(%rsp), %rsp
+	 *      call <uprobe-trampoline>
 	 */
-	if (!optimize) {
-		ctx.expect = EXPECT_CALL;
-		err = uprobe_write(auprobe, vma, vaddr, &int3, 1, verify_insn,
-				   true /* is_register */, false /* do_update_ref_ctr */,
-				   &ctx);
-		if (err)
-			return err;
-	}
+	ctx.expect = EXPECT_SWBP_OPTIMIZED;
+	err = uprobe_write(auprobe, vma, vaddr, insn, 1, verify_insn,
+			   true /* is_register */, false /* do_update_ref_ctr */,
+			   &ctx);
+	if (err)
+		goto error;
 
 	smp_text_poke_sync_each_cpu();
+	return 0;
 
-	/* Write all but the first byte of the patched range. */
+error:
+	/*
+	 * In all intermediate states byte 0 is INT3, so EXPECT_SWBP covers every
+	 * case.  Restore original NOP bytes 1..9 in one write.
+	 */
 	ctx.expect = EXPECT_SWBP;
-	err = uprobe_write(auprobe, vma, vaddr + 1, insn + 1, 4, verify_insn,
+	uprobe_write(auprobe, vma, vaddr + 1, auprobe->insn + 1, OPT_INSN_SIZE - 1,
+		     verify_insn, true, false, &ctx);
+	smp_text_poke_sync_each_cpu();
+	return err;
+}
+
+static int int3_update_unoptimize(struct arch_uprobe *auprobe, struct vm_area_struct *vma,
+				  unsigned long vaddr, uprobe_opcode_t *insn)
+{
+	uprobe_opcode_t int3 = UPROBE_SWBP_INSN;
+	struct write_opcode_ctx ctx = {
+		.base = vaddr,
+		.expect = EXPECT_OPTIMIZED,
+	};
+	int err;
+
+	/*
+	 * 1) Initial optimized state:
+	 *    48 8d 64 24 80 e8 d0 d1 d2 d3
+	 *
+	 * 2) Trap new entries before restoring the NOP bytes:
+	 *    [cc] 8d 64 24 80 e8 d0 d1 d2 d3
+	 */
+	err = uprobe_write(auprobe, vma, vaddr, &int3, 1, verify_insn,
 			   true /* is_register */, false /* do_update_ref_ctr */,
 			   &ctx);
 	if (err)
@@ -943,13 +1054,31 @@ static int int3_update(struct arch_uprobe *auprobe, struct vm_area_struct *vma,
 	smp_text_poke_sync_each_cpu();
 
 	/*
-	 * Write first byte.
+	 * 3) Restore bytes 1..4 of the original NOP while keeping byte 0 trapped
+	 *    and byte 5 as CALL:
+	 *    cc [2e 0f 1f 84] e8 d0 d1 d2 d3
+	 */
+	ctx.expect = EXPECT_SWBP_OPTIMIZED;
+	err = uprobe_write(auprobe, vma, vaddr + 1, insn + 1,
+			   LEA_INSN_SIZE - 1, verify_insn,
+			   true /* is_register */, false /* do_update_ref_ctr */,
+			   &ctx);
+	if (err)
+		return err;
+
+	smp_text_poke_sync_each_cpu();
+
+	/*
+	 * 4) Publish the first byte of the original NOP:
+	 *    [66] 2e 0f 1f 84 e8 d0 d1 d2 d3
 	 *
-	 * The swbp_unoptimize needs to finish uprobe removal together
-	 * with ref_ctr update, using uprobe_write with proper flags.
+	 * From offset 0 this is the restored 10-byte NOP; the CALL opcode and
+	 * displacement are now only NOP operands.  Offset 5 still decodes as
+	 * CALL for a thread that was already there.
 	 */
+	ctx.expect = EXPECT_SWBP;
 	err = uprobe_write(auprobe, vma, vaddr, insn, 1, verify_insn,
-			   optimize /* is_register */, !optimize /* do_update_ref_ctr */,
+			   false /* is_register */, true /* do_update_ref_ctr */,
 			   &ctx);
 	if (err)
 		return err;
@@ -961,17 +1090,25 @@ static int int3_update(struct arch_uprobe *auprobe, struct vm_area_struct *vma,
 static int swbp_optimize(struct arch_uprobe *auprobe, struct vm_area_struct *vma,
 			 unsigned long vaddr, unsigned long tramp)
 {
-	u8 call[5];
+	u8 insn[OPT_INSN_SIZE], *call = &insn[LEA_INSN_SIZE];
 
-	__text_gen_insn(call, CALL_INSN_OPCODE, (const void *) vaddr,
+	/*
+	 * We have nop10 instruction (with first byte overwritten to int3),
+	 * changing it to:
+	 *   lea -0x80(%rsp), %rsp
+	 *   call tramp
+	 */
+	memcpy(insn, lea_rsp, LEA_INSN_SIZE);
+	__text_gen_insn(call, CALL_INSN_OPCODE,
+			(const void *) (vaddr + LEA_INSN_SIZE),
 			(const void *) tramp, CALL_INSN_SIZE);
-	return int3_update(auprobe, vma, vaddr, call, true /* optimize */);
+	return int3_update_optimize(auprobe, vma, vaddr, insn);
 }
 
 static int swbp_unoptimize(struct arch_uprobe *auprobe, struct vm_area_struct *vma,
 			   unsigned long vaddr)
 {
-	return int3_update(auprobe, vma, vaddr, auprobe->insn, false /* optimize */);
+	return int3_update_unoptimize(auprobe, vma, vaddr, auprobe->insn);
 }
 
 static int copy_from_vaddr(struct mm_struct *mm, unsigned long vaddr, void *dst, int len)
@@ -993,19 +1130,19 @@ static bool __is_optimized(struct mm_struct *mm, uprobe_opcode_t *insn, unsigned
 	struct __packed __arch_relative_insn {
 		u8 op;
 		s32 raddr;
-	} *call = (struct __arch_relative_insn *) insn;
+	} *call = (struct __arch_relative_insn *)(insn + LEA_INSN_SIZE);
 
-	if (!is_call_insn(insn))
+	if (!is_opt_insns(insn))
 		return false;
-	return __in_uprobe_trampoline(mm, vaddr + 5 + call->raddr);
+	return __in_uprobe_trampoline(mm, vaddr + OPT_INSN_SIZE + call->raddr);
 }
 
 static int is_optimized(struct mm_struct *mm, unsigned long vaddr)
 {
-	uprobe_opcode_t insn[5];
+	uprobe_opcode_t insn[OPT_INSN_SIZE];
 	int err;
 
-	err = copy_from_vaddr(mm, vaddr, &insn, 5);
+	err = copy_from_vaddr(mm, vaddr, &insn, OPT_INSN_SIZE);
 	if (err)
 		return err;
 	return __is_optimized(mm, (uprobe_opcode_t *)&insn, vaddr);
@@ -1069,7 +1206,7 @@ static int __arch_uprobe_optimize(struct arch_uprobe *auprobe, struct mm_struct
 void arch_uprobe_optimize(struct arch_uprobe *auprobe, unsigned long vaddr)
 {
 	struct mm_struct *mm = current->mm;
-	uprobe_opcode_t insn[5];
+	uprobe_opcode_t insn[OPT_INSN_SIZE];
 
 	if (!should_optimize(auprobe))
 		return;
@@ -1080,7 +1217,7 @@ void arch_uprobe_optimize(struct arch_uprobe *auprobe, unsigned long vaddr)
 	 * Check if some other thread already optimized the uprobe for us,
 	 * if it's the case just go away silently.
 	 */
-	if (copy_from_vaddr(mm, vaddr, &insn, 5))
+	if (copy_from_vaddr(mm, vaddr, &insn, OPT_INSN_SIZE))
 		goto unlock;
 	if (!is_swbp_insn((uprobe_opcode_t*) &insn))
 		goto unlock;
@@ -1096,16 +1233,32 @@ void arch_uprobe_optimize(struct arch_uprobe *auprobe, unsigned long vaddr)
 	mmap_write_unlock(mm);
 }
 
+static bool is_optimizable_nop10(struct insn *insn)
+{
+	static const u8 nop10_prefix[] = {
+		0x66, 0x2e, 0x0f, 0x1f, 0x84
+	};
+
+	/*
+	 * Restrict this to the 10-byte NOP form whose last 5 bytes are
+	 * SIB/displacement operands. Unoptimization keeps the call opcode and
+	 * displacement in those bytes, so other NOP encodings are not safe.
+	 */
+	return insn->length == OPT_INSN_SIZE &&
+	       insn_is_nop(insn) &&
+	       !memcmp(insn->kaddr, nop10_prefix, ARRAY_SIZE(nop10_prefix));
+}
+
 static bool can_optimize(struct insn *insn, unsigned long vaddr)
 {
-	if (!insn->x86_64 || insn->length != 5)
+	if (!insn->x86_64)
 		return false;
 
-	if (!insn_is_nop(insn))
+	if (!is_optimizable_nop10(insn))
 		return false;
 
 	/* We can't do cross page atomic writes yet. */
-	return PAGE_SIZE - (vaddr & ~PAGE_MASK) >= 5;
+	return PAGE_SIZE - (vaddr & ~PAGE_MASK) >= OPT_INSN_SIZE;
 }
 #else /* 32-bit: */
 /*
Signature · 1 line
2.53.0
maintainer
#11 lore raw

Re: [PATCHv3 04/12] uprobes/x86: Move optimized uprobe from nop5 to nop10

Quoted 113 lines · Jiri Olsa

Andrii reported an issue with optimized uprobes [1] that can clobber redzone area with call instruction storing return address on stack where user code may keep temporary data without adjusting rsp.

Fixing this by moving the optimized uprobes on top of 10-bytes nop instruction, so we can squeeze another instruction to escape the redzone area before doing the call, like:

lea -0x80(%rsp), %rsp
call tramp

Note the lea instruction is used to adjust the rsp register without changing the flags.

We use nop10 and following transofrmation to optimized instructions above and back as suggested by Peterz [2].

Optimize path (int3_update_optimize):

1) Initial state after set_swbp() installed the uprobe:

      cc 2e 0f 1f 84 00 00 00 00 00

     From offset 0 this is INT3 followed by the tail of the original
     10-byte NOP.

2) Trap the call slot before rewriting the NOP tail:
cc 2e 0f 1f 84 [cc] 00 00 00 00

From offset 0 this traps on the uprobe INT3. A thread reaching offset 5 traps on the temporary INT3 instead of seeing a partially patched call.

3) Rewrite the LEA tail and call displacement, keeping both INT3 bytes:
cc [8d 64 24 80] cc [d0 d1 d2 d3]

From offset 0 and offset 5 this still traps. The bytes between them are not executable entry points while both traps are in place.

4) Restore the call opcode at offset 5:
cc 8d 64 24 80 [e8] d0 d1 d2 d3

From offset 0 this still traps. From offset 5 the instruction is the final CALL to the uprobe trampoline.

5) Publish the first LEA byte:

      [48] 8d 64 24 80 e8 d0 d1 d2 d3

     From offset 0 this is:
        lea -0x80(%rsp), %rsp
        call <uprobe-trampoline>

Unoptimize path (int3_update_unoptimize):

1) Initial optimized state:
48 8d 64 24 80 e8 d0 d1 d2 d3
Same as 5) above.

2) Trap new entries before restoring the NOP bytes:
[cc] 8d 64 24 80 e8 d0 d1 d2 d3

From offset 0 this traps. A thread that had already executed the LEA can still reach the intact CALL at offset 5.

3) Restore bytes 1..4 of the original NOP while keeping byte 0 trapped and byte 5 as CALL.
cc [2e 0f 1f 84] e8 d0 d1 d2 d3

From offset 0 this still traps. Offset 5 is still the CALL for any thread that was already past the first LEA byte.

4) Publish the first byte of the original NOP:
[66] 2e 0f 1f 84 e8 d0 d1 d2 d3

From offset 0 this is the restored 10-byte NOP; the CALL opcode and displacement are now only NOP operands. Offset 5 still decodes as CALL for a thread that was already there.

Note as explained in [2] we need to use following nop10:
PF1 PF2 ESC NOPL MOD SIB DISP32
NOP10: 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 -- cs nopw 0x00000000(%rax,%rax,1)

which means we need to allow 0x2e prefix which maps to INAT_PFX_CS attribute in is_prefix_bad function.

The optimized uprobe performance stays the same:

        uprobe-nop     :    3.129 ± 0.013M/s
        uprobe-push    :    3.045 ± 0.006M/s
        uprobe-ret     :    1.095 ± 0.004M/s
  -->   uprobe-nop10   :    7.170 ± 0.020M/s
        uretprobe-nop  :    2.143 ± 0.021M/s
        uretprobe-push :    2.090 ± 0.000M/s
        uretprobe-ret  :    0.942 ± 0.000M/s
  -->   uretprobe-nop10:    3.381 ± 0.003M/s
        usdt-nop       :    3.245 ± 0.004M/s
  -->   usdt-nop10     :    7.256 ± 0.023M/s
arch/x86/kernel/uprobes.c +7 -0
@@ -893,48 +918,134 @@ static int verify_insn(struct page *page, unsigned long vaddr, uprobe_opcode_t *
 }
 
 /*
+ * Modify the optimized instruction by using INT3 breakpoints on SMP.
  * We completely avoid using stop_machine() here, and achieve the
  * synchronization using INT3 breakpoints and SMP cross-calls.
  * (borrowed comment from smp_text_poke_batch_finish)
  *
+ * The way it is done for optimization (int3_update_optimize):
+ *   1) Start with the uprobe INT3 trap already installed
+ *   2) Add an INT3 trap to the call slot
+ *   3) Update everything but the first byte and the call opcode
+ *   4) Replace the call slot INT3 by the call opcode
+ *   5) Replace the first INT3 by the first byte of the LEA instruction

arch/x86/kernel/uprobes.c static int verify_insn(struct page *page, unsigned long vaddr, uprobe_opcode_t * · line 941

Quoted 10 lines
arch/x86/kernel/uprobes.c +9 -0
+ *
+ * The way it is done for unoptimization (int3_update_unoptimize):
+ *   1) Start with the optimized uprobe lea/call instructions
+ *   2) Add an INT3 trap to the address that will be patched
+ *   3) Restore the NOP bytes before the call opcode
+ *   4) Replace the first INT3 by the first byte of the NOP instruction
+ *
+ * Note that unoptimization deliberately keeps the call opcode and displacement
+ * in bytes 5..9. Those bytes become operands of the restored 10-byte NOP.
  */

One important thing to note is that (as earlier noted by Andrii) the CALL address is never changed. A new optimization pass will not change the CALL instruction again.

If you noted this anywhere, I failed to find it. This is crucially important for the correctness of the scheme and should not be emitted.

That is, please add something like:

"Since there is only a single uprobe-trampoline, the CALL instruction will not be changed across unoptimization/optimization cycles. Therefore, any task that is preempted at the CALL instruction is guaranteed to observe that CALL and not anything else."

#12 lore raw

Re: [PATCHv3 04/12] uprobes/x86: Move optimized uprobe from nop5 to nop10

Quoted 132 lines · Peter Zijlstra
Quoted 113 lines · Jiri Olsa

Andrii reported an issue with optimized uprobes [1] that can clobber redzone area with call instruction storing return address on stack where user code may keep temporary data without adjusting rsp.

Fixing this by moving the optimized uprobes on top of 10-bytes nop instruction, so we can squeeze another instruction to escape the redzone area before doing the call, like:

lea -0x80(%rsp), %rsp
call tramp

Note the lea instruction is used to adjust the rsp register without changing the flags.

We use nop10 and following transofrmation to optimized instructions above and back as suggested by Peterz [2].

Optimize path (int3_update_optimize):

1) Initial state after set_swbp() installed the uprobe:

      cc 2e 0f 1f 84 00 00 00 00 00

     From offset 0 this is INT3 followed by the tail of the original
     10-byte NOP.

2) Trap the call slot before rewriting the NOP tail:
cc 2e 0f 1f 84 [cc] 00 00 00 00

From offset 0 this traps on the uprobe INT3. A thread reaching offset 5 traps on the temporary INT3 instead of seeing a partially patched call.

3) Rewrite the LEA tail and call displacement, keeping both INT3 bytes:
cc [8d 64 24 80] cc [d0 d1 d2 d3]

From offset 0 and offset 5 this still traps. The bytes between them are not executable entry points while both traps are in place.

4) Restore the call opcode at offset 5:
cc 8d 64 24 80 [e8] d0 d1 d2 d3

From offset 0 this still traps. From offset 5 the instruction is the final CALL to the uprobe trampoline.

5) Publish the first LEA byte:

      [48] 8d 64 24 80 e8 d0 d1 d2 d3

     From offset 0 this is:
        lea -0x80(%rsp), %rsp
        call <uprobe-trampoline>

Unoptimize path (int3_update_unoptimize):

1) Initial optimized state:
48 8d 64 24 80 e8 d0 d1 d2 d3
Same as 5) above.

2) Trap new entries before restoring the NOP bytes:
[cc] 8d 64 24 80 e8 d0 d1 d2 d3

From offset 0 this traps. A thread that had already executed the LEA can still reach the intact CALL at offset 5.

3) Restore bytes 1..4 of the original NOP while keeping byte 0 trapped and byte 5 as CALL.
cc [2e 0f 1f 84] e8 d0 d1 d2 d3

From offset 0 this still traps. Offset 5 is still the CALL for any thread that was already past the first LEA byte.

4) Publish the first byte of the original NOP:
[66] 2e 0f 1f 84 e8 d0 d1 d2 d3

From offset 0 this is the restored 10-byte NOP; the CALL opcode and displacement are now only NOP operands. Offset 5 still decodes as CALL for a thread that was already there.

Note as explained in [2] we need to use following nop10:
PF1 PF2 ESC NOPL MOD SIB DISP32
NOP10: 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 -- cs nopw 0x00000000(%rax,%rax,1)

which means we need to allow 0x2e prefix which maps to INAT_PFX_CS attribute in is_prefix_bad function.

The optimized uprobe performance stays the same:

        uprobe-nop     :    3.129 ± 0.013M/s
        uprobe-push    :    3.045 ± 0.006M/s
        uprobe-ret     :    1.095 ± 0.004M/s
  -->   uprobe-nop10   :    7.170 ± 0.020M/s
        uretprobe-nop  :    2.143 ± 0.021M/s
        uretprobe-push :    2.090 ± 0.000M/s
        uretprobe-ret  :    0.942 ± 0.000M/s
  -->   uretprobe-nop10:    3.381 ± 0.003M/s
        usdt-nop       :    3.245 ± 0.004M/s
  -->   usdt-nop10     :    7.256 ± 0.023M/s
arch/x86/kernel/uprobes.c +7 -0
@@ -893,48 +918,134 @@ static int verify_insn(struct page *page, unsigned long vaddr, uprobe_opcode_t *
 }
 
 /*
+ * Modify the optimized instruction by using INT3 breakpoints on SMP.
  * We completely avoid using stop_machine() here, and achieve the
  * synchronization using INT3 breakpoints and SMP cross-calls.
  * (borrowed comment from smp_text_poke_batch_finish)
  *
+ * The way it is done for optimization (int3_update_optimize):
+ *   1) Start with the uprobe INT3 trap already installed
+ *   2) Add an INT3 trap to the call slot
+ *   3) Update everything but the first byte and the call opcode
+ *   4) Replace the call slot INT3 by the call opcode
+ *   5) Replace the first INT3 by the first byte of the LEA instruction

arch/x86/kernel/uprobes.c static int verify_insn(struct page *page, unsigned long vaddr, uprobe_opcode_t * · line 941

Quoted 10 lines
arch/x86/kernel/uprobes.c +9 -0
+ *
+ * The way it is done for unoptimization (int3_update_unoptimize):
+ *   1) Start with the optimized uprobe lea/call instructions
+ *   2) Add an INT3 trap to the address that will be patched
+ *   3) Restore the NOP bytes before the call opcode
+ *   4) Replace the first INT3 by the first byte of the NOP instruction
+ *
+ * Note that unoptimization deliberately keeps the call opcode and displacement
+ * in bytes 5..9. Those bytes become operands of the restored 10-byte NOP.
  */

One important thing to note is that (as earlier noted by Andrii) the CALL address is never changed. A new optimization pass will not change the CALL instruction again.

If you noted this anywhere, I failed to find it. This is crucially important for the correctness of the scheme and should not be emitted.

Quoted 7 lines

That is, please add something like:

"Since there is only a single uprobe-trampoline, the CALL instruction will not be changed across unoptimization/optimization cycles. Therefore, any task that is preempted at the CALL instruction is guaranteed to observe that CALL and not anything else."

nope I did not mention it, will add

thanks,
jirka

#13 lore raw

Re: [PATCHv3 04/12] uprobes/x86: Move optimized uprobe from nop5 to nop10

In reply to Jiri Olsa
Quoted 36 lines · Jiri Olsa

Andrii reported an issue with optimized uprobes [1] that can clobber redzone area with call instruction storing return address on stack where user code may keep temporary data without adjusting rsp.

Fixing this by moving the optimized uprobes on top of 10-bytes nop instruction, so we can squeeze another instruction to escape the redzone area before doing the call, like:

lea -0x80(%rsp), %rsp
call tramp

Note the lea instruction is used to adjust the rsp register without changing the flags.

We use nop10 and following transofrmation to optimized instructions above and back as suggested by Peterz [2].

Optimize path (int3_update_optimize):

1) Initial state after set_swbp() installed the uprobe:

      cc 2e 0f 1f 84 00 00 00 00 00

     From offset 0 this is INT3 followed by the tail of the original
     10-byte NOP.

2) Trap the call slot before rewriting the NOP tail:
cc 2e 0f 1f 84 [cc] 00 00 00 00

From offset 0 this traps on the uprobe INT3. A thread reaching offset 5 traps on the temporary INT3 instead of seeing a partially patched call.

3) Rewrite the LEA tail and call displacement, keeping both INT3 bytes:
cc [8d 64 24 80] cc [d0 d1 d2 d3]

Quoted 9 lines

From offset 0 and offset 5 this still traps. The bytes between them are not executable entry points while both traps are in place.

4) Restore the call opcode at offset 5:
cc 8d 64 24 80 [e8] d0 d1 d2 d3

From offset 0 this still traps. From offset 5 the instruction is the final CALL to the uprobe trampoline.

I'm sorry if I'm slow, but I don't understand why we need that second cc at offset 5? Isn't original nop10 processed by CPU as single instruction? So it will either be at ip of nop10, or at ip+10, no? If we trap at ip and in int3 handler +10 from there while we are installing lea+call, why do we need cc on byte 5?

I.e., I don't understand how CPU can end up being at ip+5 until we finalize lea+call sequence? Can it?

Quoted 26 lines

5) Publish the first LEA byte:

      [48] 8d 64 24 80 e8 d0 d1 d2 d3

     From offset 0 this is:
        lea -0x80(%rsp), %rsp
        call <uprobe-trampoline>

Unoptimize path (int3_update_unoptimize):

1) Initial optimized state:
48 8d 64 24 80 e8 d0 d1 d2 d3
Same as 5) above.

2) Trap new entries before restoring the NOP bytes:
[cc] 8d 64 24 80 e8 d0 d1 d2 d3

From offset 0 this traps. A thread that had already executed the LEA can still reach the intact CALL at offset 5.

3) Restore bytes 1..4 of the original NOP while keeping byte 0 trapped and byte 5 as CALL.
cc [2e 0f 1f 84] e8 d0 d1 d2 d3

From offset 0 this still traps. Offset 5 is still the CALL for any thread that was already past the first LEA byte.

Quoted 6 lines

4) Publish the first byte of the original NOP:
[66] 2e 0f 1f 84 e8 d0 d1 d2 d3

From offset 0 this is the restored 10-byte NOP; the CALL opcode and displacement are now only NOP operands. Offset 5 still decodes as CALL for a thread that was already there.

it's cool that we don't have to do jmp for the first byte, fancy :)

Quoted 32 lines

Note as explained in [2] we need to use following nop10:
PF1 PF2 ESC NOPL MOD SIB DISP32
NOP10: 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 -- cs nopw 0x00000000(%rax,%rax,1)

which means we need to allow 0x2e prefix which maps to INAT_PFX_CS attribute in is_prefix_bad function.

The optimized uprobe performance stays the same:

        uprobe-nop     :    3.129 ± 0.013M/s
        uprobe-push    :    3.045 ± 0.006M/s
        uprobe-ret     :    1.095 ± 0.004M/s
  -->   uprobe-nop10   :    7.170 ± 0.020M/s
        uretprobe-nop  :    2.143 ± 0.021M/s
        uretprobe-push :    2.090 ± 0.000M/s
        uretprobe-ret  :    0.942 ± 0.000M/s
  -->   uretprobe-nop10:    3.381 ± 0.003M/s
        usdt-nop       :    3.245 ± 0.004M/s
  -->   usdt-nop10     :    7.256 ± 0.023M/s

[1] https://lore.kernel.org/bpf/[email protected]/
[2] https://lore.kernel.org/bpf/[email protected]/#t

Fixes ba2bfc97b462 ("uprobes/x86: Add support to optimize uprobes")
Assisted-by Codex:GPT-5.5
---
 arch/x86/kernel/uprobes.c | 281 +++++++++++++++++++++++++++++---------
 1 file changed, 217 insertions(+), 64 deletions(-)

[...]

#14 lore raw

Re: [PATCHv3 04/12] uprobes/x86: Move optimized uprobe from nop5 to nop10

Quoted 47 lines · Andrii Nakryiko
Quoted 36 lines · Jiri Olsa

Andrii reported an issue with optimized uprobes [1] that can clobber redzone area with call instruction storing return address on stack where user code may keep temporary data without adjusting rsp.

Fixing this by moving the optimized uprobes on top of 10-bytes nop instruction, so we can squeeze another instruction to escape the redzone area before doing the call, like:

lea -0x80(%rsp), %rsp
call tramp

Note the lea instruction is used to adjust the rsp register without changing the flags.

We use nop10 and following transofrmation to optimized instructions above and back as suggested by Peterz [2].

Optimize path (int3_update_optimize):

1) Initial state after set_swbp() installed the uprobe:

      cc 2e 0f 1f 84 00 00 00 00 00

     From offset 0 this is INT3 followed by the tail of the original
     10-byte NOP.

2) Trap the call slot before rewriting the NOP tail:
cc 2e 0f 1f 84 [cc] 00 00 00 00

From offset 0 this traps on the uprobe INT3. A thread reaching offset 5 traps on the temporary INT3 instead of seeing a partially patched call.

3) Rewrite the LEA tail and call displacement, keeping both INT3 bytes:
cc [8d 64 24 80] cc [d0 d1 d2 d3]

Quoted 9 lines

From offset 0 and offset 5 this still traps. The bytes between them are not executable entry points while both traps are in place.

4) Restore the call opcode at offset 5:
cc 8d 64 24 80 [e8] d0 d1 d2 d3

From offset 0 this still traps. From offset 5 the instruction is the final CALL to the uprobe trampoline.

Quoted 8 lines

I'm sorry if I'm slow, but I don't understand why we need that second cc at offset 5? Isn't original nop10 processed by CPU as single instruction? So it will either be at ip of nop10, or at ip+10, no? If we trap at ip and in int3 handler +10 from there while we are installing lea+call, why do we need cc on byte 5?

I.e., I don't understand how CPU can end up being at ip+5 until we finalize lea+call sequence? Can it?

hum, so I though it's for the case when you do unoptimize+optimize, then you can have cpu executing the previous lea and hitting the int3 on +5 offset.. but as pointed by Peter (and you) the call instruction never changes, so now I'm not sure why we need it

jirka

maintainer
#15 lore raw

Re: [PATCHv3 04/12] uprobes/x86: Move optimized uprobe from nop5 to nop10

Quoted 54 lines · Jiri Olsa
Quoted 53 lines · Andrii Nakryiko
Quoted 36 lines · Jiri Olsa

Andrii reported an issue with optimized uprobes [1] that can clobber redzone area with call instruction storing return address on stack where user code may keep temporary data without adjusting rsp.

Fixing this by moving the optimized uprobes on top of 10-bytes nop instruction, so we can squeeze another instruction to escape the redzone area before doing the call, like:

lea -0x80(%rsp), %rsp
call tramp

Note the lea instruction is used to adjust the rsp register without changing the flags.

We use nop10 and following transofrmation to optimized instructions above and back as suggested by Peterz [2].

Optimize path (int3_update_optimize):

1) Initial state after set_swbp() installed the uprobe:

      cc 2e 0f 1f 84 00 00 00 00 00

     From offset 0 this is INT3 followed by the tail of the original
     10-byte NOP.

2) Trap the call slot before rewriting the NOP tail:
cc 2e 0f 1f 84 [cc] 00 00 00 00

From offset 0 this traps on the uprobe INT3. A thread reaching offset 5 traps on the temporary INT3 instead of seeing a partially patched call.

3) Rewrite the LEA tail and call displacement, keeping both INT3 bytes:
cc [8d 64 24 80] cc [d0 d1 d2 d3]

Quoted 9 lines

From offset 0 and offset 5 this still traps. The bytes between them are not executable entry points while both traps are in place.

4) Restore the call opcode at offset 5:
cc 8d 64 24 80 [e8] d0 d1 d2 d3

From offset 0 this still traps. From offset 5 the instruction is the final CALL to the uprobe trampoline.

I'm sorry if I'm slow, but I don't understand why we need that second cc at offset 5? Isn't original nop10 processed by CPU as single instruction? So it will either be at ip of nop10, or at ip+10, no? If we trap at ip and in int3 handler +10 from there while we are installing lea+call, why do we need cc on byte 5?

Quoted 7 lines
Quoted 2 lines

I.e., I don't understand how CPU can end up being at ip+5 until we finalize lea+call sequence? Can it?

hum, so I though it's for the case when you do unoptimize+optimize, then you can have cpu executing the previous lea and hitting the int3 on +5 offset.. but as pointed by Peter (and you) the call instruction never changes, so now I'm not sure why we need it

So I missed you did the second INT3 in my initial reading.

That second INT3 is absolutely required *IF* the CALL can ever change. However Andrii pointed out that once the CALL is written, it will always be the same CALL -- there is but the one trampoline, it doesn't move.

Therefore, the second INT3 is not strictly required.

Does this clarify?

#16 lore raw

Re: [PATCHv3 04/12] uprobes/x86: Move optimized uprobe from nop5 to nop10

Quoted 65 lines · Peter Zijlstra
Quoted 54 lines · Jiri Olsa
Quoted 53 lines · Andrii Nakryiko
Quoted 36 lines · Jiri Olsa

Andrii reported an issue with optimized uprobes [1] that can clobber redzone area with call instruction storing return address on stack where user code may keep temporary data without adjusting rsp.

Fixing this by moving the optimized uprobes on top of 10-bytes nop instruction, so we can squeeze another instruction to escape the redzone area before doing the call, like:

lea -0x80(%rsp), %rsp
call tramp

Note the lea instruction is used to adjust the rsp register without changing the flags.

We use nop10 and following transofrmation to optimized instructions above and back as suggested by Peterz [2].

Optimize path (int3_update_optimize):

1) Initial state after set_swbp() installed the uprobe:

      cc 2e 0f 1f 84 00 00 00 00 00

     From offset 0 this is INT3 followed by the tail of the original
     10-byte NOP.

2) Trap the call slot before rewriting the NOP tail:
cc 2e 0f 1f 84 [cc] 00 00 00 00

From offset 0 this traps on the uprobe INT3. A thread reaching offset 5 traps on the temporary INT3 instead of seeing a partially patched call.

3) Rewrite the LEA tail and call displacement, keeping both INT3 bytes:
cc [8d 64 24 80] cc [d0 d1 d2 d3]

Quoted 9 lines

From offset 0 and offset 5 this still traps. The bytes between them are not executable entry points while both traps are in place.

4) Restore the call opcode at offset 5:
cc 8d 64 24 80 [e8] d0 d1 d2 d3

From offset 0 this still traps. From offset 5 the instruction is the final CALL to the uprobe trampoline.

I'm sorry if I'm slow, but I don't understand why we need that second cc at offset 5? Isn't original nop10 processed by CPU as single instruction? So it will either be at ip of nop10, or at ip+10, no? If we trap at ip and in int3 handler +10 from there while we are installing lea+call, why do we need cc on byte 5?

Quoted 7 lines
Quoted 2 lines

I.e., I don't understand how CPU can end up being at ip+5 until we finalize lea+call sequence? Can it?

hum, so I though it's for the case when you do unoptimize+optimize, then you can have cpu executing the previous lea and hitting the int3 on +5 offset.. but as pointed by Peter (and you) the call instruction never changes, so now I'm not sure why we need it

So I missed you did the second INT3 in my initial reading.

Quoted 7 lines

That second INT3 is absolutely required *IF* the CALL can ever change. However Andrii pointed out that once the CALL is written, it will always be the same CALL -- there is but the one trampoline, it doesn't move.

Therefore, the second INT3 is not strictly required.

Does this clarify?

yes, will change that in next version

thanks,
jirka

author reviewer
#17 lore raw

PATCH v3 5/12 libbpf: Change has_nop_combo to work on top of nop10

In reply to Jiri Olsa

We now expect nop combo with 10 bytes nop instead of 5 bytes nop, fixing has_nop_combo to reflect that.

Fixes 41a5c7df4466 ("libbpf: Add support to detect nop,nop5 instructions combo for usdt probe")
---
 tools/lib/bpf/usdt.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)
tools/lib/bpf/usdt.c +8 -8
index e3710933fd52..484a4354e82b 100644
@@ -305,7 +305,7 @@ struct usdt_manager *usdt_manager_new(struct bpf_object *obj)
 
 	/*
 	 * Detect kernel support for uprobe() syscall, it's presence means we can
-	 * take advantage of faster nop5 uprobe handling.
+	 * take advantage of faster nop10 uprobe handling.
 	 * Added in: 56101b69c919 ("uprobes/x86: Add uprobe syscall to speed up uprobe")
 	 */
 	man->has_uprobe_syscall = kernel_supports(obj, FEAT_UPROBE_SYSCALL);
@@ -596,14 +596,14 @@ static int parse_usdt_spec(struct usdt_spec *spec, const struct usdt_note *note,
 #if defined(__x86_64__)
 static bool has_nop_combo(int fd, long off)
 {
-	unsigned char nop_combo[6] = {
-		0x90, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nop,nop5 */
+	unsigned char nop_combo[11] = {
+		0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
 	};
-	unsigned char buf[6];
+	unsigned char buf[11];
 
-	if (pread(fd, buf, 6, off) != 6)
+	if (pread(fd, buf, 11, off) != 11)
 		return false;
-	return memcmp(buf, nop_combo, 6) == 0;
+	return memcmp(buf, nop_combo, 11) == 0;
 }
 #else
 static bool has_nop_combo(int fd, long off)
@@ -814,8 +814,8 @@ static int collect_usdt_targets(struct usdt_manager *man, struct elf_fd *elf_fd,
 		memset(target, 0, sizeof(*target));
 
 		/*
-		 * We have uprobe syscall and usdt with nop,nop5 instructions combo,
-		 * so we can place the uprobe directly on nop5 (+1) and get this probe
+		 * We have uprobe syscall and usdt with nop,nop10 instructions combo,
+		 * so we can place the uprobe directly on nop10 (+1) and get this probe
 		 * optimized.
 		 */
 		if (man->has_uprobe_syscall && has_nop_combo(elf_fd->fd, usdt_rel_ip)) {
Signature · 1 line
2.53.0
#18 lore raw

Re: [PATCHv3 05/12] libbpf: Change has_nop_combo to work on top of nop10

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Replacing the 5-byte nop check entirely with a 10-byte nop check silently degrades tracing…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Replacing the 5-byte nop check entirely with a 10-byte nop check silently degrades tracing performance for existing compiled binaries and causes BPF selftest failures. --

commit 9ee5f26b2092c13d658ca6962b0ca9bbe4cfe44a
Author: Jiri Olsa <[email protected]>

libbpf: Change has_nop_combo to work on top of nop10

This commit modifies the has_nop_combo() function to detect an 11-byte nop sequence rather than a 6-byte nop sequence to optimize uprobe handling.

Quoted 4 lines
tools/lib/bpf/usdt.c +0 -0
index e3710933fd52a..484a4354e82ba 100644

[ ... ]

tools/lib/bpf/usdt.c static int parse_usdt_spec(struct usdt_spec *spec, const struct usdt_note *note, · line 601

Quoted 9 lines
tools/lib/bpf/usdt.c +2 -2
@@ -596,14 +596,14 @@ static int parse_usdt_spec(struct usdt_spec *spec, const struct usdt_note *note,
 #if defined(__x86_64__)
 static bool has_nop_combo(int fd, long off)
 {
-	unsigned char nop_combo[6] = {
-		0x90, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nop,nop5 */
+	unsigned char nop_combo[11] = {
+		0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
 	};

[Severity: Medium]
Will this drop support for older compiled binaries and cause BPF selftests to fail?

By completely replacing the 5-byte nop check rather than supporting both, it looks like legacy binaries will silently fall back to unoptimized uprobes on the first byte, which could degrade tracing performance.

Additionally, tools/testing/selftests/bpf/usdt.h still seems to define USDT_NOP using the 6-byte sequence (0x90, 0x0f, 0x1f, 0x44, 0x00, 0x00). Could this cause subtest_optimized_attach() in prog_tests/usdt.c to fail its assertions, since the +1 offset for the nop5 instruction will no longer be applied during testing?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Acked-by on v3 5/12
#19 lore raw

Re: [PATCHv3 05/12] libbpf: Change has_nop_combo to work on top of nop10

In reply to Jiri Olsa
Quoted 16 lines · Jiri Olsa

We now expect nop combo with 10 bytes nop instead of 5 bytes nop, fixing has_nop_combo to reflect that.

Fixes 41a5c7df4466 ("libbpf: Add support to detect nop,nop5 instructions combo for usdt probe")
---
 tools/lib/bpf/usdt.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)
tools/lib/bpf/usdt.c +0 -0
index e3710933fd52..484a4354e82b 100644

tools/lib/bpf/usdt.c struct usdt_manager *usdt_manager_new(struct bpf_object *obj) · line 309

Quoted 6 lines
tools/lib/bpf/usdt.c +1 -1
@@ -305,7 +305,7 @@ struct usdt_manager *usdt_manager_new(struct bpf_object *obj)
 
        /*
         * Detect kernel support for uprobe() syscall, it's presence means we can
-        * take advantage of faster nop5 uprobe handling.
+        * take advantage of faster nop10 uprobe handling.
         * Added in: 56101b69c919 ("uprobes/x86: Add uprobe syscall to speed up uprobe")

Would be nice to add commit that switches nop5 to nop10 (but until it lands hash is not stable, so, hmmm, maybe we'll land this patch separately? send it a bit later to bpf-next?)

but otherwise lgtm

Quoted 36 lines
tools/lib/bpf/usdt.c +7 -8
         */
        man->has_uprobe_syscall = kernel_supports(obj, FEAT_UPROBE_SYSCALL);
@@ -596,14 +596,14 @@ static int parse_usdt_spec(struct usdt_spec *spec, const struct usdt_note *note,
 #if defined(__x86_64__)
 static bool has_nop_combo(int fd, long off)
 {
-       unsigned char nop_combo[6] = {
-               0x90, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nop,nop5 */
+       unsigned char nop_combo[11] = {
+               0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
        };
-       unsigned char buf[6];
+       unsigned char buf[11];
 
-       if (pread(fd, buf, 6, off) != 6)
+       if (pread(fd, buf, 11, off) != 11)
                return false;
-       return memcmp(buf, nop_combo, 6) == 0;
+       return memcmp(buf, nop_combo, 11) == 0;
 }
 #else
 static bool has_nop_combo(int fd, long off)
@@ -814,8 +814,8 @@ static int collect_usdt_targets(struct usdt_manager *man, struct elf_fd *elf_fd,
                memset(target, 0, sizeof(*target));
 
                /*
-                * We have uprobe syscall and usdt with nop,nop5 instructions combo,
-                * so we can place the uprobe directly on nop5 (+1) and get this probe
+                * We have uprobe syscall and usdt with nop,nop10 instructions combo,
+                * so we can place the uprobe directly on nop10 (+1) and get this probe
                 * optimized.
                 */
                if (man->has_uprobe_syscall && has_nop_combo(elf_fd->fd, usdt_rel_ip)) {
--

2.53.0

#20 lore raw

Re: [PATCHv3 05/12] libbpf: Change has_nop_combo to work on top of nop10

Quoted 18 lines · Andrii Nakryiko
Quoted 17 lines · Jiri Olsa

We now expect nop combo with 10 bytes nop instead of 5 bytes nop, fixing has_nop_combo to reflect that.

Fixes 41a5c7df4466 ("libbpf: Add support to detect nop,nop5 instructions combo for usdt probe")
---
 tools/lib/bpf/usdt.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)
tools/lib/bpf/usdt.c +0 -0
index e3710933fd52..484a4354e82b 100644
@@ -305,7 +305,7 @@ struct usdt_manager *usdt_manager_new(struct bpf_object *obj)
 
Quoted 9 lines

tools/lib/bpf/usdt.c struct usdt_manager *usdt_manager_new(struct bpf_object *obj) · line 309

Quoted 5 lines
tools/lib/bpf/usdt.c +1 -1
        /*
         * Detect kernel support for uprobe() syscall, it's presence means we can
-        * take advantage of faster nop5 uprobe handling.
+        * take advantage of faster nop10 uprobe handling.
         * Added in: 56101b69c919 ("uprobes/x86: Add uprobe syscall to speed up uprobe")

Would be nice to add commit that switches nop5 to nop10 (but until it lands hash is not stable, so, hmmm, maybe we'll land this patch separately? send it a bit later to bpf-next?)

hm, I think that would affect the subtest_optimized_attach usdt test which depend on this behaviour, will check

jirka

Quoted 42 lines

but otherwise lgtm

Quoted 36 lines
tools/lib/bpf/usdt.c +7 -8
         */
        man->has_uprobe_syscall = kernel_supports(obj, FEAT_UPROBE_SYSCALL);
@@ -596,14 +596,14 @@ static int parse_usdt_spec(struct usdt_spec *spec, const struct usdt_note *note,
 #if defined(__x86_64__)
 static bool has_nop_combo(int fd, long off)
 {
-       unsigned char nop_combo[6] = {
-               0x90, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nop,nop5 */
+       unsigned char nop_combo[11] = {
+               0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
        };
-       unsigned char buf[6];
+       unsigned char buf[11];
 
-       if (pread(fd, buf, 6, off) != 6)
+       if (pread(fd, buf, 11, off) != 11)
                return false;
-       return memcmp(buf, nop_combo, 6) == 0;
+       return memcmp(buf, nop_combo, 11) == 0;
 }
 #else
 static bool has_nop_combo(int fd, long off)
@@ -814,8 +814,8 @@ static int collect_usdt_targets(struct usdt_manager *man, struct elf_fd *elf_fd,
                memset(target, 0, sizeof(*target));
 
                /*
-                * We have uprobe syscall and usdt with nop,nop5 instructions combo,
-                * so we can place the uprobe directly on nop5 (+1) and get this probe
+                * We have uprobe syscall and usdt with nop,nop10 instructions combo,
+                * so we can place the uprobe directly on nop10 (+1) and get this probe
                 * optimized.
                 */
                if (man->has_uprobe_syscall && has_nop_combo(elf_fd->fd, usdt_rel_ip)) {
--

2.53.0

#21 lore raw

Re: [PATCHv3 05/12] libbpf: Change has_nop_combo to work on top of nop10

Quoted 29 lines · Jiri Olsa
Quoted 18 lines · Andrii Nakryiko
Quoted 17 lines · Jiri Olsa

We now expect nop combo with 10 bytes nop instead of 5 bytes nop, fixing has_nop_combo to reflect that.

Fixes 41a5c7df4466 ("libbpf: Add support to detect nop,nop5 instructions combo for usdt probe")
---
 tools/lib/bpf/usdt.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)
tools/lib/bpf/usdt.c +0 -0
index e3710933fd52..484a4354e82b 100644
@@ -305,7 +305,7 @@ struct usdt_manager *usdt_manager_new(struct bpf_object *obj)
 
Quoted 9 lines

tools/lib/bpf/usdt.c struct usdt_manager *usdt_manager_new(struct bpf_object *obj) · line 309

Quoted 5 lines
tools/lib/bpf/usdt.c +1 -1
        /*
         * Detect kernel support for uprobe() syscall, it's presence means we can
-        * take advantage of faster nop5 uprobe handling.
+        * take advantage of faster nop10 uprobe handling.
         * Added in: 56101b69c919 ("uprobes/x86: Add uprobe syscall to speed up uprobe")

Would be nice to add commit that switches nop5 to nop10 (but until it lands hash is not stable, so, hmmm, maybe we'll land this patch separately? send it a bit later to bpf-next?)

Quoted 2 lines

hm, I think that would affect the subtest_optimized_attach usdt test which depend on this behaviour, will check

usdt/optimized_attach will fail without this change, I'll make note to update it later when we have the hash

jirka

author reviewer
#22 lore raw

PATCH v3 6/12 libbpf: Detect uprobe syscall with new error

In reply to Jiri Olsa

In the previous optimized uprobe fix we changed the syscall error used for its detection from ENXIO to EPROTO.

Changing related probe_uprobe_syscall detection check.

Fixes 05738da0efa1 ("libbpf: Add uprobe syscall feature detection")
---
 tools/lib/bpf/features.c                                | 4 ++--
 tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
tools/lib/bpf/features.c +2 -2
index b7e388f99d0b..e5641fa60163 100644
@@ -577,10 +577,10 @@ static int probe_ldimm64_full_range_off(int token_fd)
 static int probe_uprobe_syscall(int token_fd)
 {
 	/*
-	 * If kernel supports uprobe() syscall, it will return -ENXIO when called
+	 * If kernel supports uprobe() syscall, it will return -EPROTO when called
 	 * from the outside of a kernel-generated uprobe trampoline.
 	 */
-	return syscall(__NR_uprobe) < 0 && errno == ENXIO;
+	return syscall(__NR_uprobe) < 0 && errno == EPROTO;
 }
 #else
 static int probe_uprobe_syscall(int token_fd)
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +1 -1
index 955a37751b52..c944136252c6 100644
@@ -762,7 +762,7 @@ static void test_uprobe_error(void)
 	long err = syscall(__NR_uprobe);
 
 	ASSERT_EQ(err, -1, "error");
-	ASSERT_EQ(errno, ENXIO, "errno");
+	ASSERT_EQ(errno, EPROTO, "errno");
 }
 
 static void __test_uprobe_syscall(void)
Signature · 1 line
2.53.0
#23 lore raw

Re: [PATCHv3 06/12] libbpf: Detect uprobe syscall with new error

The Fixes tag points to commit 05738da0efa1 ("libbpf: Add uprobe syscall feature detection"), but wasn't the bug actually introduced by commit 40b54d7e3dab ("uprobes/x86: Move optimized uprobe from…
Quoted 6 lines

commit adef46acd6e910a58509f054ca1d94c79b4c2bf2

Author: Jiri Olsa <[email protected]>
Date:   Thu May 21 14:44:05 2026 +0200

libbpf: Detect uprobe syscall with new error

Quoted 8 lines

In the previous optimized uprobe fix we changed the syscall error used for its detection from ENXIO to EPROTO.

Changing related probe_uprobe_syscall detection check.

Fixes 05738da0efa1 ("libbpf: Add uprobe syscall feature detection")

The Fixes tag points to commit 05738da0efa1 ("libbpf: Add uprobe syscall feature detection"), but wasn't the bug actually introduced by commit 40b54d7e3dab ("uprobes/x86: Move optimized uprobe from nop5 to nop10")?

Commit 05738da0efa1 originally added the ENXIO check correctly, but commit 40b54d7e3dab changed the kernel to return EPROTO instead of ENXIO, breaking the libbpf detection.

The commit message even says "In the previous optimized uprobe fix we changed the syscall error," which refers to 40b54d7e3dab.

Should this use:

Fixes 40b54d7e3dab ("uprobes/x86: Move optimized uprobe from nop5 to nop10")

This concern was previously raised in review by [email protected] on Mon, 18 May 2026 11:37:54 +0000:

https://lore.kernel.org/bpf/545ca16cc113f00a390baf1ffcafba33233af771fc7c879e3c850bb33949da29@mail.kernel.org/

Quoted 7 lines
tools/lib/bpf/features.c +0 -0
index b7e388f99d0b..e5641fa60163 100644
@@ -577,10 +577,10 @@ static int probe_ldimm64_full_range_off(int token_fd)
 static int probe_uprobe_syscall(int token_fd)
 {

tools/lib/bpf/features.c static int probe_ldimm64_full_range_off(int token_fd) · line 586

Quoted 10 lines
tools/lib/bpf/features.c +2 -2
 	/*
-	 * If kernel supports uprobe() syscall, it will return -ENXIO when called
+	 * If kernel supports uprobe() syscall, it will return -EPROTO when called
 	 * from the outside of a kernel-generated uprobe trampoline.
 	 */
-	return syscall(__NR_uprobe) < 0 && errno == ENXIO;
+	return syscall(__NR_uprobe) < 0 && errno == EPROTO;
 }
 #else
 static int probe_uprobe_syscall(int token_fd)

[ ... ]

---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md

CI run summary: https://github.com/kernel-patches/bpf/actions/runs/26227520868

#24 lore raw

Re: [PATCHv3 06/12] libbpf: Detect uprobe syscall with new error

In reply to Jiri Olsa
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Missing kernel-side dependency causes selftest failure and feature detection breakage --

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Missing kernel-side dependency causes selftest failure and feature detection breakage --

commit 2bfbf90e3446befa63868457a72590c57c20d562
Author: Jiri Olsa <[email protected]>

libbpf: Detect uprobe syscall with new error

This commit updates libbpf feature detection and selftests to expect EPROTO instead of ENXIO when the uprobe syscall is called outside a kernel-generated uprobe trampoline.

Quoted 5 lines
tools/lib/bpf/features.c +0 -0
index 4f19a0d79b0cf..a37aaea5253e5 100644

tools/lib/bpf/features.c static int probe_ldimm64_full_range_off(int token_fd) · line 583

Quoted 9 lines
tools/lib/bpf/features.c +2 -2
@@ -577,10 +577,10 @@ static int probe_ldimm64_full_range_off(int token_fd)
 static int probe_uprobe_syscall(int token_fd)
 {
 	/*
-	 * If kernel supports uprobe() syscall, it will return -ENXIO when called
+	 * If kernel supports uprobe() syscall, it will return -EPROTO when called
 	 * from the outside of a kernel-generated uprobe trampoline.
 	 */
-	return syscall(__NR_uprobe) < 0 && errno == ENXIO;
+	return syscall(__NR_uprobe) < 0 && errno == EPROTO;

[Severity: High]
Is this patch missing a kernel-side dependency? Looking at the current kernel tree in arch/x86/kernel/uprobes.c, SYSCALL_DEFINE0(uprobe) still explicitly returns -ENXIO:

if (!in_uprobe_trampoline(regs->ip))

        return -ENXIO;

Without the corresponding kernel patch to change this to -EPROTO, will this cause libbpf to incorrectly conclude that the uprobe syscall is unsupported, and cause the updated selftests below to fail?

Quoted 1 line
tools/lib/bpf/features.c +0 -0
 }

[ ... ]

Quoted 11 lines
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +1 -1
index 955a37751b52d..c944136252c6d 100644
@@ -762,7 +762,7 @@ static void test_uprobe_error(void)
 	long err = syscall(__NR_uprobe);
 
 	ASSERT_EQ(err, -1, "error");
-	ASSERT_EQ(errno, ENXIO, "errno");
+	ASSERT_EQ(errno, EPROTO, "errno");
 }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#25 lore raw

Re: [PATCHv3 06/12] libbpf: Detect uprobe syscall with new error

Quoted 2 lines · On Thu, May 21, 2026 at 01:29:19PM +0000, [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Missing kernel-side dependency causes selftest failure and feature detection breakage

replied in the previous post:
https://lore.kernel.org/bpf/agzJtkZuSRVK3YR_@krava/

jirka

Quoted 56 lines

--

commit 2bfbf90e3446befa63868457a72590c57c20d562
Author: Jiri Olsa <[email protected]>

libbpf: Detect uprobe syscall with new error

This commit updates libbpf feature detection and selftests to expect EPROTO instead of ENXIO when the uprobe syscall is called outside a kernel-generated uprobe trampoline.

Quoted 5 lines
tools/lib/bpf/features.c +0 -0
index 4f19a0d79b0cf..a37aaea5253e5 100644

tools/lib/bpf/features.c static int probe_ldimm64_full_range_off(int token_fd) · line 583

Quoted 9 lines
tools/lib/bpf/features.c +2 -2
@@ -577,10 +577,10 @@ static int probe_ldimm64_full_range_off(int token_fd)
 static int probe_uprobe_syscall(int token_fd)
 {
 	/*
-	 * If kernel supports uprobe() syscall, it will return -ENXIO when called
+	 * If kernel supports uprobe() syscall, it will return -EPROTO when called
 	 * from the outside of a kernel-generated uprobe trampoline.
 	 */
-	return syscall(__NR_uprobe) < 0 && errno == ENXIO;
+	return syscall(__NR_uprobe) < 0 && errno == EPROTO;

[Severity: High]
Is this patch missing a kernel-side dependency? Looking at the current kernel tree in arch/x86/kernel/uprobes.c, SYSCALL_DEFINE0(uprobe) still explicitly returns -ENXIO:

if (!in_uprobe_trampoline(regs->ip))

        return -ENXIO;

Without the corresponding kernel patch to change this to -EPROTO, will this cause libbpf to incorrectly conclude that the uprobe syscall is unsupported, and cause the updated selftests below to fail?

Quoted 1 line
tools/lib/bpf/features.c +0 -0
 }

[ ... ]

Quoted 11 lines
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +1 -1
index 955a37751b52d..c944136252c6d 100644
@@ -762,7 +762,7 @@ static void test_uprobe_error(void)
 	long err = syscall(__NR_uprobe);
 
 	ASSERT_EQ(err, -1, "error");
-	ASSERT_EQ(errno, ENXIO, "errno");
+	ASSERT_EQ(errno, EPROTO, "errno");
 }
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
author reviewer
#26 lore raw

PATCH v3 7/12 selftests/bpf: Emit nop,nop10 instructions combo for x86_64 arch

In reply to Jiri Olsa

Syncing latest usdt.h change [1].

Now that we have nop10 optimization support in kernel, let's emit nop,nop10 for usdt probe. We leave it up to the library to use desirable nop instruction.

[1] TBD

---
 tools/testing/selftests/bpf/usdt.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tools/testing/selftests/bpf/usdt.h +1 -1
index c71e21df38b3..75687f50f4e2 100644
@@ -313,7 +313,7 @@ struct usdt_sema { volatile unsigned short active; };
 #if defined(__ia64__) || defined(__s390__) || defined(__s390x__)
 #define USDT_NOP			nop 0
 #elif defined(__x86_64__)
-#define USDT_NOP                       .byte 0x90, 0x0f, 0x1f, 0x44, 0x00, 0x0 /* nop, nop5 */
+#define USDT_NOP                       .byte 0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 /* nop, nop10 */
 #else
 #define USDT_NOP			nop
 #endif
Signature · 1 line
2.53.0
#27 lore raw

Re: [PATCHv3 07/12] selftests/bpf: Emit nop,nop10 instructions combo for x86_64 arch

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Changing the USDT_NOP macro to emit a 10-byte NOP breaks libbpf discovery, disables kernel…

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Changing the USDT_NOP macro to emit a 10-byte NOP breaks libbpf discovery, disables kernel uprobe optimizations, and relies on an architecturally unsafe patching concept. --

commit 963f950434fd00b2b52a00da58d5968fea9d4ebc
Author: Jiri Olsa <[email protected]>

selftests/bpf: Emit nop,nop10 instructions combo for x86_64 arch

This commit updates the USDT_NOP macro for x86_64 to emit a 1-byte nop followed by a 10-byte nop. This is intended to test new uprobe optimization support in the kernel.

Quoted 3 lines
tools/testing/selftests/bpf/usdt.h +0 -0

[ ... ]

tools/testing/selftests/bpf/usdt.h struct usdt_sema { volatile unsigned short active; }; · line 316

Quoted 6 lines
tools/testing/selftests/bpf/usdt.h +1 -1
@@ -313,7 +313,7 @@ struct usdt_sema { volatile unsigned short active; };
 #if defined(__ia64__) || defined(__s390__) || defined(__s390x__)
 #define USDT_NOP			nop 0
 #elif defined(__x86_64__)
-#define USDT_NOP                       .byte 0x90, 0x0f, 0x1f, 0x44, 0x00, 0x0 /* nop, nop5 */
+#define USDT_NOP                       .byte 0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 /* nop, nop10 */

[Severity: Medium]
Does this change to a 10-byte nop break the libbpf discovery logic?

Looking at has_nop_combo() in tools/lib/bpf/usdt.c, it seems to explicitly check for the 6-byte sequence (0x90, 0x0f, 0x1f, 0x44, 0x00, 0x00).

If has_nop_combo() returns false, the target IP won't advance to the multi-byte nop, leaving the probe at the 1-byte instruction.

Since the kernel's can_optimize() in arch/x86/kernel/uprobes.c requires an instruction length of 5, does this cause the selftest to silently degrade to the slower int3 breakpoint path rather than testing the intended optimization?

Additionally, is it safe to replace a 10-byte nop with a 5-byte call on x86_64?

The 5-byte call pushes IP + 5 to the stack. When the uprobe trampoline returns, execution would resume at IP + 5, which lands exactly in the middle of the 10-byte nop sequence.

Could those remaining 5 bytes (0x00, 0x00, 0x00, 0x00, 0x00) be incorrectly decoded, leading to unexpected behavior like memory corruption or application crashes?

Would using two consecutive 5-byte nops instead of a single 10-byte nop safely provide the padding needed for a 5-byte patch?

Quoted 3 lines
tools/testing/selftests/bpf/usdt.h +0 -0
 #else
 #define USDT_NOP			nop
 #endif
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#28 lore raw

Re: [PATCHv3 07/12] selftests/bpf: Emit nop,nop10 instructions combo for x86_64 arch

Quoted 3 lines · On Thu, May 21, 2026 at 01:21:21PM +0000, [email protected] wrote:

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Changing the USDT_NOP macro to emit a 10-byte NOP breaks libbpf discovery, disables kernel uprobe optimizations, and relies on an architecturally unsafe patching concept. --

all the other changes are in other commits, I keep the changes separated for now, we can squash them later if we think it's good idea

jirka

Quoted 55 lines

commit 963f950434fd00b2b52a00da58d5968fea9d4ebc
Author: Jiri Olsa <[email protected]>

selftests/bpf: Emit nop,nop10 instructions combo for x86_64 arch

This commit updates the USDT_NOP macro for x86_64 to emit a 1-byte nop followed by a 10-byte nop. This is intended to test new uprobe optimization support in the kernel.

Quoted 3 lines
tools/testing/selftests/bpf/usdt.h +0 -0

[ ... ]

tools/testing/selftests/bpf/usdt.h struct usdt_sema { volatile unsigned short active; }; · line 316

Quoted 6 lines
tools/testing/selftests/bpf/usdt.h +1 -1
@@ -313,7 +313,7 @@ struct usdt_sema { volatile unsigned short active; };
 #if defined(__ia64__) || defined(__s390__) || defined(__s390x__)
 #define USDT_NOP			nop 0
 #elif defined(__x86_64__)
-#define USDT_NOP                       .byte 0x90, 0x0f, 0x1f, 0x44, 0x00, 0x0 /* nop, nop5 */
+#define USDT_NOP                       .byte 0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 /* nop, nop10 */

[Severity: Medium]
Does this change to a 10-byte nop break the libbpf discovery logic?

Looking at has_nop_combo() in tools/lib/bpf/usdt.c, it seems to explicitly check for the 6-byte sequence (0x90, 0x0f, 0x1f, 0x44, 0x00, 0x00).

If has_nop_combo() returns false, the target IP won't advance to the multi-byte nop, leaving the probe at the 1-byte instruction.

Since the kernel's can_optimize() in arch/x86/kernel/uprobes.c requires an instruction length of 5, does this cause the selftest to silently degrade to the slower int3 breakpoint path rather than testing the intended optimization?

Additionally, is it safe to replace a 10-byte nop with a 5-byte call on x86_64?

The 5-byte call pushes IP + 5 to the stack. When the uprobe trampoline returns, execution would resume at IP + 5, which lands exactly in the middle of the 10-byte nop sequence.

Could those remaining 5 bytes (0x00, 0x00, 0x00, 0x00, 0x00) be incorrectly decoded, leading to unexpected behavior like memory corruption or application crashes?

Would using two consecutive 5-byte nops instead of a single 10-byte nop safely provide the padding needed for a 5-byte patch?

Quoted 3 lines
tools/testing/selftests/bpf/usdt.h +0 -0
 #else
 #define USDT_NOP			nop
 #endif
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#29 lore raw

Re: [PATCHv3 07/12] selftests/bpf: Emit nop,nop10 instructions combo for x86_64 arch

In reply to [email protected]

On Thu, May 21, 2026 at 01:21 PM GMT, [email protected] wrote:

[...]

Quoted 2 lines

Would using two consecutive 5-byte nops instead of a single 10-byte nop safely provide the padding needed for a 5-byte patch?

Perhaps worth clarifying that nop5,nop5 wouldn't allow us to leave the CALL in nop10 tail after the optimize/unoptimize cycle.

#30 lore raw

Re: [PATCHv3 07/12] selftests/bpf: Emit nop,nop10 instructions combo for x86_64 arch

Quoted 9 lines · Jakub Sitnicki

On Thu, May 21, 2026 at 01:21 PM GMT, [email protected] wrote:

[...]

Quoted 2 lines

Would using two consecutive 5-byte nops instead of a single 10-byte nop safely provide the padding needed for a 5-byte patch?

Perhaps worth clarifying that nop5,nop5 wouldn't allow us to leave the CALL in nop10 tail after the optimize/unoptimize cycle.

right, also we need to have single instruction for that to have some assurance the app won't jump in the middle

jirka

#31 lore raw

Re: [PATCHv3 07/12] selftests/bpf: Emit nop,nop10 instructions combo for x86_64 arch

In reply to Jiri Olsa
Does changing this instruction sequence from 6 bytes to 11 bytes break prog_tests/usdt.c? The test in subtest_optimized_attach() searches for the old 6-byte nop1_nop5_combo sequence:

tools/testing/selftests/bpf/usdt.h struct usdt_sema { volatile unsigned short active; }; · line 319

Quoted 13 lines
tools/testing/selftests/bpf/usdt.h +1 -1
index c71e21df38b3..75687f50f4e2 100644
@@ -313,7 +313,7 @@ struct usdt_sema { volatile unsigned short active; };
 #if defined(__ia64__) || defined(__s390__) || defined(__s390x__)
 #define USDT_NOP			nop 0
 #elif defined(__x86_64__)
-#define USDT_NOP                       .byte 0x90, 0x0f, 0x1f, 0x44, 0x00, 0x0 /* nop, nop5 */
+#define USDT_NOP                       .byte 0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 /* nop, nop10 */
 #else
 #define USDT_NOP			nop
 #endif

Does changing this instruction sequence from 6 bytes to 11 bytes break prog_tests/usdt.c? The test in subtest_optimized_attach() searches for the old 6-byte nop1_nop5_combo sequence:

tools/testing/selftests/bpf/prog_tests/usdt.c:

    /* usdt_2 USDT probe has nop,nop5 instructions combo */
    addr_2 = find_instr(usdt_2, nop1_nop5_combo, 6);
    if (!ASSERT_OK_PTR(addr_2, "usdt_2_find_nop1_nop5_combo"))
        goto cleanup;

Because the old sequence is no longer emitted by USDT_NOP, find_instr() will return NULL, causing the ASSERT_OK_PTR assertion to fail. Should the test update be squashed into this commit to avoid breaking git bisect?

---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md

CI run summary: https://github.com/kernel-patches/bpf/actions/runs/26227520868

author reviewer
#33 lore raw

PATCH v3 8/12 selftests/bpf: Change uprobe syscall tests to use nop10

In reply to Jiri Olsa

Optimized uprobes are now on top of 10-bytes nop instructions, reflect that in existing tests.

---
 .../selftests/bpf/benchs/bench_trigger.c      |  2 +-
 .../selftests/bpf/prog_tests/uprobe_syscall.c | 28 ++++++++++---------
 tools/testing/selftests/bpf/prog_tests/usdt.c | 25 ++++++++++-------
 tools/testing/selftests/bpf/usdt_2.c          |  2 +-
 4 files changed, 32 insertions(+), 25 deletions(-)
tools/testing/selftests/bpf/benchs/bench_trigger.c +1 -1
index 2f22ec61667b..a60b8173cdc4 100644
@@ -398,7 +398,7 @@ static void *uprobe_producer_ret(void *input)
 #ifdef __x86_64__
 __nocf_check __weak void uprobe_target_nop5(void)
 {
-	asm volatile (".byte 0x0f, 0x1f, 0x44, 0x00, 0x00");
+	asm volatile (".byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00");
 }
 
 static void *uprobe_producer_nop5(void *input)
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +15 -13
index c944136252c6..9653fb5608f2 100644
@@ -17,7 +17,7 @@
 #include "uprobe_syscall_executed.skel.h"
 #include "bpf/libbpf_internal.h"
 
-#define USDT_NOP .byte 0x0f, 0x1f, 0x44, 0x00, 0x00
+#define USDT_NOP .byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00
 #include "usdt.h"
 
 #pragma GCC diagnostic ignored "-Wattributes"
@@ -26,7 +26,7 @@ __attribute__((aligned(16)))
 __nocf_check __weak __naked unsigned long uprobe_regs_trigger(void)
 {
 	asm volatile (
-		".byte 0x0f, 0x1f, 0x44, 0x00, 0x00\n" /* nop5 */
+		".byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00\n" /* nop10 */
 		"movq $0xdeadbeef, %rax\n"
 		"ret\n"
 	);
@@ -345,9 +345,9 @@ static void test_uretprobe_syscall_call(void)
 __attribute__((aligned(16)))
 __nocf_check __weak __naked void uprobe_test(void)
 {
-	asm volatile ("					\n"
-		".byte 0x0f, 0x1f, 0x44, 0x00, 0x00	\n"
-		"ret					\n"
+	asm volatile (
+		".byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00\n" /* nop10 */
+		"ret\n"
 	);
 }
 
@@ -388,14 +388,15 @@ static int find_uprobes_trampoline(void *tramp_addr)
 	return ret;
 }
 
-static unsigned char nop5[5] = { 0x0f, 0x1f, 0x44, 0x00, 0x00 };
+static unsigned char nop10[10]  = { 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 };
+static unsigned char lea_rsp[5] = { 0x48, 0x8d, 0x64, 0x24, 0x80 };
 
-static void *find_nop5(void *fn)
+static void *find_nop10(void *fn)
 {
 	int i;
 
-	for (i = 0; i < 10; i++) {
-		if (!memcmp(nop5, fn + i, 5))
+	for (i = 0; i < 128; i++) {
+		if (!memcmp(nop10, fn + i, 10))
 			return fn + i;
 	}
 	return NULL;
@@ -420,7 +421,8 @@ static void *check_attach(struct uprobe_syscall_executed *skel, trigger_t trigge
 	ASSERT_EQ(skel->bss->executed, executed, "executed");
 
 	/* .. and check the trampoline is as expected. */
-	call = (struct __arch_relative_insn *) addr;
+	ASSERT_OK(memcmp(addr, lea_rsp, 5), "lea_rsp");
+	call = (struct __arch_relative_insn *)(addr + 5);
 	tramp = (void *) (call + 1) + call->raddr;
 	ASSERT_EQ(call->op, 0xe8, "call");
 	ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline");
@@ -432,7 +434,7 @@ static void check_detach(void *addr, void *tramp)
 {
 	/* [uprobes_trampoline] stays after detach */
 	ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline");
-	ASSERT_OK(memcmp(addr, nop5, 5), "nop5");
+	ASSERT_OK(memcmp(addr, jmp2B, 2), "jmp2B");
 }
 
 static void check(struct uprobe_syscall_executed *skel, struct bpf_link *link,
@@ -568,8 +570,8 @@ static void test_uprobe_usdt(void)
 	void *addr;
 
 	errno = 0;
-	addr = find_nop5(usdt_test);
-	if (!ASSERT_OK_PTR(addr, "find_nop5"))
+	addr = find_nop10(usdt_test);
+	if (!ASSERT_OK_PTR(addr, "find_nop10"))
 		return;
 
 	skel = uprobe_syscall_executed__open_and_load();
tools/testing/selftests/bpf/prog_tests/usdt.c +15 -10
index 69759b27794d..fda3a298ccfc 100644
@@ -252,7 +252,7 @@ extern void usdt_1(void);
 extern void usdt_2(void);
 
 static unsigned char nop1[1] = { 0x90 };
-static unsigned char nop1_nop5_combo[6] = { 0x90, 0x0f, 0x1f, 0x44, 0x00, 0x00 };
+static unsigned char nop1_nop10_combo[11] = { 0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
 static void *find_instr(void *fn, unsigned char *instr, size_t cnt)
 {
@@ -271,17 +271,17 @@ static void subtest_optimized_attach(void)
 	__u8 *addr_1, *addr_2;
 
 	/* usdt_1 USDT probe has single nop instruction */
-	addr_1 = find_instr(usdt_1, nop1_nop5_combo, 6);
-	if (!ASSERT_NULL(addr_1, "usdt_1_find_nop1_nop5_combo"))
+	addr_1 = find_instr(usdt_1, nop1_nop10_combo, 11);
+	if (!ASSERT_NULL(addr_1, "usdt_1_find_nop1_nop10_combo"))
 		return;
 
 	addr_1 = find_instr(usdt_1, nop1, 1);
 	if (!ASSERT_OK_PTR(addr_1, "usdt_1_find_nop1"))
 		return;
 
-	/* usdt_2 USDT probe has nop,nop5 instructions combo */
-	addr_2 = find_instr(usdt_2, nop1_nop5_combo, 6);
-	if (!ASSERT_OK_PTR(addr_2, "usdt_2_find_nop1_nop5_combo"))
+	/* usdt_2 USDT probe has nop,nop10 instructions combo */
+	addr_2 = find_instr(usdt_2, nop1_nop10_combo, 11);
+	if (!ASSERT_OK_PTR(addr_2, "usdt_2_find_nop1_nop10_combo"))
 		return;
 
 	skel = test_usdt__open_and_load();
@@ -309,12 +309,12 @@ static void subtest_optimized_attach(void)
 
 	bpf_link__destroy(skel->links.usdt_executed);
 
-	/* we expect the nop5 ip */
+	/* we expect the nop10 ip */
 	skel->bss->expected_ip = (unsigned long) addr_2 + 1;
 
 	/*
 	 * Attach program on top of usdt_2 which is probe defined on top
-	 * of nop1,nop5 combo, so the probe gets optimized on top of nop5.
+	 * of nop1,nop10 combo, so the probe gets optimized on top of nop10.
 	 */
 	skel->links.usdt_executed = bpf_program__attach_usdt(skel->progs.usdt_executed,
 						     0 /*self*/, "/proc/self/exe",
@@ -328,8 +328,13 @@ static void subtest_optimized_attach(void)
 	/* nop stays on addr_2 address */
 	ASSERT_EQ(*addr_2, 0x90, "nop");
 
-	/* call is on addr_2 + 1 address */
-	ASSERT_EQ(*(addr_2 + 1), 0xe8, "call");
+	/*
+	 * lea -0x80(%rsp), %rsp
+	 * call ...
+	 */
+	static unsigned char expected[] = { 0x48, 0x8d, 0x64, 0x24, 0x80, 0xe8 };
+
+	ASSERT_MEMEQ(addr_2 + 1, expected, sizeof(expected), "lea_and_call");
 	ASSERT_EQ(skel->bss->executed, 4, "executed");
 
 cleanup:
tools/testing/selftests/bpf/usdt_2.c +1 -1
index 789883aaca4c..b359b389f6c0 100644
@@ -3,7 +3,7 @@
 #if defined(__x86_64__)
 
 /*
- * Include usdt.h with default nop,nop5 instructions combo.
+ * Include usdt.h with default nop,nop10 instructions combo.
  */
 #include "usdt.h"
 
Signature · 1 line
2.53.0
#34 lore raw

Re: [PATCHv3 08/12] selftests/bpf: Change uprobe syscall tests to use nop10

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [Medium] The `usdt.h` header was not updated to provide the 10-byte NOP, causing `usdt_2` to be compiled…

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [Medium] The usdt.h header was not updated to provide the 10-byte NOP, causing usdt_2 to be compiled with the old 5-byte NOP and failing runtime assertions.
- [Low] The identifier jmp2B is undeclared in check_detach(), which will cause a compilation error.
- [Low] Benchmark functions and test configurations still use 'nop5' in their names despite executing 10-byte NOPs.
--

commit f5ad4c4a3a063831f82fef22be662049ca3b7fbc
Author: Jiri Olsa <[email protected]>

selftests/bpf: Change uprobe syscall tests to use nop10

Optimized uprobes are now on top of 10-bytes nop instructions, reflect that in existing tests.

tools/testing/selftests/bpf/benchs/bench_trigger.c static void *uprobe_producer_ret(void *input) · line 402

Quoted 11 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +1 -1
index 2f22ec61667b9..a60b8173cdc46 100644
@@ -398,7 +398,7 @@ static void *uprobe_producer_ret(void *input)
 #ifdef __x86_64__
 __nocf_check __weak void uprobe_target_nop5(void)
 {
-	asm volatile (".byte 0x0f, 0x1f, 0x44, 0x00, 0x00");
+	asm volatile (".byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00");
 }

[Severity: Low]
This isn't a bug, but since this benchmark function now executes a 10-byte NOP sequence, should the names be updated from nop5 to nop10 here and in the related benchmark configurations to prevent confusion?

[ ... ]

Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +0 -0
index 955a37751b52d..8e5ab135248f9 100644

[ ... ]

tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c static void check_detach(void *addr, void *tramp) · line 438

Quoted 7 lines
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +1 -1
@@ -432,7 +434,7 @@ static void check_detach(void *addr, void *tramp)
 {
 	/* [uprobes_trampoline] stays after detach */
 	ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline");
-	ASSERT_OK(memcmp(addr, nop5, 5), "nop5");
+	ASSERT_OK(memcmp(addr, jmp2B, 2), "jmp2B");
 }

[Severity: Low]
Is the jmp2B variable missing a declaration? It is used here in memcmp(), but it does not appear to be defined anywhere in this file or the included headers, which will cause a build failure.

[ ... ]

Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/usdt.c +0 -0
index 69759b27794d7..fda3a298ccfc7 100644

[ ... ]

Quoted 11 lines
tools/testing/selftests/bpf/prog_tests/usdt.c +2 -2
@@ -271,17 +271,17 @@ static void subtest_optimized_attach(void)
 	__u8 *addr_1, *addr_2;
 
 	/* usdt_1 USDT probe has single nop instruction */
-	addr_1 = find_instr(usdt_1, nop1_nop5_combo, 6);
-	if (!ASSERT_NULL(addr_1, "usdt_1_find_nop1_nop5_combo"))
+	addr_1 = find_instr(usdt_1, nop1_nop10_combo, 11);
+	if (!ASSERT_NULL(addr_1, "usdt_1_find_nop1_nop10_combo"))
 		return;
 
 	addr_1 = find_instr(usdt_1, nop1, 1);

tools/testing/selftests/bpf/prog_tests/usdt.c static void subtest_optimized_attach(void) · line 285

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/usdt.c +3 -3
 	if (!ASSERT_OK_PTR(addr_1, "usdt_1_find_nop1"))
 		return;
 
-	/* usdt_2 USDT probe has nop,nop5 instructions combo */
-	addr_2 = find_instr(usdt_2, nop1_nop5_combo, 6);
-	if (!ASSERT_OK_PTR(addr_2, "usdt_2_find_nop1_nop5_combo"))
+	/* usdt_2 USDT probe has nop,nop10 instructions combo */
+	addr_2 = find_instr(usdt_2, nop1_nop10_combo, 11);
+	if (!ASSERT_OK_PTR(addr_2, "usdt_2_find_nop1_nop10_combo"))
 		return;

[Severity: Medium]
Will this assertion fail at runtime because usdt_2 is still compiled with a 6-byte NOP sequence?

usdt_2.c includes usdt.h without overriding USDT_NOP:

tools/testing/selftests/bpf/usdt_2.c:
#include "usdt.h"

However, usdt.h still defines the x86_64 default as a 6-byte sequence (nop, nop5) rather than 11 bytes:

tools/testing/selftests/bpf/usdt.h:
#elif defined(__x86_64__)
#define USDT_NOP .byte 0x90, 0x0f, 0x1f, 0x44, 0x00, 0x0 /* nop, nop5 */

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#35 lore raw

Re: [PATCHv3 08/12] selftests/bpf: Change uprobe syscall tests to use nop10

In reply to Jiri Olsa
Is jmp2B declared somewhere? The identifier is used in memcmp() but does not appear to be defined anywhere in the file or included headers. A subsequent commit later in the series replaces this with…
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +0 -0
index c944136252c6..9653fb5608f2 100644

[ ... ]

Quoted 20 lines
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +5 -4
@@ -388,14 +388,15 @@ static int find_uprobes_trampoline(void *tramp_addr)
 	return ret;
 }
 
-static unsigned char nop5[5] = { 0x0f, 0x1f, 0x44, 0x00, 0x00 };
+static unsigned char nop10[10]  = { 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 };
+static unsigned char lea_rsp[5] = { 0x48, 0x8d, 0x64, 0x24, 0x80 };
 
-static void *find_nop5(void *fn)
+static void *find_nop10(void *fn)
 {
 	int i;
 
-	for (i = 0; i < 10; i++) {
-		if (!memcmp(nop5, fn + i, 5))
+	for (i = 0; i < 128; i++) {
+		if (!memcmp(nop10, fn + i, 10))
 			return fn + i;
 	}
 	return NULL;

[ ... ]

tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c static void check_detach(void *addr, void *tramp) · line 438

Quoted 7 lines
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +1 -1
@@ -432,7 +434,7 @@ static void check_detach(void *addr, void *tramp)
 {
 	/* [uprobes_trampoline] stays after detach */
 	ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline");
-	ASSERT_OK(memcmp(addr, nop5, 5), "nop5");
+	ASSERT_OK(memcmp(addr, jmp2B, 2), "jmp2B");
 }

Is jmp2B declared somewhere? The identifier is used in memcmp() but does not appear to be defined anywhere in the file or included headers. A subsequent commit later in the series replaces this with a properly declared nop10_prefix array, confirming this is likely a missing definition.

The pre-patch code referenced the defined static array nop5, but the new code references an undeclared symbol that will cause a compilation error.

Quoted 13 lines
tools/testing/selftests/bpf/prog_tests/usdt.c +1 -1
index 69759b27794d..fda3a298ccfc 100644
@@ -252,7 +252,7 @@ extern void usdt_1(void);
 extern void usdt_2(void);
 
 static unsigned char nop1[1] = { 0x90 };
-static unsigned char nop1_nop5_combo[6] = { 0x90, 0x0f, 0x1f, 0x44, 0x00, 0x00 };
+static unsigned char nop1_nop10_combo[11] = { 0x90, 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
 static void *find_instr(void *fn, unsigned char *instr, size_t cnt)
 {

tools/testing/selftests/bpf/prog_tests/usdt.c

Quoted 8 lines
tools/testing/selftests/bpf/prog_tests/usdt.c +0 -0
 	int i;
 
 	for (i = 0; i < 10; i++) {
 		if (!memcmp(instr, fn + i, cnt))
 			return fn + i;
 	}
 	return NULL;
 }

Is the loop in find_instr() adequate to find this instruction sequence?

In uprobe_syscall.c, find_nop10() was updated to search up to 128 bytes to account for compiler-generated prologues:

tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c:find_nop10() {
	for (i = 0; i < 128; i++) {
		if (!memcmp(nop10, fn + i, 10))
			return fn + i;
	}
}

If a modern compiler generates a prologue longer than 9 bytes for usdt_2(), find_instr() will prematurely terminate and cause the subtest_optimized_attach() test to fail. This was acknowledged in v2 review with "yea find_instr needs same update, will fix" but remains unchanged.

[ ... ]

---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md

CI run summary: https://github.com/kernel-patches/bpf/actions/runs/26227520868

#36 lore raw

Re: [PATCHv3 08/12] selftests/bpf: Change uprobe syscall tests to use nop10

In reply to Jiri Olsa
Quoted 17 lines · Jiri Olsa

Optimized uprobes are now on top of 10-bytes nop instructions, reflect that in existing tests.

---
 .../selftests/bpf/benchs/bench_trigger.c      |  2 +-
 .../selftests/bpf/prog_tests/uprobe_syscall.c | 28 ++++++++++---------
 tools/testing/selftests/bpf/prog_tests/usdt.c | 25 ++++++++++-------
 tools/testing/selftests/bpf/usdt_2.c          |  2 +-
 4 files changed, 32 insertions(+), 25 deletions(-)
tools/testing/selftests/bpf/benchs/bench_trigger.c +0 -0
index 2f22ec61667b..a60b8173cdc4 100644

tools/testing/selftests/bpf/benchs/bench_trigger.c static void *uprobe_producer_ret(void *input) · line 399

Quoted 2 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +0 -0
@@ -398,7 +398,7 @@ static void *uprobe_producer_ret(void *input)
 #ifdef __x86_64__
 __nocf_check __weak void uprobe_target_nop5(void)

heh, nop5 -> nop_a_lot ;)

Quoted 5 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +1 -1
 {
-       asm volatile (".byte 0x0f, 0x1f, 0x44, 0x00, 0x00");
+       asm volatile (".byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00");
 }
 

[...]

Quoted 11 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +2 -1
@@ -420,7 +421,8 @@ static void *check_attach(struct uprobe_syscall_executed *skel, trigger_t trigge
        ASSERT_EQ(skel->bss->executed, executed, "executed");
 
        /* .. and check the trampoline is as expected. */
-       call = (struct __arch_relative_insn *) addr;
+       ASSERT_OK(memcmp(addr, lea_rsp, 5), "lea_rsp");
+       call = (struct __arch_relative_insn *)(addr + 5);
        tramp = (void *) (call + 1) + call->raddr;
        ASSERT_EQ(call->op, 0xe8, "call");
        ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline");

tools/testing/selftests/bpf/benchs/bench_trigger.c static void check_detach(void *addr, void *tramp) · line 437

Quoted 5 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +1 -1
@@ -432,7 +434,7 @@ static void check_detach(void *addr, void *tramp)
 {
        /* [uprobes_trampoline] stays after detach */
        ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline");
-       ASSERT_OK(memcmp(addr, nop5, 5), "nop5");
+       ASSERT_OK(memcmp(addr, jmp2B, 2), "jmp2B");

yeah, not jump anymore?

Quoted 3 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +0 -0
 }
 
 static void check(struct uprobe_syscall_executed *skel, struct bpf_link *link,

[...]

#37 lore raw

Re: [PATCHv3 08/12] selftests/bpf: Change uprobe syscall tests to use nop10

Quoted 35 lines · Andrii Nakryiko
Quoted 17 lines · Jiri Olsa

Optimized uprobes are now on top of 10-bytes nop instructions, reflect that in existing tests.

---
 .../selftests/bpf/benchs/bench_trigger.c      |  2 +-
 .../selftests/bpf/prog_tests/uprobe_syscall.c | 28 ++++++++++---------
 tools/testing/selftests/bpf/prog_tests/usdt.c | 25 ++++++++++-------
 tools/testing/selftests/bpf/usdt_2.c          |  2 +-
 4 files changed, 32 insertions(+), 25 deletions(-)
tools/testing/selftests/bpf/benchs/bench_trigger.c +0 -0
index 2f22ec61667b..a60b8173cdc4 100644

tools/testing/selftests/bpf/benchs/bench_trigger.c static void *uprobe_producer_ret(void *input) · line 399

Quoted 2 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +0 -0
@@ -398,7 +398,7 @@ static void *uprobe_producer_ret(void *input)
 #ifdef __x86_64__
 __nocf_check __weak void uprobe_target_nop5(void)

heh, nop5 -> nop_a_lot ;)

Quoted 5 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +1 -1
 {
-       asm volatile (".byte 0x0f, 0x1f, 0x44, 0x00, 0x00");
+       asm volatile (".byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00");
 }
 

[...]

Quoted 3 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +0 -0
@@ -420,7 +421,8 @@ static void *check_attach(struct uprobe_syscall_executed *skel, trigger_t trigge
        ASSERT_EQ(skel->bss->executed, executed, "executed");
 
Quoted 15 lines

tools/testing/selftests/bpf/benchs/bench_trigger.c static void check_detach(void *addr, void *tramp) · line 437

Quoted 13 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +3 -2
        /* .. and check the trampoline is as expected. */
-       call = (struct __arch_relative_insn *) addr;
+       ASSERT_OK(memcmp(addr, lea_rsp, 5), "lea_rsp");
+       call = (struct __arch_relative_insn *)(addr + 5);
        tramp = (void *) (call + 1) + call->raddr;
        ASSERT_EQ(call->op, 0xe8, "call");
        ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline");
@@ -432,7 +434,7 @@ static void check_detach(void *addr, void *tramp)
 {
        /* [uprobes_trampoline] stays after detach */
        ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline");
-       ASSERT_OK(memcmp(addr, nop5, 5), "nop5");
+       ASSERT_OK(memcmp(addr, jmp2B, 2), "jmp2B");

yeah, not jump anymore?

mixed up the selftest change.. I had it fixed already, new version will have both fixes ;-)

thanks,
jirka

Quoted 6 lines
Quoted 4 lines
tools/testing/selftests/bpf/benchs/bench_trigger.c +0 -0
 }
 
 static void check(struct uprobe_syscall_executed *skel, struct bpf_link *link,

[...]

author reviewer
#38 lore raw

PATCH v3 9/12 selftests/bpf: Change uprobe/usdt trigger bench code to use nop10

In reply to Jiri Olsa

Changing uprobe/usdt trigger bench code to use nop10 instead of nop5. Also changing run_bench_uprobes.sh to use nop10 triggers.

---
 tools/testing/selftests/bpf/bench.c           | 20 +++++------
 .../selftests/bpf/benchs/bench_trigger.c      | 36 +++++++++----------
 .../selftests/bpf/benchs/run_bench_uprobes.sh |  2 +-
 3 files changed, 29 insertions(+), 29 deletions(-)
tools/testing/selftests/bpf/bench.c +10 -10
index 6155ce455c27..1252a1af2e84 100644
@@ -539,12 +539,12 @@ extern const struct bench bench_trig_uretprobe_multi_push;
 extern const struct bench bench_trig_uprobe_multi_ret;
 extern const struct bench bench_trig_uretprobe_multi_ret;
 #ifdef __x86_64__
-extern const struct bench bench_trig_uprobe_nop5;
-extern const struct bench bench_trig_uretprobe_nop5;
-extern const struct bench bench_trig_uprobe_multi_nop5;
-extern const struct bench bench_trig_uretprobe_multi_nop5;
+extern const struct bench bench_trig_uprobe_nop10;
+extern const struct bench bench_trig_uretprobe_nop10;
+extern const struct bench bench_trig_uprobe_multi_nop10;
+extern const struct bench bench_trig_uretprobe_multi_nop10;
 extern const struct bench bench_trig_usdt_nop;
-extern const struct bench bench_trig_usdt_nop5;
+extern const struct bench bench_trig_usdt_nop10;
 #endif
 
 extern const struct bench bench_rb_libbpf;
@@ -619,12 +619,12 @@ static const struct bench *benchs[] = {
 	&bench_trig_uprobe_multi_ret,
 	&bench_trig_uretprobe_multi_ret,
 #ifdef __x86_64__
-	&bench_trig_uprobe_nop5,
-	&bench_trig_uretprobe_nop5,
-	&bench_trig_uprobe_multi_nop5,
-	&bench_trig_uretprobe_multi_nop5,
+	&bench_trig_uprobe_nop10,
+	&bench_trig_uretprobe_nop10,
+	&bench_trig_uprobe_multi_nop10,
+	&bench_trig_uretprobe_multi_nop10,
 	&bench_trig_usdt_nop,
-	&bench_trig_usdt_nop5,
+	&bench_trig_usdt_nop10,
 #endif
 	/* ringbuf/perfbuf benchmarks */
 	&bench_rb_libbpf,
tools/testing/selftests/bpf/benchs/bench_trigger.c +18 -18
index a60b8173cdc4..61513efc167a 100644
@@ -396,15 +396,15 @@ static void *uprobe_producer_ret(void *input)
 }
 
 #ifdef __x86_64__
-__nocf_check __weak void uprobe_target_nop5(void)
+__nocf_check __weak void uprobe_target_nop10(void)
 {
 	asm volatile (".byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00");
 }
 
-static void *uprobe_producer_nop5(void *input)
+static void *uprobe_producer_nop10(void *input)
 {
 	while (true)
-		uprobe_target_nop5();
+		uprobe_target_nop10();
 	return NULL;
 }
 
@@ -418,7 +418,7 @@ static void *uprobe_producer_usdt_nop(void *input)
 	return NULL;
 }
 
-static void *uprobe_producer_usdt_nop5(void *input)
+static void *uprobe_producer_usdt_nop10(void *input)
 {
 	while (true)
 		usdt_2();
@@ -542,24 +542,24 @@ static void uretprobe_multi_ret_setup(void)
 }
 
 #ifdef __x86_64__
-static void uprobe_nop5_setup(void)
+static void uprobe_nop10_setup(void)
 {
-	usetup(false, false /* !use_multi */, &uprobe_target_nop5);
+	usetup(false, false /* !use_multi */, &uprobe_target_nop10);
 }
 
-static void uretprobe_nop5_setup(void)
+static void uretprobe_nop10_setup(void)
 {
-	usetup(true, false /* !use_multi */, &uprobe_target_nop5);
+	usetup(true, false /* !use_multi */, &uprobe_target_nop10);
 }
 
-static void uprobe_multi_nop5_setup(void)
+static void uprobe_multi_nop10_setup(void)
 {
-	usetup(false, true /* use_multi */, &uprobe_target_nop5);
+	usetup(false, true /* use_multi */, &uprobe_target_nop10);
 }
 
-static void uretprobe_multi_nop5_setup(void)
+static void uretprobe_multi_nop10_setup(void)
 {
-	usetup(true, true /* use_multi */, &uprobe_target_nop5);
+	usetup(true, true /* use_multi */, &uprobe_target_nop10);
 }
 
 static void usdt_setup(const char *name)
@@ -598,7 +598,7 @@ static void usdt_nop_setup(void)
 	usdt_setup("usdt_1");
 }
 
-static void usdt_nop5_setup(void)
+static void usdt_nop10_setup(void)
 {
 	usdt_setup("usdt_2");
 }
@@ -665,10 +665,10 @@ BENCH_TRIG_USERMODE(uretprobe_multi_nop, nop, "uretprobe-multi-nop");
 BENCH_TRIG_USERMODE(uretprobe_multi_push, push, "uretprobe-multi-push");
 BENCH_TRIG_USERMODE(uretprobe_multi_ret, ret, "uretprobe-multi-ret");
 #ifdef __x86_64__
-BENCH_TRIG_USERMODE(uprobe_nop5, nop5, "uprobe-nop5");
-BENCH_TRIG_USERMODE(uretprobe_nop5, nop5, "uretprobe-nop5");
-BENCH_TRIG_USERMODE(uprobe_multi_nop5, nop5, "uprobe-multi-nop5");
-BENCH_TRIG_USERMODE(uretprobe_multi_nop5, nop5, "uretprobe-multi-nop5");
+BENCH_TRIG_USERMODE(uprobe_nop10, nop10, "uprobe-nop10");
+BENCH_TRIG_USERMODE(uretprobe_nop10, nop10, "uretprobe-nop10");
+BENCH_TRIG_USERMODE(uprobe_multi_nop10, nop10, "uprobe-multi-nop10");
+BENCH_TRIG_USERMODE(uretprobe_multi_nop10, nop10, "uretprobe-multi-nop10");
 BENCH_TRIG_USERMODE(usdt_nop, usdt_nop, "usdt-nop");
-BENCH_TRIG_USERMODE(usdt_nop5, usdt_nop5, "usdt-nop5");
+BENCH_TRIG_USERMODE(usdt_nop10, usdt_nop10, "usdt-nop10");
 #endif
tools/testing/selftests/bpf/benchs/run_bench_uprobes.sh +1 -1
index 9ec59423b949..e490b337e960 100755
@@ -2,7 +2,7 @@
 
 set -eufo pipefail
 
-for i in usermode-count syscall-count {uprobe,uretprobe}-{nop,push,ret,nop5} usdt-nop usdt-nop5
+for i in usermode-count syscall-count {uprobe,uretprobe}-{nop,push,ret,nop10} usdt-nop usdt-nop10
 do
 	summary=$(sudo ./bench -w2 -d5 -a trig-$i | tail -n1 | cut -d'(' -f1 | cut -d' ' -f3-)
 	printf "%-15s: %s\n" $i "$summary"
Signature · 1 line
2.53.0
author reviewer
#39 lore raw

PATCH v3 10/12 selftests/bpf: Add reattach tests for uprobe syscall

In reply to Jiri Olsa

Adding reattach tests for uprobe syscall tests to make sure we can re-attach and optimize same uprobe multiple times.

---
 .../selftests/bpf/prog_tests/uprobe_syscall.c | 116 ++++++++++++++++--
 1 file changed, 106 insertions(+), 10 deletions(-)
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +106 -10
index 9653fb5608f2..969f4deba9fd 100644
@@ -430,21 +430,28 @@ static void *check_attach(struct uprobe_syscall_executed *skel, trigger_t trigge
 	return tramp;
 }
 
-static void check_detach(void *addr, void *tramp)
+static bool check_detach(void *addr, void *tramp)
 {
+	static const char nop10_prefix[] = { 0x66, 0x2e, 0x0f, 0x1f, 0x84 };
+	bool ok = true;
+
 	/* [uprobes_trampoline] stays after detach */
-	ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline");
-	ASSERT_OK(memcmp(addr, jmp2B, 2), "jmp2B");
+	if (!ASSERT_OK(find_uprobes_trampoline(tramp), "uprobes_trampoline"))
+		ok = false;
+	if (!ASSERT_OK(memcmp(addr, nop10_prefix, 5), "nop10_prefix"))
+		ok = false;
+	return ok;
 }
 
-static void check(struct uprobe_syscall_executed *skel, struct bpf_link *link,
-		  trigger_t trigger, void *addr, int executed)
+static void *check(struct uprobe_syscall_executed *skel, struct bpf_link *link,
+		   trigger_t trigger, void *addr, int executed)
 {
 	void *tramp;
 
 	tramp = check_attach(skel, trigger, addr, executed);
 	bpf_link__destroy(link);
 	check_detach(addr, tramp);
+	return tramp;
 }
 
 static void test_uprobe_legacy(void)
@@ -455,6 +462,7 @@ static void test_uprobe_legacy(void)
 	);
 	struct bpf_link *link;
 	unsigned long offset;
+	void *tramp;
 
 	offset = get_uprobe_offset(&uprobe_test);
 	if (!ASSERT_GE(offset, 0, "get_uprobe_offset"))
@@ -472,7 +480,28 @@ static void test_uprobe_legacy(void)
 	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_opts"))
 		goto cleanup;
 
-	check(skel, link, uprobe_test, uprobe_test, 2);
+	tramp = check(skel, link, uprobe_test, uprobe_test, 2);
+
+	/* reattach and detach without triggering optimization */
+	link = bpf_program__attach_uprobe_opts(skel->progs.test_uprobe,
+					       0, "/proc/self/exe", offset, NULL);
+	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_opts"))
+		goto cleanup;
+
+	bpf_link__destroy(link);
+	if (!check_detach(uprobe_test, tramp))
+		goto cleanup;
+
+	uprobe_test();
+	ASSERT_EQ(skel->bss->executed, 2, "executed_no_probe");
+
+	/* reattach with triggering optimization */
+	link = bpf_program__attach_uprobe_opts(skel->progs.test_uprobe,
+				0, "/proc/self/exe", offset, NULL);
+	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_opts"))
+		goto cleanup;
+
+	check(skel, link, uprobe_test, uprobe_test, 4);
 
 	/* uretprobe */
 	skel->bss->executed = 0;
@@ -494,6 +523,7 @@ static void test_uprobe_multi(void)
 	LIBBPF_OPTS(bpf_uprobe_multi_opts, opts);
 	struct bpf_link *link;
 	unsigned long offset;
+	void *tramp;
 
 	offset = get_uprobe_offset(&uprobe_test);
 	if (!ASSERT_GE(offset, 0, "get_uprobe_offset"))
@@ -514,7 +544,28 @@ static void test_uprobe_multi(void)
 	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_multi"))
 		goto cleanup;
 
-	check(skel, link, uprobe_test, uprobe_test, 2);
+	tramp = check(skel, link, uprobe_test, uprobe_test, 2);
+
+	/* reattach and detach without triggering optimization */
+	link = bpf_program__attach_uprobe_multi(skel->progs.test_uprobe_multi,
+				0, "/proc/self/exe", NULL, &opts);
+	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_multi"))
+		goto cleanup;
+
+	bpf_link__destroy(link);
+	if (!check_detach(uprobe_test, tramp))
+		goto cleanup;
+
+	uprobe_test();
+	ASSERT_EQ(skel->bss->executed, 2, "executed_no_probe");
+
+	/* reattach with triggering optimization */
+	link = bpf_program__attach_uprobe_multi(skel->progs.test_uprobe_multi,
+				0, "/proc/self/exe", NULL, &opts);
+	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_multi"))
+		goto cleanup;
+
+	check(skel, link, uprobe_test, uprobe_test, 4);
 
 	/* uretprobe.multi */
 	skel->bss->executed = 0;
@@ -538,6 +589,7 @@ static void test_uprobe_session(void)
 	);
 	struct bpf_link *link;
 	unsigned long offset;
+	void *tramp;
 
 	offset = get_uprobe_offset(&uprobe_test);
 	if (!ASSERT_GE(offset, 0, "get_uprobe_offset"))
@@ -557,7 +609,28 @@ static void test_uprobe_session(void)
 	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_multi"))
 		goto cleanup;
 
-	check(skel, link, uprobe_test, uprobe_test, 4);
+	tramp = check(skel, link, uprobe_test, uprobe_test, 4);
+
+	/* reattach and detach without triggering optimization */
+	link = bpf_program__attach_uprobe_multi(skel->progs.test_uprobe_session,
+				0, "/proc/self/exe", NULL, &opts);
+	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_multi"))
+		goto cleanup;
+
+	bpf_link__destroy(link);
+	if (!check_detach(uprobe_test, tramp))
+		goto cleanup;
+
+	uprobe_test();
+	ASSERT_EQ(skel->bss->executed, 4, "executed_no_probe");
+
+	/* reattach with triggering optimization */
+	link = bpf_program__attach_uprobe_multi(skel->progs.test_uprobe_session,
+				0, "/proc/self/exe", NULL, &opts);
+	if (!ASSERT_OK_PTR(link, "bpf_program__attach_uprobe_multi"))
+		goto cleanup;
+
+	check(skel, link, uprobe_test, uprobe_test, 8);
 
 cleanup:
 	uprobe_syscall_executed__destroy(skel);
@@ -567,7 +640,7 @@ static void test_uprobe_usdt(void)
 {
 	struct uprobe_syscall_executed *skel;
 	struct bpf_link *link;
-	void *addr;
+	void *addr, *tramp;
 
 	errno = 0;
 	addr = find_nop10(usdt_test);
@@ -586,7 +659,30 @@ static void test_uprobe_usdt(void)
 	if (!ASSERT_OK_PTR(link, "bpf_program__attach_usdt"))
 		goto cleanup;
 
-	check(skel, link, usdt_test, addr, 2);
+	tramp = check(skel, link, usdt_test, addr, 2);
+
+	/* reattach and detach without triggering optimization */
+	link = bpf_program__attach_usdt(skel->progs.test_usdt,
+				-1 /* all PIDs */, "/proc/self/exe",
+				"optimized_uprobe", "usdt", NULL);
+	if (!ASSERT_OK_PTR(link, "bpf_program__attach_usdt"))
+		goto cleanup;
+
+	bpf_link__destroy(link);
+	if (!check_detach(addr, tramp))
+		goto cleanup;
+
+	usdt_test();
+	ASSERT_EQ(skel->bss->executed, 2, "executed_no_probe");
+
+	/* reattach with triggering optimization */
+	link = bpf_program__attach_usdt(skel->progs.test_usdt,
+				-1 /* all PIDs */, "/proc/self/exe",
+				"optimized_uprobe", "usdt", NULL);
+	if (!ASSERT_OK_PTR(link, "bpf_program__attach_usdt"))
+		goto cleanup;
+
+	check(skel, link, usdt_test, addr, 4);
 
 cleanup:
 	uprobe_syscall_executed__destroy(skel);
Signature · 1 line
2.53.0
author reviewer
#40 lore raw

PATCH v3 11/12 selftests/bpf: Add tests for uprobe nop10 red zone clobbering

In reply to Jiri Olsa

From: Andrii Nakryiko <[email protected]>

The uprobe nop5 optimization used to replace a 5-byte NOP with a 5-byte CALL to a trampoline. The CALL pushes a return address onto the stack at [rsp-8], clobbering whatever was stored there.

On x86-64, the red zone is the 128 bytes below rsp that user code may use for temporary storage without adjusting rsp. Compilers can place USDT argument operands there, generating specs like "8@-8(%rbp)" when rbp == rsp. With the CALL-based optimization, the return address overwrites that argument before the BPF-side USDT argument fetch runs.

Add two tests for this case. The uprobe_syscall subtest stores known values at -8(%rsp), -16(%rsp), and -24(%rsp), executes an optimized nop10 uprobe, and verifies the red-zone data is still intact. The USDT subtest triggers a probe in a function where the compiler places three USDT operands in the red zone and verifies that all 10 optimized invocations deliver the expected argument values to BPF.

On an unfixed kernel, the first hit goes through the INT3 path and later hits use the optimized CALL path, so the red-zone checks fail after optimization.

[ updates to use nop10 ]
---
 .../selftests/bpf/prog_tests/uprobe_syscall.c | 75 +++++++++++++++++++
 tools/testing/selftests/bpf/prog_tests/usdt.c | 49 ++++++++++++
 tools/testing/selftests/bpf/progs/test_usdt.c | 25 +++++++
 tools/testing/selftests/bpf/usdt_2.c          | 13 ++++
 4 files changed, 162 insertions(+)
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +75 -0
index 969f4deba9fd..efff0c515184 100644
@@ -357,6 +357,48 @@ __nocf_check __weak void usdt_test(void)
 	USDT(optimized_uprobe, usdt);
 }
 
+/*
+ * Assembly-level red zone clobbering test. Stores known values in the
+ * red zone (below RSP), executes a nop10 (uprobe site), and checks that
+ * the values survived. Returns 0 if intact, 1 if clobbered.
+ *
+ * The nop5 optimization used CALL (which pushes a return address to
+ * [rsp-8]), the value at -8(%rsp) was overwritten. The nop10 optimization
+ * should escape that by moving stackpointer below the redzone before
+ * doing the CALL.
+ */
+__attribute__((aligned(16)))
+__nocf_check __weak __naked unsigned long uprobe_red_zone_test(void)
+{
+	asm volatile (
+		"movabs $0x1111111111111111, %%rax\n"
+		"movq   %%rax, -8(%%rsp)\n"
+		"movabs $0x2222222222222222, %%rax\n"
+		"movq   %%rax, -16(%%rsp)\n"
+		"movabs $0x3333333333333333, %%rax\n"
+		"movq   %%rax, -24(%%rsp)\n"
+
+		".byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00\n" /* nop10: uprobe site */
+
+		"movabs $0x1111111111111111, %%rax\n"
+		"cmpq   %%rax, -8(%%rsp)\n"
+		"jne    1f\n"
+		"movabs $0x2222222222222222, %%rax\n"
+		"cmpq   %%rax, -16(%%rsp)\n"
+		"jne    1f\n"
+		"movabs $0x3333333333333333, %%rax\n"
+		"cmpq   %%rax, -24(%%rsp)\n"
+		"jne    1f\n"
+
+		"xorl   %%eax, %%eax\n"
+		"retq\n"
+		"1:\n"
+		"movl   $1, %%eax\n"
+		"retq\n"
+		::: "rax", "memory"
+	);
+}
+
 static int find_uprobes_trampoline(void *tramp_addr)
 {
 	void *start, *end;
@@ -855,6 +897,37 @@ static void test_uprobe_race(void)
 #define __NR_uprobe 336
 #endif
 
+static void test_uprobe_red_zone(void)
+{
+	struct uprobe_syscall_executed *skel;
+	struct bpf_link *link;
+	void *nop10_addr;
+	size_t offset;
+	int i;
+
+	nop10_addr = find_nop10(uprobe_red_zone_test);
+	if (!ASSERT_NEQ(nop10_addr, NULL, "find_nop10"))
+		return;
+
+	skel = uprobe_syscall_executed__open_and_load();
+	if (!ASSERT_OK_PTR(skel, "open_and_load"))
+		return;
+
+	offset = get_uprobe_offset(nop10_addr);
+	link = bpf_program__attach_uprobe_opts(skel->progs.test_uprobe,
+			0, "/proc/self/exe", offset, NULL);
+	if (!ASSERT_OK_PTR(link, "attach_uprobe"))
+		goto cleanup;
+
+	for (i = 0; i < 10; i++)
+		ASSERT_EQ(uprobe_red_zone_test(), 0, "red_zone_intact");
+
+	bpf_link__destroy(link);
+
+cleanup:
+	uprobe_syscall_executed__destroy(skel);
+}
+
 static void test_uprobe_error(void)
 {
 	long err = syscall(__NR_uprobe);
@@ -881,6 +954,8 @@ static void __test_uprobe_syscall(void)
 		test_uprobe_usdt();
 	if (test__start_subtest("uprobe_race"))
 		test_uprobe_race();
+	if (test__start_subtest("uprobe_red_zone"))
+		test_uprobe_red_zone();
 	if (test__start_subtest("uprobe_error"))
 		test_uprobe_error();
 	if (test__start_subtest("uprobe_regs_equal"))
tools/testing/selftests/bpf/prog_tests/usdt.c +49 -0

67 lines not on this page · raw message

tools/testing/selftests/bpf/progs/test_usdt.c +25 -0
index f00cb52874e0..0ee78fb050a1 100644
@@ -149,5 +149,30 @@ int usdt_executed(struct pt_regs *ctx)
 		executed++;
 	return 0;
 }
+
+int arg_total;
+int arg_bad;
+long arg_last[3];
+long expected_arg[3];
+int expected_pid;
+
+SEC("usdt")
+int BPF_USDT(usdt_check_arg, long arg1, long arg2, long arg3)
+{
+	if (expected_pid != (bpf_get_current_pid_tgid() >> 32))
+		return 0;
+
+	__sync_fetch_and_add(&arg_total, 1);
+	arg_last[0] = arg1;
+	arg_last[1] = arg2;
+	arg_last[2] = arg3;
+
+	if (arg1 != expected_arg[0] ||
+	    arg2 != expected_arg[1] ||
+	    arg3 != expected_arg[2])
+		__sync_fetch_and_add(&arg_bad, 1);
+
+	return 0;
+}
 #endif
 char _license[] SEC("license") = "GPL";
tools/testing/selftests/bpf/usdt_2.c +13 -0
index b359b389f6c0..5e38f8605b02 100644
@@ -13,4 +13,17 @@ void usdt_2(void)
 	USDT(optimized_attach, usdt_2);
 }
 
+static volatile unsigned long usdt_red_zone_arg1 = 0xDEADBEEF;
+static volatile unsigned long usdt_red_zone_arg2 = 0xCAFEBABE;
+static volatile unsigned long usdt_red_zone_arg3 = 0xFEEDFACE;
+
+void __attribute__((noinline)) usdt_red_zone_trigger(void)
+{
+	unsigned long a1 = usdt_red_zone_arg1;
+	unsigned long a2 = usdt_red_zone_arg2;
+	unsigned long a3 = usdt_red_zone_arg3;
+
+	USDT(optimized_attach, usdt_red_zone, a1, a2, a3);
+}
+
 #endif
Signature · 1 line
2.53.0
#41 lore raw

Re: [PATCHv3 11/12] selftests/bpf: Add tests for uprobe nop10 red zone clobbering

Following up on a review comment from sashiko-bot: is this test reliable across different compiler versions?
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +0 -0
index 969f4deba9fd..efff0c515184 100644

[ ... ]

Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/usdt.c +0 -0
index fda3a298ccfc..8004c9568ffa 100644

[ ... ]

Quoted 4 lines
tools/testing/selftests/bpf/progs/test_usdt.c +0 -0
index f00cb52874e0..0ee78fb050a1 100644

[ ... ]

Quoted 10 lines
tools/testing/selftests/bpf/usdt_2.c +2 -0
index b359b389f6c0..5e38f8605b02 100644
@@ -13,4 +13,17 @@ void usdt_2(void)
 	USDT(optimized_attach, usdt_2);
 }
 
+static volatile unsigned long usdt_red_zone_arg1 = 0xDEADBEEF;
+static volatile unsigned long usdt_red_zone_arg2 = 0xCAFEBABE;

tools/testing/selftests/bpf/usdt_2.c void usdt_2(void) · line 27

Quoted 10 lines
tools/testing/selftests/bpf/usdt_2.c +10 -0
+static volatile unsigned long usdt_red_zone_arg3 = 0xFEEDFACE;
+
+void __attribute__((noinline)) usdt_red_zone_trigger(void)
+{
+	unsigned long a1 = usdt_red_zone_arg1;
+	unsigned long a2 = usdt_red_zone_arg2;
+	unsigned long a3 = usdt_red_zone_arg3;
+
+	USDT(optimized_attach, usdt_red_zone, a1, a2, a3);
+}

Following up on a review comment from sashiko-bot: is this test reliable across different compiler versions?

The x86-64 USDT macro uses the "nor" inline assembly constraint, which allows the compiler to allocate these operands to CPU registers. Because there is no register pressure in usdt_red_zone_trigger(), modern compilers might allocate the local variables a1, a2, and a3 directly to registers rather than the stack's red zone.

If the operands are placed in registers, the uprobe CALL optimization clobbering [rsp-8] will not corrupt them. This could cause the test to pass even on buggy kernels, creating a false positive.

The author acknowledged this concern but kept the test as-is, noting that selftests compile with -O0 and there's also an assembly-based test.

Would it be safer to explicitly force these operands into the red zone using inline assembly constraints, rather than depending on the compiler's register allocator?

Reference:
https://lore.kernel.org/bpf/[email protected]/

---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md

CI run summary: https://github.com/kernel-patches/bpf/actions/runs/26227520868

#42 lore raw

Re: [PATCHv3 11/12] selftests/bpf: Add tests for uprobe nop10 red zone clobbering

Quoted 29 lines · On Thu, May 21, 2026 at 01:26:07PM +0000, [email protected] wrote:
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +0 -0
index 969f4deba9fd..efff0c515184 100644

[ ... ]

Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/usdt.c +0 -0
index fda3a298ccfc..8004c9568ffa 100644

[ ... ]

Quoted 4 lines
tools/testing/selftests/bpf/progs/test_usdt.c +0 -0
index f00cb52874e0..0ee78fb050a1 100644

[ ... ]

Quoted 8 lines
tools/testing/selftests/bpf/usdt_2.c +0 -0
index b359b389f6c0..5e38f8605b02 100644
@@ -13,4 +13,17 @@ void usdt_2(void)
 	USDT(optimized_attach, usdt_2);
 }
 
Quoted 15 lines

tools/testing/selftests/bpf/usdt_2.c void usdt_2(void) · line 27

Quoted 12 lines
tools/testing/selftests/bpf/usdt_2.c +12 -0
+static volatile unsigned long usdt_red_zone_arg1 = 0xDEADBEEF;
+static volatile unsigned long usdt_red_zone_arg2 = 0xCAFEBABE;
+static volatile unsigned long usdt_red_zone_arg3 = 0xFEEDFACE;
+
+void __attribute__((noinline)) usdt_red_zone_trigger(void)
+{
+	unsigned long a1 = usdt_red_zone_arg1;
+	unsigned long a2 = usdt_red_zone_arg2;
+	unsigned long a3 = usdt_red_zone_arg3;
+
+	USDT(optimized_attach, usdt_red_zone, a1, a2, a3);
+}

Following up on a review comment from sashiko-bot: is this test reliable across different compiler versions?

Andrii replied this one in the original post:
https://lore.kernel.org/bpf/CAEf4BzZ-nASpoF+-vLYZ1D8eWRVd5JWAuhrwx8XZNrX7ZPY5_Q@mail.gmail.com/

jirka

Quoted 27 lines

The x86-64 USDT macro uses the "nor" inline assembly constraint, which allows the compiler to allocate these operands to CPU registers. Because there is no register pressure in usdt_red_zone_trigger(), modern compilers might allocate the local variables a1, a2, and a3 directly to registers rather than the stack's red zone.

If the operands are placed in registers, the uprobe CALL optimization clobbering [rsp-8] will not corrupt them. This could cause the test to pass even on buggy kernels, creating a false positive.

The author acknowledged this concern but kept the test as-is, noting that selftests compile with -O0 and there's also an assembly-based test.

Would it be safer to explicitly force these operands into the red zone using inline assembly constraints, rather than depending on the compiler's register allocator?

Reference:
https://lore.kernel.org/bpf/[email protected]/

---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md

CI run summary: https://github.com/kernel-patches/bpf/actions/runs/26227520868

author reviewer
#43 lore raw

PATCH v3 12/12 selftests/bpf: Add tests for forked/cloned optimized uprobes

In reply to Jiri Olsa

Adding tests for forked/cloned optimized uprobes and make sure the child can properly execute optimized probe for both fork (dups mm) and clone with CLONE_VM.

---
 .../selftests/bpf/prog_tests/uprobe_syscall.c | 88 +++++++++++++++++++
 1 file changed, 88 insertions(+)
tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c +88 -0
index efff0c515184..033d32b4cc27 100644
@@ -4,6 +4,8 @@
 
 #ifdef __x86_64__
 
+#define _GNU_SOURCE
+#include <sched.h>
 #include <unistd.h>
 #include <asm/ptrace.h>
 #include <linux/compiler.h>
@@ -936,6 +938,88 @@ static void test_uprobe_error(void)
 	ASSERT_EQ(errno, EPROTO, "errno");
 }
 
+__attribute__((aligned(16)))
+__nocf_check __weak __naked void uprobe_fork_test(void)
+{
+	asm volatile (
+		".byte 0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00\n" /* nop10 */
+		"ret\n"
+	);
+}
+
+static int child_func(void *arg)
+{
+	struct uprobe_syscall_executed *skel = arg;
+
+	/* Make sure the child's probe is still there and optimized.. */
+	if (memcmp(uprobe_fork_test, lea_rsp, sizeof(lea_rsp)))
+		_exit(1);
+
+	skel->bss->pid = getpid();
+
+	/* .. and it executes properly. */
+	uprobe_fork_test();
+
+	if (skel->bss->executed != 3)
+		_exit(2);
+
+	_exit(0);
+}
+
+static void test_uprobe_fork_optimized(bool clone_vm)
+{
+	struct uprobe_syscall_executed *skel = NULL;
+	struct bpf_link *link = NULL;
+	unsigned long offset;
+	int pid, status, err;
+	char stack[65535];
+
+	offset = get_uprobe_offset(&uprobe_fork_test);
+	if (!ASSERT_GE(offset, 0, "get_uprobe_offset"))
+		return;
+
+	skel = uprobe_syscall_executed__open_and_load();
+	if (!ASSERT_OK_PTR(skel, "open_and_load"))
+		goto cleanup;
+
+	link = bpf_program__attach_uprobe_opts(skel->progs.test_uprobe,
+				-1, "/proc/self/exe", offset, NULL);
+	if (!ASSERT_OK_PTR(link, "attach_uprobe"))
+		goto cleanup;
+
+	skel->bss->pid = getpid();
+
+	/* Trigger optimization of uprobe in uprobe_fork_test.  */
+	uprobe_fork_test();
+	uprobe_fork_test();
+
+	/* Make sure it got optimied. */
+	if (!ASSERT_OK(memcmp(uprobe_fork_test, lea_rsp, sizeof(lea_rsp)), "optimized"))
+		goto cleanup;
+
+	if (clone_vm) {
+		pid = clone(child_func, stack + sizeof(stack), CLONE_VM|SIGCHLD, skel);
+		if (!ASSERT_GT(pid, 0, "clone"))
+			goto cleanup;
+	} else {
+		pid = fork();
+		if (!ASSERT_GE(pid, 0, "fork"))
+			goto cleanup;
+		if (pid == 0)
+			child_func(skel);
+	}
+
+	/* Wait for the child and verify it exited properly with 0. */
+	err = waitpid(pid, &status, 0);
+	if (ASSERT_EQ(err, pid, "waitpid")) {
+		ASSERT_EQ(WIFEXITED(status), 1, "child_exited");
+		ASSERT_EQ(WEXITSTATUS(status), 0, "child_exit_code");
+	}
+
+cleanup:
+	uprobe_syscall_executed__destroy(skel);
+}
+
 static void __test_uprobe_syscall(void)
 {
 	if (test__start_subtest("uretprobe_regs_equal"))
@@ -956,6 +1040,10 @@ static void __test_uprobe_syscall(void)
 		test_uprobe_race();
 	if (test__start_subtest("uprobe_red_zone"))
 		test_uprobe_red_zone();
+	if (test__start_subtest("uprobe_optimized_fork"))
+		test_uprobe_fork_optimized(false);
+	if (test__start_subtest("uprobe_optimized_clone_vm"))
+		test_uprobe_fork_optimized(true);
 	if (test__start_subtest("uprobe_error"))
 		test_uprobe_error();
 	if (test__start_subtest("uprobe_regs_equal"))
Signature · 1 line
2.53.0