1 /* 2 * Copyright (c) 2003, 2018, 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 "jvm.h" 27 #include "code/codeCache.hpp" 28 #include "compiler/compileBroker.hpp" 29 #include "compiler/disassembler.hpp" 30 #include "gc/shared/collectedHeap.hpp" 31 #include "logging/logConfiguration.hpp" 32 #include "memory/resourceArea.hpp" 33 #include "prims/whitebox.hpp" 34 #include "runtime/arguments.hpp" 35 #include "runtime/atomic.hpp" 36 #include "runtime/frame.inline.hpp" 37 #include "runtime/init.hpp" 38 #include "runtime/os.hpp" 39 #include "runtime/thread.inline.hpp" 40 #include "runtime/threadSMR.hpp" 41 #include "runtime/vmThread.hpp" 42 #include "runtime/vm_operations.hpp" 43 #include "runtime/vm_version.hpp" 44 #include "services/memTracker.hpp" 45 #include "trace/traceMacros.hpp" 46 #include "utilities/debug.hpp" 47 #include "utilities/decoder.hpp" 48 #include "utilities/defaultStream.hpp" 49 #include "utilities/errorReporter.hpp" 50 #include "utilities/events.hpp" 51 #include "utilities/vmError.hpp" 52 53 #ifndef PRODUCT 54 #include <signal.h> 55 #endif // PRODUCT 56 57 bool VMError::_error_reported = false; 58 59 // call this when the VM is dying--it might loosen some asserts 60 bool VMError::is_error_reported() { return _error_reported; } 61 62 // returns an address which is guaranteed to generate a SIGSEGV on read, 63 // for test purposes, which is not NULL and contains bits in every word 64 void* VMError::get_segfault_address() { 65 return (void*) 66 #ifdef _LP64 67 0xABC0000000000ABCULL; 68 #else 69 0x00000ABC; 70 #endif 71 } 72 73 // List of environment variables that should be reported in error log file. 74 const char *env_list[] = { 75 // All platforms 76 "JAVA_HOME", "JRE_HOME", "JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "CLASSPATH", 77 "JAVA_COMPILER", "PATH", "USERNAME", 78 79 // Env variables that are defined on Solaris/Linux/BSD 80 "LD_LIBRARY_PATH", "LD_PRELOAD", "SHELL", "DISPLAY", 81 "HOSTTYPE", "OSTYPE", "ARCH", "MACHTYPE", 82 83 // defined on Linux 84 "LD_ASSUME_KERNEL", "_JAVA_SR_SIGNUM", 85 86 // defined on Darwin 87 "DYLD_LIBRARY_PATH", "DYLD_FALLBACK_LIBRARY_PATH", 88 "DYLD_FRAMEWORK_PATH", "DYLD_FALLBACK_FRAMEWORK_PATH", 89 "DYLD_INSERT_LIBRARIES", 90 91 // defined on Windows 92 "OS", "PROCESSOR_IDENTIFIER", "_ALT_JAVA_HOME_DIR", 93 94 (const char *)0 95 }; 96 97 // A simple parser for -XX:OnError, usage: 98 // ptr = OnError; 99 // while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr) != NULL) 100 // ... ... 101 static char* next_OnError_command(char* buf, int buflen, const char** ptr) { 102 if (ptr == NULL || *ptr == NULL) return NULL; 103 104 const char* cmd = *ptr; 105 106 // skip leading blanks or ';' 107 while (*cmd == ' ' || *cmd == ';') cmd++; 108 109 if (*cmd == '\0') return NULL; 110 111 const char * cmdend = cmd; 112 while (*cmdend != '\0' && *cmdend != ';') cmdend++; 113 114 Arguments::copy_expand_pid(cmd, cmdend - cmd, buf, buflen); 115 116 *ptr = (*cmdend == '\0' ? cmdend : cmdend + 1); 117 return buf; 118 } 119 120 static void print_bug_submit_message(outputStream *out, Thread *thread) { 121 if (out == NULL) return; 122 out->print_raw_cr("# If you would like to submit a bug report, please visit:"); 123 out->print_raw ("# "); 124 out->print_raw_cr(Arguments::java_vendor_url_bug()); 125 // If the crash is in native code, encourage user to submit a bug to the 126 // provider of that code. 127 if (thread && thread->is_Java_thread() && 128 !thread->is_hidden_from_external_view()) { 129 JavaThread* jt = (JavaThread*)thread; 130 if (jt->thread_state() == _thread_in_native) { 131 out->print_cr("# The crash happened outside the Java Virtual Machine in native code.\n# See problematic frame for where to report the bug."); 132 } 133 } 134 out->print_raw_cr("#"); 135 } 136 137 bool VMError::coredump_status; 138 char VMError::coredump_message[O_BUFLEN]; 139 140 void VMError::record_coredump_status(const char* message, bool status) { 141 coredump_status = status; 142 strncpy(coredump_message, message, sizeof(coredump_message)); 143 coredump_message[sizeof(coredump_message)-1] = 0; 144 } 145 146 // Return a string to describe the error 147 char* VMError::error_string(char* buf, int buflen) { 148 char signame_buf[64]; 149 const char *signame = os::exception_name(_id, signame_buf, sizeof(signame_buf)); 150 151 if (signame) { 152 jio_snprintf(buf, buflen, 153 "%s (0x%x) at pc=" PTR_FORMAT ", pid=%d, tid=" UINTX_FORMAT, 154 signame, _id, _pc, 155 os::current_process_id(), os::current_thread_id()); 156 } else if (_filename != NULL && _lineno > 0) { 157 // skip directory names 158 char separator = os::file_separator()[0]; 159 const char *p = strrchr(_filename, separator); 160 int n = jio_snprintf(buf, buflen, 161 "Internal Error at %s:%d, pid=%d, tid=" UINTX_FORMAT, 162 p ? p + 1 : _filename, _lineno, 163 os::current_process_id(), os::current_thread_id()); 164 if (n >= 0 && n < buflen && _message) { 165 if (strlen(_detail_msg) > 0) { 166 jio_snprintf(buf + n, buflen - n, "%s%s: %s", 167 os::line_separator(), _message, _detail_msg); 168 } else { 169 jio_snprintf(buf + n, buflen - n, "%sError: %s", 170 os::line_separator(), _message); 171 } 172 } 173 } else { 174 jio_snprintf(buf, buflen, 175 "Internal Error (0x%x), pid=%d, tid=" UINTX_FORMAT, 176 _id, os::current_process_id(), os::current_thread_id()); 177 } 178 179 return buf; 180 } 181 182 void VMError::print_stack_trace(outputStream* st, JavaThread* jt, 183 char* buf, int buflen, bool verbose) { 184 #ifdef ZERO 185 if (jt->zero_stack()->sp() && jt->top_zero_frame()) { 186 // StackFrameStream uses the frame anchor, which may not have 187 // been set up. This can be done at any time in Zero, however, 188 // so if it hasn't been set up then we just set it up now and 189 // clear it again when we're done. 190 bool has_last_Java_frame = jt->has_last_Java_frame(); 191 if (!has_last_Java_frame) 192 jt->set_last_Java_frame(); 193 st->print("Java frames:"); 194 st->cr(); 195 196 // Print the frames 197 StackFrameStream sfs(jt); 198 for(int i = 0; !sfs.is_done(); sfs.next(), i++) { 199 sfs.current()->zero_print_on_error(i, st, buf, buflen); 200 st->cr(); 201 } 202 203 // Reset the frame anchor if necessary 204 if (!has_last_Java_frame) 205 jt->reset_last_Java_frame(); 206 } 207 #else 208 if (jt->has_last_Java_frame()) { 209 st->print_cr("Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)"); 210 for(StackFrameStream sfs(jt); !sfs.is_done(); sfs.next()) { 211 sfs.current()->print_on_error(st, buf, buflen, verbose); 212 st->cr(); 213 } 214 } 215 #endif // ZERO 216 } 217 218 void VMError::print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) { 219 220 // see if it's a valid frame 221 if (fr.pc()) { 222 st->print_cr("Native frames: (J=compiled Java code, A=aot compiled Java code, j=interpreted, Vv=VM code, C=native code)"); 223 224 int count = 0; 225 while (count++ < StackPrintLimit) { 226 fr.print_on_error(st, buf, buf_size); 227 if (fr.pc()) { // print source file and line, if available 228 char buf[128]; 229 int line_no; 230 if (Decoder::get_source_info(fr.pc(), buf, sizeof(buf), &line_no)) { 231 st->print(" (%s:%d)", buf, line_no); 232 } 233 } 234 st->cr(); 235 // Compiled code may use EBP register on x86 so it looks like 236 // non-walkable C frame. Use frame.sender() for java frames. 237 if (t && t->is_Java_thread()) { 238 // Catch very first native frame by using stack address. 239 // For JavaThread stack_base and stack_size should be set. 240 if (!t->on_local_stack((address)(fr.real_fp() + 1))) { 241 break; 242 } 243 if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) { 244 RegisterMap map((JavaThread*)t, false); // No update 245 fr = fr.sender(&map); 246 } else { 247 // is_first_C_frame() does only simple checks for frame pointer, 248 // it will pass if java compiled code has a pointer in EBP. 249 if (os::is_first_C_frame(&fr)) break; 250 fr = os::get_sender_for_C_frame(&fr); 251 } 252 } else { 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(static_cast<unsigned int>(_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 if (_thread != NULL) { 778 // Disassembling nmethod will incur resource memory allocation, 779 // only do so when thread is valid. 780 ResourceMark rm(_thread); 781 Disassembler::decode(cb, st); 782 st->cr(); 783 } 784 } 785 } 786 } 787 788 STEP("printing VM operation") 789 790 if (_verbose && _thread && _thread->is_VM_thread()) { 791 VMThread* t = (VMThread*)_thread; 792 VM_Operation* op = t->vm_operation(); 793 if (op) { 794 op->print_on_error(st); 795 st->cr(); 796 st->cr(); 797 } 798 } 799 800 STEP("printing process") 801 802 if (_verbose) { 803 st->cr(); 804 st->print_cr("--------------- P R O C E S S ---------------"); 805 st->cr(); 806 } 807 808 STEP("printing all threads") 809 810 // all threads 811 if (_verbose && _thread) { 812 Threads::print_on_error(st, _thread, buf, sizeof(buf)); 813 st->cr(); 814 } 815 816 STEP("printing VM state") 817 818 if (_verbose) { 819 // Safepoint state 820 st->print("VM state:"); 821 822 if (SafepointSynchronize::is_synchronizing()) st->print("synchronizing"); 823 else if (SafepointSynchronize::is_at_safepoint()) st->print("at safepoint"); 824 else st->print("not at safepoint"); 825 826 // Also see if error occurred during initialization or shutdown 827 if (!Universe::is_fully_initialized()) { 828 st->print(" (not fully initialized)"); 829 } else if (VM_Exit::vm_exited()) { 830 st->print(" (shutting down)"); 831 } else { 832 st->print(" (normal execution)"); 833 } 834 st->cr(); 835 st->cr(); 836 } 837 838 STEP("printing owned locks on error") 839 840 // mutexes/monitors that currently have an owner 841 if (_verbose) { 842 print_owned_locks_on_error(st); 843 st->cr(); 844 } 845 846 STEP("printing number of OutOfMemoryError and StackOverflow exceptions") 847 848 if (_verbose && Exceptions::has_exception_counts()) { 849 st->print_cr("OutOfMemory and StackOverflow Exception counts:"); 850 Exceptions::print_exception_counts_on_error(st); 851 st->cr(); 852 } 853 854 STEP("printing compressed oops mode") 855 856 if (_verbose && UseCompressedOops) { 857 Universe::print_compressed_oops_mode(st); 858 if (UseCompressedClassPointers) { 859 Metaspace::print_compressed_class_space(st); 860 } 861 st->cr(); 862 } 863 864 STEP("printing heap information") 865 866 if (_verbose && Universe::is_fully_initialized()) { 867 Universe::heap()->print_on_error(st); 868 st->cr(); 869 st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page())); 870 st->cr(); 871 } 872 873 STEP("printing code cache information") 874 875 if (_verbose && Universe::is_fully_initialized()) { 876 // print code cache information before vm abort 877 CodeCache::print_summary(st); 878 st->cr(); 879 } 880 881 STEP("printing ring buffers") 882 883 if (_verbose) { 884 Events::print_all(st); 885 st->cr(); 886 } 887 888 STEP("printing dynamic libraries") 889 890 if (_verbose) { 891 // dynamic libraries, or memory map 892 os::print_dll_info(st); 893 st->cr(); 894 } 895 896 STEP("printing native decoder state") 897 898 if (_verbose) { 899 Decoder::print_state_on(st); 900 st->cr(); 901 } 902 903 STEP("printing VM options") 904 905 if (_verbose) { 906 // VM options 907 Arguments::print_on(st); 908 st->cr(); 909 } 910 911 STEP("printing warning if internal testing API used") 912 913 if (WhiteBox::used()) { 914 st->print_cr("Unsupported internal testing APIs have been used."); 915 st->cr(); 916 } 917 918 STEP("printing log configuration") 919 if (_verbose){ 920 st->print_cr("Logging:"); 921 LogConfiguration::describe_current_configuration(st); 922 st->cr(); 923 } 924 925 STEP("printing all environment variables") 926 927 if (_verbose) { 928 os::print_environment_variables(st, env_list); 929 st->cr(); 930 } 931 932 STEP("printing signal handlers") 933 934 if (_verbose) { 935 os::print_signal_handlers(st, buf, sizeof(buf)); 936 st->cr(); 937 } 938 939 STEP("Native Memory Tracking") 940 if (_verbose) { 941 MemTracker::error_report(st); 942 } 943 944 STEP("printing system") 945 946 if (_verbose) { 947 st->cr(); 948 st->print_cr("--------------- S Y S T E M ---------------"); 949 st->cr(); 950 } 951 952 STEP("printing OS information") 953 954 if (_verbose) { 955 os::print_os_info(st); 956 st->cr(); 957 } 958 959 STEP("printing CPU info") 960 if (_verbose) { 961 os::print_cpu_info(st, buf, sizeof(buf)); 962 st->cr(); 963 } 964 965 STEP("printing memory info") 966 967 if (_verbose) { 968 os::print_memory_info(st); 969 st->cr(); 970 } 971 972 STEP("printing internal vm info") 973 974 if (_verbose) { 975 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); 976 st->cr(); 977 } 978 979 // print a defined marker to show that error handling finished correctly. 980 STEP("printing end marker") 981 982 if (_verbose) { 983 st->print_cr("END."); 984 } 985 986 END 987 988 # undef BEGIN 989 # undef STEP 990 # undef END 991 } 992 993 // Report for the vm_info_cmd. This prints out the information above omitting 994 // crash and thread specific information. If output is added above, it should be added 995 // here also, if it is safe to call during a running process. 996 void VMError::print_vm_info(outputStream* st) { 997 998 char buf[O_BUFLEN]; 999 report_vm_version(st, buf, sizeof(buf)); 1000 1001 // STEP("printing summary") 1002 1003 st->cr(); 1004 st->print_cr("--------------- S U M M A R Y ------------"); 1005 st->cr(); 1006 1007 // STEP("printing VM option summary") 1008 1009 // VM options 1010 Arguments::print_summary_on(st); 1011 st->cr(); 1012 1013 // STEP("printing summary machine and OS info") 1014 1015 os::print_summary_info(st, buf, sizeof(buf)); 1016 1017 // STEP("printing date and time") 1018 1019 os::print_date_and_time(st, buf, sizeof(buf)); 1020 1021 // Skip: STEP("printing thread") 1022 1023 // STEP("printing process") 1024 1025 st->cr(); 1026 st->print_cr("--------------- P R O C E S S ---------------"); 1027 st->cr(); 1028 1029 // STEP("printing number of OutOfMemoryError and StackOverflow exceptions") 1030 1031 if (Exceptions::has_exception_counts()) { 1032 st->print_cr("OutOfMemory and StackOverflow Exception counts:"); 1033 Exceptions::print_exception_counts_on_error(st); 1034 st->cr(); 1035 } 1036 1037 // STEP("printing compressed oops mode") 1038 1039 if (UseCompressedOops) { 1040 Universe::print_compressed_oops_mode(st); 1041 if (UseCompressedClassPointers) { 1042 Metaspace::print_compressed_class_space(st); 1043 } 1044 st->cr(); 1045 } 1046 1047 // STEP("printing heap information") 1048 1049 if (Universe::is_fully_initialized()) { 1050 MutexLocker hl(Heap_lock); 1051 Universe::heap()->print_on_error(st); 1052 st->cr(); 1053 st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page())); 1054 st->cr(); 1055 } 1056 1057 // STEP("printing code cache information") 1058 1059 if (Universe::is_fully_initialized()) { 1060 // print code cache information before vm abort 1061 CodeCache::print_summary(st); 1062 st->cr(); 1063 } 1064 1065 // STEP("printing ring buffers") 1066 1067 Events::print_all(st); 1068 st->cr(); 1069 1070 // STEP("printing dynamic libraries") 1071 1072 // dynamic libraries, or memory map 1073 os::print_dll_info(st); 1074 st->cr(); 1075 1076 // STEP("printing VM options") 1077 1078 // VM options 1079 Arguments::print_on(st); 1080 st->cr(); 1081 1082 // STEP("printing warning if internal testing API used") 1083 1084 if (WhiteBox::used()) { 1085 st->print_cr("Unsupported internal testing APIs have been used."); 1086 st->cr(); 1087 } 1088 1089 // STEP("printing log configuration") 1090 st->print_cr("Logging:"); 1091 LogConfiguration::describe(st); 1092 st->cr(); 1093 1094 // STEP("printing all environment variables") 1095 1096 os::print_environment_variables(st, env_list); 1097 st->cr(); 1098 1099 // STEP("printing signal handlers") 1100 1101 os::print_signal_handlers(st, buf, sizeof(buf)); 1102 st->cr(); 1103 1104 // STEP("Native Memory Tracking") 1105 1106 MemTracker::error_report(st); 1107 1108 // STEP("printing system") 1109 1110 st->cr(); 1111 st->print_cr("--------------- S Y S T E M ---------------"); 1112 st->cr(); 1113 1114 // STEP("printing OS information") 1115 1116 os::print_os_info(st); 1117 st->cr(); 1118 1119 // STEP("printing CPU info") 1120 1121 os::print_cpu_info(st, buf, sizeof(buf)); 1122 st->cr(); 1123 1124 // STEP("printing memory info") 1125 1126 os::print_memory_info(st); 1127 st->cr(); 1128 1129 // STEP("printing internal vm info") 1130 1131 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); 1132 st->cr(); 1133 1134 // print a defined marker to show that error handling finished correctly. 1135 // STEP("printing end marker") 1136 1137 st->print_cr("END."); 1138 } 1139 1140 volatile intptr_t VMError::first_error_tid = -1; 1141 1142 // An error could happen before tty is initialized or after it has been 1143 // destroyed. 1144 // Please note: to prevent large stack allocations, the log- and 1145 // output-stream use a global scratch buffer for format printing. 1146 // (see VmError::report_and_die(). Access to those streams is synchronized 1147 // in VmError::report_and_die() - there is only one reporting thread at 1148 // any given time. 1149 fdStream VMError::out(defaultStream::output_fd()); 1150 fdStream VMError::log; // error log used by VMError::report_and_die() 1151 1152 /** Expand a pattern into a buffer starting at pos and open a file using constructed path */ 1153 static int expand_and_open(const char* pattern, char* buf, size_t buflen, size_t pos) { 1154 int fd = -1; 1155 if (Arguments::copy_expand_pid(pattern, strlen(pattern), &buf[pos], buflen - pos)) { 1156 // the O_EXCL flag will cause the open to fail if the file exists 1157 fd = open(buf, O_RDWR | O_CREAT | O_EXCL, 0666); 1158 } 1159 return fd; 1160 } 1161 1162 /** 1163 * Construct file name for a log file and return it's file descriptor. 1164 * Name and location depends on pattern, default_pattern params and access 1165 * permissions. 1166 */ 1167 static int prepare_log_file(const char* pattern, const char* default_pattern, char* buf, size_t buflen) { 1168 int fd = -1; 1169 1170 // If possible, use specified pattern to construct log file name 1171 if (pattern != NULL) { 1172 fd = expand_and_open(pattern, buf, buflen, 0); 1173 } 1174 1175 // Either user didn't specify, or the user's location failed, 1176 // so use the default name in the current directory 1177 if (fd == -1) { 1178 const char* cwd = os::get_current_directory(buf, buflen); 1179 if (cwd != NULL) { 1180 size_t pos = strlen(cwd); 1181 int fsep_len = jio_snprintf(&buf[pos], buflen-pos, "%s", os::file_separator()); 1182 pos += fsep_len; 1183 if (fsep_len > 0) { 1184 fd = expand_and_open(default_pattern, buf, buflen, pos); 1185 } 1186 } 1187 } 1188 1189 // try temp directory if it exists. 1190 if (fd == -1) { 1191 const char* tmpdir = os::get_temp_directory(); 1192 if (tmpdir != NULL && strlen(tmpdir) > 0) { 1193 int pos = jio_snprintf(buf, buflen, "%s%s", tmpdir, os::file_separator()); 1194 if (pos > 0) { 1195 fd = expand_and_open(default_pattern, buf, buflen, pos); 1196 } 1197 } 1198 } 1199 1200 return fd; 1201 } 1202 1203 int VMError::_id; 1204 const char* VMError::_message; 1205 char VMError::_detail_msg[1024]; 1206 Thread* VMError::_thread; 1207 address VMError::_pc; 1208 void* VMError::_siginfo; 1209 void* VMError::_context; 1210 const char* VMError::_filename; 1211 int VMError::_lineno; 1212 size_t VMError::_size; 1213 1214 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, 1215 void* context, const char* detail_fmt, ...) 1216 { 1217 va_list detail_args; 1218 va_start(detail_args, detail_fmt); 1219 report_and_die(sig, NULL, detail_fmt, detail_args, thread, pc, siginfo, context, NULL, 0, 0); 1220 va_end(detail_args); 1221 } 1222 1223 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, void* context) 1224 { 1225 report_and_die(thread, sig, pc, siginfo, context, "%s", ""); 1226 } 1227 1228 void VMError::report_and_die(const char* message, const char* detail_fmt, ...) 1229 { 1230 va_list detail_args; 1231 va_start(detail_args, detail_fmt); 1232 report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, NULL, NULL, NULL, NULL, NULL, 0, 0); 1233 va_end(detail_args); 1234 } 1235 1236 void VMError::report_and_die(const char* message) 1237 { 1238 report_and_die(message, "%s", ""); 1239 } 1240 1241 void VMError::report_and_die(Thread* thread, const char* filename, int lineno, const char* message, 1242 const char* detail_fmt, va_list detail_args) 1243 { 1244 report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, thread, NULL, NULL, NULL, filename, lineno, 0); 1245 } 1246 1247 void VMError::report_and_die(Thread* thread, const char* filename, int lineno, size_t size, 1248 VMErrorType vm_err_type, const char* detail_fmt, va_list detail_args) { 1249 report_and_die(vm_err_type, NULL, detail_fmt, detail_args, thread, NULL, NULL, NULL, filename, lineno, size); 1250 } 1251 1252 void VMError::report_and_die(int id, const char* message, const char* detail_fmt, va_list detail_args, 1253 Thread* thread, address pc, void* siginfo, void* context, const char* filename, 1254 int lineno, size_t size) 1255 { 1256 // Don't allocate large buffer on stack 1257 static char buffer[O_BUFLEN]; 1258 out.set_scratch_buffer(buffer, sizeof(buffer)); 1259 log.set_scratch_buffer(buffer, sizeof(buffer)); 1260 1261 // How many errors occurred in error handler when reporting first_error. 1262 static int recursive_error_count; 1263 1264 // We will first print a brief message to standard out (verbose = false), 1265 // then save detailed information in log file (verbose = true). 1266 static bool out_done = false; // done printing to standard out 1267 static bool log_done = false; // done saving error log 1268 static bool transmit_report_done = false; // done error reporting 1269 1270 if (SuppressFatalErrorMessage) { 1271 os::abort(CreateCoredumpOnCrash); 1272 } 1273 intptr_t mytid = os::current_thread_id(); 1274 if (first_error_tid == -1 && 1275 Atomic::cmpxchg(mytid, &first_error_tid, (intptr_t)-1) == -1) { 1276 1277 // Initialize time stamps to use the same base. 1278 out.time_stamp().update_to(1); 1279 log.time_stamp().update_to(1); 1280 1281 _id = id; 1282 _message = message; 1283 _thread = thread; 1284 _pc = pc; 1285 _siginfo = siginfo; 1286 _context = context; 1287 _filename = filename; 1288 _lineno = lineno; 1289 _size = size; 1290 jio_vsnprintf(_detail_msg, sizeof(_detail_msg), detail_fmt, detail_args); 1291 1292 // first time 1293 _error_reported = true; 1294 1295 reporting_started(); 1296 record_reporting_start_time(); 1297 1298 if (ShowMessageBoxOnError || PauseAtExit) { 1299 show_message_box(buffer, sizeof(buffer)); 1300 1301 // User has asked JVM to abort. Reset ShowMessageBoxOnError so the 1302 // WatcherThread can kill JVM if the error handler hangs. 1303 ShowMessageBoxOnError = false; 1304 } 1305 1306 os::check_dump_limit(buffer, sizeof(buffer)); 1307 1308 // reset signal handlers or exception filter; make sure recursive crashes 1309 // are handled properly. 1310 reset_signal_handlers(); 1311 1312 EventShutdown e; 1313 if (e.should_commit()) { 1314 e.set_reason("VM Error"); 1315 e.commit(); 1316 } 1317 1318 TRACE_VM_ERROR(); 1319 1320 } else { 1321 // If UseOsErrorReporting we call this for each level of the call stack 1322 // while searching for the exception handler. Only the first level needs 1323 // to be reported. 1324 if (UseOSErrorReporting && log_done) return; 1325 1326 // This is not the first error, see if it happened in a different thread 1327 // or in the same thread during error reporting. 1328 if (first_error_tid != mytid) { 1329 char msgbuf[64]; 1330 jio_snprintf(msgbuf, sizeof(msgbuf), 1331 "[thread " INTX_FORMAT " also had an error]", 1332 mytid); 1333 out.print_raw_cr(msgbuf); 1334 1335 // error reporting is not MT-safe, block current thread 1336 os::infinite_sleep(); 1337 1338 } else { 1339 if (recursive_error_count++ > 30) { 1340 out.print_raw_cr("[Too many errors, abort]"); 1341 os::die(); 1342 } 1343 1344 outputStream* const st = log.is_open() ? &log : &out; 1345 st->cr(); 1346 1347 // Timeout handling. 1348 if (_step_did_timeout) { 1349 // The current step had a timeout. Lets continue reporting with the next step. 1350 st->print_raw("[timeout occurred during error reporting in step \""); 1351 st->print_raw(_current_step_info); 1352 st->print_cr("\"] after " INT64_FORMAT " s.", 1353 (int64_t) 1354 ((get_current_timestamp() - _step_start_time) / TIMESTAMP_TO_SECONDS_FACTOR)); 1355 } else if (_reporting_did_timeout) { 1356 // We hit ErrorLogTimeout. Reporting will stop altogether. Let's wrap things 1357 // up, the process is about to be stopped by the WatcherThread. 1358 st->print_cr("------ Timeout during error reporting after " INT64_FORMAT " s. ------", 1359 (int64_t) 1360 ((get_current_timestamp() - _reporting_start_time) / TIMESTAMP_TO_SECONDS_FACTOR)); 1361 st->flush(); 1362 // Watcherthread is about to call os::die. Lets just wait. 1363 os::infinite_sleep(); 1364 } else { 1365 // Crash or assert during error reporting. Lets continue reporting with the next step. 1366 jio_snprintf(buffer, sizeof(buffer), 1367 "[error occurred during error reporting (%s), id 0x%x]", 1368 _current_step_info, _id); 1369 st->print_raw_cr(buffer); 1370 st->cr(); 1371 } 1372 } 1373 } 1374 1375 // print to screen 1376 if (!out_done) { 1377 report(&out, false); 1378 1379 out_done = true; 1380 1381 _current_step = 0; 1382 _current_step_info = ""; 1383 } 1384 1385 // print to error log file 1386 if (!log_done) { 1387 // see if log file is already open 1388 if (!log.is_open()) { 1389 // open log file 1390 int fd = prepare_log_file(ErrorFile, "hs_err_pid%p.log", buffer, sizeof(buffer)); 1391 if (fd != -1) { 1392 out.print_raw("# An error report file with more information is saved as:\n# "); 1393 out.print_raw_cr(buffer); 1394 1395 log.set_fd(fd); 1396 } else { 1397 out.print_raw_cr("# Can not save log file, dump to screen.."); 1398 log.set_fd(defaultStream::output_fd()); 1399 /* Error reporting currently needs dumpfile. 1400 * Maybe implement direct streaming in the future.*/ 1401 transmit_report_done = true; 1402 } 1403 } 1404 1405 report(&log, true); 1406 log_done = true; 1407 _current_step = 0; 1408 _current_step_info = ""; 1409 1410 // Run error reporting to determine whether or not to report the crash. 1411 if (!transmit_report_done && should_report_bug(_id)) { 1412 transmit_report_done = true; 1413 const int fd2 = ::dup(log.fd()); 1414 if (fd2 != -1) { 1415 FILE* const hs_err = ::fdopen(fd2, "r"); 1416 if (NULL != hs_err) { 1417 ErrorReporter er; 1418 er.call(hs_err, buffer, O_BUFLEN); 1419 ::fclose(hs_err); 1420 } 1421 } 1422 } 1423 1424 if (log.fd() != defaultStream::output_fd()) { 1425 close(log.fd()); 1426 } 1427 1428 log.set_fd(-1); 1429 } 1430 1431 static bool skip_replay = ReplayCompiles; // Do not overwrite file during replay 1432 if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) { 1433 skip_replay = true; 1434 ciEnv* env = ciEnv::current(); 1435 if (env != NULL) { 1436 int fd = prepare_log_file(ReplayDataFile, "replay_pid%p.log", buffer, sizeof(buffer)); 1437 if (fd != -1) { 1438 FILE* replay_data_file = os::open(fd, "w"); 1439 if (replay_data_file != NULL) { 1440 fileStream replay_data_stream(replay_data_file, /*need_close=*/true); 1441 env->dump_replay_data_unsafe(&replay_data_stream); 1442 out.print_raw("#\n# Compiler replay data is saved as:\n# "); 1443 out.print_raw_cr(buffer); 1444 } else { 1445 int e = errno; 1446 out.print_raw("#\n# Can't open file to dump replay data. Error: "); 1447 out.print_raw_cr(os::strerror(e)); 1448 } 1449 } 1450 } 1451 } 1452 1453 static bool skip_bug_url = !should_report_bug(_id); 1454 if (!skip_bug_url) { 1455 skip_bug_url = true; 1456 1457 out.print_raw_cr("#"); 1458 print_bug_submit_message(&out, _thread); 1459 } 1460 1461 static bool skip_OnError = false; 1462 if (!skip_OnError && OnError && OnError[0]) { 1463 skip_OnError = true; 1464 1465 // Flush output and finish logs before running OnError commands. 1466 ostream_abort(); 1467 1468 out.print_raw_cr("#"); 1469 out.print_raw ("# -XX:OnError=\""); 1470 out.print_raw (OnError); 1471 out.print_raw_cr("\""); 1472 1473 char* cmd; 1474 const char* ptr = OnError; 1475 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ 1476 out.print_raw ("# Executing "); 1477 #if defined(LINUX) || defined(_ALLBSD_SOURCE) 1478 out.print_raw ("/bin/sh -c "); 1479 #elif defined(SOLARIS) 1480 out.print_raw ("/usr/bin/sh -c "); 1481 #elif defined(WINDOWS) 1482 out.print_raw ("cmd /C "); 1483 #endif 1484 out.print_raw ("\""); 1485 out.print_raw (cmd); 1486 out.print_raw_cr("\" ..."); 1487 1488 if (os::fork_and_exec(cmd) < 0) { 1489 out.print_cr("os::fork_and_exec failed: %s (%s=%d)", 1490 os::strerror(errno), os::errno_name(errno), errno); 1491 } 1492 } 1493 1494 // done with OnError 1495 OnError = NULL; 1496 } 1497 1498 if (!UseOSErrorReporting) { 1499 // os::abort() will call abort hooks, try it first. 1500 static bool skip_os_abort = false; 1501 if (!skip_os_abort) { 1502 skip_os_abort = true; 1503 bool dump_core = should_report_bug(_id); 1504 os::abort(dump_core && CreateCoredumpOnCrash, _siginfo, _context); 1505 } 1506 1507 // if os::abort() doesn't abort, try os::die(); 1508 os::die(); 1509 } 1510 } 1511 1512 /* 1513 * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this 1514 * ensures utilities such as jmap can observe the process is a consistent state. 1515 */ 1516 class VM_ReportJavaOutOfMemory : public VM_Operation { 1517 private: 1518 const char* _message; 1519 public: 1520 VM_ReportJavaOutOfMemory(const char* message) { _message = message; } 1521 VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; } 1522 void doit(); 1523 }; 1524 1525 void VM_ReportJavaOutOfMemory::doit() { 1526 // Don't allocate large buffer on stack 1527 static char buffer[O_BUFLEN]; 1528 1529 tty->print_cr("#"); 1530 tty->print_cr("# java.lang.OutOfMemoryError: %s", _message); 1531 tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError); 1532 1533 // make heap parsability 1534 Universe::heap()->ensure_parsability(false); // no need to retire TLABs 1535 1536 char* cmd; 1537 const char* ptr = OnOutOfMemoryError; 1538 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ 1539 tty->print("# Executing "); 1540 #if defined(LINUX) 1541 tty->print ("/bin/sh -c "); 1542 #elif defined(SOLARIS) 1543 tty->print ("/usr/bin/sh -c "); 1544 #endif 1545 tty->print_cr("\"%s\"...", cmd); 1546 1547 if (os::fork_and_exec(cmd) < 0) { 1548 tty->print_cr("os::fork_and_exec failed: %s (%s=%d)", 1549 os::strerror(errno), os::errno_name(errno), errno); 1550 } 1551 } 1552 } 1553 1554 void VMError::report_java_out_of_memory(const char* message) { 1555 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { 1556 MutexLocker ml(Heap_lock); 1557 VM_ReportJavaOutOfMemory op(message); 1558 VMThread::execute(&op); 1559 } 1560 } 1561 1562 void VMError::show_message_box(char *buf, int buflen) { 1563 bool yes; 1564 do { 1565 error_string(buf, buflen); 1566 yes = os::start_debugging(buf,buflen); 1567 } while (yes); 1568 } 1569 1570 // Timeout handling: check if a timeout happened (either a single step did 1571 // timeout or the whole of error reporting hit ErrorLogTimeout). Interrupt 1572 // the reporting thread if that is the case. 1573 bool VMError::check_timeout() { 1574 1575 if (ErrorLogTimeout == 0) { 1576 return false; 1577 } 1578 1579 // Do not check for timeouts if we still have a message box to show to the 1580 // user or if there are OnError handlers to be run. 1581 if (ShowMessageBoxOnError 1582 || (OnError != NULL && OnError[0] != '\0') 1583 || Arguments::abort_hook() != NULL) { 1584 return false; 1585 } 1586 1587 const jlong reporting_start_time_l = get_reporting_start_time(); 1588 const jlong now = get_current_timestamp(); 1589 // Timestamp is stored in nanos. 1590 if (reporting_start_time_l > 0) { 1591 const jlong end = reporting_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR; 1592 if (end <= now) { 1593 _reporting_did_timeout = true; 1594 interrupt_reporting_thread(); 1595 return true; // global timeout 1596 } 1597 } 1598 1599 const jlong step_start_time_l = get_step_start_time(); 1600 if (step_start_time_l > 0) { 1601 // A step times out after a quarter of the total timeout. Steps are mostly fast unless they 1602 // hang for some reason, so this simple rule allows for three hanging step and still 1603 // hopefully leaves time enough for the rest of the steps to finish. 1604 const jlong end = step_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR / 4; 1605 if (end <= now) { 1606 _step_did_timeout = true; 1607 interrupt_reporting_thread(); 1608 return false; // (Not a global timeout) 1609 } 1610 } 1611 1612 return false; 1613 1614 } 1615 1616 #ifndef PRODUCT 1617 typedef void (*voidfun_t)(); 1618 // Crash with an authentic sigfpe 1619 static void crash_with_sigfpe() { 1620 // generate a native synchronous SIGFPE where possible; 1621 // if that did not cause a signal (e.g. on ppc), just 1622 // raise the signal. 1623 volatile int x = 0; 1624 volatile int y = 1/x; 1625 #ifndef _WIN32 1626 // OSX implements raise(sig) incorrectly so we need to 1627 // explicitly target the current thread 1628 pthread_kill(pthread_self(), SIGFPE); 1629 #endif 1630 } // end: crash_with_sigfpe 1631 1632 // crash with sigsegv at non-null address. 1633 static void crash_with_segfault() { 1634 1635 char* const crash_addr = (char*) VMError::get_segfault_address(); 1636 *crash_addr = 'X'; 1637 1638 } // end: crash_with_segfault 1639 1640 void VMError::test_error_handler() { 1641 controlled_crash(ErrorHandlerTest); 1642 } 1643 1644 // crash in a controlled way: 1645 // how can be one of: 1646 // 1,2 - asserts 1647 // 3,4 - guarantee 1648 // 5-7 - fatal 1649 // 8 - vm_exit_out_of_memory 1650 // 9 - ShouldNotCallThis 1651 // 10 - ShouldNotReachHere 1652 // 11 - Unimplemented 1653 // 12,13 - (not guaranteed) crashes 1654 // 14 - SIGSEGV 1655 // 15 - SIGFPE 1656 void VMError::controlled_crash(int how) { 1657 if (how == 0) return; 1658 1659 // If asserts are disabled, use the corresponding guarantee instead. 1660 NOT_DEBUG(if (how <= 2) how += 2); 1661 1662 const char* const str = "hello"; 1663 const size_t num = (size_t)os::vm_page_size(); 1664 1665 const char* const eol = os::line_separator(); 1666 const char* const msg = "this message should be truncated during formatting"; 1667 char * const dataPtr = NULL; // bad data pointer 1668 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer 1669 1670 // Keep this in sync with test/hotspot/jtreg/runtime/ErrorHandling/ErrorHandler.java 1671 // which tests cases 1 thru 13. 1672 // Case 14 is tested by test/hotspot/jtreg/runtime/ErrorHandling/SafeFetchInErrorHandlingTest.java. 1673 // Case 15 is tested by test/hotspot/jtreg/runtime/ErrorHandling/SecondaryErrorTest.java. 1674 // Case 16 is tested by test/hotspot/jtreg/runtime/ErrorHandling/ThreadsListHandleInErrorHandlingTest.java. 1675 // Case 17 is tested by test/hotspot/jtreg/runtime/ErrorHandling/NestedThreadsListHandleInErrorHandlingTest.java. 1676 switch (how) { 1677 case 1: vmassert(str == NULL, "expected null"); 1678 case 2: vmassert(num == 1023 && *str == 'X', 1679 "num=" SIZE_FORMAT " str=\"%s\"", num, str); 1680 case 3: guarantee(str == NULL, "expected null"); 1681 case 4: guarantee(num == 1023 && *str == 'X', 1682 "num=" SIZE_FORMAT " str=\"%s\"", num, str); 1683 case 5: fatal("expected null"); 1684 case 6: fatal("num=" SIZE_FORMAT " str=\"%s\"", num, str); 1685 case 7: fatal("%s%s# %s%s# %s%s# %s%s# %s%s# " 1686 "%s%s# %s%s# %s%s# %s%s# %s%s# " 1687 "%s%s# %s%s# %s%s# %s%s# %s", 1688 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 1689 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 1690 msg, eol, msg, eol, msg, eol, msg, eol, msg); 1691 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate"); 1692 case 9: ShouldNotCallThis(); 1693 case 10: ShouldNotReachHere(); 1694 case 11: Unimplemented(); 1695 // There's no guarantee the bad data pointer will crash us 1696 // so "break" out to the ShouldNotReachHere(). 1697 case 12: *dataPtr = '\0'; break; 1698 // There's no guarantee the bad function pointer will crash us 1699 // so "break" out to the ShouldNotReachHere(). 1700 case 13: (*funcPtr)(); break; 1701 case 14: crash_with_segfault(); break; 1702 case 15: crash_with_sigfpe(); break; 1703 case 16: { 1704 ThreadsListHandle tlh; 1705 fatal("Force crash with an active ThreadsListHandle."); 1706 } 1707 case 17: { 1708 ThreadsListHandle tlh; 1709 { 1710 ThreadsListHandle tlh2; 1711 fatal("Force crash with a nested ThreadsListHandle."); 1712 } 1713 } 1714 1715 default: tty->print_cr("ERROR: %d: unexpected test_num value.", how); 1716 } 1717 ShouldNotReachHere(); 1718 } 1719 #endif // !PRODUCT 1720