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/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 #include <linux/console.h>
27 #include <linux/exynos-ss.h>
28 #include <soc/samsung/exynos-condbg.h>
29 #include <asm/core_regs.h>
30 #include "sched/sched.h"
32 #include <asm/core_regs.h>
34 #define PANIC_TIMER_STEP 100
35 #define PANIC_BLINK_SPD 18
37 /* Machine specific panic information string */
38 char *mach_panic_string
;
40 int panic_on_oops
= CONFIG_PANIC_ON_OOPS_VALUE
;
41 static unsigned long tainted_mask
;
42 static int pause_on_oops
;
43 static int pause_on_oops_flag
;
44 static DEFINE_SPINLOCK(pause_on_oops_lock
);
45 bool crash_kexec_post_notifiers
;
46 int panic_on_warn __read_mostly
;
48 int panic_timeout
= CONFIG_PANIC_TIMEOUT
;
49 EXPORT_SYMBOL_GPL(panic_timeout
);
51 ATOMIC_NOTIFIER_HEAD(panic_notifier_list
);
53 EXPORT_SYMBOL(panic_notifier_list
);
55 static long no_blink(int state
)
60 /* Returns how long it waited in ms */
61 long (*panic_blink
)(int state
);
62 EXPORT_SYMBOL(panic_blink
);
65 * Stop ourself in panic -- architecture code may override this
67 void __weak
panic_smp_self_stop(void)
74 * panic - halt the system
75 * @fmt: The text string to print
77 * Display a message, then perform cleanups.
79 * This function never returns.
81 void panic(const char *fmt
, ...)
83 static DEFINE_SPINLOCK(panic_lock
);
84 static char buf
[1024];
91 if (ecd_get_enable() &&
92 ecd_get_debug_panic() &&
93 ecd_get_debug_mode() != MODE_DEBUG
) {
94 ecd_printf("Debugging in Panic on ECD\n");
98 * Disable local interrupts. This will prevent panic_smp_self_stop
99 * from deadlocking the first cpu that invokes the panic, since
100 * there is nothing to prevent an interrupt handler (that runs
101 * after the panic_lock is acquired) from invoking panic again.
106 * It's possible to come here directly from a panic-assertion and
107 * not have preempt disabled. Some functions called from here want
108 * preempt to be disabled. No point enabling it later though...
110 * Only one CPU is allowed to execute the panic code from here. For
111 * multiple parallel invocations of panic, all other CPUs either
112 * stop themself or will wait until they are stopped by the 1st CPU
113 * with smp_send_stop().
115 if (!spin_trylock(&panic_lock
)) {
116 exynos_ss_hook_hardlockup_exit();
117 panic_smp_self_stop();
123 vsnprintf(buf
, sizeof(buf
), fmt
, args
);
126 #ifdef CONFIG_SEC_DEBUG_AUTO_SUMMARY
127 if (buf
[strlen(buf
) - 1] == '\n')
128 buf
[strlen(buf
) - 1] = '\0';
131 ecd_printf("Kernel Panic - not syncing: %s\n", buf
);
132 pr_auto(ASL5
, "Kernel panic - not syncing: %s\n", buf
);
134 #ifdef CONFIG_RELOCATABLE_KERNEL
136 extern u64
*__boot_kernel_offset
;
137 u64
*kernel_addr
= (u64
*) &__boot_kernel_offset
;
139 pr_emerg("Kernel loaded at: 0x%llx, offset from compile-time address %llx\n",
140 (u64
)((u64
)kernel_addr
[1] + (u64
)kernel_addr
[0]), (u64
)((u64
)kernel_addr
[1] - (u64
)kernel_addr
[2]));
143 exynos_ss_prepare_panic();
144 exynos_ss_dump_panic(buf
, (size_t)strnlen(buf
, sizeof(buf
)));
145 #ifdef CONFIG_DEBUG_BUGVERBOSE
147 * Avoid nested stack-dumping if a panic occurs during oops processing
149 if (!test_taint(TAINT_DIE
) && oops_in_progress
<= 1)
152 sysrq_sched_debug_show();
154 * If we have crashed and we have a crash kernel loaded let it handle
156 * If we want to run this after calling panic_notifiers, pass
157 * the "crash_kexec_post_notifiers" option to the kernel.
159 if (!crash_kexec_post_notifiers
)
163 * Note smp_send_stop is the usual smp shutdown function, which
164 * unfortunately means it may not be hardened to work in a panic
168 if (!ecd_get_enable() || ecd_get_debug_mode() != MODE_DEBUG
)
172 * Run any panic handlers, including those that might need to
173 * add information to the kmsg dump output.
175 atomic_notifier_call_chain(&panic_notifier_list
, 0, buf
);
177 kmsg_dump(KMSG_DUMP_PANIC
);
179 exynos_ss_post_panic();
182 * If you doubt kdump always works fine in any situation,
183 * "crash_kexec_post_notifiers" offers you a chance to run
184 * panic_notifiers and dumping kmsg before kdump.
185 * Note: since some panic_notifiers can make crashed kernel
186 * more unstable, it can increase risks of the kdump failure too.
188 if (crash_kexec_post_notifiers
)
194 * We may have ended up stopping the CPU holding the lock (in
195 * smp_send_stop()) while still having some valuable data in the console
196 * buffer. Try to acquire the lock then release it regardless of the
197 * result. The release will also print the buffers out. Locks debug
198 * should be disabled to avoid reporting bad unlock balance when
199 * panic() is not being callled from OOPS.
202 console_flush_on_panic();
205 panic_blink
= no_blink
;
207 if (panic_timeout
> 0) {
209 * Delay timeout seconds before rebooting the machine.
210 * We can't use the "normal" timers since we just panicked.
212 pr_emerg("Rebooting in %d seconds..\n", panic_timeout
);
214 for (i
= 0; i
< panic_timeout
* 1000; i
+= PANIC_TIMER_STEP
) {
215 touch_nmi_watchdog();
217 i
+= panic_blink(state
^= 1);
218 i_next
= i
+ 3600 / PANIC_BLINK_SPD
;
220 mdelay(PANIC_TIMER_STEP
);
223 if (panic_timeout
!= 0) {
225 * This will not be a clean reboot, with everything
226 * shutting down. But if there is a chance of
227 * rebooting the system it will be rebooted.
233 extern int stop_a_enabled
;
234 /* Make sure the user can actually press Stop-A (L1-A) */
236 pr_emerg("Press Stop-A (L1-A) to return to the boot prom\n");
239 #if defined(CONFIG_S390)
241 unsigned long caller
;
243 caller
= (unsigned long)__builtin_return_address(0);
244 disabled_wait(caller
);
247 pr_emerg("---[ end Kernel panic - not syncing: %s\n", buf
);
249 for (i
= 0; ; i
+= PANIC_TIMER_STEP
) {
250 touch_softlockup_watchdog();
252 i
+= panic_blink(state
^= 1);
253 i_next
= i
+ 3600 / PANIC_BLINK_SPD
;
255 mdelay(PANIC_TIMER_STEP
);
258 EXPORT_SYMBOL(panic
);
267 static const struct tnt tnts
[] = {
268 { TAINT_PROPRIETARY_MODULE
, 'P', 'G' },
269 { TAINT_FORCED_MODULE
, 'F', ' ' },
270 { TAINT_CPU_OUT_OF_SPEC
, 'S', ' ' },
271 { TAINT_FORCED_RMMOD
, 'R', ' ' },
272 { TAINT_MACHINE_CHECK
, 'M', ' ' },
273 { TAINT_BAD_PAGE
, 'B', ' ' },
274 { TAINT_USER
, 'U', ' ' },
275 { TAINT_DIE
, 'D', ' ' },
276 { TAINT_OVERRIDDEN_ACPI_TABLE
, 'A', ' ' },
277 { TAINT_WARN
, 'W', ' ' },
278 { TAINT_CRAP
, 'C', ' ' },
279 { TAINT_FIRMWARE_WORKAROUND
, 'I', ' ' },
280 { TAINT_OOT_MODULE
, 'O', ' ' },
281 { TAINT_UNSIGNED_MODULE
, 'E', ' ' },
282 { TAINT_SOFTLOCKUP
, 'L', ' ' },
283 { TAINT_LIVEPATCH
, 'K', ' ' },
287 * print_tainted - return a string to represent the kernel taint state.
289 * 'P' - Proprietary module has been loaded.
290 * 'F' - Module has been forcibly loaded.
291 * 'S' - SMP with CPUs not designed for SMP.
292 * 'R' - User forced a module unload.
293 * 'M' - System experienced a machine check exception.
294 * 'B' - System has hit bad_page.
295 * 'U' - Userspace-defined naughtiness.
296 * 'D' - Kernel has oopsed before
297 * 'A' - ACPI table overridden.
298 * 'W' - Taint on warning.
299 * 'C' - modules from drivers/staging are loaded.
300 * 'I' - Working around severe firmware bug.
301 * 'O' - Out-of-tree module has been loaded.
302 * 'E' - Unsigned module has been loaded.
303 * 'L' - A soft lockup has previously occurred.
304 * 'K' - Kernel has been live patched.
306 * The string is overwritten by the next call to print_tainted().
308 const char *print_tainted(void)
310 static char buf
[ARRAY_SIZE(tnts
) + sizeof("Tainted: ")];
316 s
= buf
+ sprintf(buf
, "Tainted: ");
317 for (i
= 0; i
< ARRAY_SIZE(tnts
); i
++) {
318 const struct tnt
*t
= &tnts
[i
];
319 *s
++ = test_bit(t
->bit
, &tainted_mask
) ?
324 snprintf(buf
, sizeof(buf
), "Not tainted");
329 int test_taint(unsigned flag
)
331 return test_bit(flag
, &tainted_mask
);
333 EXPORT_SYMBOL(test_taint
);
335 unsigned long get_taint(void)
341 * add_taint: add a taint flag if not already set.
342 * @flag: one of the TAINT_* constants.
343 * @lockdep_ok: whether lock debugging is still OK.
345 * If something bad has gone wrong, you'll want @lockdebug_ok = false, but for
346 * some notewortht-but-not-corrupting cases, it can be set to true.
348 void add_taint(unsigned flag
, enum lockdep_ok lockdep_ok
)
350 if (lockdep_ok
== LOCKDEP_NOW_UNRELIABLE
&& __debug_locks_off())
351 pr_warn("Disabling lock debugging due to kernel taint\n");
353 set_bit(flag
, &tainted_mask
);
355 EXPORT_SYMBOL(add_taint
);
357 static void spin_msec(int msecs
)
361 for (i
= 0; i
< msecs
; i
++) {
362 touch_nmi_watchdog();
368 * It just happens that oops_enter() and oops_exit() are identically
371 static void do_oops_enter_exit(void)
374 static int spin_counter
;
379 spin_lock_irqsave(&pause_on_oops_lock
, flags
);
380 if (pause_on_oops_flag
== 0) {
381 /* This CPU may now print the oops message */
382 pause_on_oops_flag
= 1;
384 /* We need to stall this CPU */
386 /* This CPU gets to do the counting */
387 spin_counter
= pause_on_oops
;
389 spin_unlock(&pause_on_oops_lock
);
390 spin_msec(MSEC_PER_SEC
);
391 spin_lock(&pause_on_oops_lock
);
392 } while (--spin_counter
);
393 pause_on_oops_flag
= 0;
395 /* This CPU waits for a different one */
396 while (spin_counter
) {
397 spin_unlock(&pause_on_oops_lock
);
399 spin_lock(&pause_on_oops_lock
);
403 spin_unlock_irqrestore(&pause_on_oops_lock
, flags
);
407 * Return true if the calling CPU is allowed to print oops-related info.
408 * This is a bit racy..
410 int oops_may_print(void)
412 return pause_on_oops_flag
== 0;
416 * Called when the architecture enters its oops handler, before it prints
417 * anything. If this is the first CPU to oops, and it's oopsing the first
418 * time then let it proceed.
420 * This is all enabled by the pause_on_oops kernel boot option. We do all
421 * this to ensure that oopses don't scroll off the screen. It has the
422 * side-effect of preventing later-oopsing CPUs from mucking up the display,
425 * It turns out that the CPU which is allowed to print ends up pausing for
426 * the right duration, whereas all the other CPUs pause for twice as long:
427 * once in oops_enter(), once in oops_exit().
429 void oops_enter(void)
432 /* can't trust the integrity of the kernel anymore: */
434 do_oops_enter_exit();
438 * 64-bit random ID for oopses:
442 static int init_oops_id(void)
445 get_random_bytes(&oops_id
, sizeof(oops_id
));
451 late_initcall(init_oops_id
);
453 void print_oops_end_marker(void)
457 if (mach_panic_string
)
458 printk(KERN_WARNING
"Board Information: %s\n",
461 pr_warn("---[ end trace %016llx ]---\n", (unsigned long long)oops_id
);
465 * Called when the architecture exits its oops handler, after printing
470 do_oops_enter_exit();
471 print_oops_end_marker();
472 kmsg_dump(KMSG_DUMP_OOPS
);
475 #ifdef WANT_WARN_ON_SLOWPATH
476 struct slowpath_args
{
481 static void warn_slowpath_common(const char *file
, int line
, void *caller
,
482 unsigned taint
, struct slowpath_args
*args
)
484 disable_trace_on_warning();
486 pr_warn("------------[ cut here ]------------\n");
487 pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS()\n",
488 raw_smp_processor_id(), current
->pid
, file
, line
, caller
);
491 vprintk(args
->fmt
, args
->args
);
495 * This thread may hit another WARN() in the panic path.
496 * Resetting this prevents additional WARN() from panicking the
497 * system on this thread. Other threads are blocked by the
498 * panic_mutex in panic().
501 panic("panic_on_warn set ...\n");
506 print_oops_end_marker();
507 /* Just a warning, don't kill lockdep. */
508 add_taint(taint
, LOCKDEP_STILL_OK
);
511 void warn_slowpath_fmt(const char *file
, int line
, const char *fmt
, ...)
513 struct slowpath_args args
;
516 va_start(args
.args
, fmt
);
517 warn_slowpath_common(file
, line
, __builtin_return_address(0),
521 EXPORT_SYMBOL(warn_slowpath_fmt
);
523 void warn_slowpath_fmt_taint(const char *file
, int line
,
524 unsigned taint
, const char *fmt
, ...)
526 struct slowpath_args args
;
529 va_start(args
.args
, fmt
);
530 warn_slowpath_common(file
, line
, __builtin_return_address(0),
534 EXPORT_SYMBOL(warn_slowpath_fmt_taint
);
536 void warn_slowpath_null(const char *file
, int line
)
538 warn_slowpath_common(file
, line
, __builtin_return_address(0),
541 EXPORT_SYMBOL(warn_slowpath_null
);
544 #ifdef CONFIG_CC_STACKPROTECTOR
547 * Called when gcc's -fstack-protector feature is used, and
548 * gcc detects corruption of the on-stack canary value
550 __visible
void __stack_chk_fail(void)
552 panic("stack-protector: Kernel stack is corrupted in: %p\n",
553 __builtin_return_address(0));
555 EXPORT_SYMBOL(__stack_chk_fail
);
559 core_param(panic
, panic_timeout
, int, 0644);
560 core_param(pause_on_oops
, pause_on_oops
, int, 0644);
561 core_param(panic_on_warn
, panic_on_warn
, int, 0644);
563 static int __init
setup_crash_kexec_post_notifiers(char *s
)
565 crash_kexec_post_notifiers
= true;
568 early_param("crash_kexec_post_notifiers", setup_crash_kexec_post_notifiers
);
570 static int __init
oops_setup(char *s
)
574 if (!strcmp(s
, "panic"))
578 early_param("oops", oops_setup
);