[net-next-2.6.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/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>

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;

ATOMIC_NOTIFIER_HEAD(panic_notifier_list);

EXPORT_SYMBOL(panic_notifier_list);

static long no_blink(long time)
{
	return 0;
}

/* Returns how long it waited in ms */
long (*panic_blink)(long time);
EXPORT_SYMBOL(panic_blink);

/**
 *	panic - halt the system
 *	@fmt: The text string to print
 *
 *	Display a message, then perform cleanups.
 *
 *	This function never returns.
 */
NORET_TYPE void panic(const char * fmt, ...)
{
	static char buf[1024];
	va_list args;
	long i;

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

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

	/*
	 * 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; ) {
			touch_nmi_watchdog();
			i += panic_blink(i);
			mdelay(1);
			i++;
		}
		/*
		 * 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; ; ) {
		touch_softlockup_watchdog();
		i += panic_blink(i);
		mdelay(1);
		i++;
	}
}

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', ' ' },
};

/**
 *	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.
 *
 *	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 development and
	 * post-warning case.
	 */
	if (flag != TAINT_CRAP && flag != TAINT_WARN && __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);

static 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();
}

#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, 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_WARN);
}

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), &args);
	va_end(args.args);
}
EXPORT_SYMBOL(warn_slowpath_fmt);

