1 /* 2 * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "code/codeCache.hpp" 27 #include "compiler/compileBroker.hpp" 28 #include "compiler/disassembler.hpp" 29 #include "gc/shared/collectedHeap.hpp" 30 #include "logging/logConfiguration.hpp" 31 #include "prims/jvm.h" 32 #include "prims/whitebox.hpp" 33 #include "runtime/arguments.hpp" 34 #include "runtime/atomic.hpp" 35 #include "runtime/frame.inline.hpp" 36 #include "runtime/init.hpp" 37 #include "runtime/os.hpp" 38 #include "runtime/thread.inline.hpp" 39 #include "runtime/vmThread.hpp" 40 #include "runtime/vm_operations.hpp" 41 #include "runtime/vm_version.hpp" 42 #include "services/memTracker.hpp" 43 #include "trace/traceMacros.hpp" 44 #include "utilities/debug.hpp" 45 #include "utilities/decoder.hpp" 46 #include "utilities/defaultStream.hpp" 47 #include "utilities/errorReporter.hpp" 48 #include "utilities/events.hpp" 49 #include "utilities/vmError.hpp" 50 51 #ifndef PRODUCT 52 #include <signal.h> 53 #endif // PRODUCT 54 55 bool VMError::_error_reported = false; 56 57 // call this when the VM is dying--it might loosen some asserts 58 bool VMError::is_error_reported() { return _error_reported; } 59 60 // returns an address which is guaranteed to generate a SIGSEGV on read, 61 // for test purposes, which is not NULL and contains bits in every word 62 void* VMError::get_segfault_address() { 63 return (void*) 64 #ifdef _LP64 65 0xABC0000000000ABCULL; 66 #else 67 0x00000ABC; 68 #endif 69 } 70 71 // List of environment variables that should be reported in error log file. 72 const char *env_list[] = { 73 // All platforms 74 "JAVA_HOME", "JRE_HOME", "JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "CLASSPATH", 75 "JAVA_COMPILER", "PATH", "USERNAME", 76 77 // Env variables that are defined on Solaris/Linux/BSD 78 "LD_LIBRARY_PATH", "LD_PRELOAD", "SHELL", "DISPLAY", 79 "HOSTTYPE", "OSTYPE", "ARCH", "MACHTYPE", 80 81 // defined on Linux 82 "LD_ASSUME_KERNEL", "_JAVA_SR_SIGNUM", 83 84 // defined on Darwin 85 "DYLD_LIBRARY_PATH", "DYLD_FALLBACK_LIBRARY_PATH", 86 "DYLD_FRAMEWORK_PATH", "DYLD_FALLBACK_FRAMEWORK_PATH", 87 "DYLD_INSERT_LIBRARIES", 88 89 // defined on Windows 90 "OS", "PROCESSOR_IDENTIFIER", "_ALT_JAVA_HOME_DIR", 91 92 (const char *)0 93 }; 94 95 // A simple parser for -XX:OnError, usage: 96 // ptr = OnError; 97 // while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr) != NULL) 98 // ... ... 99 static char* next_OnError_command(char* buf, int buflen, const char** ptr) { 100 if (ptr == NULL || *ptr == NULL) return NULL; 101 102 const char* cmd = *ptr; 103 104 // skip leading blanks or ';' 105 while (*cmd == ' ' || *cmd == ';') cmd++; 106 107 if (*cmd == '\0') return NULL; 108 109 const char * cmdend = cmd; 110 while (*cmdend != '\0' && *cmdend != ';') cmdend++; 111 112 Arguments::copy_expand_pid(cmd, cmdend - cmd, buf, buflen); 113 114 *ptr = (*cmdend == '\0' ? cmdend : cmdend + 1); 115 return buf; 116 } 117 118 static void print_bug_submit_message(outputStream *out, Thread *thread) { 119 if (out == NULL) return; 120 out->print_raw_cr("# If you would like to submit a bug report, please visit:"); 121 out->print_raw ("# "); 122 out->print_raw_cr(Arguments::java_vendor_url_bug()); 123 // If the crash is in native code, encourage user to submit a bug to the 124 // provider of that code. 125 if (thread && thread->is_Java_thread() && 126 !thread->is_hidden_from_external_view()) { 127 JavaThread* jt = (JavaThread*)thread; 128 if (jt->thread_state() == _thread_in_native) { 129 out->print_cr("# The crash happened outside the Java Virtual Machine in native code.\n# See problematic frame for where to report the bug."); 130 } 131 } 132 out->print_raw_cr("#"); 133 } 134 135 bool VMError::coredump_status; 136 char VMError::coredump_message[O_BUFLEN]; 137 138 void VMError::record_coredump_status(const char* message, bool status) { 139 coredump_status = status; 140 strncpy(coredump_message, message, sizeof(coredump_message)); 141 coredump_message[sizeof(coredump_message)-1] = 0; 142 } 143 144 // Return a string to describe the error 145 char* VMError::error_string(char* buf, int buflen) { 146 char signame_buf[64]; 147 const char *signame = os::exception_name(_id, signame_buf, sizeof(signame_buf)); 148 149 if (signame) { 150 jio_snprintf(buf, buflen, 151 "%s (0x%x) at pc=" PTR_FORMAT ", pid=%d, tid=" UINTX_FORMAT, 152 signame, _id, _pc, 153 os::current_process_id(), os::current_thread_id()); 154 } else if (_filename != NULL && _lineno > 0) { 155 // skip directory names 156 char separator = os::file_separator()[0]; 157 const char *p = strrchr(_filename, separator); 158 int n = jio_snprintf(buf, buflen, 159 "Internal Error at %s:%d, pid=%d, tid=" UINTX_FORMAT, 160 p ? p + 1 : _filename, _lineno, 161 os::current_process_id(), os::current_thread_id()); 162 if (n >= 0 && n < buflen && _message) { 163 if (strlen(_detail_msg) > 0) { 164 jio_snprintf(buf + n, buflen - n, "%s%s: %s", 165 os::line_separator(), _message, _detail_msg); 166 } else { 167 jio_snprintf(buf + n, buflen - n, "%sError: %s", 168 os::line_separator(), _message); 169 } 170 } 171 } else { 172 jio_snprintf(buf, buflen, 173 "Internal Error (0x%x), pid=%d, tid=" UINTX_FORMAT, 174 _id, os::current_process_id(), os::current_thread_id()); 175 } 176 177 return buf; 178 } 179 180 void VMError::print_stack_trace(outputStream* st, JavaThread* jt, 181 char* buf, int buflen, bool verbose) { 182 #ifdef ZERO 183 if (jt->zero_stack()->sp() && jt->top_zero_frame()) { 184 // StackFrameStream uses the frame anchor, which may not have 185 // been set up. This can be done at any time in Zero, however, 186 // so if it hasn't been set up then we just set it up now and 187 // clear it again when we're done. 188 bool has_last_Java_frame = jt->has_last_Java_frame(); 189 if (!has_last_Java_frame) 190 jt->set_last_Java_frame(); 191 st->print("Java frames:"); 192 193 // If the top frame is a Shark frame and the frame anchor isn't 194 // set up then it's possible that the information in the frame 195 // is garbage: it could be from a previous decache, or it could 196 // simply have never been written. So we print a warning... 197 StackFrameStream sfs(jt); 198 if (!has_last_Java_frame && !sfs.is_done()) { 199 if (sfs.current()->zeroframe()->is_shark_frame()) { 200 st->print(" (TOP FRAME MAY BE JUNK)"); 201 } 202 } 203 st->cr(); 204 205 // Print the frames 206 for(int i = 0; !sfs.is_done(); sfs.next(), i++) { 207 sfs.current()->zero_print_on_error(i, st, buf, buflen); 208 st->cr(); 209 } 210 211 // Reset the frame anchor if necessary 212 if (!has_last_Java_frame) 213 jt->reset_last_Java_frame(); 214 } 215 #else 216 if (jt->has_last_Java_frame()) { 217 st->print_cr("Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)"); 218 for(StackFrameStream sfs(jt); !sfs.is_done(); sfs.next()) { 219 sfs.current()->print_on_error(st, buf, buflen, verbose); 220 st->cr(); 221 } 222 } 223 #endif // ZERO 224 } 225 226 void VMError::print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) { 227 228 // see if it's a valid frame 229 if (fr.pc()) { 230 st->print_cr("Native frames: (J=compiled Java code, A=aot compiled Java code, j=interpreted, Vv=VM code, C=native code)"); 231 232 int count = 0; 233 while (count++ < StackPrintLimit) { 234 fr.print_on_error(st, buf, buf_size); 235 st->cr(); 236 // Compiled code may use EBP register on x86 so it looks like 237 // non-walkable C frame. Use frame.sender() for java frames. 238 if (t && t->is_Java_thread()) { 239 // Catch very first native frame by using stack address. 240 // For JavaThread stack_base and stack_size should be set. 241 if (!t->on_local_stack((address)(fr.real_fp() + 1))) { 242 break; 243 } 244 if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) { 245 RegisterMap map((JavaThread*)t, false); // No update 246 fr = fr.sender(&map); 247 } else { 248 fr = os::get_sender_for_C_frame(&fr); 249 } 250 } else { 251 // is_first_C_frame() does only simple checks for frame pointer, 252 // it will pass if java compiled code has a pointer in EBP. 253 if (os::is_first_C_frame(&fr)) break; 254 fr = os::get_sender_for_C_frame(&fr); 255 } 256 } 257 258 if (count > StackPrintLimit) { 259 st->print_cr("...<more frames>..."); 260 } 261 262 st->cr(); 263 } 264 } 265 266 static void print_oom_reasons(outputStream* st) { 267 st->print_cr("# Possible reasons:"); 268 st->print_cr("# The system is out of physical RAM or swap space"); 269 if (UseCompressedOops) { 270 st->print_cr("# The process is running with CompressedOops enabled, and the Java Heap may be blocking the growth of the native heap"); 271 } 272 if (LogBytesPerWord == 2) { 273 st->print_cr("# In 32 bit mode, the process size limit was hit"); 274 } 275 st->print_cr("# Possible solutions:"); 276 st->print_cr("# Reduce memory load on the system"); 277 st->print_cr("# Increase physical memory or swap space"); 278 st->print_cr("# Check if swap backing store is full"); 279 if (LogBytesPerWord == 2) { 280 st->print_cr("# Use 64 bit Java on a 64 bit OS"); 281 } 282 st->print_cr("# Decrease Java heap size (-Xmx/-Xms)"); 283 st->print_cr("# Decrease number of Java threads"); 284 st->print_cr("# Decrease Java thread stack sizes (-Xss)"); 285 st->print_cr("# Set larger code cache with -XX:ReservedCodeCacheSize="); 286 if (UseCompressedOops) { 287 switch (Universe::narrow_oop_mode()) { 288 case Universe::UnscaledNarrowOop: 289 st->print_cr("# JVM is running with Unscaled Compressed Oops mode in which the Java heap is"); 290 st->print_cr("# placed in the first 4GB address space. The Java Heap base address is the"); 291 st->print_cr("# maximum limit for the native heap growth. Please use -XX:HeapBaseMinAddress"); 292 st->print_cr("# to set the Java Heap base and to place the Java Heap above 4GB virtual address."); 293 break; 294 case Universe::ZeroBasedNarrowOop: 295 st->print_cr("# JVM is running with Zero Based Compressed Oops mode in which the Java heap is"); 296 st->print_cr("# placed in the first 32GB address space. The Java Heap base address is the"); 297 st->print_cr("# maximum limit for the native heap growth. Please use -XX:HeapBaseMinAddress"); 298 st->print_cr("# to set the Java Heap base and to place the Java Heap above 32GB virtual address."); 299 break; 300 default: 301 break; 302 } 303 } 304 st->print_cr("# This output file may be truncated or incomplete."); 305 } 306 307 static const char* gc_mode() { 308 if (UseG1GC) return "g1 gc"; 309 if (UseParallelGC) return "parallel gc"; 310 if (UseConcMarkSweepGC) return "concurrent mark sweep gc"; 311 if (UseSerialGC) return "serial gc"; 312 return "ERROR in GC mode"; 313 } 314 315 static void report_vm_version(outputStream* st, char* buf, int buflen) { 316 // VM version 317 st->print_cr("#"); 318 JDK_Version::current().to_string(buf, buflen); 319 const char* runtime_name = JDK_Version::runtime_name() != NULL ? 320 JDK_Version::runtime_name() : ""; 321 const char* runtime_version = JDK_Version::runtime_version() != NULL ? 322 JDK_Version::runtime_version() : ""; 323 const char* jdk_debug_level = Abstract_VM_Version::printable_jdk_debug_level() != NULL ? 324 Abstract_VM_Version::printable_jdk_debug_level() : ""; 325 326 st->print_cr("# JRE version: %s (%s) (%sbuild %s)", runtime_name, buf, 327 jdk_debug_level, runtime_version); 328 329 // This is the long version with some default settings added 330 st->print_cr("# Java VM: %s (%s%s, %s%s%s%s%s, %s, %s)", 331 Abstract_VM_Version::vm_name(), 332 jdk_debug_level, 333 Abstract_VM_Version::vm_release(), 334 Abstract_VM_Version::vm_info_string(), 335 TieredCompilation ? ", tiered" : "", 336 #if INCLUDE_JVMCI 337 EnableJVMCI ? ", jvmci" : "", 338 UseJVMCICompiler ? ", jvmci compiler" : "", 339 #else 340 "", "", 341 #endif 342 UseCompressedOops ? ", compressed oops" : "", 343 gc_mode(), 344 Abstract_VM_Version::vm_platform_string() 345 ); 346 } 347 348 // This is the main function to report a fatal error. Only one thread can 349 // call this function, so we don't need to worry about MT-safety. But it's 350 // possible that the error handler itself may crash or die on an internal 351 // error, for example, when the stack/heap is badly damaged. We must be 352 // able to handle recursive errors that happen inside error handler. 353 // 354 // Error reporting is done in several steps. If a crash or internal error 355 // occurred when reporting an error, the nested signal/exception handler 356 // can skip steps that are already (or partially) done. Error reporting will 357 // continue from the next step. This allows us to retrieve and print 358 // information that may be unsafe to get after a fatal error. If it happens, 359 // you may find nested report_and_die() frames when you look at the stack 360 // in a debugger. 361 // 362 // In general, a hang in error handler is much worse than a crash or internal 363 // error, as it's harder to recover from a hang. Deadlock can happen if we 364 // try to grab a lock that is already owned by current thread, or if the 365 // owner is blocked forever (e.g. in os::infinite_sleep()). If possible, the 366 // error handler and all the functions it called should avoid grabbing any 367 // lock. An important thing to notice is that memory allocation needs a lock. 368 // 369 // We should avoid using large stack allocated buffers. Many errors happen 370 // when stack space is already low. Making things even worse is that there 371 // could be nested report_and_die() calls on stack (see above). Only one 372 // thread can report error, so large buffers are statically allocated in data 373 // segment. 374 375 int VMError::_current_step; 376 const char* VMError::_current_step_info; 377 378 volatile jlong VMError::_reporting_start_time = -1; 379 volatile bool VMError::_reporting_did_timeout = false; 380 volatile jlong VMError::_step_start_time = -1; 381 volatile bool VMError::_step_did_timeout = false; 382 383 // Helper, return current timestamp for timeout handling. 384 jlong VMError::get_current_timestamp() { 385 return os::javaTimeNanos(); 386 } 387 // Factor to translate the timestamp to seconds. 388 #define TIMESTAMP_TO_SECONDS_FACTOR (1000 * 1000 * 1000) 389 390 void VMError::record_reporting_start_time() { 391 const jlong now = get_current_timestamp(); 392 Atomic::store(now, &_reporting_start_time); 393 } 394 395 jlong VMError::get_reporting_start_time() { 396 return Atomic::load(&_reporting_start_time); 397 } 398 399 void VMError::record_step_start_time() { 400 const jlong now = get_current_timestamp(); 401 Atomic::store(now, &_step_start_time); 402 } 403 404 jlong VMError::get_step_start_time() { 405 return Atomic::load(&_step_start_time); 406 } 407 408 void VMError::report(outputStream* st, bool _verbose) { 409 410 # define BEGIN if (_current_step == 0) { _current_step = __LINE__; 411 # define STEP(s) } if (_current_step < __LINE__) { _current_step = __LINE__; _current_step_info = s; \ 412 record_step_start_time(); _step_did_timeout = false; 413 # define END } 414 415 // don't allocate large buffer on stack 416 static char buf[O_BUFLEN]; 417 418 BEGIN 419 420 STEP("printing fatal error message") 421 422 st->print_cr("#"); 423 if (should_report_bug(_id)) { 424 st->print_cr("# A fatal error has been detected by the Java Runtime Environment:"); 425 } else { 426 st->print_cr("# There is insufficient memory for the Java " 427 "Runtime Environment to continue."); 428 } 429 430 #ifndef PRODUCT 431 // Error handler self tests 432 433 // test secondary error handling. Test it twice, to test that resetting 434 // error handler after a secondary crash works. 435 STEP("test secondary crash 1") 436 if (_verbose && TestCrashInErrorHandler != 0) { 437 st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...", 438 TestCrashInErrorHandler); 439 controlled_crash(TestCrashInErrorHandler); 440 } 441 442 STEP("test secondary crash 2") 443 if (_verbose && TestCrashInErrorHandler != 0) { 444 st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...", 445 TestCrashInErrorHandler); 446 controlled_crash(TestCrashInErrorHandler); 447 } 448 449 // TestUnresponsiveErrorHandler: We want to test both step timeouts and global timeout. 450 // Step to global timeout ratio is 4:1, so in order to be absolutely sure we hit the 451 // global timeout, let's execute the timeout step five times. 452 // See corresponding test in test/runtime/ErrorHandling/TimeoutInErrorHandlingTest.java 453 #define TIMEOUT_TEST_STEP STEP("test unresponsive error reporting step") \ 454 if (_verbose && TestUnresponsiveErrorHandler) { os::infinite_sleep(); } 455 TIMEOUT_TEST_STEP 456 TIMEOUT_TEST_STEP 457 TIMEOUT_TEST_STEP 458 TIMEOUT_TEST_STEP 459 TIMEOUT_TEST_STEP 460 461 STEP("test safefetch in error handler") 462 // test whether it is safe to use SafeFetch32 in Crash Handler. Test twice 463 // to test that resetting the signal handler works correctly. 464 if (_verbose && TestSafeFetchInErrorHandler) { 465 st->print_cr("Will test SafeFetch..."); 466 if (CanUseSafeFetch32()) { 467 int* const invalid_pointer = (int*) get_segfault_address(); 468 const int x = 0x76543210; 469 int i1 = SafeFetch32(invalid_pointer, x); 470 int i2 = SafeFetch32(invalid_pointer, x); 471 if (i1 == x && i2 == x) { 472 st->print_cr("SafeFetch OK."); // Correctly deflected and returned default pattern 473 } else { 474 st->print_cr("??"); 475 } 476 } else { 477 st->print_cr("not possible; skipped."); 478 } 479 } 480 #endif // PRODUCT 481 482 STEP("printing type of error") 483 484 switch(_id) { 485 case OOM_MALLOC_ERROR: 486 case OOM_MMAP_ERROR: 487 if (_size) { 488 st->print("# Native memory allocation "); 489 st->print((_id == (int)OOM_MALLOC_ERROR) ? "(malloc) failed to allocate " : 490 "(mmap) failed to map "); 491 jio_snprintf(buf, sizeof(buf), SIZE_FORMAT, _size); 492 st->print("%s", buf); 493 st->print(" bytes"); 494 if (strlen(_detail_msg) > 0) { 495 st->print(" for "); 496 st->print("%s", _detail_msg); 497 } 498 st->cr(); 499 } else { 500 if (strlen(_detail_msg) > 0) { 501 st->print("# "); 502 st->print_cr("%s", _detail_msg); 503 } 504 } 505 // In error file give some solutions 506 if (_verbose) { 507 print_oom_reasons(st); 508 } else { 509 return; // that's enough for the screen 510 } 511 break; 512 case INTERNAL_ERROR: 513 default: 514 break; 515 } 516 517 STEP("printing exception/signal name") 518 519 st->print_cr("#"); 520 st->print("# "); 521 // Is it an OS exception/signal? 522 if (os::exception_name(_id, buf, sizeof(buf))) { 523 st->print("%s", buf); 524 st->print(" (0x%x)", _id); // signal number 525 st->print(" at pc=" PTR_FORMAT, p2i(_pc)); 526 } else { 527 if (should_report_bug(_id)) { 528 st->print("Internal Error"); 529 } else { 530 st->print("Out of Memory Error"); 531 } 532 if (_filename != NULL && _lineno > 0) { 533 #ifdef PRODUCT 534 // In product mode chop off pathname? 535 char separator = os::file_separator()[0]; 536 const char *p = strrchr(_filename, separator); 537 const char *file = p ? p+1 : _filename; 538 #else 539 const char *file = _filename; 540 #endif 541 st->print(" (%s:%d)", file, _lineno); 542 } else { 543 st->print(" (0x%x)", _id); 544 } 545 } 546 547 STEP("printing current thread and pid") 548 549 // process id, thread id 550 st->print(", pid=%d", os::current_process_id()); 551 st->print(", tid=" UINTX_FORMAT, os::current_thread_id()); 552 st->cr(); 553 554 STEP("printing error message") 555 556 if (should_report_bug(_id)) { // already printed the message. 557 // error message 558 if (strlen(_detail_msg) > 0) { 559 st->print_cr("# %s: %s", _message ? _message : "Error", _detail_msg); 560 } else if (_message) { 561 st->print_cr("# Error: %s", _message); 562 } 563 } 564 565 STEP("printing Java version string") 566 567 report_vm_version(st, buf, sizeof(buf)); 568 569 STEP("printing problematic frame") 570 571 // Print current frame if we have a context (i.e. it's a crash) 572 if (_context) { 573 st->print_cr("# Problematic frame:"); 574 st->print("# "); 575 frame fr = os::fetch_frame_from_context(_context); 576 fr.print_on_error(st, buf, sizeof(buf)); 577 st->cr(); 578 st->print_cr("#"); 579 } 580 581 STEP("printing core file information") 582 st->print("# "); 583 if (CreateCoredumpOnCrash) { 584 if (coredump_status) { 585 st->print("Core dump will be written. Default location: %s", coredump_message); 586 } else { 587 st->print("No core dump will be written. %s", coredump_message); 588 } 589 } else { 590 st->print("CreateCoredumpOnCrash turned off, no core file dumped"); 591 } 592 st->cr(); 593 st->print_cr("#"); 594 595 STEP("printing bug submit message") 596 597 if (should_report_bug(_id) && _verbose) { 598 print_bug_submit_message(st, _thread); 599 } 600 601 STEP("printing summary") 602 603 if (_verbose) { 604 st->cr(); 605 st->print_cr("--------------- S U M M A R Y ------------"); 606 st->cr(); 607 } 608 609 STEP("printing VM option summary") 610 611 if (_verbose) { 612 // VM options 613 Arguments::print_summary_on(st); 614 st->cr(); 615 } 616 617 STEP("printing summary machine and OS info") 618 619 if (_verbose) { 620 os::print_summary_info(st, buf, sizeof(buf)); 621 } 622 623 624 STEP("printing date and time") 625 626 if (_verbose) { 627 os::print_date_and_time(st, buf, sizeof(buf)); 628 } 629 630 STEP("printing thread") 631 632 if (_verbose) { 633 st->cr(); 634 st->print_cr("--------------- T H R E A D ---------------"); 635 st->cr(); 636 } 637 638 STEP("printing current thread") 639 640 // current thread 641 if (_verbose) { 642 if (_thread) { 643 st->print("Current thread (" PTR_FORMAT "): ", p2i(_thread)); 644 _thread->print_on_error(st, buf, sizeof(buf)); 645 st->cr(); 646 } else { 647 st->print_cr("Current thread is native thread"); 648 } 649 st->cr(); 650 } 651 652 STEP("printing current compile task") 653 654 if (_verbose && _thread && _thread->is_Compiler_thread()) { 655 CompilerThread* t = (CompilerThread*)_thread; 656 if (t->task()) { 657 st->cr(); 658 st->print_cr("Current CompileTask:"); 659 t->task()->print_line_on_error(st, buf, sizeof(buf)); 660 st->cr(); 661 } 662 } 663 664 665 STEP("printing stack bounds") 666 667 if (_verbose) { 668 st->print("Stack: "); 669 670 address stack_top; 671 size_t stack_size; 672 673 if (_thread) { 674 stack_top = _thread->stack_base(); 675 stack_size = _thread->stack_size(); 676 } else { 677 stack_top = os::current_stack_base(); 678 stack_size = os::current_stack_size(); 679 } 680 681 address stack_bottom = stack_top - stack_size; 682 st->print("[" PTR_FORMAT "," PTR_FORMAT "]", p2i(stack_bottom), p2i(stack_top)); 683 684 frame fr = _context ? os::fetch_frame_from_context(_context) 685 : os::current_frame(); 686 687 if (fr.sp()) { 688 st->print(", sp=" PTR_FORMAT, p2i(fr.sp())); 689 size_t free_stack_size = pointer_delta(fr.sp(), stack_bottom, 1024); 690 st->print(", free space=" SIZE_FORMAT "k", free_stack_size); 691 } 692 693 st->cr(); 694 } 695 696 STEP("printing native stack") 697 698 if (_verbose) { 699 if (os::platform_print_native_stack(st, _context, buf, sizeof(buf))) { 700 // We have printed the native stack in platform-specific code 701 // Windows/x64 needs special handling. 702 } else { 703 frame fr = _context ? os::fetch_frame_from_context(_context) 704 : os::current_frame(); 705 706 print_native_stack(st, fr, _thread, buf, sizeof(buf)); 707 } 708 } 709 710 STEP("printing Java stack") 711 712 if (_verbose && _thread && _thread->is_Java_thread()) { 713 print_stack_trace(st, (JavaThread*)_thread, buf, sizeof(buf)); 714 } 715 716 STEP("printing target Java thread stack") 717 718 // printing Java thread stack trace if it is involved in GC crash 719 if (_verbose && _thread && (_thread->is_Named_thread())) { 720 JavaThread* jt = ((NamedThread *)_thread)->processed_thread(); 721 if (jt != NULL) { 722 st->print_cr("JavaThread " PTR_FORMAT " (nid = %d) was being processed", p2i(jt), jt->osthread()->thread_id()); 723 print_stack_trace(st, jt, buf, sizeof(buf), true); 724 } 725 } 726 727 STEP("printing siginfo") 728 729 // signal no, signal code, address that caused the fault 730 if (_verbose && _siginfo) { 731 st->cr(); 732 os::print_siginfo(st, _siginfo); 733 st->cr(); 734 } 735 736 STEP("CDS archive access warning") 737 738 // Print an explicit hint if we crashed on access to the CDS archive. 739 if (_verbose && _siginfo) { 740 check_failing_cds_access(st, _siginfo); 741 st->cr(); 742 } 743 744 STEP("printing register info") 745 746 // decode register contents if possible 747 if (_verbose && _context && Universe::is_fully_initialized()) { 748 os::print_register_info(st, _context); 749 st->cr(); 750 } 751 752 STEP("printing registers, top of stack, instructions near pc") 753 754 // registers, top of stack, instructions near pc 755 if (_verbose && _context) { 756 os::print_context(st, _context); 757 st->cr(); 758 } 759 760 STEP("printing code blob if possible") 761 762 if (_verbose && _context) { 763 CodeBlob* cb = CodeCache::find_blob(_pc); 764 if (cb != NULL) { 765 if (Interpreter::contains(_pc)) { 766 // The interpreter CodeBlob is very large so try to print the codelet instead. 767 InterpreterCodelet* codelet = Interpreter::codelet_containing(_pc); 768 if (codelet != NULL) { 769 codelet->print_on(st); 770 Disassembler::decode(codelet->code_begin(), codelet->code_end(), st); 771 } 772 } else { 773 StubCodeDesc* desc = StubCodeDesc::desc_for(_pc); 774 if (desc != NULL) { 775 desc->print_on(st); 776 Disassembler::decode(desc->begin(), desc->end(), st); 777 } else { 778 Disassembler::decode(cb, st); 779 st->cr(); 780 } 781 } 782 } 783 } 784 785 STEP("printing VM operation") 786 787 if (_verbose && _thread && _thread->is_VM_thread()) { 788 VMThread* t = (VMThread*)_thread; 789 VM_Operation* op = t->vm_operation(); 790 if (op) { 791 op->print_on_error(st); 792 st->cr(); 793 st->cr(); 794 } 795 } 796 797 STEP("printing process") 798 799 if (_verbose) { 800 st->cr(); 801 st->print_cr("--------------- P R O C E S S ---------------"); 802 st->cr(); 803 } 804 805 STEP("printing all threads") 806 807 // all threads 808 if (_verbose && _thread) { 809 Threads::print_on_error(st, _thread, buf, sizeof(buf)); 810 st->cr(); 811 } 812 813 STEP("printing VM state") 814 815 if (_verbose) { 816 // Safepoint state 817 st->print("VM state:"); 818 819 if (SafepointSynchronize::is_synchronizing()) st->print("synchronizing"); 820 else if (SafepointSynchronize::is_at_safepoint()) st->print("at safepoint"); 821 else st->print("not at safepoint"); 822 823 // Also see if error occurred during initialization or shutdown 824 if (!Universe::is_fully_initialized()) { 825 st->print(" (not fully initialized)"); 826 } else if (VM_Exit::vm_exited()) { 827 st->print(" (shutting down)"); 828 } else { 829 st->print(" (normal execution)"); 830 } 831 st->cr(); 832 st->cr(); 833 } 834 835 STEP("printing owned locks on error") 836 837 // mutexes/monitors that currently have an owner 838 if (_verbose) { 839 print_owned_locks_on_error(st); 840 st->cr(); 841 } 842 843 STEP("printing number of OutOfMemoryError and StackOverflow exceptions") 844 845 if (_verbose && Exceptions::has_exception_counts()) { 846 st->print_cr("OutOfMemory and StackOverflow Exception counts:"); 847 Exceptions::print_exception_counts_on_error(st); 848 st->cr(); 849 } 850 851 STEP("printing compressed oops mode") 852 853 if (_verbose && UseCompressedOops) { 854 Universe::print_compressed_oops_mode(st); 855 if (UseCompressedClassPointers) { 856 Metaspace::print_compressed_class_space(st); 857 } 858 st->cr(); 859 } 860 861 STEP("printing heap information") 862 863 if (_verbose && Universe::is_fully_initialized()) { 864 Universe::heap()->print_on_error(st); 865 st->cr(); 866 st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page())); 867 st->cr(); 868 } 869 870 STEP("printing code cache information") 871 872 if (_verbose && Universe::is_fully_initialized()) { 873 // print code cache information before vm abort 874 CodeCache::print_summary(st); 875 st->cr(); 876 } 877 878 STEP("printing ring buffers") 879 880 if (_verbose) { 881 Events::print_all(st); 882 st->cr(); 883 } 884 885 STEP("printing dynamic libraries") 886 887 if (_verbose) { 888 // dynamic libraries, or memory map 889 os::print_dll_info(st); 890 st->cr(); 891 } 892 893 STEP("printing native decoder state") 894 895 if (_verbose) { 896 Decoder::print_state_on(st); 897 st->cr(); 898 } 899 900 STEP("printing VM options") 901 902 if (_verbose) { 903 // VM options 904 Arguments::print_on(st); 905 st->cr(); 906 } 907 908 STEP("printing warning if internal testing API used") 909 910 if (WhiteBox::used()) { 911 st->print_cr("Unsupported internal testing APIs have been used."); 912 st->cr(); 913 } 914 915 STEP("printing log configuration") 916 if (_verbose){ 917 st->print_cr("Logging:"); 918 LogConfiguration::describe_current_configuration(st); 919 st->cr(); 920 } 921 922 STEP("printing all environment variables") 923 924 if (_verbose) { 925 os::print_environment_variables(st, env_list); 926 st->cr(); 927 } 928 929 STEP("printing signal handlers") 930 931 if (_verbose) { 932 os::print_signal_handlers(st, buf, sizeof(buf)); 933 st->cr(); 934 } 935 936 STEP("Native Memory Tracking") 937 if (_verbose) { 938 MemTracker::error_report(st); 939 } 940 941 STEP("printing system") 942 943 if (_verbose) { 944 st->cr(); 945 st->print_cr("--------------- S Y S T E M ---------------"); 946 st->cr(); 947 } 948 949 STEP("printing OS information") 950 951 if (_verbose) { 952 os::print_os_info(st); 953 st->cr(); 954 } 955 956 STEP("printing CPU info") 957 if (_verbose) { 958 os::print_cpu_info(st, buf, sizeof(buf)); 959 st->cr(); 960 } 961 962 STEP("printing memory info") 963 964 if (_verbose) { 965 os::print_memory_info(st); 966 st->cr(); 967 } 968 969 STEP("printing internal vm info") 970 971 if (_verbose) { 972 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); 973 st->cr(); 974 } 975 976 // print a defined marker to show that error handling finished correctly. 977 STEP("printing end marker") 978 979 if (_verbose) { 980 st->print_cr("END."); 981 } 982 983 END 984 985 # undef BEGIN 986 # undef STEP 987 # undef END 988 } 989 990 // Report for the vm_info_cmd. This prints out the information above omitting 991 // crash and thread specific information. If output is added above, it should be added 992 // here also, if it is safe to call during a running process. 993 void VMError::print_vm_info(outputStream* st) { 994 995 char buf[O_BUFLEN]; 996 report_vm_version(st, buf, sizeof(buf)); 997 998 // STEP("printing summary") 999 1000 st->cr(); 1001 st->print_cr("--------------- S U M M A R Y ------------"); 1002 st->cr(); 1003 1004 // STEP("printing VM option summary") 1005 1006 // VM options 1007 Arguments::print_summary_on(st); 1008 st->cr(); 1009 1010 // STEP("printing summary machine and OS info") 1011 1012 os::print_summary_info(st, buf, sizeof(buf)); 1013 1014 // STEP("printing date and time") 1015 1016 os::print_date_and_time(st, buf, sizeof(buf)); 1017 1018 // Skip: STEP("printing thread") 1019 1020 // STEP("printing process") 1021 1022 st->cr(); 1023 st->print_cr("--------------- P R O C E S S ---------------"); 1024 st->cr(); 1025 1026 // STEP("printing number of OutOfMemoryError and StackOverflow exceptions") 1027 1028 if (Exceptions::has_exception_counts()) { 1029 st->print_cr("OutOfMemory and StackOverflow Exception counts:"); 1030 Exceptions::print_exception_counts_on_error(st); 1031 st->cr(); 1032 } 1033 1034 // STEP("printing compressed oops mode") 1035 1036 if (UseCompressedOops) { 1037 Universe::print_compressed_oops_mode(st); 1038 if (UseCompressedClassPointers) { 1039 Metaspace::print_compressed_class_space(st); 1040 } 1041 st->cr(); 1042 } 1043 1044 // STEP("printing heap information") 1045 1046 if (Universe::is_fully_initialized()) { 1047 MutexLocker hl(Heap_lock); 1048 Universe::heap()->print_on_error(st); 1049 st->cr(); 1050 st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page())); 1051 st->cr(); 1052 } 1053 1054 // STEP("printing code cache information") 1055 1056 if (Universe::is_fully_initialized()) { 1057 // print code cache information before vm abort 1058 CodeCache::print_summary(st); 1059 st->cr(); 1060 } 1061 1062 // STEP("printing ring buffers") 1063 1064 Events::print_all(st); 1065 st->cr(); 1066 1067 // STEP("printing dynamic libraries") 1068 1069 // dynamic libraries, or memory map 1070 os::print_dll_info(st); 1071 st->cr(); 1072 1073 // STEP("printing VM options") 1074 1075 // VM options 1076 Arguments::print_on(st); 1077 st->cr(); 1078 1079 // STEP("printing warning if internal testing API used") 1080 1081 if (WhiteBox::used()) { 1082 st->print_cr("Unsupported internal testing APIs have been used."); 1083 st->cr(); 1084 } 1085 1086 // STEP("printing log configuration") 1087 st->print_cr("Logging:"); 1088 LogConfiguration::describe(st); 1089 st->cr(); 1090 1091 // STEP("printing all environment variables") 1092 1093 os::print_environment_variables(st, env_list); 1094 st->cr(); 1095 1096 // STEP("printing signal handlers") 1097 1098 os::print_signal_handlers(st, buf, sizeof(buf)); 1099 st->cr(); 1100 1101 // STEP("Native Memory Tracking") 1102 1103 MemTracker::error_report(st); 1104 1105 // STEP("printing system") 1106 1107 st->cr(); 1108 st->print_cr("--------------- S Y S T E M ---------------"); 1109 st->cr(); 1110 1111 // STEP("printing OS information") 1112 1113 os::print_os_info(st); 1114 st->cr(); 1115 1116 // STEP("printing CPU info") 1117 1118 os::print_cpu_info(st, buf, sizeof(buf)); 1119 st->cr(); 1120 1121 // STEP("printing memory info") 1122 1123 os::print_memory_info(st); 1124 st->cr(); 1125 1126 // STEP("printing internal vm info") 1127 1128 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); 1129 st->cr(); 1130 1131 // print a defined marker to show that error handling finished correctly. 1132 // STEP("printing end marker") 1133 1134 st->print_cr("END."); 1135 } 1136 1137 volatile intptr_t VMError::first_error_tid = -1; 1138 1139 // An error could happen before tty is initialized or after it has been 1140 // destroyed. 1141 // Please note: to prevent large stack allocations, the log- and 1142 // output-stream use a global scratch buffer for format printing. 1143 // (see VmError::report_and_die(). Access to those streams is synchronized 1144 // in VmError::report_and_die() - there is only one reporting thread at 1145 // any given time. 1146 fdStream VMError::out(defaultStream::output_fd()); 1147 fdStream VMError::log; // error log used by VMError::report_and_die() 1148 1149 /** Expand a pattern into a buffer starting at pos and open a file using constructed path */ 1150 static int expand_and_open(const char* pattern, char* buf, size_t buflen, size_t pos) { 1151 int fd = -1; 1152 if (Arguments::copy_expand_pid(pattern, strlen(pattern), &buf[pos], buflen - pos)) { 1153 // the O_EXCL flag will cause the open to fail if the file exists 1154 fd = open(buf, O_RDWR | O_CREAT | O_EXCL, 0666); 1155 } 1156 return fd; 1157 } 1158 1159 /** 1160 * Construct file name for a log file and return it's file descriptor. 1161 * Name and location depends on pattern, default_pattern params and access 1162 * permissions. 1163 */ 1164 static int prepare_log_file(const char* pattern, const char* default_pattern, char* buf, size_t buflen) { 1165 int fd = -1; 1166 1167 // If possible, use specified pattern to construct log file name 1168 if (pattern != NULL) { 1169 fd = expand_and_open(pattern, buf, buflen, 0); 1170 } 1171 1172 // Either user didn't specify, or the user's location failed, 1173 // so use the default name in the current directory 1174 if (fd == -1) { 1175 const char* cwd = os::get_current_directory(buf, buflen); 1176 if (cwd != NULL) { 1177 size_t pos = strlen(cwd); 1178 int fsep_len = jio_snprintf(&buf[pos], buflen-pos, "%s", os::file_separator()); 1179 pos += fsep_len; 1180 if (fsep_len > 0) { 1181 fd = expand_and_open(default_pattern, buf, buflen, pos); 1182 } 1183 } 1184 } 1185 1186 // try temp directory if it exists. 1187 if (fd == -1) { 1188 const char* tmpdir = os::get_temp_directory(); 1189 if (tmpdir != NULL && strlen(tmpdir) > 0) { 1190 int pos = jio_snprintf(buf, buflen, "%s%s", tmpdir, os::file_separator()); 1191 if (pos > 0) { 1192 fd = expand_and_open(default_pattern, buf, buflen, pos); 1193 } 1194 } 1195 } 1196 1197 return fd; 1198 } 1199 1200 int VMError::_id; 1201 const char* VMError::_message; 1202 char VMError::_detail_msg[1024]; 1203 Thread* VMError::_thread; 1204 address VMError::_pc; 1205 void* VMError::_siginfo; 1206 void* VMError::_context; 1207 const char* VMError::_filename; 1208 int VMError::_lineno; 1209 size_t VMError::_size; 1210 1211 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, 1212 void* context, const char* detail_fmt, ...) 1213 { 1214 va_list detail_args; 1215 va_start(detail_args, detail_fmt); 1216 report_and_die(sig, NULL, detail_fmt, detail_args, thread, pc, siginfo, context, NULL, 0, 0); 1217 va_end(detail_args); 1218 } 1219 1220 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, void* context) 1221 { 1222 report_and_die(thread, sig, pc, siginfo, context, "%s", ""); 1223 } 1224 1225 void VMError::report_and_die(const char* message, const char* detail_fmt, ...) 1226 { 1227 va_list detail_args; 1228 va_start(detail_args, detail_fmt); 1229 report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, NULL, NULL, NULL, NULL, NULL, 0, 0); 1230 va_end(detail_args); 1231 } 1232 1233 void VMError::report_and_die(const char* message) 1234 { 1235 report_and_die(message, "%s", ""); 1236 } 1237 1238 void VMError::report_and_die(Thread* thread, const char* filename, int lineno, const char* message, 1239 const char* detail_fmt, va_list detail_args) 1240 { 1241 report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, thread, NULL, NULL, NULL, filename, lineno, 0); 1242 } 1243 1244 void VMError::report_and_die(Thread* thread, const char* filename, int lineno, size_t size, 1245 VMErrorType vm_err_type, const char* detail_fmt, va_list detail_args) { 1246 report_and_die(vm_err_type, NULL, detail_fmt, detail_args, thread, NULL, NULL, NULL, filename, lineno, size); 1247 } 1248 1249 void VMError::report_and_die(int id, const char* message, const char* detail_fmt, va_list detail_args, 1250 Thread* thread, address pc, void* siginfo, void* context, const char* filename, 1251 int lineno, size_t size) 1252 { 1253 // Don't allocate large buffer on stack 1254 static char buffer[O_BUFLEN]; 1255 out.set_scratch_buffer(buffer, sizeof(buffer)); 1256 log.set_scratch_buffer(buffer, sizeof(buffer)); 1257 1258 // How many errors occurred in error handler when reporting first_error. 1259 static int recursive_error_count; 1260 1261 // We will first print a brief message to standard out (verbose = false), 1262 // then save detailed information in log file (verbose = true). 1263 static bool out_done = false; // done printing to standard out 1264 static bool log_done = false; // done saving error log 1265 static bool transmit_report_done = false; // done error reporting 1266 1267 if (SuppressFatalErrorMessage) { 1268 os::abort(CreateCoredumpOnCrash); 1269 } 1270 intptr_t mytid = os::current_thread_id(); 1271 if (first_error_tid == -1 && 1272 Atomic::cmpxchg(mytid, &first_error_tid, (intptr_t)-1) == -1) { 1273 1274 // Initialize time stamps to use the same base. 1275 out.time_stamp().update_to(1); 1276 log.time_stamp().update_to(1); 1277 1278 _id = id; 1279 _message = message; 1280 _thread = thread; 1281 _pc = pc; 1282 _siginfo = siginfo; 1283 _context = context; 1284 _filename = filename; 1285 _lineno = lineno; 1286 _size = size; 1287 jio_vsnprintf(_detail_msg, sizeof(_detail_msg), detail_fmt, detail_args); 1288 1289 // first time 1290 _error_reported = true; 1291 1292 reporting_started(); 1293 record_reporting_start_time(); 1294 1295 if (ShowMessageBoxOnError || PauseAtExit) { 1296 show_message_box(buffer, sizeof(buffer)); 1297 1298 // User has asked JVM to abort. Reset ShowMessageBoxOnError so the 1299 // WatcherThread can kill JVM if the error handler hangs. 1300 ShowMessageBoxOnError = false; 1301 } 1302 1303 os::check_dump_limit(buffer, sizeof(buffer)); 1304 1305 // reset signal handlers or exception filter; make sure recursive crashes 1306 // are handled properly. 1307 reset_signal_handlers(); 1308 1309 TRACE_VM_ERROR(); 1310 1311 } else { 1312 // If UseOsErrorReporting we call this for each level of the call stack 1313 // while searching for the exception handler. Only the first level needs 1314 // to be reported. 1315 if (UseOSErrorReporting && log_done) return; 1316 1317 // This is not the first error, see if it happened in a different thread 1318 // or in the same thread during error reporting. 1319 if (first_error_tid != mytid) { 1320 char msgbuf[64]; 1321 jio_snprintf(msgbuf, sizeof(msgbuf), 1322 "[thread " INTX_FORMAT " also had an error]", 1323 mytid); 1324 out.print_raw_cr(msgbuf); 1325 1326 // error reporting is not MT-safe, block current thread 1327 os::infinite_sleep(); 1328 1329 } else { 1330 if (recursive_error_count++ > 30) { 1331 out.print_raw_cr("[Too many errors, abort]"); 1332 os::die(); 1333 } 1334 1335 outputStream* const st = log.is_open() ? &log : &out; 1336 st->cr(); 1337 1338 // Timeout handling. 1339 if (_step_did_timeout) { 1340 // The current step had a timeout. Lets continue reporting with the next step. 1341 st->print_raw("[timeout occurred during error reporting in step \""); 1342 st->print_raw(_current_step_info); 1343 st->print_cr("\"] after " INT64_FORMAT " s.", 1344 (int64_t) 1345 ((get_current_timestamp() - _step_start_time) / TIMESTAMP_TO_SECONDS_FACTOR)); 1346 } else if (_reporting_did_timeout) { 1347 // We hit ErrorLogTimeout. Reporting will stop altogether. Let's wrap things 1348 // up, the process is about to be stopped by the WatcherThread. 1349 st->print_cr("------ Timeout during error reporting after " INT64_FORMAT " s. ------", 1350 (int64_t) 1351 ((get_current_timestamp() - _reporting_start_time) / TIMESTAMP_TO_SECONDS_FACTOR)); 1352 st->flush(); 1353 // Watcherthread is about to call os::die. Lets just wait. 1354 os::infinite_sleep(); 1355 } else { 1356 // Crash or assert during error reporting. Lets continue reporting with the next step. 1357 jio_snprintf(buffer, sizeof(buffer), 1358 "[error occurred during error reporting (%s), id 0x%x]", 1359 _current_step_info, _id); 1360 st->print_raw_cr(buffer); 1361 st->cr(); 1362 } 1363 } 1364 } 1365 1366 // print to screen 1367 if (!out_done) { 1368 report(&out, false); 1369 1370 out_done = true; 1371 1372 _current_step = 0; 1373 _current_step_info = ""; 1374 } 1375 1376 // print to error log file 1377 if (!log_done) { 1378 // see if log file is already open 1379 if (!log.is_open()) { 1380 // open log file 1381 int fd = prepare_log_file(ErrorFile, "hs_err_pid%p.log", buffer, sizeof(buffer)); 1382 if (fd != -1) { 1383 out.print_raw("# An error report file with more information is saved as:\n# "); 1384 out.print_raw_cr(buffer); 1385 1386 log.set_fd(fd); 1387 } else { 1388 out.print_raw_cr("# Can not save log file, dump to screen.."); 1389 log.set_fd(defaultStream::output_fd()); 1390 /* Error reporting currently needs dumpfile. 1391 * Maybe implement direct streaming in the future.*/ 1392 transmit_report_done = true; 1393 } 1394 } 1395 1396 report(&log, true); 1397 log_done = true; 1398 _current_step = 0; 1399 _current_step_info = ""; 1400 1401 // Run error reporting to determine whether or not to report the crash. 1402 if (!transmit_report_done && should_report_bug(_id)) { 1403 transmit_report_done = true; 1404 const int fd2 = ::dup(log.fd()); 1405 if (fd2 != -1) { 1406 FILE* const hs_err = ::fdopen(fd2, "r"); 1407 if (NULL != hs_err) { 1408 ErrorReporter er; 1409 er.call(hs_err, buffer, O_BUFLEN); 1410 ::fclose(hs_err); 1411 } 1412 } 1413 } 1414 1415 if (log.fd() != defaultStream::output_fd()) { 1416 close(log.fd()); 1417 } 1418 1419 log.set_fd(-1); 1420 } 1421 1422 static bool skip_replay = ReplayCompiles; // Do not overwrite file during replay 1423 if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) { 1424 skip_replay = true; 1425 ciEnv* env = ciEnv::current(); 1426 if (env != NULL) { 1427 int fd = prepare_log_file(ReplayDataFile, "replay_pid%p.log", buffer, sizeof(buffer)); 1428 if (fd != -1) { 1429 FILE* replay_data_file = os::open(fd, "w"); 1430 if (replay_data_file != NULL) { 1431 fileStream replay_data_stream(replay_data_file, /*need_close=*/true); 1432 env->dump_replay_data_unsafe(&replay_data_stream); 1433 out.print_raw("#\n# Compiler replay data is saved as:\n# "); 1434 out.print_raw_cr(buffer); 1435 } else { 1436 int e = errno; 1437 out.print_raw("#\n# Can't open file to dump replay data. Error: "); 1438 out.print_raw_cr(os::strerror(e)); 1439 } 1440 } 1441 } 1442 } 1443 1444 static bool skip_bug_url = !should_report_bug(_id); 1445 if (!skip_bug_url) { 1446 skip_bug_url = true; 1447 1448 out.print_raw_cr("#"); 1449 print_bug_submit_message(&out, _thread); 1450 } 1451 1452 static bool skip_OnError = false; 1453 if (!skip_OnError && OnError && OnError[0]) { 1454 skip_OnError = true; 1455 1456 // Flush output and finish logs before running OnError commands. 1457 ostream_abort(); 1458 1459 out.print_raw_cr("#"); 1460 out.print_raw ("# -XX:OnError=\""); 1461 out.print_raw (OnError); 1462 out.print_raw_cr("\""); 1463 1464 char* cmd; 1465 const char* ptr = OnError; 1466 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ 1467 out.print_raw ("# Executing "); 1468 #if defined(LINUX) || defined(_ALLBSD_SOURCE) 1469 out.print_raw ("/bin/sh -c "); 1470 #elif defined(SOLARIS) 1471 out.print_raw ("/usr/bin/sh -c "); 1472 #elif defined(WINDOWS) 1473 out.print_raw ("cmd /C "); 1474 #endif 1475 out.print_raw ("\""); 1476 out.print_raw (cmd); 1477 out.print_raw_cr("\" ..."); 1478 1479 if (os::fork_and_exec(cmd) < 0) { 1480 out.print_cr("os::fork_and_exec failed: %s (%s=%d)", 1481 os::strerror(errno), os::errno_name(errno), errno); 1482 } 1483 } 1484 1485 // done with OnError 1486 OnError = NULL; 1487 } 1488 1489 if (!UseOSErrorReporting) { 1490 // os::abort() will call abort hooks, try it first. 1491 static bool skip_os_abort = false; 1492 if (!skip_os_abort) { 1493 skip_os_abort = true; 1494 bool dump_core = should_report_bug(_id); 1495 os::abort(dump_core && CreateCoredumpOnCrash, _siginfo, _context); 1496 } 1497 1498 // if os::abort() doesn't abort, try os::die(); 1499 os::die(); 1500 } 1501 } 1502 1503 /* 1504 * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this 1505 * ensures utilities such as jmap can observe the process is a consistent state. 1506 */ 1507 class VM_ReportJavaOutOfMemory : public VM_Operation { 1508 private: 1509 const char* _message; 1510 public: 1511 VM_ReportJavaOutOfMemory(const char* message) { _message = message; } 1512 VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; } 1513 void doit(); 1514 }; 1515 1516 void VM_ReportJavaOutOfMemory::doit() { 1517 // Don't allocate large buffer on stack 1518 static char buffer[O_BUFLEN]; 1519 1520 tty->print_cr("#"); 1521 tty->print_cr("# java.lang.OutOfMemoryError: %s", _message); 1522 tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError); 1523 1524 // make heap parsability 1525 Universe::heap()->ensure_parsability(false); // no need to retire TLABs 1526 1527 char* cmd; 1528 const char* ptr = OnOutOfMemoryError; 1529 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ 1530 tty->print("# Executing "); 1531 #if defined(LINUX) 1532 tty->print ("/bin/sh -c "); 1533 #elif defined(SOLARIS) 1534 tty->print ("/usr/bin/sh -c "); 1535 #endif 1536 tty->print_cr("\"%s\"...", cmd); 1537 1538 if (os::fork_and_exec(cmd) < 0) { 1539 tty->print_cr("os::fork_and_exec failed: %s (%s=%d)", 1540 os::strerror(errno), os::errno_name(errno), errno); 1541 } 1542 } 1543 } 1544 1545 void VMError::report_java_out_of_memory(const char* message) { 1546 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { 1547 MutexLocker ml(Heap_lock); 1548 VM_ReportJavaOutOfMemory op(message); 1549 VMThread::execute(&op); 1550 } 1551 } 1552 1553 void VMError::show_message_box(char *buf, int buflen) { 1554 bool yes; 1555 do { 1556 error_string(buf, buflen); 1557 yes = os::start_debugging(buf,buflen); 1558 } while (yes); 1559 } 1560 1561 // Timeout handling: check if a timeout happened (either a single step did 1562 // timeout or the whole of error reporting hit ErrorLogTimeout). Interrupt 1563 // the reporting thread if that is the case. 1564 bool VMError::check_timeout() { 1565 1566 if (ErrorLogTimeout == 0) { 1567 return false; 1568 } 1569 1570 // Do not check for timeouts if we still have a message box to show to the 1571 // user or if there are OnError handlers to be run. 1572 if (ShowMessageBoxOnError 1573 || (OnError != NULL && OnError[0] != '\0') 1574 || Arguments::abort_hook() != NULL) { 1575 return false; 1576 } 1577 1578 const jlong reporting_start_time_l = get_reporting_start_time(); 1579 const jlong now = get_current_timestamp(); 1580 // Timestamp is stored in nanos. 1581 if (reporting_start_time_l > 0) { 1582 const jlong end = reporting_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR; 1583 if (end <= now) { 1584 _reporting_did_timeout = true; 1585 interrupt_reporting_thread(); 1586 return true; // global timeout 1587 } 1588 } 1589 1590 const jlong step_start_time_l = get_step_start_time(); 1591 if (step_start_time_l > 0) { 1592 // A step times out after a quarter of the total timeout. Steps are mostly fast unless they 1593 // hang for some reason, so this simple rule allows for three hanging step and still 1594 // hopefully leaves time enough for the rest of the steps to finish. 1595 const jlong end = step_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR / 4; 1596 if (end <= now) { 1597 _step_did_timeout = true; 1598 interrupt_reporting_thread(); 1599 return false; // (Not a global timeout) 1600 } 1601 } 1602 1603 return false; 1604 1605 } 1606 1607 #ifndef PRODUCT 1608 typedef void (*voidfun_t)(); 1609 // Crash with an authentic sigfpe 1610 static void crash_with_sigfpe() { 1611 // generate a native synchronous SIGFPE where possible; 1612 // if that did not cause a signal (e.g. on ppc), just 1613 // raise the signal. 1614 volatile int x = 0; 1615 volatile int y = 1/x; 1616 #ifndef _WIN32 1617 // OSX implements raise(sig) incorrectly so we need to 1618 // explicitly target the current thread 1619 pthread_kill(pthread_self(), SIGFPE); 1620 #endif 1621 } // end: crash_with_sigfpe 1622 1623 // crash with sigsegv at non-null address. 1624 static void crash_with_segfault() { 1625 1626 char* const crash_addr = (char*) VMError::get_segfault_address(); 1627 *crash_addr = 'X'; 1628 1629 } // end: crash_with_segfault 1630 1631 void VMError::test_error_handler() { 1632 controlled_crash(ErrorHandlerTest); 1633 } 1634 1635 // crash in a controlled way: 1636 // how can be one of: 1637 // 1,2 - asserts 1638 // 3,4 - guarantee 1639 // 5-7 - fatal 1640 // 8 - vm_exit_out_of_memory 1641 // 9 - ShouldNotCallThis 1642 // 10 - ShouldNotReachHere 1643 // 11 - Unimplemented 1644 // 12,13 - (not guaranteed) crashes 1645 // 14 - SIGSEGV 1646 // 15 - SIGFPE 1647 void VMError::controlled_crash(int how) { 1648 if (how == 0) return; 1649 1650 // If asserts are disabled, use the corresponding guarantee instead. 1651 NOT_DEBUG(if (how <= 2) how += 2); 1652 1653 const char* const str = "hello"; 1654 const size_t num = (size_t)os::vm_page_size(); 1655 1656 const char* const eol = os::line_separator(); 1657 const char* const msg = "this message should be truncated during formatting"; 1658 char * const dataPtr = NULL; // bad data pointer 1659 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer 1660 1661 // Keep this in sync with test/runtime/ErrorHandling/ErrorHandler.java 1662 switch (how) { 1663 case 1: vmassert(str == NULL, "expected null"); 1664 case 2: vmassert(num == 1023 && *str == 'X', 1665 "num=" SIZE_FORMAT " str=\"%s\"", num, str); 1666 case 3: guarantee(str == NULL, "expected null"); 1667 case 4: guarantee(num == 1023 && *str == 'X', 1668 "num=" SIZE_FORMAT " str=\"%s\"", num, str); 1669 case 5: fatal("expected null"); 1670 case 6: fatal("num=" SIZE_FORMAT " str=\"%s\"", num, str); 1671 case 7: fatal("%s%s# %s%s# %s%s# %s%s# %s%s# " 1672 "%s%s# %s%s# %s%s# %s%s# %s%s# " 1673 "%s%s# %s%s# %s%s# %s%s# %s", 1674 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 1675 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 1676 msg, eol, msg, eol, msg, eol, msg, eol, msg); 1677 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate"); 1678 case 9: ShouldNotCallThis(); 1679 case 10: ShouldNotReachHere(); 1680 case 11: Unimplemented(); 1681 // There's no guarantee the bad data pointer will crash us 1682 // so "break" out to the ShouldNotReachHere(). 1683 case 12: *dataPtr = '\0'; break; 1684 // There's no guarantee the bad function pointer will crash us 1685 // so "break" out to the ShouldNotReachHere(). 1686 case 13: (*funcPtr)(); break; 1687 case 14: crash_with_segfault(); break; 1688 case 15: crash_with_sigfpe(); break; 1689 1690 default: tty->print_cr("ERROR: %d: unexpected test_num value.", how); 1691 } 1692 ShouldNotReachHere(); 1693 } 1694 #endif // !PRODUCT 1695