Skip to contentSkip to conversation

kprobes: Make KUnit and add stacktrace on kretprobe tests

PATCH In review Masami Hiramatsu 5 participants 23 messages Oct 21, 2021 – Dec 8, 2021

Subsystems (6)
Arm (32-bit) x86 Library code arm64 +2 more subsystems
lore
Share & tools
lore

Masami Hiramatsu

author maintainer
#0 lore raw

v3 cover kprobes: Make KUnit and add stacktrace on kretprobe tests

Hi,

Here is the 3rd version of the series to change the kprobes selftest to KUnit and add testcases for stacktrace on kretprobes, which has been fixed recently on x86. The previous version is here;

https://lore.kernel.org/all/163430224341.459050.2369208860773018092.stgit@devnote2/T/#u

In this version, I fixed arm's trampoline code, and add the version tag. And I also dropped the RFC patch. It may be discussed in another series.

Thank you,

---

Masami Hiramatsu (8):
kprobes: Add a test case for stacktrace from kretprobe handler x86/unwind: Compile kretprobe fixup code only if CONFIG_KRETPROBES=y
arm64: kprobes: Record frame pointer with kretprobe instance
arm64: kprobes: Make a frame pointer on __kretprobe_trampoline
arm64: Recover kretprobe modified return address in stacktrace
ARM: clang: Do not rely on lr register for stacktrace
ARM: kprobes: Make a frame pointer on __kretprobe_trampoline
ARM: Recover kretprobe modified return address in stacktrace

Sven Schnelle (1):
kprobes: convert tests to kunit

 arch/Kconfig                                  |    8 +
 arch/arm/Kconfig                              |    1 
 arch/arm/include/asm/stacktrace.h             |    9 +
 arch/arm/kernel/return_address.c              |    4 
 arch/arm/kernel/stacktrace.c                  |   17 +
 arch/arm/probes/kprobes/core.c                |   28 ++
 arch/arm64/Kconfig                            |    1 
 arch/arm64/include/asm/stacktrace.h           |    4 
 arch/arm64/kernel/probes/kprobes.c            |    4 
 arch/arm64/kernel/probes/kprobes_trampoline.S |    4 
 arch/arm64/kernel/stacktrace.c                |    7 
 arch/x86/Kconfig                              |    1 
 arch/x86/include/asm/unwind.h                 |    6 
 kernel/kprobes.c                              |    3 
 kernel/test_kprobes.c                         |  374 ++++++++++++++-----------
 lib/Kconfig.debug                             |    3 
 16 files changed, 302 insertions(+), 172 deletions(-)

--
Masami Hiramatsu (Linaro) <[email protected]>

author maintainer
#1 lore raw

PATCH v3 1/9 kprobes: convert tests to kunit

From: Sven Schnelle <[email protected]>

This converts the kprobes testcases to use the kunit framework. It adds a dependency on CONFIG_KUNIT, and the output will change to TAP:

TAP version 14
1..1
# Subtest: kprobes_test
1..4
random: crng init done
ok 1 - test_kprobe
ok 2 - test_kprobes
ok 3 - test_kretprobe
ok 4 - test_kretprobes
ok 1 - kprobes_test

Note that the kprobes testcases are no longer run immediately after kprobes initialization, but as a late initcall when kunit is initialized. kprobes itself is initialized with an early initcall, so the order is still correct.

---
 kernel/kprobes.c      |    3 -
 kernel/test_kprobes.c |  222 +++++++++++++------------------------------------
 lib/Kconfig.debug     |    3 -
 3 files changed, 61 insertions(+), 167 deletions(-)
kernel/kprobes.c +0 -3
index b62af9fc3607..4676627cb066 100644
@@ -2581,9 +2581,6 @@ static int __init init_kprobes(void)
 		err = register_module_notifier(&kprobe_module_nb);
 
 	kprobes_initialized = (err == 0);
-
-	if (!err)
-		init_test_probes();
 	return err;
 }
 early_initcall(init_kprobes);
kernel/test_kprobes.c +59 -163

338 lines not on this page · raw message

lib/Kconfig.debug +2 -1
index 2a9b6dcdac4f..6ceb11a43e4c 100644
@@ -2080,9 +2080,10 @@ config TEST_DIV64
 	  If unsure, say N.
 
 config KPROBES_SANITY_TEST
-	bool "Kprobes sanity tests"
+	tristate "Kprobes sanity tests"
 	depends on DEBUG_KERNEL
 	depends on KPROBES
+	depends on KUNIT
 	help
 	  This option provides for testing basic kprobes functionality on
 	  boot. Samples of kprobe and kretprobe are inserted and
author maintainer
#2 lore raw

PATCH v3 2/9 kprobes: Add a test case for stacktrace from kretprobe handler

In reply to Masami Hiramatsu

Add a test case for stacktrace from kretprobe handler and nested kretprobe handlers.

This test checks both of stack trace inside kretprobe handler and stack trace from pt_regs. Those stack trace must include actual function return address instead of kretprobe trampoline. The nested kretprobe stacktrace test checks whether the unwinder can correctly unwind the call frame on the stack which has been modified by the kretprobe.

Since the stacktrace on kretprobe is correctly fixed only on x86, this introduces a meta kconfig ARCH_CORRECT_STACKTRACE_ON_KRETPROBE which tells user that the stacktrace on kretprobe is correct or not.

