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/kallsyms.h> 14 #include <linux/notifier.h> 15 #include <linux/module.h> 16 #include <linux/random.h> 17 #include <linux/reboot.h> 18 #include <linux/delay.h> 19 #include <linux/kexec.h> 20 #include <linux/sched.h> 21 #include <linux/sysrq.h> 22 #include <linux/init.h> 23 #include <linux/nmi.h> 24 #include <linux/dmi.h> 25 26 int panic_on_oops; 27 static unsigned long tainted_mask; 28 static int pause_on_oops; 29 static int pause_on_oops_flag; 30 static DEFINE_SPINLOCK(pause_on_oops_lock); 31 32 int panic_timeout; 33 34 ATOMIC_NOTIFIER_HEAD(panic_notifier_list); 35 36 EXPORT_SYMBOL(panic_notifier_list); 37 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 */ 55 NORET_TYPE void panic(const char * fmt, ...) 56 { 57 static char buf[1024]; 58 va_list args; 59 long i; 60 61 /* 62 * It's possible to come here directly from a panic-assertion and 63 * not have preempt disabled. Some functions called from here want 64 * preempt to be disabled. No point enabling it later though... 65 */ 66 preempt_disable(); 67 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); 73 #ifdef CONFIG_DEBUG_BUGVERBOSE 74 dump_stack(); 75 #endif 76 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 */ 82 crash_kexec(NULL); 83 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 */ 89 smp_send_stop(); 90 91 atomic_notifier_call_chain(&panic_notifier_list, 0, buf); 92 93 bust_spinlocks(0); 94 95 if (!panic_blink) 96 panic_blink = no_blink; 97 98 if (panic_timeout > 0) { 99 /* 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 105 for (i = 0; i < panic_timeout*1000; ) { 106 touch_nmi_watchdog(); 107 i += panic_blink(i); 108 mdelay(1); 109 i++; 110 } 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. 115 */ 116 emergency_restart(); 117 } 118 #ifdef __sparc__ 119 { 120 extern int stop_a_enabled; 121 /* Make sure the user can actually press Stop-A (L1-A) */ 122 stop_a_enabled = 1; 123 printk(KERN_EMERG "Press Stop-A (L1-A) to return to the boot prom\n"); 124 } 125 #endif 126 #if defined(CONFIG_S390) 127 { 128 unsigned long caller; 129 130 caller = (unsigned long)__builtin_return_address(0); 131 disabled_wait(caller); 132 } 133 #endif 134 local_irq_enable(); 135 for (i = 0; ; ) { 136 touch_softlockup_watchdog(); 137 i += panic_blink(i); 138 mdelay(1); 139 i++; 140 } 141 } 142 143 EXPORT_SYMBOL(panic); 144 145 146 struct tnt { 147 u8 bit; 148 char true; 149 char false; 150 }; 151 152 static const struct tnt tnts[] = { 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', ' ' }, 164 }; 165 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. 173 * 'M' - System experienced a machine check exception. 174 * 'B' - System has hit bad_page. 175 * 'U' - Userspace-defined naughtiness. 176 * 'D' - Kernel has oopsed before 177 * 'A' - ACPI table overridden. 178 * 'W' - Taint on warning. 179 * 'C' - modules from drivers/staging are loaded. 180 * 181 * The string is overwritten by the next call to print_tainted(). 182 */ 183 const char *print_tainted(void) 184 { 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 199 snprintf(buf, sizeof(buf), "Not tainted"); 200 201 return buf; 202 } 203 204 int test_taint(unsigned flag) 205 { 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; 213 } 214 215 void add_taint(unsigned flag) 216 { 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 221 * Also we want to keep up lockdep for staging development and 222 * post-warning case. 223 */ 224 if (flag != TAINT_CRAP && flag != TAINT_WARN && __debug_locks_off()) 225 printk(KERN_WARNING "Disabling lock debugging due to kernel taint\n"); 226 227 set_bit(flag, &tainted_mask); 228 } 229 EXPORT_SYMBOL(add_taint); 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 /* 281 * Return true if the calling CPU is allowed to print oops-related info. 282 * This is a bit racy.. 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 291 * anything. If this is the first CPU to oops, and it's oopsing the first 292 * time then let it proceed. 293 * 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. 298 * 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(). 302 */ 303 void oops_enter(void) 304 { 305 tracing_off(); 306 /* can't trust the integrity of the kernel anymore: */ 307 debug_locks_off(); 308 do_oops_enter_exit(); 309 } 310 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)); 320 else 321 oops_id++; 322 323 return 0; 324 } 325 late_initcall(init_oops_id); 326 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 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(); 341 print_oops_end_marker(); 342 } 343 344 #ifdef WANT_WARN_ON_SLOWPATH 345 struct slowpath_args { 346 const char *fmt; 347 va_list args; 348 }; 349 350 static void warn_slowpath_common(const char *file, int line, void *caller, struct slowpath_args *args) 351 { 352 const char *board; 353 354 printk(KERN_WARNING "------------[ cut here ]------------\n"); 355 printk(KERN_WARNING "WARNING: at %s:%d %pS()\n", file, line, caller); 356 board = dmi_get_system_info(DMI_PRODUCT_NAME); 357 if (board) 358 printk(KERN_WARNING "Hardware name: %s\n", board); 359 360 if (args) 361 vprintk(args->fmt, args->args); 362 363 print_modules(); 364 dump_stack(); 365 print_oops_end_marker(); 366 add_taint(TAINT_WARN); 367 } 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 } 378 EXPORT_SYMBOL(warn_slowpath_fmt); 379 380 void warn_slowpath_null(const char *file, int line) 381 { 382 warn_slowpath_common(file, line, __builtin_return_address(0), NULL); 383 } 384 EXPORT_SYMBOL(warn_slowpath_null); 385 #endif 386 387 #ifdef CONFIG_CC_STACKPROTECTOR 388 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 { 395 panic("stack-protector: Kernel stack is corrupted in: %p\n", 396 __builtin_return_address(0)); 397 } 398 EXPORT_SYMBOL(__stack_chk_fail); 399 400 #endif 401 402 core_param(panic, panic_timeout, int, 0644); 403 core_param(pause_on_oops, pause_on_oops, int, 0644); 404