panic.c 16.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10
/*
 *  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.
 */
11
#include <linux/debug_locks.h>
12
#include <linux/sched/debug.h>
13
#include <linux/interrupt.h>
14
#include <linux/kmsg_dump.h>
15 16
#include <linux/kallsyms.h>
#include <linux/notifier.h>
17
#include <linux/vt_kern.h>
Linus Torvalds's avatar
Linus Torvalds committed
18
#include <linux/module.h>
19
#include <linux/random.h>
20
#include <linux/ftrace.h>
Linus Torvalds's avatar
Linus Torvalds committed
21
#include <linux/reboot.h>
22 23 24
#include <linux/delay.h>
#include <linux/kexec.h>
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
25
#include <linux/sysrq.h>
26
#include <linux/init.h>
Linus Torvalds's avatar
Linus Torvalds committed
27
#include <linux/nmi.h>
28
#include <linux/console.h>
29
#include <linux/bug.h>
30
#include <linux/ratelimit.h>
31 32
#include <linux/debugfs.h>
#include <asm/sections.h>
Linus Torvalds's avatar
Linus Torvalds committed
33

34 35 36
#define PANIC_TIMER_STEP 100
#define PANIC_BLINK_SPD 18

37
int panic_on_oops = CONFIG_PANIC_ON_OOPS_VALUE;
38 39
static unsigned long tainted_mask =
	IS_ENABLED(CONFIG_GCC_PLUGIN_RANDSTRUCT) ? (1 << TAINT_RANDSTRUCT) : 0;
40 41 42
static int pause_on_oops;
static int pause_on_oops_flag;
static DEFINE_SPINLOCK(pause_on_oops_lock);
43
bool crash_kexec_post_notifiers;
44
int panic_on_warn __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
45

46
int panic_timeout = CONFIG_PANIC_TIMEOUT;
47
EXPORT_SYMBOL_GPL(panic_timeout);
Linus Torvalds's avatar
Linus Torvalds committed
48

49
ATOMIC_NOTIFIER_HEAD(panic_notifier_list);
Linus Torvalds's avatar
Linus Torvalds committed
50 51 52

EXPORT_SYMBOL(panic_notifier_list);

53
static long no_blink(int state)
54
{
55
	return 0;
56 57
}

58 59 60 61
/* Returns how long it waited in ms */
long (*panic_blink)(int state);
EXPORT_SYMBOL(panic_blink);

62 63 64 65 66 67 68 69 70
/*
 * Stop ourself in panic -- architecture code may override this
 */
void __weak panic_smp_self_stop(void)
{
	while (1)
		cpu_relax();
}

71 72 73 74 75 76 77 78 79
/*
 * 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 nmi_panic_self_stop(struct pt_regs *regs)
{
	panic_smp_self_stop();
}

80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
/*
 * 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;
}

106 107
atomic_t panic_cpu = ATOMIC_INIT(PANIC_CPU_INVALID);

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
/*
 * 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, cpu;

	cpu = raw_smp_processor_id();
	old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, cpu);

	if (old_cpu == PANIC_CPU_INVALID)
		panic("%s", msg);
	else if (old_cpu != cpu)
		nmi_panic_self_stop(regs);
}
EXPORT_SYMBOL(nmi_panic);

Linus Torvalds's avatar
Linus Torvalds committed
128 129 130 131 132 133 134 135
/**
 *	panic - halt the system
 *	@fmt: The text string to print
 *
 *	Display a message, then perform cleanups.
 *
 *	This function never returns.
 */
