[deliverable/linux.git] / kernel / panic.c

/*
 *  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/interrupt.h>
#include <linux/kmsg_dump.h>
#include <linux/kallsyms.h>
#include <linux/notifier.h>
#include <linux/module.h>
#include <linux/random.h>
#include <linux/reboot.h>
#include <linux/delay.h>
#include <linux/kexec.h>
#include <linux/sched.h>
#include <linux/sysrq.h>
#include <linux/init.h>
#include <linux/nmi.h>
#include <linux/dmi.h>

#define PANIC_TIMER_STEP 100
#define PANIC_BLINK_SPD 18

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);

int panic_timeout;
EXPORT_SYMBOL_GPL(panic_timeout);

ATOMIC_NOTIFIER_HEAD(panic_notifier_list);

EXPORT_SYMBOL(panic_notifier_list);

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 panic_smp_self_stop(void)
{
	while (1)
		cpu_relax();
}

/**
 *	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 DEFINE_SPINLOCK(panic_lock);
	static char buf[1024];
	va_list args;
	long i, i_next = 0;
	int state = 0;

	/*
	 * 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().
	 */
	if (!spin_trylock(&panic_lock))
		panic_smp_self_stop();

	console_verbose();
	bust_spinlocks(1);
	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf), fmt, args);
	va_end(args);
	printk(KERN_EMERG "Kernel panic - not syncing: %s\n",buf);
#ifdef CONFIG_DEBUG_BUGVERBOSE
	/*
	 * Avoid nested stack-dumping if a panic occurs during oops processing
	 */
	if (!oops_in_progress)
		dump_stack();
#endif

	/*
	 * If we have crashed and we have a crash kernel loaded let it handle
	 * everything else.
	 * Do we want to call this before we try to display a message?
	 */
	crash_kexec(NULL);

	kmsg_dump(KMSG_DUMP_PANIC);

	/*
	 * 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();

	atomic_notifier_call_chain(&panic_notifier_list, 0, buf);

	bust_spinlocks(0);

	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.
		 */
		printk(KERN_EMERG "Rebooting in %d seconds..", 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.
		 */
		emergency_restart();
	}
#ifdef __sparc__
	{
		extern int stop_a_enabled;
		/* Make sure the user can actually press Stop-A (L1-A) */
		stop_a_enabled = 1;
		printk(KERN_EMERG "Press Stop-A (L1-A) to return to the boot prom\n");
	}
#endif
#if defined(CONFIG_S390)
	{
		unsigned long caller;

		caller = (unsigned long)__builtin_return_address(0);
		disabled_wait(caller);
	}
#endif
	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);


struct tnt {
	u8	bit;
	char	true;
	char	false;
};

static const struct tnt tnts[] = {
	{ TAINT_PROPRIETARY_MODULE,	'P', 'G' },
	{ TAINT_FORCED_MODULE,		'F', ' ' },
	{ TAINT_UNSAFE_SMP,		'S', ' ' },
	{ TAINT_FORCED_RMMOD,		'R', ' ' },
	{ TAINT_MACHINE_CHECK,		'M', ' ' },
	{ TAINT_BAD_PAGE,		'B', ' ' },
	{ TAINT_USER,			'U', ' ' },
	{ TAINT_DIE,			'D', ' ' },
	{ TAINT_OVERRIDDEN_ACPI_TABLE,	'A', ' ' },
	{ TAINT_WARN,			'W', ' ' },
	{ TAINT_CRAP,			'C', ' ' },
	{ TAINT_FIRMWARE_WORKAROUND,	'I', ' ' },
	{ TAINT_OOT_MODULE,		'O', ' ' },
};

/**
 *	print_tainted - return a string to represent the kernel taint state.
 *
 *  'P' - Proprietary module has been loaded.
 *  'F' - Module has been forcibly loaded.
 *  'S' - SMP with CPUs not designed for SMP.
 *  'R' - User forced a module unload.
 *  'M' - System experienced a machine check exception.
 *  'B' - System has hit bad_page.
 *  'U' - Userspace-defined naughtiness.
 *  'D' - Kernel has oopsed before
 *  'A' - ACPI table overridden.
 *  'W' - Taint on warning.
 *  'C' - modules from drivers/staging are loaded.
 *  'I' - Working around severe firmware bug.
 *  'O' - Out-of-tree module has been loaded.
 *
 *	The string is overwritten by the next call to print_tainted().
 */
