// 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 100#define PANIC_BLINK_SPD 18 #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 0#endif /* CONFIG_SMP */ int panic_on_oops = CONFIG_PANIC_ON_OOPS_VALUE;static unsigned long tainted_mask =	IS_ENABLED(CONFIG_RANDSTRUCT) ? (1 << TAINT_RANDSTRUCT) : 0;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 = false;static unsigned int warn_limit __read_mostly; bool panic_triggering_all_cpu_backtrace; int panic_timeout = CONFIG_PANIC_TIMEOUT;EXPORT_SYMBOL_GPL(panic_timeout); #define PANIC_PRINT_TASK_INFO		0x00000001#define PANIC_PRINT_MEM_INFO		0x00000002#define PANIC_PRINT_TIMER_INFO		0x00000004#define PANIC_PRINT_LOCK_INFO		0x00000008#define PANIC_PRINT_FTRACE_INFO		0x00000010#define PANIC_PRINT_ALL_PRINTK_MSG	0x00000020#define PANIC_PRINT_ALL_CPU_BT		0x00000040#define PANIC_PRINT_BLOCKED_TASKS	0x00000080unsigned long panic_print; ATOMIC_NOTIFIER_HEAD(panic_notifier_list); EXPORT_SYMBOL(panic_notifier_list); #ifdef CONFIG_SYSCTLstatic struct ctl_table kern_panic_table[] = {#ifdef CONFIG_SMP	{		.procname       = "oops_all_cpu_backtrace",		.data           = &sysctl_oops_all_cpu_backtrace,		.maxlen         = sizeof(int),		.mode           = 0644,		.proc_handler   = proc_dointvec_minmax,		.extra1         = SYSCTL_ZERO,		.extra2         = SYSCTL_ONE,	},#endif	{		.procname       = "warn_limit",		.data           = &warn_limit,		.maxlen         = sizeof(warn_limit),		.mode           = 0644,		.proc_handler   = proc_douintvec,	},}; static __init int kernel_panic_sysctls_init(void){	register_sysctl_init("kernel", kern_panic_table);	return 0;}late_initcall(kernel_panic_sysctls_init);#endif static atomic_t warn_count = ATOMIC_INIT(0); #ifdef CONFIG_SYSFSstatic ssize_t warn_count_show(struct kobject *kobj, struct kobj_attribute *attr,			       char *page){	return sysfs_emit(page, "%d\n", atomic_read(&warn_count));} static struct kobj_attribute warn_count_attr = __ATTR_RO(warn_count); static __init int kernel_panic_sysfs_init(void){	sysfs_add_file_to_group(kernel_kobj, &warn_count_attr.attr, NULL);	return 0;}late_initcall(kernel_panic_sysfs_init);#endif static long no_blink(int state){	return 0;} /* Returns how long it waited in ms */long (*panic_blink)(int state);EXPORT_SYMBOL(panic_blink); /* * Stop ourself in panic -- architecture code may override this */void __weak __noreturn panic_smp_self_stop(void){	while (1)		cpu_relax();} /* * 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){	panic_smp_self_stop();} /* * 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){	static int cpus_stopped; 	/*	 * This function can be called twice in panic path, but obviously	 * we execute this only once.	 */	if (cpus_stopped)		return; 	/*	 * Note smp_send_stop is the usual smp shutdown function, which	 * unfortunately means it may not be hardened to work in a panic	 * situation.	 */	smp_send_stop();	cpus_stopped = 1;} atomic_t panic_cpu = ATOMIC_INIT(PANIC_CPU_INVALID); /* * 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){	int old_cpu, this_cpu; 	old_cpu = PANIC_CPU_INVALID;	this_cpu = raw_smp_processor_id(); 	/* atomic_try_cmpxchg updates old_cpu on failure */	if (atomic_try_cmpxchg(&panic_cpu, &old_cpu, this_cpu))		panic("%s", msg);	else if (old_cpu != this_cpu)		nmi_panic_self_stop(regs);}EXPORT_SYMBOL(nmi_panic); static void panic_print_sys_info(bool console_flush){	if (console_flush) {		if (panic_print & PANIC_PRINT_ALL_PRINTK_MSG)			console_flush_on_panic(CONSOLE_REPLAY_ALL);		return;	} 	if (panic_print & PANIC_PRINT_TASK_INFO)		show_state(); 	if (panic_print & PANIC_PRINT_MEM_INFO)		show_mem(); 	if (panic_print & PANIC_PRINT_TIMER_INFO)		sysrq_timer_list_show(); 	if (panic_print & PANIC_PRINT_LOCK_INFO)		debug_show_all_locks(); 	if (panic_print & PANIC_PRINT_FTRACE_INFO)		ftrace_dump(DUMP_ALL); 	if (panic_print & PANIC_PRINT_BLOCKED_TASKS)		show_state_filter(TASK_UNINTERRUPTIBLE);} void check_panic_on_warn(const char *origin){	unsigned int limit; 	if (panic_on_warn)		panic("%s: panic_on_warn set ...\n", origin); 	limit = READ_ONCE(warn_limit);	if (atomic_inc_return(&warn_count) >= limit && limit)		panic("%s: system warned too often (kernel.warn_limit is %d)",		      origin, limit);} /* * 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){	if (panic_print & PANIC_PRINT_ALL_CPU_BT) {		/* Temporary allow non-panic CPUs to write their backtraces. */		panic_triggering_all_cpu_backtrace = true;		trigger_all_cpu_backtrace();		panic_triggering_all_cpu_backtrace = false;	} 	/*	 * Note that smp_send_stop() is the usual SMP shutdown function,	 * which unfortunately may not be hardened to work in a panic	 * situation. If we want to do crash dump after notifier calls	 * and kmsg_dump, we will need architecture dependent extra	 * bits in addition to stopping other CPUs, hence we rely on	 * crash_smp_send_stop() for that.	 */	if (!crash_kexec)		smp_send_stop();	else		crash_smp_send_stop();} /** *	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, ...){	static char buf[1024];	va_list args;	long i, i_next = 0, len;	int state = 0;	int old_cpu, this_cpu;	bool _crash_kexec_post_notifiers = crash_kexec_post_notifiers; 	if (panic_on_warn) {		/*		 * This thread may hit another WARN() in the panic path.		 * Resetting this prevents additional WARN() from panicking the		 * system on this thread.  Other threads are blocked by the		 * panic_mutex in panic().		 */		panic_on_warn = 0;	} 	/*	 * Disable local interrupts. This will prevent panic_smp_self_stop	 * from deadlocking the first cpu that invokes the panic, since	 * there is nothing to prevent an interrupt handler (that runs	 * after setting panic_cpu) from invoking panic() again.	 */	local_irq_disable();	preempt_disable_notrace(); 	/*	 * It's possible to come here directly from a panic-assertion and	 * not have preempt disabled. Some functions called from here want	 * preempt to be disabled. No point enabling it later though...	 *	 * Only one CPU is allowed to execute the panic code from here. For	 * multiple parallel invocations of panic, all other CPUs either	 * stop themself or will wait until they are stopped by the 1st CPU	 * with smp_send_stop().	 *	 * cmpxchg success means this is the 1st CPU which comes here,	 * so go ahead.	 * `old_cpu == this_cpu' means we came from nmi_panic() which sets	 * panic_cpu to this CPU.  In this case, this is also the 1st CPU.	 */	old_cpu = PANIC_CPU_INVALID;	this_cpu = raw_smp_processor_id(); 	/* atomic_try_cmpxchg updates old_cpu on failure */	if (atomic_try_cmpxchg(&panic_cpu, &old_cpu, this_cpu)) {		/* go ahead */	} else if (old_cpu != this_cpu)		panic_smp_self_stop(); 	console_verbose();	bust_spinlocks(1);	va_start(args, fmt);	len = vscnprintf(buf, sizeof(buf), fmt, args);	va_end(args); 	if (len && buf[len - 1] == '\n')		buf[len - 1] = '\0'; 	pr_emerg("Kernel panic - not syncing: %s\n", buf);#ifdef CONFIG_DEBUG_BUGVERBOSE	/*	 * Avoid nested stack-dumping if a panic occurs during oops processing	 */	if (!test_taint(TAINT_DIE) && oops_in_progress <= 1)		dump_stack();#endif 	/*	 * If kgdb is enabled, give it a chance to run before we stop all	 * the other CPUs or else we won't be able to debug processes left	 * running on them.	 */	kgdb_panic(buf); 	/*	 * If we have crashed and we have a crash kernel loaded let it handle	 * everything else.	 * If we want to run this after calling panic_notifiers, pass	 * the "crash_kexec_post_notifiers" option to the kernel.	 *	 * Bypass the panic_cpu check and call __crash_kexec directly.	 */	if (!_crash_kexec_post_notifiers)		__crash_kexec(NULL); 	panic_other_cpus_shutdown(_crash_kexec_post_notifiers); 	printk_legacy_allow_panic_sync(); 	/*	 * Run any panic handlers, including those that might need to	 * add information to the kmsg dump output.	 */	atomic_notifier_call_chain(&panic_notifier_list, 0, buf); 	panic_print_sys_info(false); 	kmsg_dump_desc(KMSG_DUMP_PANIC, buf); 	/*	 * If you doubt kdump always works fine in any situation,	 * "crash_kexec_post_notifiers" offers you a chance to run	 * panic_notifiers and dumping kmsg before kdump.	 * Note: since some panic_notifiers can make crashed kernel	 * more unstable, it can increase risks of the kdump failure too.	 *	 * Bypass the panic_cpu check and call __crash_kexec directly.	 */	if (_crash_kexec_post_notifiers)		__crash_kexec(NULL); 	console_unblank(); 	/*	 * We may have ended up stopping the CPU holding the lock (in	 * smp_send_stop()) while still having some valuable data in the console	 * buffer.  Try to acquire the lock then release it regardless of the	 * result.  The release will also print the buffers out.  Locks debug	 * should be disabled to avoid reporting bad unlock balance when	 * panic() is not being callled from OOPS.	 */	debug_locks_off();	console_flush_on_panic(CONSOLE_FLUSH_PENDING); 	panic_print_sys_info(true); 	if (!panic_blink)		panic_blink = no_blink; 	if (panic_timeout > 0) {		/*		 * Delay timeout seconds before rebooting the machine.		 * We can't use the "normal" timers since we just panicked.		 */		pr_emerg("Rebooting in %d seconds..\n", panic_timeout); 		for (i = 0; i < panic_timeout * 1000; i += PANIC_TIMER_STEP) {			touch_nmi_watchdog();			if (i >= i_next) {				i += panic_blink(state ^= 1);				i_next = i + 3600 / PANIC_BLINK_SPD;			}			mdelay(PANIC_TIMER_STEP);		}	}	if (panic_timeout != 0) {		/*		 * This will not be a clean reboot, with everything		 * shutting down.  But if there is a chance of		 * rebooting the system it will be rebooted.		 */		if (panic_reboot_mode != REBOOT_UNDEFINED)			reboot_mode = panic_reboot_mode;		emergency_restart();	}#ifdef __sparc__	{		extern int stop_a_enabled;		/* Make sure the user can actually press Stop-A (L1-A) */		stop_a_enabled = 1;		pr_emerg("Press Stop-A (L1-A) from sun keyboard or send break\n"			 "twice on console to return to the boot prom\n");	}#endif#if defined(CONFIG_S390)	disabled_wait();#endif	pr_emerg("---[ end Kernel panic - not syncing: %s ]---\n", buf); 	/* Do not scroll important messages printed above */	suppress_printk = 1; 	/*	 * The final messages may not have been printed if in a context that	 * defers printing (such as NMI) and irq_work is not available.	 * Explicitly flush the kernel log buffer one last time.	 */	console_flush_on_panic(CONSOLE_FLUSH_PENDING);	nbcon_atomic_flush_unsafe(); 	local_irq_enable();	for (i = 0; ; i += PANIC_TIMER_STEP) {		touch_softlockup_watchdog();		if (i >= i_next) {			i += panic_blink(state ^= 1);			i_next = i + 3600 / PANIC_BLINK_SPD;		}		mdelay(PANIC_TIMER_STEP);	}} EXPORT_SYMBOL(panic); #define TAINT_FLAG(taint, _c_true, _c_false, _module)			\	[ TAINT_##taint ] = {						\		.c_true = _c_true, .c_false = _c_false,			\		.module = _module,					\		.desc = #taint,						\	} /* * 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] = {	TAINT_FLAG(PROPRIETARY_MODULE,		'P', 'G', true),	TAINT_FLAG(FORCED_MODULE,		'F', ' ', true),	TAINT_FLAG(CPU_OUT_OF_SPEC,		'S', ' ', false),	TAINT_FLAG(FORCED_RMMOD,		'R', ' ', false),	TAINT_FLAG(MACHINE_CHECK,		'M', ' ', false),	TAINT_FLAG(BAD_PAGE,			'B', ' ', false),

Lines 1–500 of 885. Load more