1/*
2 *  Copyright (C) 1991, 1992  Linus Torvalds
3 *  Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
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
22int panic_on_unrecovered_nmi;
23int panic_on_io_nmi;
24unsigned int code_bytes = 64;
25int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE;
26static int die_counter;
27
28static void printk_stack_address(unsigned long address, int reliable,
29		void *data)
30{
31	printk("%s [<%p>] %s%pB\n",
32		(char *)data, (void *)address, reliable ? "" : "? ",
33		(void *)address);
34}
35
36void printk_address(unsigned long address)
37{
38	pr_cont(" [<%p>] %pS\n", (void *)address, (void *)address);
39}
40
41#ifdef CONFIG_FUNCTION_GRAPH_TRACER
42static void
43print_ftrace_graph_addr(unsigned long addr, void *data,
44			const struct stacktrace_ops *ops,
45			struct thread_info *tinfo, int *graph)
46{
47	struct task_struct *task;
48	unsigned long ret_addr;
49	int index;
50
51	if (addr != (unsigned long)return_to_handler)
52		return;
53
54	task = tinfo->task;
55	index = task->curr_ret_stack;
56
57	if (!task->ret_stack || index < *graph)
58		return;
59
60	index -= *graph;
61	ret_addr = task->ret_stack[index].ret;
62
63	ops->address(data, ret_addr, 1);
64
65	(*graph)++;
66}
67#else
68static inline void
69print_ftrace_graph_addr(unsigned long addr, void *data,
70			const struct stacktrace_ops *ops,
71			struct thread_info *tinfo, int *graph)
72{ }
73#endif
74
75/*
76 * x86-64 can have up to three kernel stacks:
77 * process stack
78 * interrupt stack
79 * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
80 */
81
82static inline int valid_stack_ptr(struct thread_info *tinfo,
83			void *p, unsigned int size, void *end)
84{
85	void *t = tinfo;
86	if (end) {
87		if (p < end && p >= (end-THREAD_SIZE))
88			return 1;
89		else
90			return 0;
91	}
92	return p > t && p < t + THREAD_SIZE - size;
93}
94
95unsigned long
96print_context_stack(struct thread_info *tinfo,
97		unsigned long *stack, unsigned long bp,
98		const struct stacktrace_ops *ops, void *data,
99		unsigned long *end, int *graph)
100{
101	struct stack_frame *frame = (struct stack_frame *)bp;
102
103	while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) {
104		unsigned long addr;
105
106		addr = *stack;
107		if (__kernel_text_address(addr)) {
108			if ((unsigned long) stack == bp + sizeof(long)) {
109				ops->address(data, addr, 1);
110				frame = frame->next_frame;
111				bp = (unsigned long) frame;
112			} else {
113				ops->address(data, addr, 0);
114			}
115			print_ftrace_graph_addr(addr, data, ops, tinfo, graph);
116		}
117		stack++;
118	}
119	return bp;
120}
121EXPORT_SYMBOL_GPL(print_context_stack);
122
123unsigned long
124print_context_stack_bp(struct thread_info *tinfo,
125		       unsigned long *stack, unsigned long bp,
126		       const struct stacktrace_ops *ops, void *data,
127		       unsigned long *end, int *graph)
128{
129	struct stack_frame *frame = (struct stack_frame *)bp;
130	unsigned long *ret_addr = &frame->return_address;
131
132	while (valid_stack_ptr(tinfo, ret_addr, sizeof(*ret_addr), end)) {
133		unsigned long addr = *ret_addr;
134
135		if (!__kernel_text_address(addr))
136			break;
137
138		ops->address(data, addr, 1);
139		frame = frame->next_frame;
140		ret_addr = &frame->return_address;
141		print_ftrace_graph_addr(addr, data, ops, tinfo, graph);
142	}
143
144	return (unsigned long)frame;
145}
146EXPORT_SYMBOL_GPL(print_context_stack_bp);
147
148static int print_trace_stack(void *data, char *name)
149{
150	printk("%s <%s> ", (char *)data, name);
151	return 0;
152}
153
154/*
155 * Print one address/symbol entries per line.
156 */
157static void print_trace_address(void *data, unsigned long addr, int reliable)
158{
159	touch_nmi_watchdog();
160	printk_stack_address(addr, reliable, data);
161}
162
163static const struct stacktrace_ops print_trace_ops = {
164	.stack			= print_trace_stack,
165	.address		= print_trace_address,
166	.walk_stack		= print_context_stack,
167};
168
169void
170show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
171		unsigned long *stack, unsigned long bp, char *log_lvl)
172{
173	printk("%sCall Trace:\n", log_lvl);
174	dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl);
175}
176
177void show_trace(struct task_struct *task, struct pt_regs *regs,
178		unsigned long *stack, unsigned long bp)
179{
180	show_trace_log_lvl(task, regs, stack, bp, "");
181}
182
183void show_stack(struct task_struct *task, unsigned long *sp)
184{
185	unsigned long bp = 0;
186	unsigned long stack;
187
188	/*
189	 * Stack frames below this one aren't interesting.  Don't show them
190	 * if we're printing for %current.
191	 */
192	if (!sp && (!task || task == current)) {
193		sp = &stack;
194		bp = stack_frame(current, NULL);
195	}
196
197	show_stack_log_lvl(task, NULL, sp, bp, "");
198}
199
200static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED;
201static int die_owner = -1;
202static unsigned int die_nest_count;
203
204unsigned long oops_begin(void)
205{
206	int cpu;
207	unsigned long flags;
208
209	oops_enter();
210
211	/* racy, but better than risking deadlock. */
212	raw_local_irq_save(flags);
213	cpu = smp_processor_id();
214	if (!arch_spin_trylock(&die_lock)) {
215		if (cpu == die_owner)
216			/* nested oops. should stop eventually */;
217		else
218			arch_spin_lock(&die_lock);
219	}
220	die_nest_count++;
221	die_owner = cpu;
222	console_verbose();
223	bust_spinlocks(1);
224	return flags;
225}
226EXPORT_SYMBOL_GPL(oops_begin);
227NOKPROBE_SYMBOL(oops_begin);
228
229void oops_end(unsigned long flags, struct pt_regs *regs, int signr)
230{
231	if (regs && kexec_should_crash(current))
232		crash_kexec(regs);
233
234	bust_spinlocks(0);
235	die_owner = -1;
236	add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
237	die_nest_count--;
238	if (!die_nest_count)
239		/* Nest count reaches zero, release the lock. */
240		arch_spin_unlock(&die_lock);
241	raw_local_irq_restore(flags);
242	oops_exit();
243
244	if (!signr)
245		return;
246	if (in_interrupt())
247		panic("Fatal exception in interrupt");
248	if (panic_on_oops)
249		panic("Fatal exception");
250	do_exit(signr);
251}
252NOKPROBE_SYMBOL(oops_end);
253
254int __die(const char *str, struct pt_regs *regs, long err)
255{
256#ifdef CONFIG_X86_32
257	unsigned short ss;
258	unsigned long sp;
259#endif
260	printk(KERN_DEFAULT
261	       "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
262#ifdef CONFIG_PREEMPT
263	printk("PREEMPT ");
264#endif
265#ifdef CONFIG_SMP
266	printk("SMP ");
267#endif
268#ifdef CONFIG_DEBUG_PAGEALLOC
269	printk("DEBUG_PAGEALLOC ");
270#endif
271#ifdef CONFIG_KASAN
272	printk("KASAN");
273#endif
274	printk("\n");
275	if (notify_die(DIE_OOPS, str, regs, err,
276			current->thread.trap_nr, SIGSEGV) == NOTIFY_STOP)
277		return 1;
278
279	print_modules();
280	show_regs(regs);
281#ifdef CONFIG_X86_32
282	if (user_mode(regs)) {
283		sp = regs->sp;
284		ss = regs->ss & 0xffff;
285	} else {
286		sp = kernel_stack_pointer(regs);
287		savesegment(ss, ss);
288	}
289	printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip);
290	print_symbol("%s", regs->ip);
291	printk(" SS:ESP %04x:%08lx\n", ss, sp);
292#else
293	/* Executive summary in case the oops scrolled away */
294	printk(KERN_ALERT "RIP ");
295	printk_address(regs->ip);
296	printk(" RSP <%016lx>\n", regs->sp);
297#endif
298	return 0;
299}
300NOKPROBE_SYMBOL(__die);
301
302/*
303 * This is gone through when something in the kernel has done something bad
304 * and is about to be terminated:
305 */
306void die(const char *str, struct pt_regs *regs, long err)
307{
308	unsigned long flags = oops_begin();
309	int sig = SIGSEGV;
310
311	if (!user_mode(regs))
312		report_bug(regs->ip, regs);
313
314	if (__die(str, regs, err))
315		sig = 0;
316	oops_end(flags, regs, sig);
317}
318
319static int __init kstack_setup(char *s)
320{
321	ssize_t ret;
322	unsigned long val;
323
324	if (!s)
325		return -EINVAL;
326
327	ret = kstrtoul(s, 0, &val);
328	if (ret)
329		return ret;
330	kstack_depth_to_print = val;
331	return 0;
332}
333early_param("kstack", kstack_setup);
334
335static int __init code_bytes_setup(char *s)
336{
337	ssize_t ret;
338	unsigned long val;
339
340	if (!s)
341		return -EINVAL;
342
343	ret = kstrtoul(s, 0, &val);
344	if (ret)
345		return ret;
346
347	code_bytes = val;
348	if (code_bytes > 8192)
349		code_bytes = 8192;
350
351	return 1;
352}
353__setup("code_bytes=", code_bytes_setup);
354