136
void panic(const char *fmt, ...)
Linus Torvalds's avatar
Linus Torvalds committed
137 138 139
{
	static char buf[1024];
	va_list args;
140
	long i, i_next = 0, len;
141
	int state = 0;
142
	int old_cpu, this_cpu;
143
	bool _crash_kexec_post_notifiers = crash_kexec_post_notifiers;
Linus Torvalds's avatar
Linus Torvalds committed
144

145 146 147 148
	/*
	 * 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
149
	 * after setting panic_cpu) from invoking panic() again.
150 151 152
	 */
	local_irq_disable();

153
	/*
154 155
	 * It's possible to come here directly from a panic-assertion and
	 * not have preempt disabled. Some functions called from here want
156
	 * preempt to be disabled. No point enabling it later though...
157 158 159 160 161
	 *
	 * 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().
162 163 164 165 166
	 *
	 * `old_cpu == PANIC_CPU_INVALID' 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.
167
	 */
168 169 170 171
	this_cpu = raw_smp_processor_id();
	old_cpu  = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu);

	if (old_cpu != PANIC_CPU_INVALID && old_cpu != this_cpu)
172
		panic_smp_self_stop();
173

174
	console_verbose();
Linus Torvalds's avatar
Linus Torvalds committed
175 176
	bust_spinlocks(1);
	va_start(args, fmt);
177
	len = vscnprintf(buf, sizeof(buf), fmt, args);
Linus Torvalds's avatar
Linus Torvalds committed
178
	va_end(args);
179 180 181 182

	if (len && buf[len - 1] == '\n')
		buf[len - 1] = '\0';

183
	pr_emerg("Kernel panic - not syncing: %s\n", buf);
184
#ifdef CONFIG_DEBUG_BUGVERBOSE
185 186 187
	/*
	 * Avoid nested stack-dumping if a panic occurs during oops processing
	 */
188
	if (!test_taint(TAINT_DIE) && oops_in_progress <= 1)
189
		dump_stack();
190
#endif
Linus Torvalds's avatar
Linus Torvalds committed
191

192 193 194
	/*
	 * If we have crashed and we have a crash kernel loaded let it handle
	 * everything else.
195 196
	 * If we want to run this after calling panic_notifiers, pass
	 * the "crash_kexec_post_notifiers" option to the kernel.
197 198
	 *
	 * Bypass the panic_cpu check and call __crash_kexec directly.
199
	 */
200
	if (!_crash_kexec_post_notifiers) {
201
		printk_safe_flush_on_panic();
202
		__crash_kexec(NULL);
203

204 205 206 207 208 209 210 211 212 213 214 215 216 217
		/*
		 * 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();
	} else {
		/*
		 * If we want to do crash dump after notifier calls and
		 * kmsg_dump, we will need architecture dependent extra
		 * works in addition to stopping other CPUs.
		 */
		crash_smp_send_stop();
	}
Linus Torvalds's avatar
Linus Torvalds committed
218

219 220 221 222
	/*
	 * Run any panic handlers, including those that might need to
	 * add information to the kmsg dump output.
	 */
223
	atomic_notifier_call_chain(&panic_notifier_list, 0, buf);
Linus Torvalds's avatar
Linus Torvalds committed
224

225
	/* Call flush even twice. It tries harder with a single online CPU */
226
	printk_safe_flush_on_panic();
227 228
	kmsg_dump(KMSG_DUMP_PANIC);

229 230 231 232 233 234
	/*
	 * 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.
235 236
	 *
	 * Bypass the panic_cpu check and call __crash_kexec directly.
237
	 */
238
	if (_crash_kexec_post_notifiers)
239
		__crash_kexec(NULL);
240

241 242 243 244
#ifdef CONFIG_VT
	unblank_screen();
#endif
	console_unblank();
245

246 247 248 249
	/*
	 * 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
250 251 252
	 * 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.
253
	 */
254
	debug_locks_off();
255
	console_flush_on_panic();
256

257 258 259
	if (!panic_blink)
		panic_blink = no_blink;

260
	if (panic_timeout > 0) {
Linus Torvalds's avatar
Linus Torvalds committed
261
		/*
262 263 264
		 * Delay timeout seconds before rebooting the machine.
		 * We can't use the "normal" timers since we just panicked.
		 */
265
		pr_emerg("Rebooting in %d seconds..\n", panic_timeout);
266

267
		for (i = 0; i < panic_timeout * 1000; i += PANIC_TIMER_STEP) {
Linus Torvalds's avatar
Linus Torvalds committed
268
			touch_nmi_watchdog();
269 270 271 272 273
			if (i >= i_next) {
				i += panic_blink(state ^= 1);
				i_next = i + 3600 / PANIC_BLINK_SPD;
			}
			mdelay(PANIC_TIMER_STEP);
Linus Torvalds's avatar
Linus Torvalds committed
274
		}
275 276
	}
	if (panic_timeout != 0) {
277 278 279 280
		/*
		 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
281
		 */
282
		emergency_restart();
Linus Torvalds's avatar
Linus Torvalds committed
283 284 285 286
	}
