Commit | Line | Data |
---|---|---|
7af76c5f ME |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | ||
fd3e0bbc | 3 | /* |
7af76c5f | 4 | * Stack trace utility functions etc. |
fd3e0bbc CH |
5 | * |
6 | * Copyright 2008 Christoph Hellwig, IBM Corp. | |
df78d3f6 | 7 | * Copyright 2018 SUSE Linux GmbH |
7af76c5f | 8 | * Copyright 2018 Nick Piggin, Michael Ellerman, IBM Corp. |
fd3e0bbc CH |
9 | */ |
10 | ||
4b16f8e2 | 11 | #include <linux/export.h> |
df78d3f6 TD |
12 | #include <linux/kallsyms.h> |
13 | #include <linux/module.h> | |
5cc05910 | 14 | #include <linux/nmi.h> |
fd3e0bbc | 15 | #include <linux/sched.h> |
b17b0153 | 16 | #include <linux/sched/debug.h> |
df78d3f6 | 17 | #include <linux/sched/task_stack.h> |
fd3e0bbc CH |
18 | #include <linux/stacktrace.h> |
19 | #include <asm/ptrace.h> | |
01f4b8b8 | 20 | #include <asm/processor.h> |
df78d3f6 TD |
21 | #include <linux/ftrace.h> |
22 | #include <asm/kprobes.h> | |
fd3e0bbc | 23 | |
5cc05910 ME |
24 | #include <asm/paca.h> |
25 | ||
fd3e0bbc CH |
26 | /* |
27 | * Save stack-backtrace addresses into a stack_trace buffer. | |
28 | */ | |
01f4b8b8 AB |
29 | static void save_context_stack(struct stack_trace *trace, unsigned long sp, |
30 | struct task_struct *tsk, int savesched) | |
fd3e0bbc | 31 | { |
fd3e0bbc CH |
32 | for (;;) { |
33 | unsigned long *stack = (unsigned long *) sp; | |
34 | unsigned long newsp, ip; | |
35 | ||
01f4b8b8 | 36 | if (!validate_sp(sp, tsk, STACK_FRAME_OVERHEAD)) |
fd3e0bbc CH |
37 | return; |
38 | ||
39 | newsp = stack[0]; | |
40 | ip = stack[STACK_FRAME_LR_SAVE]; | |
41 | ||
01f4b8b8 AB |
42 | if (savesched || !in_sched_functions(ip)) { |
43 | if (!trace->skip) | |
44 | trace->entries[trace->nr_entries++] = ip; | |
45 | else | |
46 | trace->skip--; | |
47 | } | |
fd3e0bbc CH |
48 | |
49 | if (trace->nr_entries >= trace->max_entries) | |
50 | return; | |
51 | ||
52 | sp = newsp; | |
53 | } | |
54 | } | |
01f4b8b8 AB |
55 | |
56 | void save_stack_trace(struct stack_trace *trace) | |
57 | { | |
58 | unsigned long sp; | |
59 | ||
acf620ec | 60 | sp = current_stack_pointer(); |
01f4b8b8 AB |
61 | |
62 | save_context_stack(trace, sp, current, 1); | |
63 | } | |
64 | EXPORT_SYMBOL_GPL(save_stack_trace); | |
65 | ||
66 | void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace) | |
67 | { | |
4f9b514b TLSC |
68 | unsigned long sp; |
69 | ||
018cce33 CL |
70 | if (!try_get_task_stack(tsk)) |
71 | return; | |
72 | ||
4f9b514b TLSC |
73 | if (tsk == current) |
74 | sp = current_stack_pointer(); | |
75 | else | |
76 | sp = tsk->thread.ksp; | |
77 | ||
78 | save_context_stack(trace, sp, tsk, 0); | |
018cce33 CL |
79 | |
80 | put_task_stack(tsk); | |
01f4b8b8 AB |
81 | } |
82 | EXPORT_SYMBOL_GPL(save_stack_trace_tsk); | |
35de3b1a SR |
83 | |
84 | void | |
85 | save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace) | |
86 | { | |
87 | save_context_stack(trace, regs->gpr[1], current, 0); | |
88 | } | |
89 | EXPORT_SYMBOL_GPL(save_stack_trace_regs); | |
df78d3f6 TD |
90 | |
91 | #ifdef CONFIG_HAVE_RELIABLE_STACKTRACE | |
18be3760 JL |
92 | /* |
93 | * This function returns an error if it detects any unreliable features of the | |
94 | * stack. Otherwise it guarantees that the stack trace is reliable. | |
95 | * | |
96 | * If the task is not 'current', the caller *must* ensure the task is inactive. | |
97 | */ | |
018cce33 CL |
98 | static int __save_stack_trace_tsk_reliable(struct task_struct *tsk, |
99 | struct stack_trace *trace) | |
df78d3f6 TD |
100 | { |
101 | unsigned long sp; | |
29a77bbb | 102 | unsigned long newsp; |
df78d3f6 TD |
103 | unsigned long stack_page = (unsigned long)task_stack_page(tsk); |
104 | unsigned long stack_end; | |
105 | int graph_idx = 0; | |
29a77bbb | 106 | bool firstframe; |
df78d3f6 TD |
107 | |
108 | stack_end = stack_page + THREAD_SIZE; | |
109 | if (!is_idle_task(tsk)) { | |
110 | /* | |
111 | * For user tasks, this is the SP value loaded on | |
112 | * kernel entry, see "PACAKSAVE(r13)" in _switch() and | |
113 | * system_call_common()/EXCEPTION_PROLOG_COMMON(). | |
114 | * | |
115 | * Likewise for non-swapper kernel threads, | |
116 | * this also happens to be the top of the stack | |
117 | * as setup by copy_thread(). | |
118 | * | |
119 | * Note that stack backlinks are not properly setup by | |
120 | * copy_thread() and thus, a forked task() will have | |
121 | * an unreliable stack trace until it's been | |
122 | * _switch()'ed to for the first time. | |
123 | */ | |
124 | stack_end -= STACK_FRAME_OVERHEAD + sizeof(struct pt_regs); | |
125 | } else { | |
126 | /* | |
127 | * idle tasks have a custom stack layout, | |
128 | * c.f. cpu_idle_thread_init(). | |
129 | */ | |
130 | stack_end -= STACK_FRAME_OVERHEAD; | |
131 | } | |
132 | ||
29a77bbb JL |
133 | if (tsk == current) |
134 | sp = current_stack_pointer(); | |
135 | else | |
136 | sp = tsk->thread.ksp; | |
137 | ||
df78d3f6 TD |
138 | if (sp < stack_page + sizeof(struct thread_struct) || |
139 | sp > stack_end - STACK_FRAME_MIN_SIZE) { | |
3de27dcf | 140 | return -EINVAL; |
df78d3f6 TD |
141 | } |
142 | ||
29a77bbb JL |
143 | for (firstframe = true; sp != stack_end; |
144 | firstframe = false, sp = newsp) { | |
df78d3f6 | 145 | unsigned long *stack = (unsigned long *) sp; |
29a77bbb | 146 | unsigned long ip; |
df78d3f6 TD |
147 | |
148 | /* sanity check: ABI requires SP to be aligned 16 bytes. */ | |
149 | if (sp & 0xF) | |
3de27dcf | 150 | return -EINVAL; |
df78d3f6 | 151 | |
df78d3f6 TD |
152 | newsp = stack[0]; |
153 | /* Stack grows downwards; unwinder may only go up. */ | |
154 | if (newsp <= sp) | |
3de27dcf | 155 | return -EINVAL; |
df78d3f6 TD |
156 | |
157 | if (newsp != stack_end && | |
158 | newsp > stack_end - STACK_FRAME_MIN_SIZE) { | |
3de27dcf | 159 | return -EINVAL; /* invalid backlink, too far up. */ |
df78d3f6 TD |
160 | } |
161 | ||
18be3760 JL |
162 | /* |
163 | * We can only trust the bottom frame's backlink, the | |
164 | * rest of the frame may be uninitialized, continue to | |
165 | * the next. | |
166 | */ | |
29a77bbb JL |
167 | if (firstframe) |
168 | continue; | |
18be3760 JL |
169 | |
170 | /* Mark stacktraces with exception frames as unreliable. */ | |
171 | if (sp <= stack_end - STACK_INT_FRAME_SIZE && | |
172 | stack[STACK_FRAME_MARKER] == STACK_FRAME_REGS_MARKER) { | |
3de27dcf | 173 | return -EINVAL; |
18be3760 JL |
174 | } |
175 | ||
df78d3f6 TD |
176 | /* Examine the saved LR: it must point into kernel code. */ |
177 | ip = stack[STACK_FRAME_LR_SAVE]; | |
18be3760 | 178 | if (!__kernel_text_address(ip)) |
3de27dcf | 179 | return -EINVAL; |
df78d3f6 TD |
180 | |
181 | /* | |
182 | * FIXME: IMHO these tests do not belong in | |
183 | * arch-dependent code, they are generic. | |
184 | */ | |
370011a2 | 185 | ip = ftrace_graph_ret_addr(tsk, &graph_idx, ip, stack); |
5e3f0d15 | 186 | #ifdef CONFIG_KPROBES |
df78d3f6 TD |
187 | /* |
188 | * Mark stacktraces with kretprobed functions on them | |
189 | * as unreliable. | |
190 | */ | |
191 | if (ip == (unsigned long)kretprobe_trampoline) | |
3de27dcf | 192 | return -EINVAL; |
5e3f0d15 | 193 | #endif |
df78d3f6 | 194 | |
29a77bbb JL |
195 | if (trace->nr_entries >= trace->max_entries) |
196 | return -E2BIG; | |
df78d3f6 TD |
197 | if (!trace->skip) |
198 | trace->entries[trace->nr_entries++] = ip; | |
199 | else | |
200 | trace->skip--; | |
df78d3f6 TD |
201 | } |
202 | return 0; | |
203 | } | |
018cce33 CL |
204 | |
205 | int save_stack_trace_tsk_reliable(struct task_struct *tsk, | |
206 | struct stack_trace *trace) | |
207 | { | |
208 | int ret; | |
209 | ||
210 | /* | |
211 | * If the task doesn't have a stack (e.g., a zombie), the stack is | |
212 | * "reliably" empty. | |
213 | */ | |
214 | if (!try_get_task_stack(tsk)) | |
215 | return 0; | |
216 | ||
217 | ret = __save_stack_trace_tsk_reliable(tsk, trace); | |
218 | ||
219 | put_task_stack(tsk); | |
220 | ||
221 | return ret; | |
222 | } | |
df78d3f6 | 223 | #endif /* CONFIG_HAVE_RELIABLE_STACKTRACE */ |
5cc05910 | 224 | |
e08ecba1 | 225 | #if defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_NMI_IPI) |
5cc05910 ME |
226 | static void handle_backtrace_ipi(struct pt_regs *regs) |
227 | { | |
228 | nmi_cpu_backtrace(regs); | |
229 | } | |
230 | ||
231 | static void raise_backtrace_ipi(cpumask_t *mask) | |
232 | { | |
233 | unsigned int cpu; | |
234 | ||
235 | for_each_cpu(cpu, mask) { | |
236 | if (cpu == smp_processor_id()) | |
237 | handle_backtrace_ipi(NULL); | |
238 | else | |
239 | smp_send_safe_nmi_ipi(cpu, handle_backtrace_ipi, 5 * USEC_PER_SEC); | |
240 | } | |
241 | ||
242 | for_each_cpu(cpu, mask) { | |
243 | struct paca_struct *p = paca_ptrs[cpu]; | |
244 | ||
245 | cpumask_clear_cpu(cpu, mask); | |
246 | ||
247 | pr_warn("CPU %d didn't respond to backtrace IPI, inspecting paca.\n", cpu); | |
248 | if (!virt_addr_valid(p)) { | |
249 | pr_warn("paca pointer appears corrupt? (%px)\n", p); | |
250 | continue; | |
251 | } | |
252 | ||
253 | pr_warn("irq_soft_mask: 0x%02x in_mce: %d in_nmi: %d", | |
254 | p->irq_soft_mask, p->in_mce, p->in_nmi); | |
255 | ||
256 | if (virt_addr_valid(p->__current)) | |
257 | pr_cont(" current: %d (%s)\n", p->__current->pid, | |
258 | p->__current->comm); | |
259 | else | |
260 | pr_cont(" current pointer corrupt? (%px)\n", p->__current); | |
261 | ||
262 | pr_warn("Back trace of paca->saved_r1 (0x%016llx) (possibly stale):\n", p->saved_r1); | |
263 | show_stack(p->__current, (unsigned long *)p->saved_r1); | |
264 | } | |
265 | } | |
266 | ||
267 | void arch_trigger_cpumask_backtrace(const cpumask_t *mask, bool exclude_self) | |
268 | { | |
269 | nmi_trigger_cpumask_backtrace(mask, exclude_self, raise_backtrace_ipi); | |
270 | } | |
e08ecba1 | 271 | #endif /* defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_NMI_IPI) */ |