The test results will be shown like below;

TAP version 14
1..1
# Subtest: kprobes_test
1..6
ok 1 - test_kprobe
ok 2 - test_kprobes
ok 3 - test_kretprobe
ok 4 - test_kretprobes
ok 5 - test_stacktrace_on_kretprobe
ok 6 - test_stacktrace_on_nested_kretprobe
# kprobes_test: pass:6 fail:0 skip:0 total:6
# Totals: pass:6 fail:0 skip:0 total:6
ok 1 - kprobes_test

---
 arch/Kconfig          |    8 ++
 arch/x86/Kconfig      |    1 
 kernel/test_kprobes.c |  158 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 167 insertions(+)
arch/Kconfig +8 -0
index 8df1c7102643..8378f83b462c 100644
@@ -191,6 +191,14 @@ config HAVE_OPTPROBES
 config HAVE_KPROBES_ON_FTRACE
 	bool
 
+config ARCH_CORRECT_STACKTRACE_ON_KRETPROBE
+	bool
+	help
+	  Since kretprobes modifies return address on the stack, the
+	  stacktrace may see the kretprobe trampoline address instead
+	  of correct one. If the architecture stacktrace code and
+	  unwinder can adjust such entries, select this configuration.
+
 config HAVE_FUNCTION_ERROR_INJECTION
 	bool
 
arch/x86/Kconfig +1 -0
index ab83c22d274e..2049364b3981 100644
@@ -61,6 +61,7 @@ config X86
 	select ACPI_SYSTEM_POWER_STATES_SUPPORT	if ACPI
 	select ARCH_32BIT_OFF_T			if X86_32
 	select ARCH_CLOCKSOURCE_INIT
+	select ARCH_CORRECT_STACKTRACE_ON_KRETPROBE
 	select ARCH_ENABLE_HUGEPAGE_MIGRATION if X86_64 && HUGETLB_PAGE && MIGRATION
 	select ARCH_ENABLE_MEMORY_HOTPLUG if X86_64 || (X86_32 && HIGHMEM)
 	select ARCH_ENABLE_MEMORY_HOTREMOVE if MEMORY_HOTPLUG
kernel/test_kprobes.c +158 -0

188 lines not on this page · raw message

#3 lore raw

Re: [PATCH v3 2/9] kprobes: Add a test case for stacktrace from kretprobe handler

Quoted 16 lines · On Thu, 21 Oct 2021 09:54:32 +0900 Masami Hiramatsu <[email protected]> wrote:

Add a test case for stacktrace from kretprobe handler and nested kretprobe handlers.

This test checks both of stack trace inside kretprobe handler and stack trace from pt_regs. Those stack trace must include actual function return address instead of kretprobe trampoline. The nested kretprobe stacktrace test checks whether the unwinder can correctly unwind the call frame on the stack which has been modified by the kretprobe.

Since the stacktrace on kretprobe is correctly fixed only on x86, this introduces a meta kconfig ARCH_CORRECT_STACKTRACE_ON_KRETPROBE which tells user that the stacktrace on kretprobe is correct or not.

The test results will be shown like below;

Quoted 13 lines

TAP version 14
1..1
# Subtest: kprobes_test
1..6
ok 1 - test_kprobe
ok 2 - test_kprobes
ok 3 - test_kretprobe
ok 4 - test_kretprobes
ok 5 - test_stacktrace_on_kretprobe
ok 6 - test_stacktrace_on_nested_kretprobe
# kprobes_test: pass:6 fail:0 skip:0 total:6
# Totals: pass:6 fail:0 skip:0 total:6
ok 1 - kprobes_test

So my allmodconfig test failed on this:

ERROR: modpost: "stack_trace_save_regs" [kernel/test_kprobes.ko] undefined!

kernel/test_kprobes.c static void test_kretprobes(struct kunit *test) · line 246

Quoted 10 lines
kernel/test_kprobes.c +10 -0
+	/*
+	 * Test stacktrace from pt_regs at the return address. Thus the stack
+	 * trace must start from the target return address.
+	 */
+	ret = stack_trace_save_regs(regs, stack_buf, STACK_BUF_SIZE, 0);
+	KUNIT_EXPECT_NE(current_test, ret, 0);
+	KUNIT_EXPECT_EQ(current_test, stack_buf[0], target_return_address[1]);
+
+	return 0;
+}

It appears that that "stack_trace_save_regs" is not exported. And this code can be compiled as a module.

I'm going to continue testing my code, as I have over 40 patches that need to go into next. I'll just rebase removing this commit only (hopefully nothing else breaks), and if everything then passes, I'll push to next.

-- Steve

#4 lore raw

Re: [PATCH v3 2/9] kprobes: Add a test case for stacktrace from kretprobe handler

Quoted 3 lines · On Fri, 22 Oct 2021 12:15:37 -0400 Steven Rostedt <[email protected]> wrote:

I'm going to continue testing my code, as I have over 40 patches that need to go into next. I'll just rebase removing this commit only (hopefully nothing else breaks), and if everything then passes, I'll push to next.

My tests are now back at the allmodconfig (did most the tests, but not all, to save time), hopefully it will pass this time ;-)

What I plan on posting soon is located here (if you want to see them).

git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
branch: ftrace/core

-- Steve

author maintainer
#5 lore raw

