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