#ifdef __sparc__
	{
		extern int stop_a_enabled;
287
		/* Make sure the user can actually press Stop-A (L1-A) */
Linus Torvalds's avatar
Linus Torvalds committed
288
		stop_a_enabled = 1;
289 290
		pr_emerg("Press Stop-A (L1-A) from sun keyboard or send break\n"
			 "twice on console to return to the boot prom\n");
Linus Torvalds's avatar
Linus Torvalds committed
291 292
	}
#endif
293
#if defined(CONFIG_S390)
294 295 296 297 298 299
	{
		unsigned long caller;

		caller = (unsigned long)__builtin_return_address(0);
		disabled_wait(caller);
	}
Linus Torvalds's avatar
Linus Torvalds committed
300
#endif
301
	pr_emerg("---[ end Kernel panic - not syncing: %s ]---\n", buf);
Linus Torvalds's avatar
Linus Torvalds committed
302
	local_irq_enable();
303
	for (i = 0; ; i += PANIC_TIMER_STEP) {
304
		touch_softlockup_watchdog();
305 306 307 308 309
		if (i >= i_next) {
			i += panic_blink(state ^= 1);
			i_next = i + 3600 / PANIC_BLINK_SPD;
		}
		mdelay(PANIC_TIMER_STEP);
Linus Torvalds's avatar
Linus Torvalds committed
310 311 312 313 314
	}
}

EXPORT_SYMBOL(panic);

315 316 317 318 319
/*
 * 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] = {
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
	[ TAINT_PROPRIETARY_MODULE ]	= { 'P', 'G', true },
	[ TAINT_FORCED_MODULE ]		= { 'F', ' ', true },
	[ TAINT_CPU_OUT_OF_SPEC ]	= { 'S', ' ', false },
	[ TAINT_FORCED_RMMOD ]		= { 'R', ' ', false },
	[ TAINT_MACHINE_CHECK ]		= { 'M', ' ', false },
	[ TAINT_BAD_PAGE ]		= { 'B', ' ', false },
	[ TAINT_USER ]			= { 'U', ' ', false },
	[ TAINT_DIE ]			= { 'D', ' ', false },
	[ TAINT_OVERRIDDEN_ACPI_TABLE ]	= { 'A', ' ', false },
	[ TAINT_WARN ]			= { 'W', ' ', false },
	[ TAINT_CRAP ]			= { 'C', ' ', true },
	[ TAINT_FIRMWARE_WORKAROUND ]	= { 'I', ' ', false },
	[ TAINT_OOT_MODULE ]		= { 'O', ' ', true },
	[ TAINT_UNSIGNED_MODULE ]	= { 'E', ' ', true },
	[ TAINT_SOFTLOCKUP ]		= { 'L', ' ', false },
	[ TAINT_LIVEPATCH ]		= { 'K', ' ', true },
	[ TAINT_AUX ]			= { 'X', ' ', true },
337
	[ TAINT_RANDSTRUCT ]		= { 'T', ' ', true },
338 339
};

Linus Torvalds's avatar
Linus Torvalds committed
340
/**
341
 * print_tainted - return a string to represent the kernel taint state.
Linus Torvalds's avatar
Linus Torvalds committed
342
 *
343
 * For individual taint flag meanings, see Documentation/sysctl/kernel.txt
Linus Torvalds's avatar
Linus Torvalds committed
344
 *
345 346
 * The string is overwritten by the next call to print_tainted(),
 * but is always NULL terminated.
Linus Torvalds's avatar
Linus Torvalds committed
347 348 349
 */
