// 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 <linux/sys_info.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 = IS_ENABLED(CONFIG_PANIC_ON_OOPS);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;static bool panic_console_replay; bool panic_triggering_all_cpu_backtrace;static bool panic_this_cpu_backtrace_printed; int panic_timeout = CONFIG_PANIC_TIMEOUT;EXPORT_SYMBOL_GPL(panic_timeout); unsigned long panic_print; ATOMIC_NOTIFIER_HEAD(panic_notifier_list); EXPORT_SYMBOL(panic_notifier_list); static void panic_print_deprecated(void){	pr_info_once("Kernel: The 'panic_print' parameter is now deprecated. Please use 'panic_sys_info' and 'panic_console_replay' instead.\n");} #ifdef CONFIG_SYSCTL /* * Taint values can only be increased * This means we can safely use a temporary. */static int proc_taint(const struct ctl_table *table, int write,			       void *buffer, size_t *lenp, loff_t *ppos){	struct ctl_table t;	unsigned long tmptaint = get_taint();	int err; 	if (write && !capable(CAP_SYS_ADMIN))		return -EPERM; 	t = *table;	t.data = &tmptaint;	err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);	if (err < 0)		return err; 	if (write) {		int i; 		/*		 * If we are relying on panic_on_taint not producing		 * false positives due to userspace input, bail out		 * before setting the requested taint flags.		 */		if (panic_on_taint_nousertaint && (tmptaint & panic_on_taint))			return -EINVAL; 		/*		 * Poor man's atomic or. Not worth adding a primitive		 * to everyone's atomic.h for this		 */		for (i = 0; i < TAINT_FLAGS_COUNT; i++)			if ((1UL << i) & tmptaint)				add_taint(i, LOCKDEP_STILL_OK);	} 	return err;} static int sysctl_panic_print_handler(const struct ctl_table *table, int write,			   void *buffer, size_t *lenp, loff_t *ppos){	panic_print_deprecated();	return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);} static const 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	= "tainted",		.maxlen		= sizeof(long),		.mode		= 0644,		.proc_handler	= proc_taint,	},	{		.procname	= "panic",		.data		= &panic_timeout,		.maxlen		= sizeof(int),		.mode		= 0644,		.proc_handler	= proc_dointvec,	},	{		.procname	= "panic_on_oops",		.data		= &panic_on_oops,		.maxlen		= sizeof(int),		.mode		= 0644,		.proc_handler	= proc_dointvec,	},	{		.procname	= "panic_print",		.data		= &panic_print,		.maxlen		= sizeof(unsigned long),		.mode		= 0644,		.proc_handler	= sysctl_panic_print_handler,	},	{		.procname	= "panic_on_warn",		.data		= &panic_on_warn,		.maxlen		= sizeof(int),		.mode		= 0644,		.proc_handler	= proc_dointvec_minmax,		.extra1		= SYSCTL_ZERO,		.extra2		= SYSCTL_ONE,	},	{		.procname       = "warn_limit",		.data           = &warn_limit,		.maxlen         = sizeof(warn_limit),		.mode           = 0644,		.proc_handler   = proc_douintvec,	},#if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \	defined(CONFIG_DEBUG_STACKOVERFLOW)	{		.procname	= "panic_on_stackoverflow",		.data		= &sysctl_panic_on_stackoverflow,		.maxlen		= sizeof(int),		.mode		= 0644,		.proc_handler	= proc_dointvec,	},#endif	{		.procname	= "panic_sys_info",		.data		= &panic_print,		.maxlen         = sizeof(panic_print),		.mode		= 0644,		.proc_handler	= sysctl_sys_info_handler,	},}; static __init int kernel_panic_sysctls_init(void){	register_sysctl_init("kernel", kern_panic_table);	return 0;}late_initcall(kernel_panic_sysctls_init);#endif /* The format is "panic_sys_info=tasks,mem,locks,ftrace,..." */static int __init setup_panic_sys_info(char *buf){	/* There is no risk of race in kernel boot phase */	panic_print = sys_info_parse_param(buf);	return 1;}__setup("panic_sys_info=", setup_panic_sys_info); 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); bool panic_try_start(void){	int old_cpu, this_cpu; 	/*	 * Only one CPU is allowed to execute the crash_kexec() code as with	 * panic().  Otherwise parallel calls of panic() and crash_kexec()	 * may stop each other.  To exclude them, we use panic_cpu here too.	 */	old_cpu = PANIC_CPU_INVALID;	this_cpu = raw_smp_processor_id(); 	return atomic_try_cmpxchg(&panic_cpu, &old_cpu, this_cpu);}EXPORT_SYMBOL(panic_try_start); void panic_reset(void){	atomic_set(&panic_cpu, PANIC_CPU_INVALID);}EXPORT_SYMBOL(panic_reset); bool panic_in_progress(void){	return unlikely(atomic_read(&panic_cpu) != PANIC_CPU_INVALID);}EXPORT_SYMBOL(panic_in_progress); /* Return true if a panic is in progress on the current CPU. */bool panic_on_this_cpu(void){	/*	 * We can use raw_smp_processor_id() here because it is impossible for	 * the task to be migrated to the panic_cpu, or away from it. If	 * panic_cpu has already been set, and we're not currently executing on	 * that CPU, then we never will be.	 */	return unlikely(atomic_read(&panic_cpu) == raw_smp_processor_id());}EXPORT_SYMBOL(panic_on_this_cpu); /* * Return true if a panic is in progress on a remote CPU. * * On true, the local CPU should immediately release any printing resources * that may be needed by the panic CPU. */bool panic_on_other_cpu(void){	return (panic_in_progress() && !panic_on_this_cpu());}EXPORT_SYMBOL(panic_on_other_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){	if (panic_try_start())		panic("%s", msg);	else if (panic_on_other_cpu())		nmi_panic_self_stop(regs);}EXPORT_SYMBOL(nmi_panic); 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);} static void panic_trigger_all_cpu_backtrace(void){	/* Temporary allow non-panic CPUs to write their backtraces. */	panic_triggering_all_cpu_backtrace = true; 	if (panic_this_cpu_backtrace_printed)		trigger_allbutcpu_cpu_backtrace(raw_smp_processor_id());	else		trigger_all_cpu_backtrace(); 	panic_triggering_all_cpu_backtrace = false;} /* * 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 & SYS_INFO_ALL_BT)		panic_trigger_all_cpu_backtrace(); 	/*	 * 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();} /** * vpanic - halt the system * @fmt: The text string to print * @args: Arguments for the format string * * Display a message, then perform cleanups. This function never returns. */void vpanic(const char *fmt, va_list args){	static char buf[1024];	long i, i_next = 0, len;	int state = 0;	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.	 */	/* atomic_try_cmpxchg updates old_cpu on failure */	if (panic_try_start()) {		/* go ahead */	} else if (panic_on_other_cpu())		panic_smp_self_stop(); 	console_verbose();	bust_spinlocks(1);	len = vscnprintf(buf, sizeof(buf), fmt, args); 	if (len && buf[len - 1] == '\n')		buf[len - 1] = '\0'; 	pr_emerg("Kernel panic - not syncing: %s\n", buf);	/*	 * Avoid nested stack-dumping if a panic occurs during oops processing	 */	if (test_taint(TAINT_DIE) || oops_in_progress > 1) {		panic_this_cpu_backtrace_printed = true;	} else if (IS_ENABLED(CONFIG_DEBUG_BUGVERBOSE)) {		dump_stack();		panic_this_cpu_backtrace_printed = true;	} 	/*	 * 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); 	/*

Lines 1–500 of 1062. Load more