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