4 * Copyright (C) 1991, 1992 Linus Torvalds
8 * This function is used through-out the kernel (including mm and fs)
9 * to indicate a major problem.
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>
27 static unsigned long tainted_mask
;
28 static int pause_on_oops
;
29 static int pause_on_oops_flag
;
30 static DEFINE_SPINLOCK(pause_on_oops_lock
);
34 ATOMIC_NOTIFIER_HEAD(panic_notifier_list
);
36 EXPORT_SYMBOL(panic_notifier_list
);
38 static long no_blink(long time
)
43 /* Returns how long it waited in ms */
44 long (*panic_blink
)(long time
);
45 EXPORT_SYMBOL(panic_blink
);
48 * panic - halt the system
49 * @fmt: The text string to print
51 * Display a message, then perform cleanups.
53 * This function never returns.
55 NORET_TYPE
void panic(const char * fmt
, ...)
57 static char buf
[1024];
62 * It's possible to come here directly from a panic-assertion and
63 * not have preempt disabled. Some functions called from here want
64 * preempt to be disabled. No point enabling it later though...
70 vsnprintf(buf
, sizeof(buf
), fmt
, args
);
72 printk(KERN_EMERG
"Kernel panic - not syncing: %s\n",buf
);
73 #ifdef CONFIG_DEBUG_BUGVERBOSE
78 * If we have crashed and we have a crash kernel loaded let it handle
80 * Do we want to call this before we try to display a message?
85 * Note smp_send_stop is the usual smp shutdown function, which
86 * unfortunately means it may not be hardened to work in a panic
91 atomic_notifier_call_chain(&panic_notifier_list
, 0, buf
);
94 panic_blink
= no_blink
;
96 if (panic_timeout
> 0) {
98 * Delay timeout seconds before rebooting the machine.
99 * We can't use the "normal" timers since we just panicked.
101 printk(KERN_EMERG
"Rebooting in %d seconds..", panic_timeout
);
103 for (i
= 0; i
< panic_timeout
*1000; ) {
104 touch_nmi_watchdog();
110 * This will not be a clean reboot, with everything
111 * shutting down. But if there is a chance of
112 * rebooting the system it will be rebooted.
118 extern int stop_a_enabled
;
119 /* Make sure the user can actually press Stop-A (L1-A) */
121 printk(KERN_EMERG
"Press Stop-A (L1-A) to return to the boot prom\n");
124 #if defined(CONFIG_S390)
126 unsigned long caller
;
128 caller
= (unsigned long)__builtin_return_address(0);
129 disabled_wait(caller
);
134 touch_softlockup_watchdog();
142 EXPORT_SYMBOL(panic
);
151 static const struct tnt tnts
[] = {
152 { TAINT_PROPRIETARY_MODULE
, 'P', 'G' },
153 { TAINT_FORCED_MODULE
, 'F', ' ' },
154 { TAINT_UNSAFE_SMP
, 'S', ' ' },
155 { TAINT_FORCED_RMMOD
, 'R', ' ' },
156 { TAINT_MACHINE_CHECK
, 'M', ' ' },
157 { TAINT_BAD_PAGE
, 'B', ' ' },
158 { TAINT_USER
, 'U', ' ' },
159 { TAINT_DIE
, 'D', ' ' },
160 { TAINT_OVERRIDDEN_ACPI_TABLE
, 'A', ' ' },
161 { TAINT_WARN
, 'W', ' ' },
162 { TAINT_CRAP
, 'C', ' ' },
166 * print_tainted - return a string to represent the kernel taint state.
168 * 'P' - Proprietary module has been loaded.
169 * 'F' - Module has been forcibly loaded.
170 * 'S' - SMP with CPUs not designed for SMP.
171 * 'R' - User forced a module unload.
172 * 'M' - System experienced a machine check exception.
173 * 'B' - System has hit bad_page.
174 * 'U' - Userspace-defined naughtiness.
175 * 'D' - Kernel has oopsed before
176 * 'A' - ACPI table overridden.
177 * 'W' - Taint on warning.
178 * 'C' - modules from drivers/staging are loaded.
180 * The string is overwritten by the next call to print_taint().
182 const char *print_tainted(void)
184 static char buf
[ARRAY_SIZE(tnts
) + sizeof("Tainted: ") + 1];
190 s
= buf
+ sprintf(buf
, "Tainted: ");
191 for (i
= 0; i
< ARRAY_SIZE(tnts
); i
++) {
192 const struct tnt
*t
= &tnts
[i
];
193 *s
++ = test_bit(t
->bit
, &tainted_mask
) ?
198 snprintf(buf
, sizeof(buf
), "Not tainted");
203 int test_taint(unsigned flag
)
205 return test_bit(flag
, &tainted_mask
);
207 EXPORT_SYMBOL(test_taint
);
209 unsigned long get_taint(void)
214 void add_taint(unsigned flag
)
217 * Can't trust the integrity of the kernel anymore.
218 * We don't call directly debug_locks_off() because the issue
219 * is not necessarily serious enough to set oops_in_progress to 1
220 * Also we want to keep up lockdep for staging development and
223 if (flag
!= TAINT_CRAP
&& flag
!= TAINT_WARN
&& __debug_locks_off())
224 printk(KERN_WARNING
"Disabling lock debugging due to kernel taint\n");
226 set_bit(flag
, &tainted_mask
);
228 EXPORT_SYMBOL(add_taint
);
230 static void spin_msec(int msecs
)
234 for (i
= 0; i
< msecs
; i
++) {
235 touch_nmi_watchdog();
241 * It just happens that oops_enter() and oops_exit() are identically
244 static void do_oops_enter_exit(void)
247 static int spin_counter
;
252 spin_lock_irqsave(&pause_on_oops_lock
, flags
);
253 if (pause_on_oops_flag
== 0) {
254 /* This CPU may now print the oops message */
255 pause_on_oops_flag
= 1;
257 /* We need to stall this CPU */
259 /* This CPU gets to do the counting */
260 spin_counter
= pause_on_oops
;
262 spin_unlock(&pause_on_oops_lock
);
263 spin_msec(MSEC_PER_SEC
);
264 spin_lock(&pause_on_oops_lock
);
265 } while (--spin_counter
);
266 pause_on_oops_flag
= 0;
268 /* This CPU waits for a different one */
269 while (spin_counter
) {
270 spin_unlock(&pause_on_oops_lock
);
272 spin_lock(&pause_on_oops_lock
);
276 spin_unlock_irqrestore(&pause_on_oops_lock
, flags
);
280 * Return true if the calling CPU is allowed to print oops-related info.
281 * This is a bit racy..
283 int oops_may_print(void)
285 return pause_on_oops_flag
== 0;
289 * Called when the architecture enters its oops handler, before it prints
290 * anything. If this is the first CPU to oops, and it's oopsing the first
291 * time then let it proceed.
293 * This is all enabled by the pause_on_oops kernel boot option. We do all
294 * this to ensure that oopses don't scroll off the screen. It has the
295 * side-effect of preventing later-oopsing CPUs from mucking up the display,
298 * It turns out that the CPU which is allowed to print ends up pausing for
299 * the right duration, whereas all the other CPUs pause for twice as long:
300 * once in oops_enter(), once in oops_exit().
302 void oops_enter(void)
304 /* can't trust the integrity of the kernel anymore: */
306 do_oops_enter_exit();
310 * 64-bit random ID for oopses:
314 static int init_oops_id(void)
317 get_random_bytes(&oops_id
, sizeof(oops_id
));
323 late_initcall(init_oops_id
);
325 static void print_oops_end_marker(void)
328 printk(KERN_WARNING
"---[ end trace %016llx ]---\n",
329 (unsigned long long)oops_id
);
333 * Called when the architecture exits its oops handler, after printing
338 do_oops_enter_exit();
339 print_oops_end_marker();
342 #ifdef WANT_WARN_ON_SLOWPATH
343 struct slowpath_args
{
348 static void warn_slowpath_common(const char *file
, int line
, void *caller
, struct slowpath_args
*args
)
352 printk(KERN_WARNING
"------------[ cut here ]------------\n");
353 printk(KERN_WARNING
"WARNING: at %s:%d %pS()\n", file
, line
, caller
);
354 board
= dmi_get_system_info(DMI_PRODUCT_NAME
);
356 printk(KERN_WARNING
"Hardware name: %s\n", board
);
359 vprintk(args
->fmt
, args
->args
);
363 print_oops_end_marker();
364 add_taint(TAINT_WARN
);
367 void warn_slowpath_fmt(const char *file
, int line
, const char *fmt
, ...)
369 struct slowpath_args args
;
372 va_start(args
.args
, fmt
);
373 warn_slowpath_common(file
, line
, __builtin_return_address(0), &args
);
376 EXPORT_SYMBOL(warn_slowpath_fmt
);
378 void warn_slowpath_null(const char *file
, int line
)
380 warn_slowpath_common(file
, line
, __builtin_return_address(0), NULL
);
382 EXPORT_SYMBOL(warn_slowpath_null
);
385 #ifdef CONFIG_CC_STACKPROTECTOR
388 * Called when gcc's -fstack-protector feature is used, and
389 * gcc detects corruption of the on-stack canary value
391 void __stack_chk_fail(void)
393 panic("stack-protector: Kernel stack is corrupted in: %p\n",
394 __builtin_return_address(0));
396 EXPORT_SYMBOL(__stack_chk_fail
);
400 core_param(panic
, panic_timeout
, int, 0644);
401 core_param(pause_on_oops
, pause_on_oops
, int, 0644);