Loading...
1// SPDX-License-Identifier: GPL-2.0
2
3/*
4 * Stack trace utility functions etc.
5 *
6 * Copyright 2008 Christoph Hellwig, IBM Corp.
7 * Copyright 2018 SUSE Linux GmbH
8 * Copyright 2018 Nick Piggin, Michael Ellerman, IBM Corp.
9 */
10
11#include <linux/delay.h>
12#include <linux/export.h>
13#include <linux/kallsyms.h>
14#include <linux/module.h>
15#include <linux/nmi.h>
16#include <linux/sched.h>
17#include <linux/sched/debug.h>
18#include <linux/sched/task_stack.h>
19#include <linux/stacktrace.h>
20#include <asm/ptrace.h>
21#include <asm/processor.h>
22#include <linux/ftrace.h>
23#include <asm/kprobes.h>
24
25#include <asm/paca.h>
26
27void __no_sanitize_address arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,
28 struct task_struct *task, struct pt_regs *regs)
29{
30 unsigned long sp;
31
32 if (regs && !consume_entry(cookie, regs->nip))
33 return;
34
35 if (regs)
36 sp = regs->gpr[1];
37 else if (task == current)
38 sp = current_stack_frame();
39 else
40 sp = task->thread.ksp;
41
42 for (;;) {
43 unsigned long *stack = (unsigned long *) sp;
44 unsigned long newsp, ip;
45
46 if (!validate_sp(sp, task))
47 return;
48
49 newsp = stack[0];
50 ip = stack[STACK_FRAME_LR_SAVE];
51
52 if (!consume_entry(cookie, ip))
53 return;
54
55 sp = newsp;
56 }
57}
58
59/*
60 * This function returns an error if it detects any unreliable features of the
61 * stack. Otherwise it guarantees that the stack trace is reliable.
62 *
63 * If the task is not 'current', the caller *must* ensure the task is inactive.
64 */
65int __no_sanitize_address arch_stack_walk_reliable(stack_trace_consume_fn consume_entry,
66 void *cookie, struct task_struct *task)
67{
68 unsigned long sp;
69 unsigned long newsp;
70 unsigned long stack_page = (unsigned long)task_stack_page(task);
71 unsigned long stack_end;
72 int graph_idx = 0;
73 bool firstframe;
74
75 stack_end = stack_page + THREAD_SIZE;
76
77 // See copy_thread() for details.
78 if (task->flags & PF_KTHREAD)
79 stack_end -= STACK_FRAME_MIN_SIZE;
80 else
81 stack_end -= STACK_USER_INT_FRAME_SIZE;
82
83 if (task == current)
84 sp = current_stack_frame();
85 else
86 sp = task->thread.ksp;
87
88 if (sp < stack_page + sizeof(struct thread_struct) ||
89 sp > stack_end - STACK_FRAME_MIN_SIZE) {
90 return -EINVAL;
91 }
92
93 for (firstframe = true; sp != stack_end;
94 firstframe = false, sp = newsp) {
95 unsigned long *stack = (unsigned long *) sp;
96 unsigned long ip;
97
98 /* sanity check: ABI requires SP to be aligned 16 bytes. */
99 if (sp & 0xF)
100 return -EINVAL;
101
102 newsp = stack[0];
103 /* Stack grows downwards; unwinder may only go up. */
104 if (newsp <= sp)
105 return -EINVAL;
106
107 if (newsp != stack_end &&
108 newsp > stack_end - STACK_FRAME_MIN_SIZE) {
109 return -EINVAL; /* invalid backlink, too far up. */
110 }
111
112 /*
113 * We can only trust the bottom frame's backlink, the
114 * rest of the frame may be uninitialized, continue to
115 * the next.
116 */
117 if (firstframe)
118 continue;
119
120 /* Mark stacktraces with exception frames as unreliable. */
121 if (sp <= stack_end - STACK_INT_FRAME_SIZE &&
122 stack[STACK_INT_FRAME_MARKER_LONGS] == STACK_FRAME_REGS_MARKER) {
123 return -EINVAL;
124 }
125
126 /* Examine the saved LR: it must point into kernel code. */
127 ip = stack[STACK_FRAME_LR_SAVE];
128 if (!__kernel_text_address(ip))
129 return -EINVAL;
130
131 /*
132 * FIXME: IMHO these tests do not belong in
133 * arch-dependent code, they are generic.
134 */
135 ip = ftrace_graph_ret_addr(task, &graph_idx, ip, stack);
136#ifdef CONFIG_KPROBES
137 /*
138 * Mark stacktraces with kretprobed functions on them
139 * as unreliable.
140 */
141 if (ip == (unsigned long)__kretprobe_trampoline)
142 return -EINVAL;
143#endif
144
145 if (!consume_entry(cookie, ip))
146 return -EINVAL;
147 }
148 return 0;
149}
150
151#if defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_NMI_IPI)
152static void handle_backtrace_ipi(struct pt_regs *regs)
153{
154 nmi_cpu_backtrace(regs);
155}
156
157static void raise_backtrace_ipi(cpumask_t *mask)
158{
159 struct paca_struct *p;
160 unsigned int cpu;
161 u64 delay_us;
162
163 for_each_cpu(cpu, mask) {
164 if (cpu == smp_processor_id()) {
165 handle_backtrace_ipi(NULL);
166 continue;
167 }
168
169 delay_us = 5 * USEC_PER_SEC;
170
171 if (smp_send_safe_nmi_ipi(cpu, handle_backtrace_ipi, delay_us)) {
172 // Now wait up to 5s for the other CPU to do its backtrace
173 while (cpumask_test_cpu(cpu, mask) && delay_us) {
174 udelay(1);
175 delay_us--;
176 }
177
178 // Other CPU cleared itself from the mask
179 if (delay_us)
180 continue;
181 }
182
183 p = paca_ptrs[cpu];
184
185 cpumask_clear_cpu(cpu, mask);
186
187 pr_warn("CPU %d didn't respond to backtrace IPI, inspecting paca.\n", cpu);
188 if (!virt_addr_valid(p)) {
189 pr_warn("paca pointer appears corrupt? (%px)\n", p);
190 continue;
191 }
192
193 pr_warn("irq_soft_mask: 0x%02x in_mce: %d in_nmi: %d",
194 p->irq_soft_mask, p->in_mce, p->in_nmi);
195
196 if (virt_addr_valid(p->__current))
197 pr_cont(" current: %d (%s)\n", p->__current->pid,
198 p->__current->comm);
199 else
200 pr_cont(" current pointer corrupt? (%px)\n", p->__current);
201
202 pr_warn("Back trace of paca->saved_r1 (0x%016llx) (possibly stale):\n", p->saved_r1);
203 show_stack(p->__current, (unsigned long *)p->saved_r1, KERN_WARNING);
204 }
205}
206
207void arch_trigger_cpumask_backtrace(const cpumask_t *mask, int exclude_cpu)
208{
209 nmi_trigger_cpumask_backtrace(mask, exclude_cpu, raise_backtrace_ipi);
210}
211#endif /* defined(CONFIG_PPC_BOOK3S_64) && defined(CONFIG_NMI_IPI) */
1/*
2 * Stack trace utility
3 *
4 * Copyright 2008 Christoph Hellwig, IBM Corp.
5 *
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 */
12
13#include <linux/export.h>
14#include <linux/sched.h>
15#include <linux/stacktrace.h>
16#include <asm/ptrace.h>
17#include <asm/processor.h>
18
19/*
20 * Save stack-backtrace addresses into a stack_trace buffer.
21 */
22static void save_context_stack(struct stack_trace *trace, unsigned long sp,
23 struct task_struct *tsk, int savesched)
24{
25 for (;;) {
26 unsigned long *stack = (unsigned long *) sp;
27 unsigned long newsp, ip;
28
29 if (!validate_sp(sp, tsk, STACK_FRAME_OVERHEAD))
30 return;
31
32 newsp = stack[0];
33 ip = stack[STACK_FRAME_LR_SAVE];
34
35 if (savesched || !in_sched_functions(ip)) {
36 if (!trace->skip)
37 trace->entries[trace->nr_entries++] = ip;
38 else
39 trace->skip--;
40 }
41
42 if (trace->nr_entries >= trace->max_entries)
43 return;
44
45 sp = newsp;
46 }
47}
48
49void save_stack_trace(struct stack_trace *trace)
50{
51 unsigned long sp;
52
53 sp = current_stack_pointer();
54
55 save_context_stack(trace, sp, current, 1);
56}
57EXPORT_SYMBOL_GPL(save_stack_trace);
58
59void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
60{
61 save_context_stack(trace, tsk->thread.ksp, tsk, 0);
62}
63EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
64
65void
66save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace)
67{
68 save_context_stack(trace, regs->gpr[1], current, 0);
69}
70EXPORT_SYMBOL_GPL(save_stack_trace_regs);