Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / arch / cris / kernel / traps.c
1 /*
2  *  linux/arch/cris/traps.c
3  *
4  *  Here we handle the break vectors not used by the system call
5  *  mechanism, as well as some general stack/register dumping
6  *  things.
7  *
8  *  Copyright (C) 2000-2007 Axis Communications AB
9  *
10  *  Authors:   Bjorn Wesen
11  *             Hans-Peter Nilsson
12  *
13  */
14
15 #include <linux/init.h>
16 #include <linux/module.h>
17
18 #include <asm/pgtable.h>
19 #include <asm/uaccess.h>
20
21 extern void arch_enable_nmi(void);
22 extern void stop_watchdog(void);
23 extern void reset_watchdog(void);
24 extern void show_registers(struct pt_regs *regs);
25
26 #ifdef CONFIG_DEBUG_BUGVERBOSE
27 extern void handle_BUG(struct pt_regs *regs);
28 #else
29 #define handle_BUG(regs)
30 #endif
31
32 static int kstack_depth_to_print = 24;
33
34 void (*nmi_handler)(struct pt_regs *);
35
36 void
37 show_trace(unsigned long *stack)
38 {
39         unsigned long addr, module_start, module_end;
40         extern char _stext, _etext;
41         int i;
42
43         printk("\nCall Trace: ");
44
45         i = 1;
46         module_start = VMALLOC_START;
47         module_end = VMALLOC_END;
48
49         while (((long)stack & (THREAD_SIZE-1)) != 0) {
50                 if (__get_user(addr, stack)) {
51                         /* This message matches "failing address" marked
52                            s390 in ksymoops, so lines containing it will
53                            not be filtered out by ksymoops.  */
54                         printk("Failing address 0x%lx\n", (unsigned long)stack);
55                         break;
56                 }
57                 stack++;
58
59                 /*
60                  * If the address is either in the text segment of the
61                  * kernel, or in the region which contains vmalloc'ed
62                  * memory, it *may* be the address of a calling
63                  * routine; if so, print it so that someone tracing
64                  * down the cause of the crash will be able to figure
65                  * out the call path that was taken.
66                  */
67                 if (((addr >= (unsigned long)&_stext) &&
68                      (addr <= (unsigned long)&_etext)) ||
69                     ((addr >= module_start) && (addr <= module_end))) {
70                         if (i && ((i % 8) == 0))
71                                 printk("\n       ");
72                         printk("[<%08lx>] ", addr);
73                         i++;
74                 }
75         }
76 }
77
78 /*
79  * These constants are for searching for possible module text
80  * segments. MODULE_RANGE is a guess of how much space is likely
81  * to be vmalloced.
82  */
83
84 #define MODULE_RANGE (8*1024*1024)
85
86 /*
87  * The output (format, strings and order) is adjusted to be usable with
88  * ksymoops-2.4.1 with some necessary CRIS-specific patches.  Please don't
89  * change it unless you're serious about adjusting ksymoops and syncing
90  * with the ksymoops maintainer.
91  */
92
93 void
94 show_stack(struct task_struct *task, unsigned long *sp)
95 {
96         unsigned long *stack, addr;
97         int i;
98
99         /*
100          * debugging aid: "show_stack(NULL);" prints a
101          * back trace.
102          */
103
104         if (sp == NULL) {
105                 if (task)
106                         sp = (unsigned long*)task->thread.ksp;
107                 else
108                         sp = (unsigned long*)rdsp();
109         }
110
111         stack = sp;
112
113         printk("\nStack from %08lx:\n       ", (unsigned long)stack);
114         for (i = 0; i < kstack_depth_to_print; i++) {
115                 if (((long)stack & (THREAD_SIZE-1)) == 0)
116                         break;
117                 if (i && ((i % 8) == 0))
118                         printk("\n       ");
119                 if (__get_user(addr, stack)) {
120                         /* This message matches "failing address" marked
121                            s390 in ksymoops, so lines containing it will
122                            not be filtered out by ksymoops.  */
123                         printk("Failing address 0x%lx\n", (unsigned long)stack);
124                         break;
125                 }
126                 stack++;
127                 printk("%08lx ", addr);
128         }
129         show_trace(sp);
130 }
131
132 #if 0
133 /* displays a short stack trace */
134
135 int
136 show_stack(void)
137 {
138         unsigned long *sp = (unsigned long *)rdusp();
139         int i;
140
141         printk("Stack dump [0x%08lx]:\n", (unsigned long)sp);
142         for (i = 0; i < 16; i++)
143                 printk("sp + %d: 0x%08lx\n", i*4, sp[i]);
144         return 0;
145 }
146 #endif
147
148 void
149 dump_stack(void)
150 {
151         show_stack(NULL, NULL);
152 }
153 EXPORT_SYMBOL(dump_stack);
154
155 void
156 set_nmi_handler(void (*handler)(struct pt_regs *))
157 {
158         nmi_handler = handler;
159         arch_enable_nmi();
160 }
161
162 #ifdef CONFIG_DEBUG_NMI_OOPS
163 void
164 oops_nmi_handler(struct pt_regs *regs)
165 {
166         stop_watchdog();
167         oops_in_progress = 1;
168         printk("NMI!\n");
169         show_registers(regs);
170         oops_in_progress = 0;
171 }
172
173 static int __init
174 oops_nmi_register(void)
175 {
176         set_nmi_handler(oops_nmi_handler);
177         return 0;
178 }
179
180 __initcall(oops_nmi_register);
181
182 #endif
183
184 /*
185  * This gets called from entry.S when the watchdog has bitten. Show something
186  * similiar to an Oops dump, and if the kernel is configured to be a nice
187  * doggy, then halt instead of reboot.
188  */
189 void
190 watchdog_bite_hook(struct pt_regs *regs)
191 {
192 #ifdef CONFIG_ETRAX_WATCHDOG_NICE_DOGGY
193         local_irq_disable();
194         stop_watchdog();
195         show_registers(regs);
196
197         while (1)
198                 ; /* Do nothing. */
199 #else
200         show_registers(regs);
201 #endif
202 }
203
204 /* This is normally the Oops function. */
205 void
206 die_if_kernel(const char *str, struct pt_regs *regs, long err)
207 {
208         if (user_mode(regs))
209                 return;
210
211 #ifdef CONFIG_ETRAX_WATCHDOG_NICE_DOGGY
212         /*
213          * This printout might take too long and could trigger
214          * the watchdog normally. If NICE_DOGGY is set, simply
215          * stop the watchdog during the printout.
216          */
217         stop_watchdog();
218 #endif
219
220         handle_BUG(regs);
221
222         printk("%s: %04lx\n", str, err & 0xffff);
223
224         show_registers(regs);
225
226         oops_in_progress = 0;
227
228 #ifdef CONFIG_ETRAX_WATCHDOG_NICE_DOGGY
229         reset_watchdog();
230 #endif
231         do_exit(SIGSEGV);
232 }
233
234 void __init
235 trap_init(void)
236 {
237         /* Nothing needs to be done */
238 }