x86: merge APIC_init_uniprocessor
[linux-2.6] / arch / x86 / kernel / dumpstack_32.c
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/kexec.h>
14 #include <linux/bug.h>
15 #include <linux/nmi.h>
16
17 #include <asm/stacktrace.h>
18
19 #define STACKSLOTS_PER_LINE 8
20 #define get_bp(bp) asm("movl %%ebp, %0" : "=r" (bp) :)
21
22 int panic_on_unrecovered_nmi;
23 int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE;
24 static unsigned int code_bytes = 64;
25 static int die_counter;
26
27 void printk_address(unsigned long address, int reliable)
28 {
29         printk(" [<%p>] %s%pS\n", (void *) address,
30                         reliable ? "" : "? ", (void *) address);
31 }
32
33 static inline int valid_stack_ptr(struct thread_info *tinfo,
34                         void *p, unsigned int size, void *end)
35 {
36         void *t = tinfo;
37         if (end) {
38                 if (p < end && p >= (end-THREAD_SIZE))
39                         return 1;
40                 else
41                         return 0;
42         }
43         return p > t && p < t + THREAD_SIZE - size;
44 }
45
46 /* The form of the top of the frame on the stack */
47 struct stack_frame {
48         struct stack_frame *next_frame;
49         unsigned long return_address;
50 };
51
52 static inline unsigned long
53 print_context_stack(struct thread_info *tinfo,
54                 unsigned long *stack, unsigned long bp,
55                 const struct stacktrace_ops *ops, void *data,
56                 unsigned long *end)
57 {
58         struct stack_frame *frame = (struct stack_frame *)bp;
59
60         while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) {
61                 unsigned long addr;
62
63                 addr = *stack;
64                 if (__kernel_text_address(addr)) {
65                         if ((unsigned long) stack == bp + sizeof(long)) {
66                                 ops->address(data, addr, 1);
67                                 frame = frame->next_frame;
68                                 bp = (unsigned long) frame;
69                         } else {
70                                 ops->address(data, addr, bp == 0);
71                         }
72                 }
73                 stack++;
74         }
75         return bp;
76 }
77
78 void dump_trace(struct task_struct *task, struct pt_regs *regs,
79                 unsigned long *stack, unsigned long bp,
80                 const struct stacktrace_ops *ops, void *data)
81 {
82         if (!task)
83                 task = current;
84
85         if (!stack) {
86                 unsigned long dummy;
87                 stack = &dummy;
88                 if (task && task != current)
89                         stack = (unsigned long *)task->thread.sp;
90         }
91
92 #ifdef CONFIG_FRAME_POINTER
93         if (!bp) {
94                 if (task == current) {
95                         /* Grab bp right from our regs */
96                         get_bp(bp);
97                 } else {
98                         /* bp is the last reg pushed by switch_to */
99                         bp = *(unsigned long *) task->thread.sp;
100                 }
101         }
102 #endif
103
104         for (;;) {
105                 struct thread_info *context;
106
107                 context = (struct thread_info *)
108                         ((unsigned long)stack & (~(THREAD_SIZE - 1)));
109                 bp = print_context_stack(context, stack, bp, ops, data, NULL);
110
111                 stack = (unsigned long *)context->previous_esp;
112                 if (!stack)
113                         break;
114                 if (ops->stack(data, "IRQ") < 0)
115                         break;
116                 touch_nmi_watchdog();
117         }
118 }
119 EXPORT_SYMBOL(dump_trace);
120
121 static void
122 print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
123 {
124         printk(data);
125         print_symbol(msg, symbol);
126         printk("\n");
127 }
128
129 static void print_trace_warning(void *data, char *msg)
130 {
131         printk("%s%s\n", (char *)data, msg);
132 }
133
134 static int print_trace_stack(void *data, char *name)
135 {
136         printk("%s <%s> ", (char *)data, name);
137         return 0;
138 }
139
140 /*
141  * Print one address/symbol entries per line.
142  */
143 static void print_trace_address(void *data, unsigned long addr, int reliable)
144 {
145         touch_nmi_watchdog();
146         printk(data);
147         printk_address(addr, reliable);
148 }
149
150 static const struct stacktrace_ops print_trace_ops = {
151         .warning = print_trace_warning,
152         .warning_symbol = print_trace_warning_symbol,
153         .stack = print_trace_stack,
154         .address = print_trace_address,
155 };
156
157 static void
158 show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
159                 unsigned long *stack, unsigned long bp, char *log_lvl)
160 {
161         printk("%sCall Trace:\n", log_lvl);
162         dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl);
163 }
164
165 void show_trace(struct task_struct *task, struct pt_regs *regs,
166                 unsigned long *stack, unsigned long bp)
167 {
168         show_trace_log_lvl(task, regs, stack, bp, "");
169 }
170
171 static void
172 show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs,
173                 unsigned long *sp, unsigned long bp, char *log_lvl)
174 {
175         unsigned long *stack;
176         int i;
177
178         if (sp == NULL) {
179                 if (task)
180                         sp = (unsigned long *)task->thread.sp;
181                 else
182                         sp = (unsigned long *)&sp;
183         }
184
185         stack = sp;
186         for (i = 0; i < kstack_depth_to_print; i++) {
187                 if (kstack_end(stack))
188                         break;
189                 if (i && ((i % STACKSLOTS_PER_LINE) == 0))
190                         printk("\n%s", log_lvl);
191                 printk(" %08lx", *stack++);
192                 touch_nmi_watchdog();
193         }
194         printk("\n");
195         show_trace_log_lvl(task, regs, sp, bp, log_lvl);
196 }
197
198 void show_stack(struct task_struct *task, unsigned long *sp)
199 {
200         show_stack_log_lvl(task, NULL, sp, 0, "");
201 }
202
203 /*
204  * The architecture-independent dump_stack generator
205  */
206 void dump_stack(void)
207 {
208         unsigned long bp = 0;
209         unsigned long stack;
210
211 #ifdef CONFIG_FRAME_POINTER
212         if (!bp)
213                 get_bp(bp);
214 #endif
215
216         printk("Pid: %d, comm: %.20s %s %s %.*s\n",
217                 current->pid, current->comm, print_tainted(),
218                 init_utsname()->release,
219                 (int)strcspn(init_utsname()->version, " "),
220                 init_utsname()->version);
221         show_trace(NULL, NULL, &stack, bp);
222 }
223
224 EXPORT_SYMBOL(dump_stack);
225
226 void show_registers(struct pt_regs *regs)
227 {
228         int i;
229
230         print_modules();
231         __show_regs(regs, 0);
232
233         printk(KERN_EMERG "Process %.*s (pid: %d, ti=%p task=%p task.ti=%p)\n",
234                 TASK_COMM_LEN, current->comm, task_pid_nr(current),
235                 current_thread_info(), current, task_thread_info(current));
236         /*
237          * When in-kernel, we also print out the stack and code at the
238          * time of the fault..
239          */
240         if (!user_mode_vm(regs)) {
241                 unsigned int code_prologue = code_bytes * 43 / 64;
242                 unsigned int code_len = code_bytes;
243                 unsigned char c;
244                 u8 *ip;
245
246                 printk(KERN_EMERG "Stack:\n");
247                 show_stack_log_lvl(NULL, regs, &regs->sp,
248                                 0, KERN_EMERG);
249
250                 printk(KERN_EMERG "Code: ");
251
252                 ip = (u8 *)regs->ip - code_prologue;
253                 if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) {
254                         /* try starting at IP */
255                         ip = (u8 *)regs->ip;
256                         code_len = code_len - code_prologue + 1;
257                 }
258                 for (i = 0; i < code_len; i++, ip++) {
259                         if (ip < (u8 *)PAGE_OFFSET ||
260                                         probe_kernel_address(ip, c)) {
261                                 printk(" Bad EIP value.");
262                                 break;
263                         }
264                         if (ip == (u8 *)regs->ip)
265                                 printk("<%02x> ", c);
266                         else
267                                 printk("%02x ", c);
268                 }
269         }
270         printk("\n");
271 }
272
273 int is_valid_bugaddr(unsigned long ip)
274 {
275         unsigned short ud2;
276
277         if (ip < PAGE_OFFSET)
278                 return 0;
279         if (probe_kernel_address((unsigned short *)ip, ud2))
280                 return 0;
281
282         return ud2 == 0x0b0f;
283 }
284
285 static raw_spinlock_t die_lock = __RAW_SPIN_LOCK_UNLOCKED;
286 static int die_owner = -1;
287 static unsigned int die_nest_count;
288
289 unsigned __kprobes long oops_begin(void)
290 {
291         unsigned long flags;
292
293         oops_enter();
294
295         if (die_owner != raw_smp_processor_id()) {
296                 console_verbose();
297                 raw_local_irq_save(flags);
298                 __raw_spin_lock(&die_lock);
299                 die_owner = smp_processor_id();
300                 die_nest_count = 0;
301                 bust_spinlocks(1);
302         } else {
303                 raw_local_irq_save(flags);
304         }
305         die_nest_count++;
306         return flags;
307 }
308
309 void __kprobes oops_end(unsigned long flags, struct pt_regs *regs, int signr)
310 {
311         bust_spinlocks(0);
312         die_owner = -1;
313         add_taint(TAINT_DIE);
314         __raw_spin_unlock(&die_lock);
315         raw_local_irq_restore(flags);
316
317         if (!regs)
318                 return;
319
320         if (kexec_should_crash(current))
321                 crash_kexec(regs);
322         if (in_interrupt())
323                 panic("Fatal exception in interrupt");
324         if (panic_on_oops)
325                 panic("Fatal exception");
326         oops_exit();
327         do_exit(signr);
328 }
329
330 int __kprobes __die(const char *str, struct pt_regs *regs, long err)
331 {
332         unsigned short ss;
333         unsigned long sp;
334
335         printk(KERN_EMERG "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
336 #ifdef CONFIG_PREEMPT
337         printk("PREEMPT ");
338 #endif
339 #ifdef CONFIG_SMP
340         printk("SMP ");
341 #endif
342 #ifdef CONFIG_DEBUG_PAGEALLOC
343         printk("DEBUG_PAGEALLOC");
344 #endif
345         printk("\n");
346         if (notify_die(DIE_OOPS, str, regs, err,
347                         current->thread.trap_no, SIGSEGV) == NOTIFY_STOP)
348                 return 1;
349
350         show_registers(regs);
351         /* Executive summary in case the oops scrolled away */
352         sp = (unsigned long) (&regs->sp);
353         savesegment(ss, ss);
354         if (user_mode(regs)) {
355                 sp = regs->sp;
356                 ss = regs->ss & 0xffff;
357         }
358         printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip);
359         print_symbol("%s", regs->ip);
360         printk(" SS:ESP %04x:%08lx\n", ss, sp);
361         return 0;
362 }
363
364 /*
365  * This is gone through when something in the kernel has done something bad
366  * and is about to be terminated:
367  */
368 void die(const char *str, struct pt_regs *regs, long err)
369 {
370         unsigned long flags = oops_begin();
371
372         if (die_nest_count < 3) {
373                 report_bug(regs->ip, regs);
374
375                 if (__die(str, regs, err))
376                         regs = NULL;
377         } else {
378                 printk(KERN_EMERG "Recursive die() failure, output suppressed\n");
379         }
380
381         oops_end(flags, regs, SIGSEGV);
382 }
383
384 static DEFINE_SPINLOCK(nmi_print_lock);
385
386 void notrace __kprobes
387 die_nmi(char *str, struct pt_regs *regs, int do_panic)
388 {
389         if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP)
390                 return;
391
392         spin_lock(&nmi_print_lock);
393         /*
394         * We are in trouble anyway, lets at least try
395         * to get a message out:
396         */
397         bust_spinlocks(1);
398         printk(KERN_EMERG "%s", str);
399         printk(" on CPU%d, ip %08lx, registers:\n",
400                 smp_processor_id(), regs->ip);
401         show_registers(regs);
402         if (do_panic)
403                 panic("Non maskable interrupt");
404         console_silent();
405         spin_unlock(&nmi_print_lock);
406         bust_spinlocks(0);
407
408         /*
409          * If we are in kernel we are probably nested up pretty bad
410          * and might aswell get out now while we still can:
411          */
412         if (!user_mode_vm(regs)) {
413                 current->thread.trap_no = 2;
414                 crash_kexec(regs);
415         }
416
417         do_exit(SIGSEGV);
418 }
419
420 static int __init oops_setup(char *s)
421 {
422         if (!s)
423                 return -EINVAL;
424         if (!strcmp(s, "panic"))
425                 panic_on_oops = 1;
426         return 0;
427 }
428 early_param("oops", oops_setup);
429
430 static int __init kstack_setup(char *s)
431 {
432         if (!s)
433                 return -EINVAL;
434         kstack_depth_to_print = simple_strtoul(s, NULL, 0);
435         return 0;
436 }
437 early_param("kstack", kstack_setup);
438
439 static int __init code_bytes_setup(char *s)
440 {
441         code_bytes = simple_strtoul(s, NULL, 0);
442         if (code_bytes > 8192)
443                 code_bytes = 8192;
444
445         return 1;
446 }
447 __setup("code_bytes=", code_bytes_setup);