Re: [PATCH v3 2/9] kprobes: Add a test case for stacktrace from kretprobe handler

In reply to Steven Rostedt
Quoted 33 lines · On Fri, 22 Oct 2021 12:15:37 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 16 lines · On Thu, 21 Oct 2021 09:54:32 +0900 Masami Hiramatsu <[email protected]> wrote:

Add a test case for stacktrace from kretprobe handler and nested kretprobe handlers.

This test checks both of stack trace inside kretprobe handler and stack trace from pt_regs. Those stack trace must include actual function return address instead of kretprobe trampoline. The nested kretprobe stacktrace test checks whether the unwinder can correctly unwind the call frame on the stack which has been modified by the kretprobe.

Since the stacktrace on kretprobe is correctly fixed only on x86, this introduces a meta kconfig ARCH_CORRECT_STACKTRACE_ON_KRETPROBE which tells user that the stacktrace on kretprobe is correct or not.

The test results will be shown like below;

Quoted 13 lines

TAP version 14
1..1
# Subtest: kprobes_test
1..6
ok 1 - test_kprobe
ok 2 - test_kprobes
ok 3 - test_kretprobe
ok 4 - test_kretprobes
ok 5 - test_stacktrace_on_kretprobe
ok 6 - test_stacktrace_on_nested_kretprobe
# kprobes_test: pass:6 fail:0 skip:0 total:6
# Totals: pass:6 fail:0 skip:0 total:6
ok 1 - kprobes_test

Quoted 3 lines

So my allmodconfig test failed on this:

ERROR: modpost: "stack_trace_save_regs" [kernel/test_kprobes.ko] undefined!

Oops.

Quoted 5 lines
Quoted 5 lines
kernel/test_kprobes.c +5 -0
+	/*
+	 * Test stacktrace from pt_regs at the return address. Thus the stack
+	 * trace must start from the target return address.
+	 */
+	ret = stack_trace_save_regs(regs, stack_buf, STACK_BUF_SIZE, 0);
Quoted 8 lines

kernel/test_kprobes.c static void test_kretprobes(struct kunit *test) · line 246

Quoted 5 lines
kernel/test_kprobes.c +5 -0
+	KUNIT_EXPECT_NE(current_test, ret, 0);
+	KUNIT_EXPECT_EQ(current_test, stack_buf[0], target_return_address[1]);
+
+	return 0;
+}

It appears that that "stack_trace_save_regs" is not exported. And this code can be compiled as a module.

Yes, if the selftest is compiled as a module, it has to remove the stack_trace_save_regs().

Quoted 4 lines

I'm going to continue testing my code, as I have over 40 patches that need to go into next. I'll just rebase removing this commit only (hopefully nothing else breaks), and if everything then passes, I'll push to next.

OK, let me fix that.

Thank you,

Quoted 2 lines

-- Steve

Signature · 1 line
Masami Hiramatsu <[email protected]>
author maintainer
#6 lore raw

PATCH v3 3/9 x86/unwind: Compile kretprobe fixup code only if CONFIG_KRETPROBES=y

In reply to Masami Hiramatsu

Compile kretprobe related stacktrace entry recovery code and unwind_state::kr_cur field only when CONFIG_KRETPROBES=y.

---
 arch/x86/include/asm/unwind.h |    6 ++++++
 1 file changed, 6 insertions(+)