void warn_slowpath_null(const char *file, int line)
{
	warn_slowpath_common(file, line, __builtin_return_address(0), 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);
Commit	Line	Data
1da177e4 LT	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	*/
c95dbf27 IM	11	#include <linux/debug_locks.h>
	12	#include <linux/interrupt.h>
	13	#include <linux/kallsyms.h>
	14	#include <linux/notifier.h>
1da177e4	15	#include <linux/module.h>
c95dbf27	16	#include <linux/random.h>
1da177e4	17	#include <linux/reboot.h>
c95dbf27 IM	18	#include <linux/delay.h>
	19	#include <linux/kexec.h>
	20	#include <linux/sched.h>
1da177e4	21	#include <linux/sysrq.h>
c95dbf27	22	#include <linux/init.h>
1da177e4	23	#include <linux/nmi.h>
bd89bb29	24	#include <linux/dmi.h>
1da177e4	25
1da177e4	26	int panic_on_oops;
25ddbb18	27	static unsigned long tainted_mask;
dd287796 AM	28	static int pause_on_oops;
	29	static int pause_on_oops_flag;
	30	static DEFINE_SPINLOCK(pause_on_oops_lock);
1da177e4	31
dd287796	32	int panic_timeout;
1da177e4	33
e041c683	34	ATOMIC_NOTIFIER_HEAD(panic_notifier_list);
1da177e4 LT	35
	36	EXPORT_SYMBOL(panic_notifier_list);
	37
1da177e4 LT	38	static long no_blink(long time)
	39	{
	40	return 0;
	41	}
	42
	43	/* Returns how long it waited in ms */
	44	long (*panic_blink)(long time);
	45	EXPORT_SYMBOL(panic_blink);
	46
	47	/**
	48	* panic - halt the system
	49	* @fmt: The text string to print
	50	*
	51	* Display a message, then perform cleanups.
	52	*
	53	* This function never returns.
	54	*/
1da177e4 LT	55	NORET_TYPE void panic(const char * fmt, ...)
1da177e4 LT	56	{
1da177e4 LT	57	static char buf[1024];
1da177e4 LT	58	va_list args;
c95dbf27	59	long i;
1da177e4	60
dc009d92	61	/*
c95dbf27 IM	62	* It's possible to come here directly from a panic-assertion and
c95dbf27 IM	63	* not have preempt disabled. Some functions called from here want
dc009d92 EB	64	* preempt to be disabled. No point enabling it later though...
	65	*/
	66	preempt_disable();
	67
1da177e4 LT	68	bust_spinlocks(1);
	69	va_start(args, fmt);
	70	vsnprintf(buf, sizeof(buf), fmt, args);
	71	va_end(args);
	72	printk(KERN_EMERG "Kernel panic - not syncing: %s\n",buf);
5cb27301 IM	73	#ifdef CONFIG_DEBUG_BUGVERBOSE
	74	dump_stack();
	75	#endif
1da177e4	76
dc009d92 EB	77	/*
	78	* If we have crashed and we have a crash kernel loaded let it handle
	79	* everything else.
	80	* Do we want to call this before we try to display a message?
	81	*/
6e274d14	82	crash_kexec(NULL);
dc009d92	83
dc009d92 EB	84	/*
	85	* Note smp_send_stop is the usual smp shutdown function, which
	86	* unfortunately means it may not be hardened to work in a panic
	87	* situation.
	88	*/
1da177e4	89	smp_send_stop();
1da177e4	90
e041c683	91	atomic_notifier_call_chain(&panic_notifier_list, 0, buf);
1da177e4	92
d014e889 AK	93	bust_spinlocks(0);
d014e889 AK	94
1da177e4 LT	95	if (!panic_blink)
	96	panic_blink = no_blink;
	97
dc009d92	98	if (panic_timeout > 0) {
1da177e4	99	/*
c95dbf27 IM	100	* Delay timeout seconds before rebooting the machine.
	101	* We can't use the "normal" timers since we just panicked.
	102	*/
	103	printk(KERN_EMERG "Rebooting in %d seconds..", panic_timeout);
	104
1da177e4 LT	105	for (i = 0; i < panic_timeout*1000; ) {
	106	touch_nmi_watchdog();
	107	i += panic_blink(i);
	108	mdelay(1);
	109	i++;
	110	}
c95dbf27 IM	111	/*
	112	* This will not be a clean reboot, with everything
	113	* shutting down. But if there is a chance of
	114	* rebooting the system it will be rebooted.
1da177e4	115	*/
2f048ea8	116	emergency_restart();
1da177e4 LT	117	}
	118	#ifdef __sparc__
	119	{
	120	extern int stop_a_enabled;
a271c241	121	/* Make sure the user can actually press Stop-A (L1-A) */
1da177e4	122	stop_a_enabled = 1;
a271c241	123	printk(KERN_EMERG "Press Stop-A (L1-A) to return to the boot prom\n");
1da177e4 LT	124	}
1da177e4 LT	125	#endif
347a8dc3	126	#if defined(CONFIG_S390)
c95dbf27 IM	127	{
	128	unsigned long caller;
	129
	130	caller = (unsigned long)__builtin_return_address(0);
	131	disabled_wait(caller);
	132	}
1da177e4 LT	133	#endif
1da177e4 LT	134	local_irq_enable();
c95dbf27	135	for (i = 0; ; ) {
c22db941	136	touch_softlockup_watchdog();
1da177e4 LT	137	i += panic_blink(i);
	138	mdelay(1);
	139	i++;
	140	}
	141	}
	142
	143	EXPORT_SYMBOL(panic);
	144
c277e63f	145
25ddbb18	146	struct tnt {
c95dbf27 IM	147	u8 bit;
	148	char true;
	149	char false;
25ddbb18 AK	150	};
	151
	152	static const struct tnt tnts[] = {
c95dbf27 IM	153	{ TAINT_PROPRIETARY_MODULE, 'P', 'G' },
	154	{ TAINT_FORCED_MODULE, 'F', ' ' },
	155	{ TAINT_UNSAFE_SMP, 'S', ' ' },
	156	{ TAINT_FORCED_RMMOD, 'R', ' ' },
	157	{ TAINT_MACHINE_CHECK, 'M', ' ' },
	158	{ TAINT_BAD_PAGE, 'B', ' ' },
	159	{ TAINT_USER, 'U', ' ' },
	160	{ TAINT_DIE, 'D', ' ' },
	161	{ TAINT_OVERRIDDEN_ACPI_TABLE, 'A', ' ' },
	162	{ TAINT_WARN, 'W', ' ' },
	163	{ TAINT_CRAP, 'C', ' ' },
25ddbb18 AK	164	};
25ddbb18 AK	165
1da177e4 LT	166	/**
	167	* print_tainted - return a string to represent the kernel taint state.
	168	*
	169	* 'P' - Proprietary module has been loaded.
	170	* 'F' - Module has been forcibly loaded.
	171	* 'S' - SMP with CPUs not designed for SMP.
	172	* 'R' - User forced a module unload.
9aa5e993	173	* 'M' - System experienced a machine check exception.
1da177e4	174	* 'B' - System has hit bad_page.
34f5a398	175	* 'U' - Userspace-defined naughtiness.
a8005992	176	* 'D' - Kernel has oopsed before
95b570c9 NH	177	* 'A' - ACPI table overridden.
95b570c9 NH	178	* 'W' - Taint on warning.
061b1bd3	179	* 'C' - modules from drivers/staging are loaded.
1da177e4	180	*
fe002a41	181	* The string is overwritten by the next call to print_tainted().
1da177e4	182	*/
1da177e4 LT	183	const char *print_tainted(void)
1da177e4 LT	184	{
25ddbb18 AK	185	static char buf[ARRAY_SIZE(tnts) + sizeof("Tainted: ") + 1];
	186
	187	if (tainted_mask) {
	188	char *s;
	189	int i;
	190
	191	s = buf + sprintf(buf, "Tainted: ");
	192	for (i = 0; i < ARRAY_SIZE(tnts); i++) {
	193	const struct tnt *t = &tnts[i];
	194	*s++ = test_bit(t->bit, &tainted_mask) ?
	195	t->true : t->false;
	196	}
	197	*s = 0;
	198	} else
1da177e4	199	snprintf(buf, sizeof(buf), "Not tainted");
c95dbf27 IM	200
c95dbf27 IM	201	return buf;
1da177e4 LT	202	}
1da177e4 LT	203
25ddbb18	204	int test_taint(unsigned flag)
1da177e4	205	{
25ddbb18 AK	206	return test_bit(flag, &tainted_mask);
	207	}
	208	EXPORT_SYMBOL(test_taint);
	209
	210	unsigned long get_taint(void)
	211	{
	212	return tainted_mask;
1da177e4	213	}
dd287796	214
1da177e4	215	void add_taint(unsigned flag)
dd287796	216	{
9eeba613 FW	217	/*
	218	* Can't trust the integrity of the kernel anymore.
	219	* We don't call directly debug_locks_off() because the issue
	220	* is not necessarily serious enough to set oops_in_progress to 1
574bbe78 FW	221	* Also we want to keep up lockdep for staging development and
574bbe78 FW	222	* post-warning case.
9eeba613	223	*/
574bbe78	224	if (flag != TAINT_CRAP && flag != TAINT_WARN && __debug_locks_off())
b48ccb09	225	printk(KERN_WARNING "Disabling lock debugging due to kernel taint\n");
9eeba613	226
25ddbb18	227	set_bit(flag, &tainted_mask);
dd287796	228	}
1da177e4	229	EXPORT_SYMBOL(add_taint);
dd287796 AM	230
	231	static void spin_msec(int msecs)
	232	{
	233	int i;
	234
	235	for (i = 0; i < msecs; i++) {
	236	touch_nmi_watchdog();
	237	mdelay(1);
	238	}
	239	}
	240
	241	/*
	242	* It just happens that oops_enter() and oops_exit() are identically
	243	* implemented...
	244	*/
	245	static void do_oops_enter_exit(void)
	246	{
	247	unsigned long flags;
	248	static int spin_counter;
	249
	250	if (!pause_on_oops)
	251	return;
	252
	253	spin_lock_irqsave(&pause_on_oops_lock, flags);
	254	if (pause_on_oops_flag == 0) {
	255	/* This CPU may now print the oops message */
	256	pause_on_oops_flag = 1;
	257	} else {
	258	/* We need to stall this CPU */
	259	if (!spin_counter) {
	260	/* This CPU gets to do the counting */
	261	spin_counter = pause_on_oops;
	262	do {
	263	spin_unlock(&pause_on_oops_lock);
	264	spin_msec(MSEC_PER_SEC);
	265	spin_lock(&pause_on_oops_lock);
	266	} while (--spin_counter);
	267	pause_on_oops_flag = 0;
	268	} else {
	269	/* This CPU waits for a different one */
	270	while (spin_counter) {
	271	spin_unlock(&pause_on_oops_lock);
	272	spin_msec(1);
	273	spin_lock(&pause_on_oops_lock);
	274	}
	275	}
	276	}
	277	spin_unlock_irqrestore(&pause_on_oops_lock, flags);
	278	}
	279
	280	/*
c95dbf27 IM	281	* Return true if the calling CPU is allowed to print oops-related info.
c95dbf27 IM	282	* This is a bit racy..
dd287796 AM	283	*/
	284	int oops_may_print(void)
	285	{
	286	return pause_on_oops_flag == 0;
	287	}
	288
	289	/*
	290	* Called when the architecture enters its oops handler, before it prints
c95dbf27 IM	291	* anything. If this is the first CPU to oops, and it's oopsing the first
c95dbf27 IM	292	* time then let it proceed.
dd287796	293	*
c95dbf27 IM	294	* This is all enabled by the pause_on_oops kernel boot option. We do all
	295	* this to ensure that oopses don't scroll off the screen. It has the
	296	* side-effect of preventing later-oopsing CPUs from mucking up the display,
	297	* too.
dd287796	298	*
c95dbf27 IM	299	* It turns out that the CPU which is allowed to print ends up pausing for
	300	* the right duration, whereas all the other CPUs pause for twice as long:
	301	* once in oops_enter(), once in oops_exit().
dd287796 AM	302	*/
	303	void oops_enter(void)
	304	{
bdff7870	305	tracing_off();
c95dbf27 IM	306	/* can't trust the integrity of the kernel anymore: */
c95dbf27 IM	307	debug_locks_off();
dd287796 AM	308	do_oops_enter_exit();
	309	}
	310
2c3b20e9 AV	311	/*
	312	* 64-bit random ID for oopses:
	313	*/
	314	static u64 oops_id;
	315
	316	static int init_oops_id(void)
	317	{
	318	if (!oops_id)
	319	get_random_bytes(&oops_id, sizeof(oops_id));
d6624f99 AV	320	else
d6624f99 AV	321	oops_id++;
2c3b20e9 AV	322
	323	return 0;
	324	}
	325	late_initcall(init_oops_id);
	326
71c33911 AV	327	static void print_oops_end_marker(void)
	328	{
	329	init_oops_id();
	330	printk(KERN_WARNING "---[ end trace %016llx ]---\n",
	331	(unsigned long long)oops_id);
	332	}
	333
dd287796 AM	334	/*
	335	* Called when the architecture exits its oops handler, after printing
	336	* everything.
	337	*/
	338	void oops_exit(void)
	339	{
	340	do_oops_enter_exit();
71c33911	341	print_oops_end_marker();
dd287796	342	}
3162f751	343
79b4cc5e	344	#ifdef WANT_WARN_ON_SLOWPATH
0f6f49a8 LT	345	struct slowpath_args {
0f6f49a8 LT	346	const char *fmt;
a8f18b90	347	va_list args;
0f6f49a8	348	};
bd89bb29	349
0f6f49a8 LT	350	static void warn_slowpath_common(const char file, int line, void caller, struct slowpath_args *args)
	351	{
	352	const char *board;
a8f18b90 AV	353
a8f18b90 AV	354	printk(KERN_WARNING "------------[ cut here ]------------\n");
0f6f49a8	355	printk(KERN_WARNING "WARNING: at %s:%d %pS()\n", file, line, caller);
bd89bb29 AV	356	board = dmi_get_system_info(DMI_PRODUCT_NAME);
	357	if (board)
	358	printk(KERN_WARNING "Hardware name: %s\n", board);
74853dba	359
0f6f49a8 LT	360	if (args)
0f6f49a8 LT	361	vprintk(args->fmt, args->args);
a8f18b90 AV	362
	363	print_modules();
	364	dump_stack();
	365	print_oops_end_marker();
	366	add_taint(TAINT_WARN);
	367	}
0f6f49a8 LT	368
	369	void warn_slowpath_fmt(const char file, int line, const char fmt, ...)
	370	{
	371	struct slowpath_args args;
	372
	373	args.fmt = fmt;
	374	va_start(args.args, fmt);
	375	warn_slowpath_common(file, line, __builtin_return_address(0), &args);
	376	va_end(args.args);
	377	}
57adc4d2 AK	378	EXPORT_SYMBOL(warn_slowpath_fmt);
	379
	380	void warn_slowpath_null(const char *file, int line)
	381	{
0f6f49a8	382	warn_slowpath_common(file, line, __builtin_return_address(0), NULL);
57adc4d2 AK	383	}
57adc4d2 AK	384	EXPORT_SYMBOL(warn_slowpath_null);
79b4cc5e AV	385	#endif
79b4cc5e AV	386
3162f751	387	#ifdef CONFIG_CC_STACKPROTECTOR
54371a43	388
3162f751 AV	389	/*
	390	* Called when gcc's -fstack-protector feature is used, and
	391	* gcc detects corruption of the on-stack canary value
	392	*/
	393	void __stack_chk_fail(void)
	394	{
517a92c4 IM	395	panic("stack-protector: Kernel stack is corrupted in: %p\n",
517a92c4 IM	396	__builtin_return_address(0));
3162f751 AV	397	}
3162f751 AV	398	EXPORT_SYMBOL(__stack_chk_fail);
54371a43	399
3162f751	400	#endif
f44dd164 RR	401
	402	core_param(panic, panic_timeout, int, 0644);
	403	core_param(pause_on_oops, pause_on_oops, int, 0644);