// SPDX-License-Identifier: GPL-2.0-only /* * linux/kernel/panic.c * * Copyright (C) 1991, 1992 Linus Torvalds */ /* * This function is used through-out the kernel (including mm and fs) * to indicate a major problem. */ #include <linux/debug_locks.h> #include <linux/sched/debug.h> #include <linux/interrupt.h> #include <linux/kgdb.h> #include <linux/kmsg_dump.h> #include <linux/kallsyms.h> #include <linux/notifier.h> #include <linux/vt_kern.h> #include <linux/module.h> #include <linux/random.h> #include <linux/ftrace.h> #include <linux/reboot.h> #include <linux/delay.h> #include <linux/kexec.h> #include <linux/panic_notifier.h> #include <linux/sched.h> #include <linux/string_helpers.h> #include <linux/sysrq.h> #include <linux/init.h> #include <linux/nmi.h> #include <linux/console.h> #include <linux/bug.h> #include <linux/ratelimit.h> #include <linux/debugfs.h> #include <linux/sysfs.h> #include <linux/context_tracking.h> #include <linux/seq_buf.h> #include <trace/events/error_report.h> #include <asm/sections.h> #define PANIC_TIMER_STEP … #define PANIC_BLINK_SPD … #ifdef CONFIG_SMP /* * Should we dump all CPUs backtraces in an oops event? * Defaults to 0, can be changed via sysctl. */ static unsigned int __read_mostly sysctl_oops_all_cpu_backtrace; #else #define sysctl_oops_all_cpu_backtrace … #endif /* CONFIG_SMP */ int panic_on_oops = …; static unsigned long tainted_mask = …; static int pause_on_oops; static int pause_on_oops_flag; static DEFINE_SPINLOCK(pause_on_oops_lock); bool crash_kexec_post_notifiers; int panic_on_warn __read_mostly; unsigned long panic_on_taint; bool panic_on_taint_nousertaint = …; static unsigned int warn_limit __read_mostly; int panic_timeout = …; EXPORT_SYMBOL_GPL(…); #define PANIC_PRINT_TASK_INFO … #define PANIC_PRINT_MEM_INFO … #define PANIC_PRINT_TIMER_INFO … #define PANIC_PRINT_LOCK_INFO … #define PANIC_PRINT_FTRACE_INFO … #define PANIC_PRINT_ALL_PRINTK_MSG … #define PANIC_PRINT_ALL_CPU_BT … #define PANIC_PRINT_BLOCKED_TASKS … unsigned long panic_print; ATOMIC_NOTIFIER_HEAD(…); EXPORT_SYMBOL(…); #ifdef CONFIG_SYSCTL static struct ctl_table kern_panic_table[] = …; static __init int kernel_panic_sysctls_init(void) { … } late_initcall(kernel_panic_sysctls_init); #endif static atomic_t warn_count = …; #ifdef CONFIG_SYSFS static ssize_t warn_count_show(struct kobject *kobj, struct kobj_attribute *attr, char *page) { … } static struct kobj_attribute warn_count_attr = …; static __init int kernel_panic_sysfs_init(void) { … } late_initcall(kernel_panic_sysfs_init); #endif static long no_blink(int state) { … } /* Returns how long it waited in ms */ long (*panic_blink)(int state); EXPORT_SYMBOL(…); /* * Stop ourself in panic -- architecture code may override this */ void __weak __noreturn panic_smp_self_stop(void) { … } /* * Stop ourselves in NMI context if another CPU has already panicked. Arch code * may override this to prepare for crash dumping, e.g. save regs info. */ void __weak __noreturn nmi_panic_self_stop(struct pt_regs *regs) { … } /* * Stop other CPUs in panic. Architecture dependent code may override this * with more suitable version. For example, if the architecture supports * crash dump, it should save registers of each stopped CPU and disable * per-CPU features such as virtualization extensions. */ void __weak crash_smp_send_stop(void) { … } atomic_t panic_cpu = …; /* * A variant of panic() called from NMI context. We return if we've already * panicked on this CPU. If another CPU already panicked, loop in * nmi_panic_self_stop() which can provide architecture dependent code such * as saving register state for crash dump. */ void nmi_panic(struct pt_regs *regs, const char *msg) { … } EXPORT_SYMBOL(…); static void panic_print_sys_info(bool console_flush) { … } void check_panic_on_warn(const char *origin) { … } /* * Helper that triggers the NMI backtrace (if set in panic_print) * and then performs the secondary CPUs shutdown - we cannot have * the NMI backtrace after the CPUs are off! */ static void panic_other_cpus_shutdown(bool crash_kexec) { … } /** * panic - halt the system * @fmt: The text string to print * * Display a message, then perform cleanups. * * This function never returns. */ void panic(const char *fmt, ...) { … } EXPORT_SYMBOL(…); #define TAINT_FLAG … /* * TAINT_FORCED_RMMOD could be a per-module flag but the module * is being removed anyway. */ const struct taint_flag taint_flags[TAINT_FLAGS_COUNT] = …; #undef TAINT_FLAG static void print_tainted_seq(struct seq_buf *s, bool verbose) { … } static const char *_print_tainted(bool verbose) { … } /** * print_tainted - return a string to represent the kernel taint state. * * For individual taint flag meanings, see Documentation/admin-guide/sysctl/kernel.rst * * The string is overwritten by the next call to print_tainted(), * but is always NULL terminated. */ const char *print_tainted(void) { … } /** * print_tainted_verbose - A more verbose version of print_tainted() */ const char *print_tainted_verbose(void) { … } int test_taint(unsigned flag) { … } EXPORT_SYMBOL(…); unsigned long get_taint(void) { … } /** * add_taint: add a taint flag if not already set. * @flag: one of the TAINT_* constants. * @lockdep_ok: whether lock debugging is still OK. * * If something bad has gone wrong, you'll want @lockdebug_ok = false, but for * some notewortht-but-not-corrupting cases, it can be set to true. */ void add_taint(unsigned flag, enum lockdep_ok lockdep_ok) { … } EXPORT_SYMBOL(…); static void spin_msec(int msecs) { … } /* * It just happens that oops_enter() and oops_exit() are identically * implemented... */ static void do_oops_enter_exit(void) { … } /* * Return true if the calling CPU is allowed to print oops-related info. * This is a bit racy.. */ bool oops_may_print(void) { … } /* * Called when the architecture enters its oops handler, before it prints * anything. If this is the first CPU to oops, and it's oopsing the first * time then let it proceed. * * This is all enabled by the pause_on_oops kernel boot option. We do all * this to ensure that oopses don't scroll off the screen. It has the * side-effect of preventing later-oopsing CPUs from mucking up the display, * too. * * It turns out that the CPU which is allowed to print ends up pausing for * the right duration, whereas all the other CPUs pause for twice as long: * once in oops_enter(), once in oops_exit(). */ void oops_enter(void) { … } static void print_oops_end_marker(void) { … } /* * Called when the architecture exits its oops handler, after printing * everything. */ void oops_exit(void) { … } struct warn_args { … }; void __warn(const char *file, int line, void *caller, unsigned taint, struct pt_regs *regs, struct warn_args *args) { … } #ifdef CONFIG_BUG #ifndef __WARN_FLAGS void warn_slowpath_fmt(const char *file, int line, unsigned taint, const char *fmt, ...) { bool rcu = warn_rcu_enter(); struct warn_args args; pr_warn(CUT_HERE); if (!fmt) { __warn(file, line, __builtin_return_address(0), taint, NULL, NULL); warn_rcu_exit(rcu); return; } args.fmt = fmt; va_start(args.args, fmt); __warn(file, line, __builtin_return_address(0), taint, NULL, &args); va_end(args.args); warn_rcu_exit(rcu); } EXPORT_SYMBOL(warn_slowpath_fmt); #else void __warn_printk(const char *fmt, ...) { … } EXPORT_SYMBOL(…); #endif /* Support resetting WARN*_ONCE state */ static int clear_warn_once_set(void *data, u64 val) { … } DEFINE_DEBUGFS_ATTRIBUTE(…); static __init int register_warn_debugfs(void) { … } device_initcall(register_warn_debugfs); #endif #ifdef CONFIG_STACKPROTECTOR /* * Called when gcc's -fstack-protector feature is used, and * gcc detects corruption of the on-stack canary value */ __visible noinstr void __stack_chk_fail(void) { … } EXPORT_SYMBOL(…); #endif core_param(…); core_param(…); core_param(…); core_param(…); core_param(…); static int __init oops_setup(char *s) { … } early_param(…); static int __init panic_on_taint_setup(char *s) { … } early_param(…);
Codebase Browser
linux