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[PANIC_MSG_BUFSZ];	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(); 	/* Redirect panic to target CPU if configured via panic_force_cpu=. */	if (panic_try_force_cpu(fmt, args)) {		/*		 * Mark ourselves offline so panic_other_cpus_shutdown() won't wait		 * for us on architectures that check num_online_cpus().		 */		set_cpu_online(smp_processor_id(), false);		panic_smp_self_stop();	}	/*	 * 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 (atomic_read(&panic_redirect_cpu) != PANIC_CPU_INVALID &&	    panic_force_cpu == raw_smp_processor_id()) {		pr_emerg("panic: Redirected from CPU %d, skipping stack dump.\n",			 atomic_read(&panic_redirect_cpu));	} else 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); 	/*	 * 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); 	sys_info(panic_print); 	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); 	if ((panic_print & SYS_INFO_PANIC_CONSOLE_REPLAY) ||		panic_console_replay)		console_flush_on_panic(CONSOLE_REPLAY_ALL); 	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(vpanic); /* Identical to vpanic(), except it takes variadic arguments instead of va_list */void panic(const char *fmt, ...){	va_list args; 	va_start(args, fmt);	vpanic(fmt, args);	va_end(args);}EXPORT_SYMBOL(panic); #define TAINT_FLAG(taint, _c_true, _c_false)				\	[ TAINT_##taint ] = {						\		.c_true = _c_true, .c_false = _c_false,			\		.desc = #taint,						\	} /* * NOTE: if you modify the taint_flags or TAINT_FLAGS_COUNT, * please also modify tools/debugging/kernel-chktaint and * Documentation/admin-guide/tainted-kernels.rst, including its * small shell script that prints the TAINT_FLAGS_COUNT bits of * /proc/sys/kernel/tainted. * * Also, update INIT_TAINT_BUF_MAX below. */const struct taint_flag taint_flags[TAINT_FLAGS_COUNT] = {	TAINT_FLAG(PROPRIETARY_MODULE,		'P', 'G'),	TAINT_FLAG(FORCED_MODULE,		'F', ' '),	TAINT_FLAG(CPU_OUT_OF_SPEC,		'S', ' '),	TAINT_FLAG(FORCED_RMMOD,		'R', ' '),	TAINT_FLAG(MACHINE_CHECK,		'M', ' '),	TAINT_FLAG(BAD_PAGE,			'B', ' '),	TAINT_FLAG(USER,			'U', ' '),	TAINT_FLAG(DIE,				'D', ' '),	TAINT_FLAG(OVERRIDDEN_ACPI_TABLE,	'A', ' '),	TAINT_FLAG(WARN,			'W', ' '),	TAINT_FLAG(CRAP,			'C', ' '),	TAINT_FLAG(FIRMWARE_WORKAROUND,		'I', ' '),	TAINT_FLAG(OOT_MODULE,			'O', ' '),	TAINT_FLAG(UNSIGNED_MODULE,		'E', ' '),	TAINT_FLAG(SOFTLOCKUP,			'L', ' '),	TAINT_FLAG(LIVEPATCH,			'K', ' '),	TAINT_FLAG(AUX,				'X', ' '),	TAINT_FLAG(RANDSTRUCT,			'T', ' '),	TAINT_FLAG(TEST,			'N', ' '),	TAINT_FLAG(FWCTL,			'J', ' '),}; #undef TAINT_FLAG static void print_tainted_seq(struct seq_buf *s, bool verbose){	const char *sep = "";	int i; 	if (!tainted_mask) {		seq_buf_puts(s, "Not tainted");		return;	} 	seq_buf_printf(s, "Tainted: ");	for (i = 0; i < TAINT_FLAGS_COUNT; i++) {		const struct taint_flag *t = &taint_flags[i];		bool is_set = test_bit(i, &tainted_mask);		char c = is_set ? t->c_true : t->c_false; 		if (verbose) {			if (is_set) {				seq_buf_printf(s, "%s[%c]=%s", sep, c, t->desc);				sep = ", ";			}		} else {			seq_buf_putc(s, c);		}	}} /* The initial buffer can accommodate all taint flags in verbose * mode, with some headroom. Once the allocator is available, the * exact size is allocated dynamically; the initial buffer remains * as a fallback if allocation fails. * * The verbose taint string currently requires up to 327 characters. */#define INIT_TAINT_BUF_MAX 350 static char init_taint_buf[INIT_TAINT_BUF_MAX] __initdata;static char *taint_buf __refdata = init_taint_buf;static size_t taint_buf_size = INIT_TAINT_BUF_MAX; static __init int alloc_taint_buf(void){	int i;	char *buf;	size_t size = 0; 	size += sizeof("Tainted: ") - 1;	for (i = 0; i < TAINT_FLAGS_COUNT; i++) {		size += 2; /* For ", " */		size += 4; /* For "[%c]=" */		size += strlen(taint_flags[i].desc);	} 	size += 1; /* For NULL terminator */ 	buf = kmalloc(size, GFP_KERNEL); 	if (!buf) {		panic("Failed to allocate taint string buffer");	} 	taint_buf = buf;	taint_buf_size = size; 	return 0;}postcore_initcall(alloc_taint_buf); static const char *_print_tainted(bool verbose){	struct seq_buf s; 	BUILD_BUG_ON(ARRAY_SIZE(taint_flags) != TAINT_FLAGS_COUNT); 	seq_buf_init(&s, taint_buf, taint_buf_size); 	print_tainted_seq(&s, verbose); 	return seq_buf_str(&s);} /** * 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){	return _print_tainted(false);} /** * print_tainted_verbose - A more verbose version of print_tainted() */const char *print_tainted_verbose(void){	return _print_tainted(true);} int test_taint(unsigned flag){	return test_bit(flag, &tainted_mask);}EXPORT_SYMBOL(test_taint); unsigned long get_taint(void){	return tainted_mask;} /** * 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){	if (lockdep_ok == LOCKDEP_NOW_UNRELIABLE && __debug_locks_off())		pr_warn("Disabling lock debugging due to kernel taint\n"); 	set_bit(flag, &tainted_mask); 	if (tainted_mask & panic_on_taint) {		panic_on_taint = 0;		panic("panic_on_taint set ...");	}}EXPORT_SYMBOL(add_taint); static void spin_msec(int msecs){	int i; 	for (i = 0; i < msecs; i++) {		touch_nmi_watchdog();		mdelay(1);	}} /* * It just happens that oops_enter() and oops_exit() are identically * implemented... */static void do_oops_enter_exit(void){	unsigned long flags;	static int spin_counter; 	if (!pause_on_oops)		return; 	spin_lock_irqsave(&pause_on_oops_lock, flags);	if (pause_on_oops_flag == 0) {		/* This CPU may now print the oops message */		pause_on_oops_flag = 1;	} else {		/* We need to stall this CPU */		if (!spin_counter) {			/* This CPU gets to do the counting */			spin_counter = pause_on_oops;			do {				spin_unlock(&pause_on_oops_lock);

Lines 501–1000 of 1274. Previous lines Load more