const char *print_tainted(void)
{
350
	static char buf[TAINT_FLAGS_COUNT + sizeof("Tainted: ")];
351

352 353
	BUILD_BUG_ON(ARRAY_SIZE(taint_flags) != TAINT_FLAGS_COUNT);

354 355 356 357 358
	if (tainted_mask) {
		char *s;
		int i;

		s = buf + sprintf(buf, "Tainted: ");
359 360 361
		for (i = 0; i < TAINT_FLAGS_COUNT; i++) {
			const struct taint_flag *t = &taint_flags[i];
			*s++ = test_bit(i, &tainted_mask) ?
362
					t->c_true : t->c_false;
363 364 365
		}
		*s = 0;
	} else
Linus Torvalds's avatar
Linus Torvalds committed
366
		snprintf(buf, sizeof(buf), "Not tainted");
367 368

	return buf;
Linus Torvalds's avatar
Linus Torvalds committed
369 370
}

371
int test_taint(unsigned flag)
Linus Torvalds's avatar
Linus Torvalds committed
372
{
373 374 375 376 377 378 379
	return test_bit(flag, &tainted_mask);
}
EXPORT_SYMBOL(test_taint);

unsigned long get_taint(void)
{
	return tainted_mask;
Linus Torvalds's avatar
Linus Torvalds committed
380
}
381

382 383 384 385 386 387 388 389 390
/**
 * 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)
391
{
392
	if (lockdep_ok == LOCKDEP_NOW_UNRELIABLE && __debug_locks_off())
393
		pr_warn("Disabling lock debugging due to kernel taint\n");
394

395
	set_bit(flag, &tainted_mask);
396
}
Linus Torvalds's avatar
Linus Torvalds committed
397
EXPORT_SYMBOL(add_taint);
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448

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

/*
449 450
 * Return true if the calling CPU is allowed to print oops-related info.
 * This is a bit racy..
451 452 453 454 455 456 457 458
 */
int oops_may_print(void)
{
	return pause_on_oops_flag == 0;
}

/*
 * Called when the architecture enters its oops handler, before it prints
459 460
 * anything.  If this is the first CPU to oops, and it's oopsing the first
 * time then let it proceed.
461
 *
462 463 464 465
 * 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.
466
 *
467 468 469
 * 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().
470 471 472
 */
void oops_enter(void)
{
473
	tracing_off();
474 475
	/* can't trust the integrity of the kernel anymore: */
	debug_locks_off();
476 477 478
	do_oops_enter_exit();
}

479 480 481 482 483 484 485 486 487
/*
 * 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));
488 489
	else
		oops_id++;
490 491 492 493 494

	return 0;
}
late_initcall(init_oops_id);

495
void print_oops_end_marker(void)
496 497
{
	init_oops_id();
498
	pr_warn("---[ end trace %016llx ]---\n", (unsigned long long)oops_id);
499 500
}

501 502 503 504 505 506 507
/*
 * Called when the architecture exits its oops handler, after printing
 * everything.
 */
void oops_exit(void)
{
	do_oops_enter_exit();
508
	print_oops_end_marker();
509
	kmsg_dump(KMSG_DUMP_OOPS);
510
}
511

512
struct warn_args {
513
	const char *fmt;
514
	va_list args;
515
};
516

517 518
void __warn(const char *file, int line, void *caller, unsigned taint,
	    struct pt_regs *regs, struct warn_args *args)
519
{
520 521
	disable_trace_on_warning();

522 523
	if (args)
		pr_warn(CUT_HERE);
524 525 526 527 528 529 530 531

	if (file)
		pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS\n",
			raw_smp_processor_id(), current->pid, file, line,
			caller);
	else
		pr_warn("WARNING: CPU: %d PID: %d at %pS\n",
			raw_smp_processor_id(), current->pid, caller);
532

533 534
	if (args)
		vprintk(args->fmt, args->args);
535

536 537 538 539 540 541 542 543 544 545 546
	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;
		panic("panic_on_warn set ...\n");
	}

547
	print_modules();
548 549 550 551 552 553

	if (regs)
		show_regs(regs);
	else
		dump_stack();