const char *print_tainted(void)
{
	static char buf[ARRAY_SIZE(tnts) + sizeof("Tainted: ") + 1];

	if (tainted_mask) {
		char *s;
		int i;

		s = buf + sprintf(buf, "Tainted: ");
		for (i = 0; i < ARRAY_SIZE(tnts); i++) {
			const struct tnt *t = &tnts[i];
			*s++ = test_bit(t->bit, &tainted_mask) ?
					t->true : t->false;
		}
		*s = 0;
	} else
		snprintf(buf, sizeof(buf), "Not tainted");

	return buf;
}

int test_taint(unsigned flag)
{
	return test_bit(flag, &tainted_mask);
}
EXPORT_SYMBOL(test_taint);

unsigned long get_taint(void)
{
	return tainted_mask;
}

void add_taint(unsigned flag)
{
	/*
	 * Can't trust the integrity of the kernel anymore.
	 * We don't call directly debug_locks_off() because the issue
	 * is not necessarily serious enough to set oops_in_progress to 1
	 * Also we want to keep up lockdep for staging/out-of-tree
	 * development and post-warning case.
	 */
	switch (flag) {
	case TAINT_CRAP:
	case TAINT_OOT_MODULE:
	case TAINT_WARN:
	case TAINT_FIRMWARE_WORKAROUND:
		break;

	default:
		if (__debug_locks_off())
			printk(KERN_WARNING "Disabling lock debugging due to kernel taint\n");
	}

	set_bit(flag, &tainted_mask);
}
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);
				spin_msec(MSEC_PER_SEC);
				spin_lock(&pause_on_oops_lock);
			} while (--spin_counter);
			pause_on_oops_flag = 0;
		} else {
			/* This CPU waits for a different one */
			while (spin_counter) {
				spin_unlock(&pause_on_oops_lock);
				spin_msec(1);
				spin_lock(&pause_on_oops_lock);
			}
		}
	}
	spin_unlock_irqrestore(&pause_on_oops_lock, flags);
}

/*
 * Return true if the calling CPU is allowed to print oops-related info.
 * This is a bit racy..
 */
int oops_may_print(void)
{
	return pause_on_oops_flag == 0;
}

/*
 * 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)
{
	tracing_off();
	/* can't trust the integrity of the kernel anymore: */
	debug_locks_off();
	do_oops_enter_exit();
}

/*
 * 64-bit random ID for oopses:
 */
static u64 oops_id;

static int init_oops_id(void)
{
	if (!oops_id)
		get_random_bytes(&oops_id, sizeof(oops_id));
	else
		oops_id++;

	return 0;
}
late_initcall(init_oops_id);

void print_oops_end_marker(void)
{
	init_oops_id();
	printk(KERN_WARNING "---[ end trace %016llx ]---\n",
		(unsigned long long)oops_id);
}

/*
 * Called when the architecture exits its oops handler, after printing
 * everything.
 */
void oops_exit(void)
{
	do_oops_enter_exit();
	print_oops_end_marker();
	kmsg_dump(KMSG_DUMP_OOPS);
}

#ifdef WANT_WARN_ON_SLOWPATH
struct slowpath_args {
	const char *fmt;
	va_list args;
};

static void warn_slowpath_common(const char *file, int line, void *caller,
				 unsigned taint, struct slowpath_args *args)
{
	const char *board;

	printk(KERN_WARNING "------------[ cut here ]------------\n");
	printk(KERN_WARNING "WARNING: at %s:%d %pS()\n", file, line, caller);
	board = dmi_get_system_info(DMI_PRODUCT_NAME);
	if (board)
		printk(KERN_WARNING "Hardware name: %s\n", board);

	if (args)
		vprintk(args->fmt, args->args);

	print_modules();
	dump_stack();
	print_oops_end_marker();
	add_taint(taint);
}

void warn_slowpath_fmt(const char *file, int line, const char *fmt, ...)
{
	struct slowpath_args args;

	args.fmt = fmt;
	va_start(args.args, fmt);
	warn_slowpath_common(file, line, __builtin_return_address(0),
			     TAINT_WARN, &args);
	va_end(args.args);
}
EXPORT_SYMBOL(warn_slowpath_fmt);

void warn_slowpath_fmt_taint(const char *file, int line,
			     unsigned taint, const char *fmt, ...)
{
	struct slowpath_args args;

	args.fmt = fmt;
	va_start(args.args, fmt);
	warn_slowpath_common(file, line, __builtin_return_address(0),
			     taint, &args);
	va_end(args.args);
}
EXPORT_SYMBOL(warn_slowpath_fmt_taint);