arch/x86/include/asm/unwind.h +6 -0
index fca2e783e3ce..2a1f8734416d 100644
@@ -16,7 +16,9 @@ struct unwind_state {
 	unsigned long stack_mask;
 	struct task_struct *task;
 	int graph_idx;
+#ifdef CONFIG_KRETPROBES
 	struct llist_node *kr_cur;
+#endif
 	bool error;
 #if defined(CONFIG_UNWINDER_ORC)
 	bool signal, full_regs;
@@ -105,9 +107,13 @@ static inline
 unsigned long unwind_recover_kretprobe(struct unwind_state *state,
 				       unsigned long addr, unsigned long *addr_p)
 {
+#ifdef CONFIG_KRETPROBES
 	return is_kretprobe_trampoline(addr) ?
 		kretprobe_find_ret_addr(state->task, addr_p, &state->kr_cur) :
 		addr;
+#else
+	return addr;
+#endif
 }
 
 /* Recover the return address modified by kretprobe and ftrace_graph. */
author maintainer
#7 lore raw

PATCH v3 4/9 arm64: kprobes: Record frame pointer with kretprobe instance

In reply to Masami Hiramatsu

Record the frame pointer instead of stack address with kretprobe instance as the identifier on the instance list.
Since arm64 always enable CONFIG_FRAME_POINTER, we can use the actual frame pointer (x29).

This will allow the stacktrace code to find the original return address from the FP alone.

---
Changes in v2:
- Update changelog according to Mark's comment.

---
 arch/arm64/kernel/probes/kprobes.c |    4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
arch/arm64/kernel/probes/kprobes.c +2 -2
index e7ad6da980e8..d9dfa82c1f18 100644
@@ -401,14 +401,14 @@ int __init arch_populate_kprobe_blacklist(void)
 
 void __kprobes __used *trampoline_probe_handler(struct pt_regs *regs)
 {
-	return (void *)kretprobe_trampoline_handler(regs, (void *)kernel_stack_pointer(regs));
+	return (void *)kretprobe_trampoline_handler(regs, (void *)regs->regs[29]);
 }
 
 void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri,
 				      struct pt_regs *regs)
 {
 	ri->ret_addr = (kprobe_opcode_t *)regs->regs[30];
-	ri->fp = (void *)kernel_stack_pointer(regs);
+	ri->fp = (void *)regs->regs[29];
 
 	/* replace return addr (x30) with trampoline */
 	regs->regs[30] = (long)&__kretprobe_trampoline;
author maintainer
#8 lore raw

PATCH v3 5/9 arm64: kprobes: Make a frame pointer on __kretprobe_trampoline

In reply to Masami Hiramatsu

Make a frame pointer (make the x29 register points the address of pt_regs->regs[29]) on __kretprobe_trampoline.

This frame pointer will be used by the stacktracer when it is called from the kretprobe handlers. In this case, the stack tracer will unwind stack to trampoline_probe_handler() and find the next frame pointer in the stack frame of the __kretprobe_trampoline().

---
 arch/arm64/kernel/probes/kprobes_trampoline.S |    4 ++++
 1 file changed, 4 insertions(+)
arch/arm64/kernel/probes/kprobes_trampoline.S +4 -0
index 520ee8711db1..9a6499bed58b 100644
@@ -66,6 +66,9 @@ SYM_CODE_START(__kretprobe_trampoline)
 
 	save_all_base_regs
 
+	/* Setup a frame pointer. */
+	add x29, sp, #S_FP
+
 	mov x0, sp
 	bl trampoline_probe_handler
 	/*
@@ -74,6 +77,7 @@ SYM_CODE_START(__kretprobe_trampoline)
 	 */
 	mov lr, x0
 
+	/* The frame pointer (x29) is restored with other registers. */
 	restore_all_base_regs
 
 	add sp, sp, #PT_REGS_SIZE
author maintainer
#9 lore raw

PATCH v3 6/9 arm64: Recover kretprobe modified return address in stacktrace

In reply to Masami Hiramatsu

Since the kretprobe replaces the function return address with the kretprobe_trampoline on the stack, stack unwinder shows it instead of the correct return address.

This checks whether the next return address is the __kretprobe_trampoline(), and if so, try to find the correct return address from the kretprobe instance list. For this purpose this adds 'kr_cur' loop cursor to memorize the current kretprobe instance.

With this fix, now arm64 can enable CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE, and pass the kprobe self tests.

---
Changes in v2:
- Add comment for kr_cur.
- Make the kretprobe related code depends on CONFIG_KRETPROBES.
- Initialize "kr_cur" directly in start_backtrace() instead of clearing "frame" data structure by memset().

---
 arch/arm64/Kconfig                  |    1 +
 arch/arm64/include/asm/stacktrace.h |    4 ++++
 arch/arm64/kernel/stacktrace.c      |    7 +++++++
 3 files changed, 12 insertions(+)
arch/arm64/Kconfig +1 -0
index 5c7ae4c3954b..edde5171ffb2 100644
@@ -11,6 +11,7 @@ config ARM64
 	select ACPI_PPTT if ACPI
 	select ARCH_HAS_DEBUG_WX
 	select ARCH_BINFMT_ELF_STATE
+	select ARCH_CORRECT_STACKTRACE_ON_KRETPROBE
 	select ARCH_ENABLE_HUGEPAGE_MIGRATION if HUGETLB_PAGE && MIGRATION
 	select ARCH_ENABLE_MEMORY_HOTPLUG
 	select ARCH_ENABLE_MEMORY_HOTREMOVE
arch/arm64/include/asm/stacktrace.h +4 -0
index 8aebc00c1718..a4e046ef4568 100644
@@ -9,6 +9,7 @@
 #include <linux/sched.h>
 #include <linux/sched/task_stack.h>
 #include <linux/types.h>
+#include <linux/llist.h>
 
 #include <asm/memory.h>
 #include <asm/ptrace.h>
@@ -59,6 +60,9 @@ struct stackframe {
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 	int graph;
 #endif
+#ifdef CONFIG_KRETPROBES
+	struct llist_node *kr_cur;
+#endif
 };
 
 extern int unwind_frame(struct task_struct *tsk, struct stackframe *frame);
arch/arm64/kernel/stacktrace.c +7 -0
index 8982a2b78acf..c30624fff6ac 100644
@@ -41,6 +41,9 @@ void start_backtrace(struct stackframe *frame, unsigned long fp,
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 	frame->graph = 0;
 #endif
+#ifdef CONFIG_KRETPROBES
+	frame->kr_cur = NULL;
+#endif
 
 	/*
 	 * Prime the first unwind.
@@ -129,6 +132,10 @@ int notrace unwind_frame(struct task_struct *tsk, struct stackframe *frame)
 		frame->pc = ret_stack->ret;
 	}
 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
+#ifdef CONFIG_KRETPROBES
+	if (is_kretprobe_trampoline(frame->pc))
+		frame->pc = kretprobe_find_ret_addr(tsk, (void *)frame->fp, &frame->kr_cur);
+#endif
 
 	frame->pc = ptrauth_strip_insn_pac(frame->pc);
 
maintainer Acked-by on v3 6/9
#10 lore raw

Re: [PATCH v3 6/9] arm64: Recover kretprobe modified return address in stacktrace

Quoted 21 lines · Masami Hiramatsu

Since the kretprobe replaces the function return address with the kretprobe_trampoline on the stack, stack unwinder shows it instead of the correct return address.

This checks whether the next return address is the __kretprobe_trampoline(), and if so, try to find the correct return address from the kretprobe instance list. For this purpose this adds 'kr_cur' loop cursor to memorize the current kretprobe instance.

With this fix, now arm64 can enable CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE, and pass the kprobe self tests.

---
Changes in v2:
- Add comment for kr_cur.
- Make the kretprobe related code depends on CONFIG_KRETPROBES.
- Initialize "kr_cur" directly in start_backtrace() instead of clearing "frame" data structure by memset().

Quoted 5 lines
---
 arch/arm64/Kconfig                  |    1 +
 arch/arm64/include/asm/stacktrace.h |    4 ++++
 arch/arm64/kernel/stacktrace.c      |    7 +++++++
 3 files changed, 12 insertions(+)

I'm not sure how you're planning to merge this, so please let me know if you want me to queue any of the arm64 bits.

Will

author maintainer
#11 lore raw

Re: [PATCH v3 6/9] arm64: Recover kretprobe modified return address in stacktrace

Quoted 28 lines · On Thu, 21 Oct 2021 11:15:12 +0100 Will Deacon <[email protected]> wrote:
Quoted 21 lines · Masami Hiramatsu

Since the kretprobe replaces the function return address with the kretprobe_trampoline on the stack, stack unwinder shows it instead of the correct return address.

This checks whether the next return address is the __kretprobe_trampoline(), and if so, try to find the correct return address from the kretprobe instance list. For this purpose this adds 'kr_cur' loop cursor to memorize the current kretprobe instance.

With this fix, now arm64 can enable CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE, and pass the kprobe self tests.

---
Changes in v2:
- Add comment for kr_cur.
- Make the kretprobe related code depends on CONFIG_KRETPROBES.
- Initialize "kr_cur" directly in start_backtrace() instead of clearing "frame" data structure by memset().

Quoted 5 lines
---
 arch/arm64/Kconfig                  |    1 +
 arch/arm64/include/asm/stacktrace.h |    4 ++++
 arch/arm64/kernel/stacktrace.c      |    7 +++++++
 3 files changed, 12 insertions(+)
Quoted 1 line

Thank you!

Quoted 3 lines

I'm not sure how you're planning to merge this, so please let me know if you want me to queue any of the arm64 bits.

Ah, good question. Since this part depends on the first 3 patches and Steve's tracing tree, these should go through the tracing tree. Is that OK for you?

(Or, wait for merging the current tracing tree and merge rest of them.
but this will take a long time.)

Thank you,

Signature · 1 line
Masami Hiramatsu <[email protected]>
#12 lore raw

Re: [PATCH v3 6/9] arm64: Recover kretprobe modified return address in stacktrace

Quoted 8 lines · On Thu, 21 Oct 2021 23:26:30 +0900 Masami Hiramatsu <[email protected]> wrote:
Quoted 3 lines

I'm not sure how you're planning to merge this, so please let me know if you want me to queue any of the arm64 bits.

Ah, good question. Since this part depends on the first 3 patches and Steve's tracing tree, these should go through the tracing tree. Is that OK for you?

I'm OK with merging this.

Quoted 2 lines

(Or, wait for merging the current tracing tree and merge rest of them.
but this will take a long time.)

And my linux-next is behind because my tests triggered a bug on one of my arcane configs, and I'm still debugging it. :-p

-- Steve

maintainer
#13 lore raw

Re: [PATCH v3 6/9] arm64: Recover kretprobe modified return address in stacktrace

Quoted 7 lines · Steven Rostedt
Quoted 4 lines · On Thu, 21 Oct 2021 23:26:30 +0900 Masami Hiramatsu <[email protected]> wrote:
Quoted 3 lines

I'm not sure how you're planning to merge this, so please let me know if you want me to queue any of the arm64 bits.

Quoted 6 lines
Quoted 4 lines

Ah, good question. Since this part depends on the first 3 patches and Steve's tracing tree, these should go through the tracing tree. Is that OK for you?

I'm OK with merging this.

Ok, cool. I've acked the arm64 bits so I'll leave it in your hands!

Quoted 5 lines
Quoted 2 lines

(Or, wait for merging the current tracing tree and merge rest of them.
but this will take a long time.)

And my linux-next is behind because my tests triggered a bug on one of my arcane configs, and I'm still debugging it. :-p

Happy debugging :)

Will

#14 lore raw

Re: [PATCH v3 6/9] arm64: Recover kretprobe modified return address in stacktrace

Quoted 3 lines · On Thu, 21 Oct 2021 17:52:42 +0100 Will Deacon <[email protected]> wrote:
Quoted 1 line

I'm OK with merging this.

Ok, cool. I've acked the arm64 bits so I'll leave it in your hands!

Thanks! I'll pull them in.

Quoted 8 lines
Quoted 6 lines
Quoted 3 lines

(Or, wait for merging the current tracing tree and merge rest of them.
but this will take a long time.)

And my linux-next is behind because my tests triggered a bug on one of my arcane configs, and I'm still debugging it. :-p

Happy debugging :)

Found the bug. I'll restart my tests (takes around 13 hours more or less to complete) and when/if they succeed, I'll push it for inclusion in linux-next.

-- Steve

#15 lore raw

Re: [PATCH v3 6/9] arm64: Recover kretprobe modified return address in stacktrace

Quoted 5 lines · On Thu, 21 Oct 2021 12:59:43 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 1 line

Happy debugging :)

Found the bug. I'll restart my tests (takes around 13 hours more or less to complete) and when/if they succeed, I'll push it for inclusion in linux-next.

And of course, more bugs appear. Nothing (yet) to do with this patch series, but as I started running tests I haven't run yet, it's triggering bugs in other places that I need to go sort out :-p

-- Steve

author maintainer
#16 lore raw

PATCH v3 7/9 ARM: clang: Do not rely on lr register for stacktrace

In reply to Masami Hiramatsu

Currently the stacktrace on clang compiled arm kernel uses the 'lr' register to find the first frame address from pt_regs. However, that is wrong after calling another function, because the 'lr' register is used by 'bl' instruction and never be recovered.

As same as gcc arm kernel, directly use the frame pointer (r11) of the pt_regs to find the first frame address.

Note that this fixes kretprobe stacktrace issue only with CONFIG_UNWINDER_FRAME_POINTER=y. For the CONFIG_UNWINDER_ARM, we need another fix.

---
Changes in v2:
- Fix typos in changelog.

---
 arch/arm/kernel/stacktrace.c |    3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
arch/arm/kernel/stacktrace.c +1 -2
index 76ea4178a55c..db798eac7431 100644
@@ -54,8 +54,7 @@ int notrace unwind_frame(struct stackframe *frame)
 
 	frame->sp = frame->fp;
 	frame->fp = *(unsigned long *)(fp);
-	frame->pc = frame->lr;
-	frame->lr = *(unsigned long *)(fp + 4);
+	frame->pc = *(unsigned long *)(fp + 4);
 #else
 	/* check current frame pointer is within bounds */
 	if (fp < low + 12 || fp > high - 4)
author maintainer
#17 lore raw

PATCH v3 8/9 ARM: kprobes: Make a frame pointer on __kretprobe_trampoline

In reply to Masami Hiramatsu

Currently kretprobe on ARM just fills r0-r11 of pt_regs, but that is not enough for the stacktrace. Moreover, from the user kretprobe handler, stacktrace needs a frame pointer on the __kretprobe_trampoline.

This adds a frame pointer on __kretprobe_trampoline for both gcc and clang case. Those have different frame pointer so we need different but similar stack on pt_regs.

Gcc makes the frame pointer (fp) to point the 'pc' address of the {fp, ip (=sp), lr, pc}, this means {r11, r13, r14, r15}. Thus if we save the r11 (fp) on pt_regs->r12, we can make this set on the end of pt_regs.

On the other hand, Clang makes the frame pointer to point the 'fp' address of {fp, lr} on stack. Since the next to the pt_regs->lr is pt_regs->sp, I reused the pair of pt_regs->fp and pt_regs->ip.
So this stores the 'lr' on pt_regs->ip and make the fp to point pt_regs->fp.

For both cases, saves __kretprobe_trampoline address to pt_regs->lr, so that the stack tracer can identify this frame pointer has been made by the __kretprobe_trampoline.

Note that if the CONFIG_FRAME_POINTER is not set, this keeps fp as is.

---
Changes in v3:
- Avoid using !sp when storing sp itself.
- Unify stmdb register list.
- Keep the current assembly code when CONFIG_FRAME_POINTER=n.

---
 arch/arm/probes/kprobes/core.c |   28 ++++++++++++++++++++++++----
 1 file changed, 24 insertions(+), 4 deletions(-)
arch/arm/probes/kprobes/core.c +24 -4
index 95f23b47ba27..4848404ba51b 100644
@@ -368,16 +368,36 @@ int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
 /*
  * When a retprobed function returns, trampoline_handler() is called,
  * calling the kretprobe's handler. We construct a struct pt_regs to
- * give a view of registers r0-r11 to the user return-handler.  This is
- * not a complete pt_regs structure, but that should be plenty sufficient
- * for kretprobe handlers which should normally be interested in r0 only
- * anyway.
+ * give a view of registers r0-r11, sp, lr, and pc to the user
+ * return-handler. This is not a complete pt_regs structure, but that
+ * should be enough for stacktrace from the return handler with or
+ * without pt_regs.
  */
 void __naked __kprobes __kretprobe_trampoline(void)
 {
 	__asm__ __volatile__ (
+#ifdef CONFIG_FRAME_POINTER
+		"ldr	lr, =__kretprobe_trampoline	\n\t"
+	/* __kretprobe_trampoline makes a framepointer on pt_regs. */
+#ifdef CONFIG_CC_IS_CLANG
+		"stmdb	sp, {sp, lr, pc}	\n\t"
+		"sub	sp, sp, #12		\n\t"
+		/* In clang case, pt_regs->ip = lr. */
+		"stmdb	sp!, {r0 - r11, lr}	\n\t"
+		/* fp points regs->r11 (fp) */
+		"add	fp, sp,	#44		\n\t"
+#else /* !CONFIG_CC_IS_CLANG */
+		/* In gcc case, pt_regs->ip = fp. */
+		"stmdb	sp, {fp, sp, lr, pc}	\n\t"
 		"sub	sp, sp, #16		\n\t"
 		"stmdb	sp!, {r0 - r11}		\n\t"
+		/* fp points regs->r15 (pc) */
+		"add	fp, sp, #60		\n\t"
+#endif /* CONFIG_CC_IS_CLANG */
+#else /* !CONFIG_FRAME_POINTER */
+		"sub	sp, sp, #16		\n\t"
+		"stmdb	sp!, {r0 - r11}		\n\t"
+#endif /* CONFIG_FRAME_POINTER */
 		"mov	r0, sp			\n\t"
 		"bl	trampoline_handler	\n\t"
 		"mov	lr, r0			\n\t"
#18 lore raw

Re: [PATCH v3 8/9] ARM: kprobes: Make a frame pointer on __kretprobe_trampoline

Quoted 26 lines · Masami Hiramatsu

Currently kretprobe on ARM just fills r0-r11 of pt_regs, but that is not enough for the stacktrace. Moreover, from the user kretprobe handler, stacktrace needs a frame pointer on the __kretprobe_trampoline.

This adds a frame pointer on __kretprobe_trampoline for both gcc and clang case. Those have different frame pointer so we need different but similar stack on pt_regs.

Gcc makes the frame pointer (fp) to point the 'pc' address of the {fp, ip (=sp), lr, pc}, this means {r11, r13, r14, r15}. Thus if we save the r11 (fp) on pt_regs->r12, we can make this set on the end of pt_regs.

On the other hand, Clang makes the frame pointer to point the 'fp' address of {fp, lr} on stack. Since the next to the pt_regs->lr is pt_regs->sp, I reused the pair of pt_regs->fp and pt_regs->ip.
So this stores the 'lr' on pt_regs->ip and make the fp to point pt_regs->fp.

For both cases, saves __kretprobe_trampoline address to pt_regs->lr, so that the stack tracer can identify this frame pointer has been made by the __kretprobe_trampoline.

Quoted 5 lines

Note that if the CONFIG_FRAME_POINTER is not set, this keeps fp as is.

This causes a regression that I see in randconfig builds with gcc-11:

/tmp/ccovvQNw.s: Assembler messages:
/tmp/ccovvQNw.s:32: Error: invalid literal constant: pool needs to be closer make[5]: *** [/git/arm-soc/scripts/Makefile.build:288:
arch/arm/probes/kprobes/core.o] Error 1

I have two randconfigs that reproduce it locally, here is a .config
[1] and assembly
output[2] for reference. I have not done any further analysis, but maybe you have
an idea.

Arnd

[1] https://pastebin.com/y4rkH8qX
[2] https://pastebin.com/9mEVU8Rd

#19 lore raw

Re: [PATCH v3 8/9] ARM: kprobes: Make a frame pointer on __kretprobe_trampoline

Quoted 41 lines · Arnd Bergmann
Quoted 26 lines · Masami Hiramatsu

Currently kretprobe on ARM just fills r0-r11 of pt_regs, but that is not enough for the stacktrace. Moreover, from the user kretprobe handler, stacktrace needs a frame pointer on the __kretprobe_trampoline.

This adds a frame pointer on __kretprobe_trampoline for both gcc and clang case. Those have different frame pointer so we need different but similar stack on pt_regs.

Gcc makes the frame pointer (fp) to point the 'pc' address of the {fp, ip (=sp), lr, pc}, this means {r11, r13, r14, r15}. Thus if we save the r11 (fp) on pt_regs->r12, we can make this set on the end of pt_regs.

On the other hand, Clang makes the frame pointer to point the 'fp' address of {fp, lr} on stack. Since the next to the pt_regs->lr is pt_regs->sp, I reused the pair of pt_regs->fp and pt_regs->ip.
So this stores the 'lr' on pt_regs->ip and make the fp to point pt_regs->fp.

For both cases, saves __kretprobe_trampoline address to pt_regs->lr, so that the stack tracer can identify this frame pointer has been made by the __kretprobe_trampoline.

Quoted 5 lines

Note that if the CONFIG_FRAME_POINTER is not set, this keeps fp as is.

This causes a regression that I see in randconfig builds with gcc-11:

/tmp/ccovvQNw.s: Assembler messages:
/tmp/ccovvQNw.s:32: Error: invalid literal constant: pool needs to be closer make[5]: *** [/git/arm-soc/scripts/Makefile.build:288:
arch/arm/probes/kprobes/core.o] Error 1

Quoted 5 lines

I have two randconfigs that reproduce it locally, here is a .config
[1] and assembly
output[2] for reference. I have not done any further analysis, but maybe you have
an idea.

Does this help?

arch/arm/probes/kprobes/core.c +1 -0
index 9090c3a74dcc..88999ed2cfc4 100644
@@ -408,6 +408,7 @@ void __naked __kprobes __kretprobe_trampoline(void)
 #else
                "mov    pc, lr                  \n\t"
 #endif
+               ".ltorg                         \n\t"
                : : : "memory");
 }
 

_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

#20 lore raw

Re: [PATCH v3 8/9] ARM: kprobes: Make a frame pointer on __kretprobe_trampoline

Quoted 2 lines · Ard Biesheuvel

Does this help?

Yes, this fixes it, thanks for the quick help!

Arnd

author maintainer
#21 lore raw

Re: [PATCH v3 8/9] ARM: kprobes: Make a frame pointer on __kretprobe_trampoline

Quoted 5 lines · On Sat, 4 Dec 2021 13:08:46 +0100 Arnd Bergmann <[email protected]> wrote:
Quoted 2 lines · Ard Biesheuvel

Does this help?

Yes, this fixes it, thanks for the quick help!

Thanks Ard and Arnd!
BTW, would you know what kconfig item warns this issue, or is it only with gcc-11?
I would like to build the same environment.

Thank you,

Quoted 2 lines

Arnd

Signature · 1 line
Masami Hiramatsu <[email protected]>
author maintainer
#22 lore raw

PATCH v3 9/9 ARM: Recover kretprobe modified return address in stacktrace

In reply to Masami Hiramatsu

Since the kretprobe replaces the function return address with the kretprobe_trampoline on the stack, arm unwinder shows it instead of the correct return address.

This finds the correct return address from the per-task kretprobe_instances list and verify it is in between the caller fp and callee fp.

Note that this supports both GCC and clang if CONFIG_FRAME_POINTER=y and CONFIG_ARM_UNWIND=n. For the ARM unwinder, this is still not working correctly.

---
Changes in v2:
- Compile this code only when CONFIG_KRETPROBES=y

---
 arch/arm/Kconfig                  |    1 +
 arch/arm/include/asm/stacktrace.h |    9 +++++++++
 arch/arm/kernel/return_address.c  |    4 ++++
 arch/arm/kernel/stacktrace.c      |   14 ++++++++++++++
 4 files changed, 28 insertions(+)
arch/arm/Kconfig +1 -0
index fc196421b2ce..bb4f1872967c 100644
@@ -3,6 +3,7 @@ config ARM
 	bool
 	default y
 	select ARCH_32BIT_OFF_T
+	select ARCH_CORRECT_STACKTRACE_ON_KRETPROBE if HAVE_KRETPROBES && FRAME_POINTER && !ARM_UNWIND
 	select ARCH_HAS_BINFMT_FLAT
 	select ARCH_HAS_DEBUG_VIRTUAL if MMU
 	select ARCH_HAS_DMA_WRITE_COMBINE if !ARM_DMA_MEM_BUFFERABLE
arch/arm/include/asm/stacktrace.h +9 -0
index 2d76a2e29f05..8f54f9ad8a9b 100644
@@ -3,6 +3,7 @@
 #define __ASM_STACKTRACE_H
 
 #include <asm/ptrace.h>
+#include <linux/llist.h>
 
 struct stackframe {
 	/*
@@ -13,6 +14,10 @@ struct stackframe {
 	unsigned long sp;
 	unsigned long lr;
 	unsigned long pc;
+#ifdef CONFIG_KRETPROBES
+	struct llist_node *kr_cur;
+	struct task_struct *tsk;
+#endif
 };
 
 static __always_inline
@@ -22,6 +27,10 @@ void arm_get_current_stackframe(struct pt_regs *regs, struct stackframe *frame)
 		frame->sp = regs->ARM_sp;
 		frame->lr = regs->ARM_lr;
 		frame->pc = regs->ARM_pc;
+#ifdef CONFIG_KRETPROBES
+		frame->kr_cur = NULL;
+		frame->tsk = current;
+#endif
 }
 
 extern int unwind_frame(struct stackframe *frame);
arch/arm/kernel/return_address.c +4 -0
index 7b42ac010fdf..00c11579406c 100644
@@ -42,6 +42,10 @@ void *return_address(unsigned int level)
 	frame.sp = current_stack_pointer;
 	frame.lr = (unsigned long)__builtin_return_address(0);
 	frame.pc = (unsigned long)return_address;
+#ifdef CONFIG_KRETPROBES
+	frame.kr_cur = NULL;
+	frame.tsk = current;
+#endif
 
 	walk_stackframe(&frame, save_return_addr, &data);
 
arch/arm/kernel/stacktrace.c +14 -0
index db798eac7431..75e905508f27 100644
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 #include <linux/export.h>
+#include <linux/kprobes.h>
 #include <linux/sched.h>
 #include <linux/sched/debug.h>
 #include <linux/stacktrace.h>
@@ -65,6 +66,11 @@ int notrace unwind_frame(struct stackframe *frame)
 	frame->sp = *(unsigned long *)(fp - 8);
 	frame->pc = *(unsigned long *)(fp - 4);
 #endif
+#ifdef CONFIG_KRETPROBES
+	if (is_kretprobe_trampoline(frame->pc))
+		frame->pc = kretprobe_find_ret_addr(frame->tsk,
+					(void *)frame->fp, &frame->kr_cur);
+#endif
 
 	return 0;
 }
@@ -156,6 +162,10 @@ static noinline void __save_stack_trace(struct task_struct *tsk,
 		frame.lr = (unsigned long)__builtin_return_address(0);
 		frame.pc = (unsigned long)__save_stack_trace;
 	}
+#ifdef CONFIG_KRETPROBES
+	frame.kr_cur = NULL;
+	frame.tsk = tsk;
+#endif
 
 	walk_stackframe(&frame, save_trace, &data);
 }
@@ -173,6 +183,10 @@ void save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace)
 	frame.sp = regs->ARM_sp;
 	frame.lr = regs->ARM_lr;
 	frame.pc = regs->ARM_pc;
+#ifdef CONFIG_KRETPROBES
+	frame.kr_cur = NULL;
+	frame.tsk = current;
+#endif
 
 	walk_stackframe(&frame, save_trace, &data);
 }