1
2
3
4
5#include <linux/kallsyms.h>
6#include <linux/kprobes.h>
7#include <linux/uaccess.h>
8#include <linux/utsname.h>
9#include <linux/hardirq.h>
10#include <linux/kdebug.h>
11#include <linux/module.h>
12#include <linux/ptrace.h>
13#include <linux/ftrace.h>
14#include <linux/kexec.h>
15#include <linux/bug.h>
16#include <linux/nmi.h>
17#include <linux/sysfs.h>
18
19#include <asm/stacktrace.h>
20
21#include "dumpstack.h"
22
23int panic_on_unrecovered_nmi;
24int panic_on_io_nmi;
25unsigned int code_bytes = 64;
26int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE;
27static int die_counter;
28
29void printk_address(unsigned long address, int reliable)
30{
31 printk(" [<%p>] %s%pS\n", (void *) address,
32 reliable ? "" : "? ", (void *) address);
33}
34
35#ifdef CONFIG_FUNCTION_GRAPH_TRACER
36static void
37print_ftrace_graph_addr(unsigned long addr, void *data,
38 const struct stacktrace_ops *ops,
39 struct thread_info *tinfo, int *graph)
40{
41 struct task_struct *task = tinfo->task;
42 unsigned long ret_addr;
43 int index = task->curr_ret_stack;
44
45 if (addr != (unsigned long)return_to_handler)
46 return;
47
48 if (!task->ret_stack || index < *graph)
49 return;
50
51 index -= *graph;
52 ret_addr = task->ret_stack[index].ret;
53
54 ops->address(data, ret_addr, 1);
55
56 (*graph)++;
57}
58#else
59static inline void
60print_ftrace_graph_addr(unsigned long addr, void *data,
61 const struct stacktrace_ops *ops,
62 struct thread_info *tinfo, int *graph)
63{ }
64#endif
65
66
67
68
69
70
71
72
73static inline int valid_stack_ptr(struct thread_info *tinfo,
74 void *p, unsigned int size, void *end)
75{
76 void *t = tinfo;
77 if (end) {
78 if (p < end && p >= (end-THREAD_SIZE))
79 return 1;
80 else
81 return 0;
82 }
83 return p > t && p < t + THREAD_SIZE - size;
84}
85
86unsigned long
87print_context_stack(struct thread_info *tinfo,
88 unsigned long *stack, unsigned long bp,
89 const struct stacktrace_ops *ops, void *data,
90 unsigned long *end, int *graph)
91{
92 struct stack_frame *frame = (struct stack_frame *)bp;
93
94 while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) {
95 unsigned long addr;
96
97 addr = *stack;
98 if (__kernel_text_address(addr)) {
99 if ((unsigned long) stack == bp + sizeof(long)) {
100 ops->address(data, addr, 1);
101 frame = frame->next_frame;
102 bp = (unsigned long) frame;
103 } else {
104 ops->address(data, addr, 0);
105 }
106 print_ftrace_graph_addr(addr, data, ops, tinfo, graph);
107 }
108 stack++;
109 }
110 return bp;
111}
112
113
114static void
115print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
116{
117 printk(data);
118 print_symbol(msg, symbol);
119 printk("\n");
120}
121
122static void print_trace_warning(void *data, char *msg)
123{
124 printk("%s%s\n", (char *)data, msg);
125}
126
127static int print_trace_stack(void *data, char *name)
128{
129 printk("%s <%s> ", (char *)data, name);
130 return 0;
131}
132
133
134
135
136static void print_trace_address(void *data, unsigned long addr, int reliable)
137{
138 touch_nmi_watchdog();
139 printk(data);
140 printk_address(addr, reliable);
141}
142
143static const struct stacktrace_ops print_trace_ops = {
144 .warning = print_trace_warning,
145 .warning_symbol = print_trace_warning_symbol,
146 .stack = print_trace_stack,
147 .address = print_trace_address,
148};
149
150void
151show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
152 unsigned long *stack, unsigned long bp, char *log_lvl)
153{
154 printk("%sCall Trace:\n", log_lvl);
155 dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl);
156}
157
158void show_trace(struct task_struct *task, struct pt_regs *regs,
159 unsigned long *stack, unsigned long bp)
160{
161 show_trace_log_lvl(task, regs, stack, bp, "");
162}
163
164void show_stack(struct task_struct *task, unsigned long *sp)
165{
166 show_stack_log_lvl(task, NULL, sp, 0, "");
167}
168
169
170
171
172void dump_stack(void)
173{
174 unsigned long bp = 0;
175 unsigned long stack;
176
177#ifdef CONFIG_FRAME_POINTER
178 if (!bp)
179 get_bp(bp);
180#endif
181
182 printk("Pid: %d, comm: %.20s %s %s %.*s\n",
183 current->pid, current->comm, print_tainted(),
184 init_utsname()->release,
185 (int)strcspn(init_utsname()->version, " "),
186 init_utsname()->version);
187 show_trace(NULL, NULL, &stack, bp);
188}
189EXPORT_SYMBOL(dump_stack);
190
191static raw_spinlock_t die_lock = __RAW_SPIN_LOCK_UNLOCKED;
192static int die_owner = -1;
193static unsigned int die_nest_count;
194
195unsigned __kprobes long oops_begin(void)
196{
197 int cpu;
198 unsigned long flags;
199
200
201
202
203 trace_hw_branch_oops();
204
205 oops_enter();
206
207
208 raw_local_irq_save(flags);
209 cpu = smp_processor_id();
210 if (!__raw_spin_trylock(&die_lock)) {
211 if (cpu == die_owner)
212 ;
213 else
214 __raw_spin_lock(&die_lock);
215 }
216 die_nest_count++;
217 die_owner = cpu;
218 console_verbose();
219 bust_spinlocks(1);
220 return flags;
221}
222
223void __kprobes oops_end(unsigned long flags, struct pt_regs *regs, int signr)
224{
225 if (regs && kexec_should_crash(current))
226 crash_kexec(regs);
227
228 bust_spinlocks(0);
229 die_owner = -1;
230 add_taint(TAINT_DIE);
231 die_nest_count--;
232 if (!die_nest_count)
233
234 __raw_spin_unlock(&die_lock);
235 raw_local_irq_restore(flags);
236 oops_exit();
237
238 if (!signr)
239 return;
240 if (in_interrupt())
241 panic("Fatal exception in interrupt");
242 if (panic_on_oops)
243 panic("Fatal exception");
244 do_exit(signr);
245}
246
247int __kprobes __die(const char *str, struct pt_regs *regs, long err)
248{
249#ifdef CONFIG_X86_32
250 unsigned short ss;
251 unsigned long sp;
252#endif
253 printk(KERN_EMERG "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
254#ifdef CONFIG_PREEMPT
255 printk("PREEMPT ");
256#endif
257#ifdef CONFIG_SMP
258 printk("SMP ");
259#endif
260#ifdef CONFIG_DEBUG_PAGEALLOC
261 printk("DEBUG_PAGEALLOC");
262#endif
263 printk("\n");
264 sysfs_printk_last_file();
265 if (notify_die(DIE_OOPS, str, regs, err,
266 current->thread.trap_no, SIGSEGV) == NOTIFY_STOP)
267 return 1;
268
269 show_registers(regs);
270#ifdef CONFIG_X86_32
271 sp = (unsigned long) (®s->sp);
272 savesegment(ss, ss);
273 if (user_mode(regs)) {
274 sp = regs->sp;
275 ss = regs->ss & 0xffff;
276 }
277 printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip);
278 print_symbol("%s", regs->ip);
279 printk(" SS:ESP %04x:%08lx\n", ss, sp);
280#else
281
282 printk(KERN_ALERT "RIP ");
283 printk_address(regs->ip, 1);
284 printk(" RSP <%016lx>\n", regs->sp);
285#endif
286 return 0;
287}
288
289
290
291
292
293void die(const char *str, struct pt_regs *regs, long err)
294{
295 unsigned long flags = oops_begin();
296 int sig = SIGSEGV;
297
298 if (!user_mode_vm(regs))
299 report_bug(regs->ip, regs);
300
301 if (__die(str, regs, err))
302 sig = 0;
303 oops_end(flags, regs, sig);
304}
305
306void notrace __kprobes
307die_nmi(char *str, struct pt_regs *regs, int do_panic)
308{
309 unsigned long flags;
310
311 if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP)
312 return;
313
314
315
316
317
318 flags = oops_begin();
319 printk(KERN_EMERG "%s", str);
320 printk(" on CPU%d, ip %08lx, registers:\n",
321 smp_processor_id(), regs->ip);
322 show_registers(regs);
323 oops_end(flags, regs, 0);
324 if (do_panic || panic_on_oops)
325 panic("Non maskable interrupt");
326 nmi_exit();
327 local_irq_enable();
328 do_exit(SIGBUS);
329}
330
331static int __init oops_setup(char *s)
332{
333 if (!s)
334 return -EINVAL;
335 if (!strcmp(s, "panic"))
336 panic_on_oops = 1;
337 return 0;
338}
339early_param("oops", oops_setup);
340
341static int __init kstack_setup(char *s)
342{
343 if (!s)
344 return -EINVAL;
345 kstack_depth_to_print = simple_strtoul(s, NULL, 0);
346 return 0;
347}
348early_param("kstack", kstack_setup);
349
350static int __init code_bytes_setup(char *s)
351{
352 code_bytes = simple_strtoul(s, NULL, 0);
353 if (code_bytes > 8192)
354 code_bytes = 8192;
355
356 return 1;
357}
358__setup("code_bytes=", code_bytes_setup);
359