554 555
	print_irqtrace_events(current);

556
	print_oops_end_marker();
557

558 559
	/* Just a warning, don't kill lockdep. */
	add_taint(taint, LOCKDEP_STILL_OK);
560
}
561

562
#ifdef WANT_WARN_ON_SLOWPATH
563 564
void warn_slowpath_fmt(const char *file, int line, const char *fmt, ...)
{
565
	struct warn_args args;
566 567 568

	args.fmt = fmt;
	va_start(args.args, fmt);
569 570
	__warn(file, line, __builtin_return_address(0), TAINT_WARN, NULL,
	       &args);
571 572
	va_end(args.args);
}
573 574
EXPORT_SYMBOL(warn_slowpath_fmt);

575 576 577
void warn_slowpath_fmt_taint(const char *file, int line,
			     unsigned taint, const char *fmt, ...)
{
578
	struct warn_args args;
579 580 581

	args.fmt = fmt;
	va_start(args.args, fmt);
582
	__warn(file, line, __builtin_return_address(0), taint, NULL, &args);
583 584 585 586
	va_end(args.args);
}
EXPORT_SYMBOL(warn_slowpath_fmt_taint);

587 588
void warn_slowpath_null(const char *file, int line)
{
589
	pr_warn(CUT_HERE);
590
	__warn(file, line, __builtin_return_address(0), TAINT_WARN, NULL, NULL);
591 592
}
EXPORT_SYMBOL(warn_slowpath_null);
593 594 595 596 597 598 599 600 601 602 603 604
#else
void __warn_printk(const char *fmt, ...)
{
	va_list args;

	pr_warn(CUT_HERE);

	va_start(args, fmt);
	vprintk(fmt, args);
	va_end(args);
}
EXPORT_SYMBOL(__warn_printk);
605 606
#endif

607 608 609 610 611 612
#ifdef CONFIG_BUG

/* Support resetting WARN*_ONCE state */

static int clear_warn_once_set(void *data, u64 val)
{
613
	generic_bug_clear_once();
614 615 616 617 618 619 620 621 622 623 624 625
	memset(__start_once, 0, __end_once - __start_once);
	return 0;
}

DEFINE_SIMPLE_ATTRIBUTE(clear_warn_once_fops,
			NULL,
			clear_warn_once_set,
			"%lld\n");

static __init int register_warn_debugfs(void)
{
	/* Don't care about failure */
626
	debugfs_create_file("clear_warn_once", 0200, NULL,
627 628 629 630 631 632 633
			    NULL, &clear_warn_once_fops);
	return 0;
}

device_initcall(register_warn_debugfs);
#endif

634
#ifdef CONFIG_STACKPROTECTOR
635

636 637 638 639
/*
 * Called when gcc's -fstack-protector feature is used, and
 * gcc detects corruption of the on-stack canary value
 */
640
__visible void __stack_chk_fail(void)
641
{
642
	panic("stack-protector: Kernel stack is corrupted in: %pB",
643
		__builtin_return_address(0));
644 645
}
EXPORT_SYMBOL(__stack_chk_fail);
646

647
#endif
648

649 650 651 652 653 654 655 656 657 658 659
#ifdef CONFIG_ARCH_HAS_REFCOUNT
void refcount_error_report(struct pt_regs *regs, const char *err)
{
	WARN_RATELIMIT(1, "refcount_t %s at %pB in %s[%d], uid/euid: %u/%u\n",
		err, (void *)instruction_pointer(regs),
		current->comm, task_pid_nr(current),
		from_kuid_munged(&init_user_ns, current_uid()),
		from_kuid_munged(&init_user_ns, current_euid()));
}
#endif

660 661
core_param(panic, panic_timeout, int, 0644);
core_param(pause_on_oops, pause_on_oops, int, 0644);
662
core_param(panic_on_warn, panic_on_warn, int, 0644);
663
core_param(crash_kexec_post_notifiers, crash_kexec_post_notifiers, bool, 0644);
664

665 666 667 668 669 670 671 672 673
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);