[RFC PATCH 12/12] unwind: arm64: use .lr_unwind to unwind interrupt frames
From: Dylan Hatch
Date: Mon Nov 16 2026 - 23:36:12 EST
Add kunwind_next_regs_lr_unwind() to unwind across pt_regs exception
boundaries using .lr_unwind mode and SP-offset metadata (live x30, [x29]
frame record, or [sp + sp_off] frame record), falling back to
frame-pointer unwinding and marking the stacktrace unreliable on
failure.
Signed-off-by: Dylan Hatch <dylanbhatch@xxxxxxxxxx>
---
arch/arm64/kernel/stacktrace.c | 85 ++++++++++++++++++++++++++++++----
1 file changed, 75 insertions(+), 10 deletions(-)
diff --git a/arch/arm64/kernel/stacktrace.c b/arch/arm64/kernel/stacktrace.c
index 3ebcf8c53fb04..842555a4a3fe2 100644
--- a/arch/arm64/kernel/stacktrace.c
+++ b/arch/arm64/kernel/stacktrace.c
@@ -10,6 +10,7 @@
#include <linux/filter.h>
#include <linux/ftrace.h>
#include <linux/kprobes.h>
+#include <linux/overflow.h>
#include <linux/sched.h>
#include <linux/sched/debug.h>
#include <linux/sched/task_stack.h>
@@ -17,6 +18,7 @@
#include <asm/efi.h>
#include <asm/irq.h>
+#include <asm/lr_unwind.h>
#include <asm/stack_pointer.h>
#include <asm/stacktrace.h>
@@ -26,6 +28,7 @@ enum kunwind_source {
KUNWIND_SOURCE_CALLER,
KUNWIND_SOURCE_TASK,
KUNWIND_SOURCE_REGS_PC,
+ KUNWIND_SOURCE_REGS_LR,
};
union unwind_flags {
@@ -45,6 +48,7 @@ union unwind_flags {
* @kr_cur: When KRETPROBES is selected, holds the kretprobe instance
* associated with the most recently encountered replacement lr
* value.
+ * @unreliable: Stacktrace is unreliable.
*/
struct kunwind_state {
struct unwind_state common;
@@ -56,6 +60,7 @@ struct kunwind_state {
enum kunwind_source source;
union unwind_flags flags;
struct pt_regs *regs;
+ bool unreliable;
};
static __always_inline void
@@ -67,6 +72,7 @@ kunwind_init(struct kunwind_state *state,
state->source = KUNWIND_SOURCE_UNKNOWN;
state->flags.all = 0;
state->regs = NULL;
+ state->unreliable = false;
}
/*
@@ -181,7 +187,6 @@ int kunwind_next_regs_pc(struct kunwind_state *state)
state->regs = regs;
state->common.pc = regs->pc;
state->common.fp = regs->regs[29];
- state->regs = NULL;
state->source = KUNWIND_SOURCE_REGS_PC;
return 0;
}
@@ -244,6 +249,65 @@ kunwind_next_frame_record(struct kunwind_state *state)
return 0;
}
+#ifdef CONFIG_ARM64_LR_UNWIND
+
+/*
+ * Unwind from a pt_regs according to .lr_unwind info.
+ */
+static __always_inline int
+kunwind_next_regs_lr_unwind(struct kunwind_state *state)
+{
+ struct pt_regs *regs = state->regs;
+ enum lr_unwind_mode mode;
+ unsigned int sp_off;
+ unsigned long fp;
+ int err;
+
+ if (WARN_ON_ONCE(state->source != KUNWIND_SOURCE_REGS_PC))
+ return -EINVAL;
+ if (WARN_ON_ONCE(!regs))
+ return -EINVAL;
+
+ state->regs = NULL;
+
+ err = lr_unwind_find(state->common.pc, &mode, &sp_off);
+ if (err) {
+ /* Fallback to FP based unwinder */
+ state->unreliable = true;
+ return kunwind_next_frame_record(state);
+ }
+
+ switch (mode) {
+ case LR_UNWIND_LIVE:
+ if (state->common.fp & 0x7)
+ return -EINVAL;
+ state->common.pc = regs->regs[30];
+ state->source = KUNWIND_SOURCE_REGS_LR;
+ return 0;
+ case LR_UNWIND_FP:
+ return kunwind_next_frame_record(state);
+ case LR_UNWIND_SP:
+ if (check_add_overflow(regs->sp, (unsigned long)sp_off, &fp))
+ return -EINVAL;
+ state->common.fp = fp;
+ return kunwind_next_frame_record(state);
+ default:
+ return -EINVAL;
+ }
+}
+
+#else /* !CONFIG_ARM64_LR_UNWIND */
+
+static __always_inline int
+kunwind_next_regs_lr_unwind(struct kunwind_state *state)
+{
+ state->regs = NULL;
+ state->unreliable = true;
+ return kunwind_next_frame_record(state);
+}
+
+#endif /* CONFIG_ARM64_LR_UNWIND */
+
/*
* Unwind from one frame record (A) to the next frame record (B).
*
@@ -259,10 +323,13 @@ kunwind_next(struct kunwind_state *state)
state->flags.all = 0;
switch (state->source) {
+ case KUNWIND_SOURCE_REGS_PC:
+ err = kunwind_next_regs_lr_unwind(state);
+ break;
case KUNWIND_SOURCE_FRAME:
case KUNWIND_SOURCE_CALLER:
case KUNWIND_SOURCE_TASK:
- case KUNWIND_SOURCE_REGS_PC:
+ case KUNWIND_SOURCE_REGS_LR:
err = kunwind_next_frame_record(state);
break;
default:
@@ -294,7 +361,7 @@ do_kunwind(struct kunwind_state *state, kunwind_consume_fn consume_state,
return -EINVAL;
ret = kunwind_next(state);
if (ret == -ENOENT)
- return 0;
+ return state->unreliable ? -EINVAL : 0;
if (ret < 0)
return ret;
}
@@ -394,14 +461,11 @@ static __always_inline bool
arch_reliable_kunwind_consume_entry(const struct kunwind_state *state, void *cookie)
{
/*
- * At an exception boundary we can reliably consume the saved PC. We do
- * not know whether the LR was live when the exception was taken, and
- * so we cannot perform the next unwind step reliably.
- *
- * All that matters is whether the *entire* unwind is reliable, so give
- * up as soon as we hit an exception boundary.
+ * If unwinding across an exception boundary fell back to frame-pointer
+ * unwinding without a valid .lr_unwind entry, the caller frame may
+ * have been skipped or duplicated. Abort reliable stack walks.
*/
- if (state->source == KUNWIND_SOURCE_REGS_PC)
+ if (state->unreliable)
return false;
return arch_kunwind_consume_entry(state, cookie);
@@ -452,6 +516,7 @@ static const char *state_source_string(const struct kunwind_state *state)
case KUNWIND_SOURCE_CALLER: return "C";
case KUNWIND_SOURCE_TASK: return "T";
case KUNWIND_SOURCE_REGS_PC: return "P";
+ case KUNWIND_SOURCE_REGS_LR: return "L";
default: return "U";
}
}
--
2.56.0.679.gc527c65306-goog