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>
28 static unsigned long tainted_mask
;
29 static int pause_on_oops
;
30 static int pause_on_oops_flag
;
31 static DEFINE_SPINLOCK(pause_on_oops_lock
);
35 ATOMIC_NOTIFIER_HEAD(panic_notifier_list
);
37 EXPORT_SYMBOL(panic_notifier_list
);
39 static long no_blink(long time
)
44 /* Returns how long it waited in ms */
45 long (*panic_blink
)(long time
);
46 EXPORT_SYMBOL(panic_blink
);
49 * panic - halt the system
50 * @fmt: The text string to print
52 * Display a message, then perform cleanups.
54 * This function never returns.
56 NORET_TYPE
void panic(const char * fmt
, ...)
58 static char buf
[1024];
63 * It's possible to come here directly from a panic-assertion and
64 * not have preempt disabled. Some functions called from here want
65 * preempt to be disabled. No point enabling it later though...
69 /* don't redirect the panic message to some hidden console */
74 vsnprintf(buf
, sizeof(buf
), fmt
, args
);
76 printk(KERN_EMERG
"Kernel panic - not syncing: %s\n",buf
);
77 #ifdef CONFIG_DEBUG_BUGVERBOSE
82 * If we have crashed and we have a crash kernel loaded let it handle
84 * Do we want to call this before we try to display a message?
89 * Note smp_send_stop is the usual smp shutdown function, which
90 * unfortunately means it may not be hardened to work in a panic
95 atomic_notifier_call_chain(&panic_notifier_list
, 0, buf
);
100 panic_blink
= no_blink
;
102 if (panic_timeout
> 0) {
104 * Delay timeout seconds before rebooting the machine.
105 * We can't use the "normal" timers since we just panicked.
107 printk(KERN_EMERG
"Rebooting in %d seconds..", panic_timeout
);
109 for (i
= 0; i
< panic_timeout
*1000; ) {
110 touch_nmi_watchdog();
116 * This will not be a clean reboot, with everything
117 * shutting down. But if there is a chance of
118 * rebooting the system it will be rebooted.
124 extern int stop_a_enabled
;
125 /* Make sure the user can actually press Stop-A (L1-A) */
127 printk(KERN_EMERG
"Press Stop-A (L1-A) to return to the boot prom\n");
130 #if defined(CONFIG_S390)
132 unsigned long caller
;
134 caller
= (unsigned long)__builtin_return_address(0);
135 disabled_wait(caller
);
140 touch_softlockup_watchdog();
147 EXPORT_SYMBOL(panic
);
156 static const struct tnt tnts
[] = {
157 { TAINT_PROPRIETARY_MODULE
, 'P', 'G' },
158 { TAINT_FORCED_MODULE
, 'F', ' ' },
159 { TAINT_UNSAFE_SMP
, 'S', ' ' },
160 { TAINT_FORCED_RMMOD
, 'R', ' ' },
161 { TAINT_MACHINE_CHECK
, 'M', ' ' },
162 { TAINT_BAD_PAGE
, 'B', ' ' },
163 { TAINT_USER
, 'U', ' ' },
164 { TAINT_DIE
, 'D', ' ' },
165 { TAINT_OVERRIDDEN_ACPI_TABLE
, 'A', ' ' },
166 { TAINT_WARN
, 'W', ' ' },
167 { TAINT_CRAP
, 'C', ' ' },
171 * print_tainted - return a string to represent the kernel taint state.
173 * 'P' - Proprietary module has been loaded.
174 * 'F' - Module has been forcibly loaded.
175 * 'S' - SMP with CPUs not designed for SMP.
176 * 'R' - User forced a module unload.
177 * 'M' - System experienced a machine check exception.
178 * 'B' - System has hit bad_page.
179 * 'U' - Userspace-defined naughtiness.
180 * 'D' - Kernel has oopsed before
181 * 'A' - ACPI table overridden.
182 * 'W' - Taint on warning.
183 * 'C' - modules from drivers/staging are loaded.
185 * The string is overwritten by the next call to print_tainted().
187 const char *print_tainted(void)
189 static char buf
[ARRAY_SIZE(tnts
) + sizeof("Tainted: ") + 1];
195 s
= buf
+ sprintf(buf
, "Tainted: ");
196 for (i
= 0; i
< ARRAY_SIZE(tnts
); i
++) {
197 const struct tnt
*t
= &tnts
[i
];
198 *s
++ = test_bit(t
->bit
, &tainted_mask
) ?
203 snprintf(buf
, sizeof(buf
), "Not tainted");
208 int test_taint(unsigned flag
)
210 return test_bit(flag
, &tainted_mask
);
212 EXPORT_SYMBOL(test_taint
);
214 unsigned long get_taint(void)
219 void add_taint(unsigned flag
)
222 * Can't trust the integrity of the kernel anymore.
223 * We don't call directly debug_locks_off() because the issue
224 * is not necessarily serious enough to set oops_in_progress to 1
225 * Also we want to keep up lockdep for staging development and
228 if (flag
!= TAINT_CRAP
&& flag
!= TAINT_WARN
&& __debug_locks_off())
229 printk(KERN_WARNING
"Disabling lock debugging due to kernel taint\n");
231 set_bit(flag
, &tainted_mask
);
233 EXPORT_SYMBOL(add_taint
);
235 static void spin_msec(int msecs
)
239 for (i
= 0; i
< msecs
; i
++) {
240 touch_nmi_watchdog();
246 * It just happens that oops_enter() and oops_exit() are identically
249 static void do_oops_enter_exit(void)
252 static int spin_counter
;
257 spin_lock_irqsave(&pause_on_oops_lock
, flags
);
258 if (pause_on_oops_flag
== 0) {
259 /* This CPU may now print the oops message */
260 pause_on_oops_flag
= 1;
262 /* We need to stall this CPU */
264 /* This CPU gets to do the counting */
265 spin_counter
= pause_on_oops
;
267 spin_unlock(&pause_on_oops_lock
);
268 spin_msec(MSEC_PER_SEC
);
269 spin_lock(&pause_on_oops_lock
);
270 } while (--spin_counter
);
271 pause_on_oops_flag
= 0;
273 /* This CPU waits for a different one */
274 while (spin_counter
) {
275 spin_unlock(&pause_on_oops_lock
);
277 spin_lock(&pause_on_oops_lock
);
281 spin_unlock_irqrestore(&pause_on_oops_lock
, flags
);
285 * Return true if the calling CPU is allowed to print oops-related info.
286 * This is a bit racy..
288 int oops_may_print(void)
290 return pause_on_oops_flag
== 0;
294 * Called when the architecture enters its oops handler, before it prints
295 * anything. If this is the first CPU to oops, and it's oopsing the first
296 * time then let it proceed.
298 * This is all enabled by the pause_on_oops kernel boot option. We do all
299 * this to ensure that oopses don't scroll off the screen. It has the
300 * side-effect of preventing later-oopsing CPUs from mucking up the display,
303 * It turns out that the CPU which is allowed to print ends up pausing for
304 * the right duration, whereas all the other CPUs pause for twice as long:
305 * once in oops_enter(), once in oops_exit().
307 void oops_enter(void)
310 /* can't trust the integrity of the kernel anymore: */
312 do_oops_enter_exit();
316 * 64-bit random ID for oopses:
320 static int init_oops_id(void)
323 get_random_bytes(&oops_id
, sizeof(oops_id
));
329 late_initcall(init_oops_id
);
331 static void print_oops_end_marker(void)
334 printk(KERN_WARNING
"---[ end trace %016llx ]---\n",
335 (unsigned long long)oops_id
);
339 * Called when the architecture exits its oops handler, after printing
344 do_oops_enter_exit();
345 print_oops_end_marker();
348 #ifdef WANT_WARN_ON_SLOWPATH
349 struct slowpath_args
{
354 static void warn_slowpath_common(const char *file
, int line
, void *caller
, struct slowpath_args
*args
)
358 printk(KERN_WARNING
"------------[ cut here ]------------\n");
359 printk(KERN_WARNING
"WARNING: at %s:%d %pS()\n", file
, line
, caller
);
360 board
= dmi_get_system_info(DMI_PRODUCT_NAME
);
362 printk(KERN_WARNING
"Hardware name: %s\n", board
);
365 vprintk(args
->fmt
, args
->args
);
369 print_oops_end_marker();
370 add_taint(TAINT_WARN
);
373 void warn_slowpath_fmt(const char *file
, int line
, const char *fmt
, ...)
375 struct slowpath_args args
;
378 va_start(args
.args
, fmt
);
379 warn_slowpath_common(file
, line
, __builtin_return_address(0), &args
);
382 EXPORT_SYMBOL(warn_slowpath_fmt
);
384 void warn_slowpath_null(const char *file
, int line
)
386 warn_slowpath_common(file
, line
, __builtin_return_address(0), NULL
);
388 EXPORT_SYMBOL(warn_slowpath_null
);
391 #ifdef CONFIG_CC_STACKPROTECTOR
394 * Called when gcc's -fstack-protector feature is used, and
395 * gcc detects corruption of the on-stack canary value
397 void __stack_chk_fail(void)
399 panic("stack-protector: Kernel stack is corrupted in: %p\n",
400 __builtin_return_address(0));
402 EXPORT_SYMBOL(__stack_chk_fail
);
406 core_param(panic
, panic_timeout
, int, 0644);
407 core_param(pause_on_oops
, pause_on_oops
, int, 0644);