1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Stack tracing support 4 * 5 * Copyright (C) 2012 ARM Ltd. 6 */ 7 #include <linux/kernel.h> 8 #include <linux/export.h> 9 #include <linux/ftrace.h> 10 #include <linux/kprobes.h> 11 #include <linux/sched.h> 12 #include <linux/sched/debug.h> 13 #include <linux/sched/task_stack.h> 14 #include <linux/stacktrace.h> 15 16 #include <asm/irq.h> 17 #include <asm/pointer_auth.h> 18 #include <asm/stack_pointer.h> 19 #include <asm/stacktrace.h> 20 21 /* 22 * AArch64 PCS assigns the frame pointer to x29. 23 * 24 * A simple function prologue looks like this: 25 * sub sp, sp, #0x10 26 * stp x29, x30, [sp] 27 * mov x29, sp 28 * 29 * A simple function epilogue looks like this: 30 * mov sp, x29 31 * ldp x29, x30, [sp] 32 * add sp, sp, #0x10 33 */ 34 35 36 void start_backtrace(struct stackframe *frame, unsigned long fp, 37 unsigned long pc) 38 { 39 frame->fp = fp; 40 frame->pc = pc; 41 #ifdef CONFIG_KRETPROBES 42 frame->kr_cur = NULL; 43 #endif 44 45 /* 46 * Prime the first unwind. 47 * 48 * In unwind_frame() we'll check that the FP points to a valid stack, 49 * which can't be STACK_TYPE_UNKNOWN, and the first unwind will be 50 * treated as a transition to whichever stack that happens to be. The 51 * prev_fp value won't be used, but we set it to 0 such that it is 52 * definitely not an accessible stack address. 53 */ 54 bitmap_zero(frame->stacks_done, __NR_STACK_TYPES); 55 frame->prev_fp = 0; 56 frame->prev_type = STACK_TYPE_UNKNOWN; 57 } 58 59 /* 60 * Unwind from one frame record (A) to the next frame record (B). 61 * 62 * We terminate early if the location of B indicates a malformed chain of frame 63 * records (e.g. a cycle), determined based on the location and fp value of A 64 * and the location (but not the fp value) of B. 65 */ 66 int notrace unwind_frame(struct task_struct *tsk, struct stackframe *frame) 67 { 68 unsigned long fp = frame->fp; 69 struct stack_info info; 70 71 if (!tsk) 72 tsk = current; 73 74 /* Final frame; nothing to unwind */ 75 if (fp == (unsigned long)task_pt_regs(tsk)->stackframe) 76 return -ENOENT; 77 78 if (fp & 0x7) 79 return -EINVAL; 80 81 if (!on_accessible_stack(tsk, fp, 16, &info)) 82 return -EINVAL; 83 84 if (test_bit(info.type, frame->stacks_done)) 85 return -EINVAL; 86 87 /* 88 * As stacks grow downward, any valid record on the same stack must be 89 * at a strictly higher address than the prior record. 90 * 91 * Stacks can nest in several valid orders, e.g. 92 * 93 * TASK -> IRQ -> OVERFLOW -> SDEI_NORMAL 94 * TASK -> SDEI_NORMAL -> SDEI_CRITICAL -> OVERFLOW 95 * 96 * ... but the nesting itself is strict. Once we transition from one 97 * stack to another, it's never valid to unwind back to that first 98 * stack. 99 */ 100 if (info.type == frame->prev_type) { 101 if (fp <= frame->prev_fp) 102 return -EINVAL; 103 } else { 104 set_bit(frame->prev_type, frame->stacks_done); 105 } 106 107 /* 108 * Record this frame record's values and location. The prev_fp and 109 * prev_type are only meaningful to the next unwind_frame() invocation. 110 */ 111 frame->fp = READ_ONCE_NOCHECK(*(unsigned long *)(fp)); 112 frame->pc = READ_ONCE_NOCHECK(*(unsigned long *)(fp + 8)); 113 frame->prev_fp = fp; 114 frame->prev_type = info.type; 115 116 frame->pc = ptrauth_strip_insn_pac(frame->pc); 117 118 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 119 if (tsk->ret_stack && 120 (frame->pc == (unsigned long)return_to_handler)) { 121 unsigned long orig_pc; 122 /* 123 * This is a case where function graph tracer has 124 * modified a return address (LR) in a stack frame 125 * to hook a function return. 126 * So replace it to an original value. 127 */ 128 orig_pc = ftrace_graph_ret_addr(tsk, NULL, frame->pc, 129 (void *)frame->fp); 130 if (WARN_ON_ONCE(frame->pc == orig_pc)) 131 return -EINVAL; 132 frame->pc = orig_pc; 133 } 134 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ 135 #ifdef CONFIG_KRETPROBES 136 if (is_kretprobe_trampoline(frame->pc)) 137 frame->pc = kretprobe_find_ret_addr(tsk, (void *)frame->fp, &frame->kr_cur); 138 #endif 139 140 return 0; 141 } 142 NOKPROBE_SYMBOL(unwind_frame); 143 144 void notrace walk_stackframe(struct task_struct *tsk, struct stackframe *frame, 145 bool (*fn)(void *, unsigned long), void *data) 146 { 147 while (1) { 148 int ret; 149 150 if (!fn(data, frame->pc)) 151 break; 152 ret = unwind_frame(tsk, frame); 153 if (ret < 0) 154 break; 155 } 156 } 157 NOKPROBE_SYMBOL(walk_stackframe); 158 159 static void dump_backtrace_entry(unsigned long where, const char *loglvl) 160 { 161 printk("%s %pSb\n", loglvl, (void *)where); 162 } 163 164 void dump_backtrace(struct pt_regs *regs, struct task_struct *tsk, 165 const char *loglvl) 166 { 167 struct stackframe frame; 168 int skip = 0; 169 170 pr_debug("%s(regs = %p tsk = %p)\n", __func__, regs, tsk); 171 172 if (regs) { 173 if (user_mode(regs)) 174 return; 175 skip = 1; 176 } 177 178 if (!tsk) 179 tsk = current; 180 181 if (!try_get_task_stack(tsk)) 182 return; 183 184 if (tsk == current) { 185 start_backtrace(&frame, 186 (unsigned long)__builtin_frame_address(0), 187 (unsigned long)dump_backtrace); 188 } else { 189 /* 190 * task blocked in __switch_to 191 */ 192 start_backtrace(&frame, 193 thread_saved_fp(tsk), 194 thread_saved_pc(tsk)); 195 } 196 197 printk("%sCall trace:\n", loglvl); 198 do { 199 /* skip until specified stack frame */ 200 if (!skip) { 201 dump_backtrace_entry(frame.pc, loglvl); 202 } else if (frame.fp == regs->regs[29]) { 203 skip = 0; 204 /* 205 * Mostly, this is the case where this function is 206 * called in panic/abort. As exception handler's 207 * stack frame does not contain the corresponding pc 208 * at which an exception has taken place, use regs->pc 209 * instead. 210 */ 211 dump_backtrace_entry(regs->pc, loglvl); 212 } 213 } while (!unwind_frame(tsk, &frame)); 214 215 put_task_stack(tsk); 216 } 217 218 void show_stack(struct task_struct *tsk, unsigned long *sp, const char *loglvl) 219 { 220 dump_backtrace(NULL, tsk, loglvl); 221 barrier(); 222 } 223 224 noinline notrace void arch_stack_walk(stack_trace_consume_fn consume_entry, 225 void *cookie, struct task_struct *task, 226 struct pt_regs *regs) 227 { 228 struct stackframe frame; 229 230 if (regs) 231 start_backtrace(&frame, regs->regs[29], regs->pc); 232 else if (task == current) 233 start_backtrace(&frame, 234 (unsigned long)__builtin_frame_address(1), 235 (unsigned long)__builtin_return_address(0)); 236 else 237 start_backtrace(&frame, thread_saved_fp(task), 238 thread_saved_pc(task)); 239 240 walk_stackframe(task, &frame, consume_entry, cookie); 241 } 242