1
2
3
4
5
6
7
8
9
10
11#include <linux/debug_locks.h>
12#include <linux/interrupt.h>
13#include <linux/kallsyms.h>
14#include <linux/notifier.h>
15#include <linux/module.h>
16#include <linux/random.h>
17#include <linux/reboot.h>
18#include <linux/delay.h>
19#include <linux/kexec.h>
20#include <linux/sched.h>
21#include <linux/sysrq.h>
22#include <linux/init.h>
23#include <linux/nmi.h>
24#include <linux/dmi.h>
25
26int panic_on_oops;
27static unsigned long tainted_mask;
28static int pause_on_oops;
29static int pause_on_oops_flag;
30static DEFINE_SPINLOCK(pause_on_oops_lock);
31
32int panic_timeout;
33
34ATOMIC_NOTIFIER_HEAD(panic_notifier_list);
35
36EXPORT_SYMBOL(panic_notifier_list);
37
38static long no_blink(long time)
39{
40 return 0;
41}
42
43
44long (*panic_blink)(long time);
45EXPORT_SYMBOL(panic_blink);
46
47
48
49
50
51
52
53
54
55NORET_TYPE void panic(const char * fmt, ...)
56{
57 static char buf[1024];
58 va_list args;
59 long i;
60
61
62
63
64
65
66 preempt_disable();
67
68 bust_spinlocks(1);
69 va_start(args, fmt);
70 vsnprintf(buf, sizeof(buf), fmt, args);
71 va_end(args);
72 printk(KERN_EMERG "Kernel panic - not syncing: %s\n",buf);
73#ifdef CONFIG_DEBUG_BUGVERBOSE
74 dump_stack();
75#endif
76
77
78
79
80
81
82 crash_kexec(NULL);
83
84
85
86
87
88
89 smp_send_stop();
90
91 atomic_notifier_call_chain(&panic_notifier_list, 0, buf);
92
93 bust_spinlocks(0);
94
95 if (!panic_blink)
96 panic_blink = no_blink;
97
98 if (panic_timeout > 0) {
99
100
101
102
103 printk(KERN_EMERG "Rebooting in %d seconds..", panic_timeout);
104
105 for (i = 0; i < panic_timeout*1000; ) {
106 touch_nmi_watchdog();
107 i += panic_blink(i);
108 mdelay(1);
109 i++;
110 }
111
112
113
114
115
116 emergency_restart();
117 }
118#ifdef __sparc__
119 {
120 extern int stop_a_enabled;
121
122 stop_a_enabled = 1;
123 printk(KERN_EMERG "Press Stop-A (L1-A) to return to the boot prom\n");
124 }
125#endif
126#if defined(CONFIG_S390)
127 {
128 unsigned long caller;
129
130 caller = (unsigned long)__builtin_return_address(0);
131 disabled_wait(caller);
132 }
133#endif
134 local_irq_enable();
135 for (i = 0; ; ) {
136 touch_softlockup_watchdog();
137 i += panic_blink(i);
138 mdelay(1);
139 i++;
140 }
141}
142
143EXPORT_SYMBOL(panic);
144
145
146struct tnt {
147 u8 bit;
148 char true;
149 char false;
150};
151
152static const struct tnt tnts[] = {
153 { TAINT_PROPRIETARY_MODULE, 'P', 'G' },
154 { TAINT_FORCED_MODULE, 'F', ' ' },
155 { TAINT_UNSAFE_SMP, 'S', ' ' },
156 { TAINT_FORCED_RMMOD, 'R', ' ' },
157 { TAINT_MACHINE_CHECK, 'M', ' ' },
158 { TAINT_BAD_PAGE, 'B', ' ' },
159 { TAINT_USER, 'U', ' ' },
160 { TAINT_DIE, 'D', ' ' },
161 { TAINT_OVERRIDDEN_ACPI_TABLE, 'A', ' ' },
162 { TAINT_WARN, 'W', ' ' },
163 { TAINT_CRAP, 'C', ' ' },
164};
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183const char *print_tainted(void)
184{
185 static char buf[ARRAY_SIZE(tnts) + sizeof("Tainted: ") + 1];
186
187 if (tainted_mask) {
188 char *s;
189 int i;
190
191 s = buf + sprintf(buf, "Tainted: ");
192 for (i = 0; i < ARRAY_SIZE(tnts); i++) {
193 const struct tnt *t = &tnts[i];
194 *s++ = test_bit(t->bit, &tainted_mask) ?
195 t->true : t->false;
196 }
197 *s = 0;
198 } else
199 snprintf(buf, sizeof(buf), "Not tainted");
200
201 return buf;
202}
203
204int test_taint(unsigned flag)
205{
206 return test_bit(flag, &tainted_mask);
207}
208EXPORT_SYMBOL(test_taint);
209
210unsigned long get_taint(void)
211{
212 return tainted_mask;
213}
214
215void add_taint(unsigned flag)
216{
217
218
219
220
221
222
223
224 if (flag != TAINT_CRAP && flag != TAINT_WARN && __debug_locks_off())
225 printk(KERN_WARNING "Disabling lock debugging due to kernel taint\n");
226
227 set_bit(flag, &tainted_mask);
228}
229EXPORT_SYMBOL(add_taint);
230
231static void spin_msec(int msecs)
232{
233 int i;
234
235 for (i = 0; i < msecs; i++) {
236 touch_nmi_watchdog();
237 mdelay(1);
238 }
239}
240
241
242
243
244
245static void do_oops_enter_exit(void)
246{
247 unsigned long flags;
248 static int spin_counter;
249
250 if (!pause_on_oops)
251 return;
252
253 spin_lock_irqsave(&pause_on_oops_lock, flags);
254 if (pause_on_oops_flag == 0) {
255
256 pause_on_oops_flag = 1;
257 } else {
258
259 if (!spin_counter) {
260
261 spin_counter = pause_on_oops;
262 do {
263 spin_unlock(&pause_on_oops_lock);
264 spin_msec(MSEC_PER_SEC);
265 spin_lock(&pause_on_oops_lock);
266 } while (--spin_counter);
267 pause_on_oops_flag = 0;
268 } else {
269
270 while (spin_counter) {
271 spin_unlock(&pause_on_oops_lock);
272 spin_msec(1);
273 spin_lock(&pause_on_oops_lock);
274 }
275 }
276 }
277 spin_unlock_irqrestore(&pause_on_oops_lock, flags);
278}
279
280
281
282
283
284int oops_may_print(void)
285{
286 return pause_on_oops_flag == 0;
287}
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303void oops_enter(void)
304{
305 tracing_off();
306
307 debug_locks_off();
308 do_oops_enter_exit();
309}
310
311
312
313
314static u64 oops_id;
315
316static int init_oops_id(void)
317{
318 if (!oops_id)
319 get_random_bytes(&oops_id, sizeof(oops_id));
320 else
321 oops_id++;
322
323 return 0;
324}
325late_initcall(init_oops_id);
326
327static void print_oops_end_marker(void)
328{
329 init_oops_id();
330 printk(KERN_WARNING "---[ end trace %016llx ]---\n",
331 (unsigned long long)oops_id);
332}
333
334
335
336
337
338void oops_exit(void)
339{
340 do_oops_enter_exit();
341 print_oops_end_marker();
342}
343
344#ifdef WANT_WARN_ON_SLOWPATH
345struct slowpath_args {
346 const char *fmt;
347 va_list args;
348};
349
350static void warn_slowpath_common(const char *file, int line, void *caller, struct slowpath_args *args)
351{
352 const char *board;
353
354 printk(KERN_WARNING "------------[ cut here ]------------\n");
355 printk(KERN_WARNING "WARNING: at %s:%d %pS()\n", file, line, caller);
356 board = dmi_get_system_info(DMI_PRODUCT_NAME);
357 if (board)
358 printk(KERN_WARNING "Hardware name: %s\n", board);
359
360 if (args)
361 vprintk(args->fmt, args->args);
362
363 print_modules();
364 dump_stack();
365 print_oops_end_marker();
366 add_taint(TAINT_WARN);
367}
368
369void warn_slowpath_fmt(const char *file, int line, const char *fmt, ...)
370{
371 struct slowpath_args args;
372
373 args.fmt = fmt;
374 va_start(args.args, fmt);
375 warn_slowpath_common(file, line, __builtin_return_address(0), &args);
376 va_end(args.args);
377}
378EXPORT_SYMBOL(warn_slowpath_fmt);
379
380void warn_slowpath_null(const char *file, int line)
381{
382 warn_slowpath_common(file, line, __builtin_return_address(0), NULL);
383}
384EXPORT_SYMBOL(warn_slowpath_null);
385#endif
386
387#ifdef CONFIG_CC_STACKPROTECTOR
388
389
390
391
392
393void __stack_chk_fail(void)
394{
395 panic("stack-protector: Kernel stack is corrupted in: %p\n",
396 __builtin_return_address(0));
397}
398EXPORT_SYMBOL(__stack_chk_fail);
399
400#endif
401
402core_param(panic, panic_timeout, int, 0644);
403core_param(pause_on_oops, pause_on_oops, int, 0644);
404