| // SPDX-License-Identifier: GPL-2.0-only |
| /* |
| * Stack tracing support |
| * |
| * Copyright (C) 2012 ARM Ltd. |
| */ |
| #include <linux/kernel.h> |
| #include <linux/export.h> |
| #include <linux/ftrace.h> |
| #include <linux/kprobes.h> |
| #include <linux/sched.h> |
| #include <linux/sched/debug.h> |
| #include <linux/sched/task_stack.h> |
| #include <linux/stacktrace.h> |
| |
| #include <asm/irq.h> |
| #include <asm/pointer_auth.h> |
| #include <asm/stack_pointer.h> |
| #include <asm/stacktrace.h> |
| |
| /* |
| * AArch64 PCS assigns the frame pointer to x29. |
| * |
| * A simple function prologue looks like this: |
| * sub sp, sp, #0x10 |
| * stp x29, x30, [sp] |
| * mov x29, sp |
| * |
| * A simple function epilogue looks like this: |
| * mov sp, x29 |
| * ldp x29, x30, [sp] |
| * add sp, sp, #0x10 |
| */ |
| |
| /* |
| * Unwind from one frame record (A) to the next frame record (B). |
| * |
| * We terminate early if the location of B indicates a malformed chain of frame |
| * records (e.g. a cycle), determined based on the location and fp value of A |
| * and the location (but not the fp value) of B. |
| */ |
| int notrace unwind_frame(struct task_struct *tsk, struct stackframe *frame) |
| { |
| unsigned long fp = frame->fp; |
| struct stack_info info; |
| |
| if (fp & 0xf) |
| return -EINVAL; |
| |
| if (!tsk) |
| tsk = current; |
| |
| if (!on_accessible_stack(tsk, fp, &info)) |
| return -EINVAL; |
| |
| if (test_bit(info.type, frame->stacks_done)) |
| return -EINVAL; |
| |
| /* |
| * As stacks grow downward, any valid record on the same stack must be |
| * at a strictly higher address than the prior record. |
| * |
| * Stacks can nest in several valid orders, e.g. |
| * |
| * TASK -> IRQ -> OVERFLOW -> SDEI_NORMAL |
| * TASK -> SDEI_NORMAL -> SDEI_CRITICAL -> OVERFLOW |
| * |
| * ... but the nesting itself is strict. Once we transition from one |
| * stack to another, it's never valid to unwind back to that first |
| * stack. |
| */ |
| if (info.type == frame->prev_type) { |
| if (fp <= frame->prev_fp) |
| return -EINVAL; |
| } else { |
| set_bit(frame->prev_type, frame->stacks_done); |
| } |
| |
| /* |
| * Record this frame record's values and location. The prev_fp and |
| * prev_type are only meaningful to the next unwind_frame() invocation. |
| */ |
| frame->fp = READ_ONCE_NOCHECK(*(unsigned long *)(fp)); |
| frame->pc = READ_ONCE_NOCHECK(*(unsigned long *)(fp + 8)); |
| frame->prev_fp = fp; |
| frame->prev_type = info.type; |
| |
| #ifdef CONFIG_FUNCTION_GRAPH_TRACER |
| if (tsk->ret_stack && |
| (ptrauth_strip_insn_pac(frame->pc) == (unsigned long)return_to_handler)) { |
| struct ftrace_ret_stack *ret_stack; |
| /* |
| * This is a case where function graph tracer has |
| * modified a return address (LR) in a stack frame |
| * to hook a function return. |
| * So replace it to an original value. |
| */ |
| ret_stack = ftrace_graph_get_ret_stack(tsk, frame->graph++); |
| if (WARN_ON_ONCE(!ret_stack)) |
| return -EINVAL; |
| frame->pc = ret_stack->ret; |
| } |
| #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ |
| |
| frame->pc = ptrauth_strip_insn_pac(frame->pc); |
| |
| /* |
| * Frames created upon entry from EL0 have NULL FP and PC values, so |
| * don't bother reporting these. Frames created by __noreturn functions |
| * might have a valid FP even if PC is bogus, so only terminate where |
| * both are NULL. |
| */ |
| if (!frame->fp && !frame->pc) |
| return -EINVAL; |
| |
| return 0; |
| } |
| NOKPROBE_SYMBOL(unwind_frame); |
| |
| void notrace walk_stackframe(struct task_struct *tsk, struct stackframe *frame, |
| int (*fn)(struct stackframe *, void *), void *data) |
| { |
| while (1) { |
| int ret; |
| |
| if (fn(frame, data)) |
| break; |
| ret = unwind_frame(tsk, frame); |
| if (ret < 0) |
| break; |
| } |
| } |
| NOKPROBE_SYMBOL(walk_stackframe); |
| |
| #ifdef CONFIG_STACKTRACE |
| struct stack_trace_data { |
| struct stack_trace *trace; |
| unsigned int no_sched_functions; |
| unsigned int skip; |
| }; |
| |
| static int save_trace(struct stackframe *frame, void *d) |
| { |
| struct stack_trace_data *data = d; |
| struct stack_trace *trace = data->trace; |
| unsigned long addr = frame->pc; |
| |
| if (data->no_sched_functions && in_sched_functions(addr)) |
| return 0; |
| if (data->skip) { |
| data->skip--; |
| return 0; |
| } |
| |
| trace->entries[trace->nr_entries++] = addr; |
| |
| return trace->nr_entries >= trace->max_entries; |
| } |
| |
| void save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace) |
| { |
| struct stack_trace_data data; |
| struct stackframe frame; |
| |
| data.trace = trace; |
| data.skip = trace->skip; |
| data.no_sched_functions = 0; |
| |
| start_backtrace(&frame, regs->regs[29], regs->pc); |
| walk_stackframe(current, &frame, save_trace, &data); |
| } |
| EXPORT_SYMBOL_GPL(save_stack_trace_regs); |
| |
| static noinline void __save_stack_trace(struct task_struct *tsk, |
| struct stack_trace *trace, unsigned int nosched) |
| { |
| struct stack_trace_data data; |
| struct stackframe frame; |
| |
| if (!try_get_task_stack(tsk)) |
| return; |
| |
| data.trace = trace; |
| data.skip = trace->skip; |
| data.no_sched_functions = nosched; |
| |
| if (tsk != current) { |
| start_backtrace(&frame, thread_saved_fp(tsk), |
| thread_saved_pc(tsk)); |
| } else { |
| /* We don't want this function nor the caller */ |
| data.skip += 2; |
| start_backtrace(&frame, |
| (unsigned long)__builtin_frame_address(0), |
| (unsigned long)__save_stack_trace); |
| } |
| |
| walk_stackframe(tsk, &frame, save_trace, &data); |
| |
| put_task_stack(tsk); |
| } |
| EXPORT_SYMBOL_GPL(save_stack_trace_tsk); |
| |
| void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace) |
| { |
| __save_stack_trace(tsk, trace, 1); |
| } |
| |
| void save_stack_trace(struct stack_trace *trace) |
| { |
| __save_stack_trace(current, trace, 0); |
| } |
| |
| EXPORT_SYMBOL_GPL(save_stack_trace); |
| #endif |