void warn_slowpath_null(const char *file, int line)
{
	warn_slowpath_common(file, line, __builtin_return_address(0),
			     TAINT_WARN, NULL);
}
EXPORT_SYMBOL(warn_slowpath_null);
#endif

#ifdef CONFIG_CC_STACKPROTECTOR

/*
 * Called when gcc's -fstack-protector feature is used, and
 * gcc detects corruption of the on-stack canary value
 */
void __stack_chk_fail(void)
{
	panic("stack-protector: Kernel stack is corrupted in: %p\n",
		__builtin_return_address(0));
}
EXPORT_SYMBOL(__stack_chk_fail);

#endif

core_param(panic, panic_timeout, int, 0644);
core_param(pause_on_oops, pause_on_oops, int, 0644);

static int __init oops_setup(char *s)
{
	if (!s)
		return -EINVAL;
	if (!strcmp(s, "panic"))
		panic_on_oops = 1;
	return 0;
}
early_param("oops", oops_setup);
Commit	Line	Data
	1	/*
	2	* linux/kernel/panic.c
	3	*
	4	* Copyright (C) 1991, 1992 Linus Torvalds
	5	*/
	6
	7	/*
	8	* This function is used through-out the kernel (including mm and fs)
	9	* to indicate a major problem.
	10	*/
	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/reboot.h>
	19	#include <linux/delay.h>
	20	#include <linux/kexec.h>
	21	#include <linux/sched.h>
	22	#include <linux/sysrq.h>
	23	#include <linux/init.h>
	24	#include <linux/nmi.h>
	25	#include <linux/dmi.h>
	26
	27	#define PANIC_TIMER_STEP 100
	28	#define PANIC_BLINK_SPD 18
	29
	30	int panic_on_oops;
	31	static unsigned long tainted_mask;
	32	static int pause_on_oops;
	33	static int pause_on_oops_flag;
	34	static DEFINE_SPINLOCK(pause_on_oops_lock);
	35
	36	int panic_timeout;
	37	EXPORT_SYMBOL_GPL(panic_timeout);
	38
	39	ATOMIC_NOTIFIER_HEAD(panic_notifier_list);
	40
	41	EXPORT_SYMBOL(panic_notifier_list);
	42
	43	static long no_blink(int state)
	44	{
	45	return 0;
	46	}
	47
	48	/* Returns how long it waited in ms */
	49	long (*panic_blink)(int state);
	50	EXPORT_SYMBOL(panic_blink);
	51
	52	/*
	53	* Stop ourself in panic -- architecture code may override this
	54	*/
	55	void __weak panic_smp_self_stop(void)
	56	{
	57	while (1)
	58	cpu_relax();
	59	}
	60
	61	/**
	62	* panic - halt the system
	63	* @fmt: The text string to print
	64	*
	65	* Display a message, then perform cleanups.
	66	*
	67	* This function never returns.
	68	*/
	69	void panic(const char *fmt, ...)
	70	{
	71	static DEFINE_SPINLOCK(panic_lock);
	72	static char buf[1024];
	73	va_list args;
	74	long i, i_next = 0;
	75	int state = 0;
	76
	77	/*
	78	* It's possible to come here directly from a panic-assertion and
	79	* not have preempt disabled. Some functions called from here want
	80	* preempt to be disabled. No point enabling it later though...
	81	*
	82	* Only one CPU is allowed to execute the panic code from here. For
	83	* multiple parallel invocations of panic, all other CPUs either
	84	* stop themself or will wait until they are stopped by the 1st CPU
	85	* with smp_send_stop().
	86	*/
	87	if (!spin_trylock(&panic_lock))
	88	panic_smp_self_stop();
	89
	90	console_verbose();
	91	bust_spinlocks(1);
	92	va_start(args, fmt);
	93	vsnprintf(buf, sizeof(buf), fmt, args);
	94	va_end(args);
	95	printk(KERN_EMERG "Kernel panic - not syncing: %s\n",buf);
	96	#ifdef CONFIG_DEBUG_BUGVERBOSE
	97	/*
	98	* Avoid nested stack-dumping if a panic occurs during oops processing
	99	*/
	100	if (!oops_in_progress)
	101	dump_stack();
	102	#endif
	103
	104	/*
	105	* If we have crashed and we have a crash kernel loaded let it handle
	106	* everything else.
	107	* Do we want to call this before we try to display a message?
	108	*/
	109	crash_kexec(NULL);
	110
	111	kmsg_dump(KMSG_DUMP_PANIC);
	112
	113	/*
	114	* Note smp_send_stop is the usual smp shutdown function, which
	115	* unfortunately means it may not be hardened to work in a panic
	116	* situation.
	117	*/
	118	smp_send_stop();
	119
	120	atomic_notifier_call_chain(&panic_notifier_list, 0, buf);
	121
	122	bust_spinlocks(0);
	123
	124	if (!panic_blink)
	125	panic_blink = no_blink;
	126
	127	if (panic_timeout > 0) {
	128	/*
	129	* Delay timeout seconds before rebooting the machine.
	130	* We can't use the "normal" timers since we just panicked.
	131	*/
	132	printk(KERN_EMERG "Rebooting in %d seconds..", panic_timeout);
	133
	134	for (i = 0; i < panic_timeout * 1000; i += PANIC_TIMER_STEP) {
	135	touch_nmi_watchdog();
	136	if (i >= i_next) {
	137	i += panic_blink(state ^= 1);
	138	i_next = i + 3600 / PANIC_BLINK_SPD;
	139	}
	140	mdelay(PANIC_TIMER_STEP);
	141	}
	142	}
	143	if (panic_timeout != 0) {
	144	/*
	145	* This will not be a clean reboot, with everything
	146	* shutting down. But if there is a chance of
	147	* rebooting the system it will be rebooted.
	148	*/
	149	emergency_restart();
	150	}
	151	#ifdef __sparc__
	152	{
	153	extern int stop_a_enabled;
	154	/* Make sure the user can actually press Stop-A (L1-A) */
	155	stop_a_enabled = 1;
	156	printk(KERN_EMERG "Press Stop-A (L1-A) to return to the boot prom\n");
	157	}
	158	#endif
	159	#if defined(CONFIG_S390)
	160	{
	161	unsigned long caller;
	162
	163	caller = (unsigned long)__builtin_return_address(0);
	164	disabled_wait(caller);
	165	}
	166	#endif
	167	local_irq_enable();
	168	for (i = 0; ; i += PANIC_TIMER_STEP) {
	169	touch_softlockup_watchdog();
	170	if (i >= i_next) {
	171	i += panic_blink(state ^= 1);
	172	i_next = i + 3600 / PANIC_BLINK_SPD;
	173	}
	174	mdelay(PANIC_TIMER_STEP);
	175	}
	176	}
	177
	178	EXPORT_SYMBOL(panic);
	179
	180
	181	struct tnt {
	182	u8 bit;
	183	char true;
	184	char false;
	185	};
	186
	187	static const struct tnt tnts[] = {
	188	{ TAINT_PROPRIETARY_MODULE, 'P', 'G' },
	189	{ TAINT_FORCED_MODULE, 'F', ' ' },
	190	{ TAINT_UNSAFE_SMP, 'S', ' ' },
	191	{ TAINT_FORCED_RMMOD, 'R', ' ' },
	192	{ TAINT_MACHINE_CHECK, 'M', ' ' },
	193	{ TAINT_BAD_PAGE, 'B', ' ' },
	194	{ TAINT_USER, 'U', ' ' },
	195	{ TAINT_DIE, 'D', ' ' },
	196	{ TAINT_OVERRIDDEN_ACPI_TABLE, 'A', ' ' },
	197	{ TAINT_WARN, 'W', ' ' },
	198	{ TAINT_CRAP, 'C', ' ' },
	199	{ TAINT_FIRMWARE_WORKAROUND, 'I', ' ' },
	200	{ TAINT_OOT_MODULE, 'O', ' ' },
	201	};
	202
	203	/**
	204	* print_tainted - return a string to represent the kernel taint state.
	205	*
	206	* 'P' - Proprietary module has been loaded.
	207	* 'F' - Module has been forcibly loaded.
	208	* 'S' - SMP with CPUs not designed for SMP.
	209	* 'R' - User forced a module unload.
	210	* 'M' - System experienced a machine check exception.
	211	* 'B' - System has hit bad_page.
	212	* 'U' - Userspace-defined naughtiness.
	213	* 'D' - Kernel has oopsed before
	214	* 'A' - ACPI table overridden.
	215	* 'W' - Taint on warning.
	216	* 'C' - modules from drivers/staging are loaded.
	217	* 'I' - Working around severe firmware bug.
	218	* 'O' - Out-of-tree module has been loaded.
	219	*
	220	* The string is overwritten by the next call to print_tainted().
	221	*/
	222	const char *print_tainted(void)
	223	{
	224	static char buf[ARRAY_SIZE(tnts) + sizeof("Tainted: ") + 1];
	225
	226	if (tainted_mask) {
	227	char *s;
	228	int i;
	229
	230	s = buf + sprintf(buf, "Tainted: ");
	231	for (i = 0; i < ARRAY_SIZE(tnts); i++) {
	232	const struct tnt *t = &tnts[i];
	233	*s++ = test_bit(t->bit, &tainted_mask) ?
	234	t->true : t->false;
	235	}
	236	*s = 0;
	237	} else
	238	snprintf(buf, sizeof(buf), "Not tainted");
	239
	240	return buf;
	241	}
	242
	243	int test_taint(unsigned flag)
	244	{
	245	return test_bit(flag, &tainted_mask);
	246	}
	247	EXPORT_SYMBOL(test_taint);
	248
	249	unsigned long get_taint(void)
	250	{
	251	return tainted_mask;
	252	}
	253
	254	void add_taint(unsigned flag)
	255	{
	256	/*
	257	* Can't trust the integrity of the kernel anymore.
	258	* We don't call directly debug_locks_off() because the issue
	259	* is not necessarily serious enough to set oops_in_progress to 1
	260	* Also we want to keep up lockdep for staging/out-of-tree
	261	* development and post-warning case.
	262	*/
	263	switch (flag) {
	264	case TAINT_CRAP:
	265	case TAINT_OOT_MODULE:
	266	case TAINT_WARN:
	267	case TAINT_FIRMWARE_WORKAROUND:
	268	break;
	269
	270	default:
	271	if (__debug_locks_off())
	272	printk(KERN_WARNING "Disabling lock debugging due to kernel taint\n");
	273	}
	274
	275	set_bit(flag, &tainted_mask);
	276	}
	277	EXPORT_SYMBOL(add_taint);
	278
	279	static void spin_msec(int msecs)
	280	{
	281	int i;
	282
	283	for (i = 0; i < msecs; i++) {
	284	touch_nmi_watchdog();
	285	mdelay(1);
	286	}
	287	}
	288
	289	/*
	290	* It just happens that oops_enter() and oops_exit() are identically
	291	* implemented...
	292	*/
	293	static void do_oops_enter_exit(void)
	294	{
	295	unsigned long flags;
	296	static int spin_counter;
	297
	298	if (!pause_on_oops)
	299	return;
	300
	301	spin_lock_irqsave(&pause_on_oops_lock, flags);
	302	if (pause_on_oops_flag == 0) {
	303	/* This CPU may now print the oops message */
	304	pause_on_oops_flag = 1;
	305	} else {
	306	/* We need to stall this CPU */
	307	if (!spin_counter) {
	308	/* This CPU gets to do the counting */
	309	spin_counter = pause_on_oops;
	310	do {
	311	spin_unlock(&pause_on_oops_lock);
	312	spin_msec(MSEC_PER_SEC);
	313	spin_lock(&pause_on_oops_lock);
	314	} while (--spin_counter);
	315	pause_on_oops_flag = 0;
	316	} else {
	317	/* This CPU waits for a different one */
	318	while (spin_counter) {
	319	spin_unlock(&pause_on_oops_lock);
	320	spin_msec(1);
	321	spin_lock(&pause_on_oops_lock);
	322	}
	323	}
	324	}
	325	spin_unlock_irqrestore(&pause_on_oops_lock, flags);
	326	}
	327
	328	/*
	329	* Return true if the calling CPU is allowed to print oops-related info.
	330	* This is a bit racy..
	331	*/
	332	int oops_may_print(void)
	333	{
	334	return pause_on_oops_flag == 0;
	335	}
	336
	337	/*
	338	* Called when the architecture enters its oops handler, before it prints
	339	* anything. If this is the first CPU to oops, and it's oopsing the first
	340	* time then let it proceed.
	341	*
	342	* This is all enabled by the pause_on_oops kernel boot option. We do all
	343	* this to ensure that oopses don't scroll off the screen. It has the
	344	* side-effect of preventing later-oopsing CPUs from mucking up the display,
	345	* too.
	346	*
	347	* It turns out that the CPU which is allowed to print ends up pausing for
	348	* the right duration, whereas all the other CPUs pause for twice as long:
	349	* once in oops_enter(), once in oops_exit().
	350	*/
	351	void oops_enter(void)
	352	{
	353	tracing_off();
	354	/* can't trust the integrity of the kernel anymore: */
	355	debug_locks_off();
	356	do_oops_enter_exit();
	357	}
	358
	359	/*
	360	* 64-bit random ID for oopses:
	361	*/
	362	static u64 oops_id;
	363
	364	static int init_oops_id(void)
	365	{
	366	if (!oops_id)
	367	get_random_bytes(&oops_id, sizeof(oops_id));
	368	else
	369	oops_id++;
	370
	371	return 0;
	372	}
	373	late_initcall(init_oops_id);
	374
	375	void print_oops_end_marker(void)
	376	{
	377	init_oops_id();
	378	printk(KERN_WARNING "---[ end trace %016llx ]---\n",
	379	(unsigned long long)oops_id);
	380	}
	381
	382	/*
	383	* Called when the architecture exits its oops handler, after printing
	384	* everything.
	385	*/
	386	void oops_exit(void)
	387	{
	388	do_oops_enter_exit();
	389	print_oops_end_marker();
	390	kmsg_dump(KMSG_DUMP_OOPS);
	391	}
	392
	393	#ifdef WANT_WARN_ON_SLOWPATH
	394	struct slowpath_args {
	395	const char *fmt;
	396	va_list args;
	397	};
	398
	399	static void warn_slowpath_common(const char file, int line, void caller,
	400	unsigned taint, struct slowpath_args *args)
	401	{
	402	const char *board;
	403
	404	printk(KERN_WARNING "------------[ cut here ]------------\n");
	405	printk(KERN_WARNING "WARNING: at %s:%d %pS()\n", file, line, caller);
	406	board = dmi_get_system_info(DMI_PRODUCT_NAME);
	407	if (board)
	408	printk(KERN_WARNING "Hardware name: %s\n", board);
	409
	410	if (args)
	411	vprintk(args->fmt, args->args);
	412
	413	print_modules();
	414	dump_stack();
	415	print_oops_end_marker();
	416	add_taint(taint);
	417	}
	418
	419	void warn_slowpath_fmt(const char file, int line, const char fmt, ...)
	420	{
	421	struct slowpath_args args;
	422
	423	args.fmt = fmt;
	424	va_start(args.args, fmt);
	425	warn_slowpath_common(file, line, __builtin_return_address(0),
	426	TAINT_WARN, &args);
	427	va_end(args.args);
	428	}
	429	EXPORT_SYMBOL(warn_slowpath_fmt);
	430
	431	void warn_slowpath_fmt_taint(const char *file, int line,
	432	unsigned taint, const char *fmt, ...)
	433	{
	434	struct slowpath_args args;
	435
	436	args.fmt = fmt;
	437	va_start(args.args, fmt);
	438	warn_slowpath_common(file, line, __builtin_return_address(0),
	439	taint, &args);
	440	va_end(args.args);
	441	}
	442	EXPORT_SYMBOL(warn_slowpath_fmt_taint);
	443
	444	void warn_slowpath_null(const char *file, int line)
	445	{
	446	warn_slowpath_common(file, line, __builtin_return_address(0),
	447	TAINT_WARN, NULL);
	448	}
	449	EXPORT_SYMBOL(warn_slowpath_null);
	450	#endif
	451
	452	#ifdef CONFIG_CC_STACKPROTECTOR
	453
	454	/*
	455	* Called when gcc's -fstack-protector feature is used, and
	456	* gcc detects corruption of the on-stack canary value
	457	*/
	458	void __stack_chk_fail(void)
	459	{
	460	panic("stack-protector: Kernel stack is corrupted in: %p\n",
	461	__builtin_return_address(0));
	462	}
	463	EXPORT_SYMBOL(__stack_chk_fail);
	464
	465	#endif
	466
	467	core_param(panic, panic_timeout, int, 0644);
	468	core_param(pause_on_oops, pause_on_oops, int, 0644);
	469
	470	static int __init oops_setup(char *s)
	471	{
	472	if (!s)
	473	return -EINVAL;
	474	if (!strcmp(s, "panic"))
	475	panic_on_oops = 1;
	476	return 0;
	477	}
	478	early_param("oops", oops_setup);