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