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/gcConfig.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 void report_vm_version(outputStream* st, char* buf, int buflen) { 308 // VM version 309 st->print_cr("#"); 310 JDK_Version::current().to_string(buf, buflen); 311 const char* runtime_name = JDK_Version::runtime_name() != NULL ? 312 JDK_Version::runtime_name() : ""; 313 const char* runtime_version = JDK_Version::runtime_version() != NULL ? 314 JDK_Version::runtime_version() : ""; 315 const char* jdk_debug_level = Abstract_VM_Version::printable_jdk_debug_level() != NULL ? 316 Abstract_VM_Version::printable_jdk_debug_level() : ""; 317 318 st->print_cr("# JRE version: %s (%s) (%sbuild %s)", runtime_name, buf, 319 jdk_debug_level, runtime_version); 320 321 // This is the long version with some default settings added 322 st->print_cr("# Java VM: %s (%s%s, %s%s%s%s%s, %s, %s)", 323 Abstract_VM_Version::vm_name(), 324 jdk_debug_level, 325 Abstract_VM_Version::vm_release(), 326 Abstract_VM_Version::vm_info_string(), 327 TieredCompilation ? ", tiered" : "", 328 #if INCLUDE_JVMCI 329 EnableJVMCI ? ", jvmci" : "", 330 UseJVMCICompiler ? ", jvmci compiler" : "", 331 #else 332 "", "", 333 #endif 334 UseCompressedOops ? ", compressed oops" : "", 335 GCConfig::hs_err_name(), 336 Abstract_VM_Version::vm_platform_string() 337 ); 338 } 339 340 // This is the main function to report a fatal error. Only one thread can 341 // call this function, so we don't need to worry about MT-safety. But it's 342 // possible that the error handler itself may crash or die on an internal 343 // error, for example, when the stack/heap is badly damaged. We must be 344 // able to handle recursive errors that happen inside error handler. 345 // 346 // Error reporting is done in several steps. If a crash or internal error 347 // occurred when reporting an error, the nested signal/exception handler 348 // can skip steps that are already (or partially) done. Error reporting will 349 // continue from the next step. This allows us to retrieve and print 350 // information that may be unsafe to get after a fatal error. If it happens, 351 // you may find nested report_and_die() frames when you look at the stack 352 // in a debugger. 353 // 354 // In general, a hang in error handler is much worse than a crash or internal 355 // error, as it's harder to recover from a hang. Deadlock can happen if we 356 // try to grab a lock that is already owned by current thread, or if the 357 // owner is blocked forever (e.g. in os::infinite_sleep()). If possible, the 358 // error handler and all the functions it called should avoid grabbing any 359 // lock. An important thing to notice is that memory allocation needs a lock. 360 // 361 // We should avoid using large stack allocated buffers. Many errors happen 362 // when stack space is already low. Making things even worse is that there 363 // could be nested report_and_die() calls on stack (see above). Only one 364 // thread can report error, so large buffers are statically allocated in data 365 // segment. 366 367 int VMError::_current_step; 368 const char* VMError::_current_step_info; 369 370 volatile jlong VMError::_reporting_start_time = -1; 371 volatile bool VMError::_reporting_did_timeout = false; 372 volatile jlong VMError::_step_start_time = -1; 373 volatile bool VMError::_step_did_timeout = false; 374 375 // Helper, return current timestamp for timeout handling. 376 jlong VMError::get_current_timestamp() { 377 return os::javaTimeNanos(); 378 } 379 // Factor to translate the timestamp to seconds. 380 #define TIMESTAMP_TO_SECONDS_FACTOR (1000 * 1000 * 1000) 381 382 void VMError::record_reporting_start_time() { 383 const jlong now = get_current_timestamp(); 384 Atomic::store(now, &_reporting_start_time); 385 } 386 387 jlong VMError::get_reporting_start_time() { 388 return Atomic::load(&_reporting_start_time); 389 } 390 391 void VMError::record_step_start_time() { 392 const jlong now = get_current_timestamp(); 393 Atomic::store(now, &_step_start_time); 394 } 395 396 jlong VMError::get_step_start_time() { 397 return Atomic::load(&_step_start_time); 398 } 399 400 void VMError::report(outputStream* st, bool _verbose) { 401 402 # define BEGIN if (_current_step == 0) { _current_step = __LINE__; 403 # define STEP(s) } if (_current_step < __LINE__) { _current_step = __LINE__; _current_step_info = s; \ 404 record_step_start_time(); _step_did_timeout = false; 405 # define END } 406 407 // don't allocate large buffer on stack 408 static char buf[O_BUFLEN]; 409 410 BEGIN 411 412 STEP("printing fatal error message") 413 414 st->print_cr("#"); 415 if (should_report_bug(_id)) { 416 st->print_cr("# A fatal error has been detected by the Java Runtime Environment:"); 417 } else { 418 st->print_cr("# There is insufficient memory for the Java " 419 "Runtime Environment to continue."); 420 } 421 422 #ifndef PRODUCT 423 // Error handler self tests 424 425 // test secondary error handling. Test it twice, to test that resetting 426 // error handler after a secondary crash works. 427 STEP("test secondary crash 1") 428 if (_verbose && TestCrashInErrorHandler != 0) { 429 st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...", 430 TestCrashInErrorHandler); 431 controlled_crash(TestCrashInErrorHandler); 432 } 433 434 STEP("test secondary crash 2") 435 if (_verbose && TestCrashInErrorHandler != 0) { 436 st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...", 437 TestCrashInErrorHandler); 438 controlled_crash(TestCrashInErrorHandler); 439 } 440 441 // TestUnresponsiveErrorHandler: We want to test both step timeouts and global timeout. 442 // Step to global timeout ratio is 4:1, so in order to be absolutely sure we hit the 443 // global timeout, let's execute the timeout step five times. 444 // See corresponding test in test/runtime/ErrorHandling/TimeoutInErrorHandlingTest.java 445 #define TIMEOUT_TEST_STEP STEP("test unresponsive error reporting step") \ 446 if (_verbose && TestUnresponsiveErrorHandler) { os::infinite_sleep(); } 447 TIMEOUT_TEST_STEP 448 TIMEOUT_TEST_STEP 449 TIMEOUT_TEST_STEP 450 TIMEOUT_TEST_STEP 451 TIMEOUT_TEST_STEP 452 453 STEP("test safefetch in error handler") 454 // test whether it is safe to use SafeFetch32 in Crash Handler. Test twice 455 // to test that resetting the signal handler works correctly. 456 if (_verbose && TestSafeFetchInErrorHandler) { 457 st->print_cr("Will test SafeFetch..."); 458 if (CanUseSafeFetch32()) { 459 int* const invalid_pointer = (int*) get_segfault_address(); 460 const int x = 0x76543210; 461 int i1 = SafeFetch32(invalid_pointer, x); 462 int i2 = SafeFetch32(invalid_pointer, x); 463 if (i1 == x && i2 == x) { 464 st->print_cr("SafeFetch OK."); // Correctly deflected and returned default pattern 465 } else { 466 st->print_cr("??"); 467 } 468 } else { 469 st->print_cr("not possible; skipped."); 470 } 471 } 472 #endif // PRODUCT 473 474 STEP("printing type of error") 475 476 switch(static_cast<unsigned int>(_id)) { 477 case OOM_MALLOC_ERROR: 478 case OOM_MMAP_ERROR: 479 if (_size) { 480 st->print("# Native memory allocation "); 481 st->print((_id == (int)OOM_MALLOC_ERROR) ? "(malloc) failed to allocate " : 482 "(mmap) failed to map "); 483 jio_snprintf(buf, sizeof(buf), SIZE_FORMAT, _size); 484 st->print("%s", buf); 485 st->print(" bytes"); 486 if (strlen(_detail_msg) > 0) { 487 st->print(" for "); 488 st->print("%s", _detail_msg); 489 } 490 st->cr(); 491 } else { 492 if (strlen(_detail_msg) > 0) { 493 st->print("# "); 494 st->print_cr("%s", _detail_msg); 495 } 496 } 497 // In error file give some solutions 498 if (_verbose) { 499 print_oom_reasons(st); 500 } else { 501 return; // that's enough for the screen 502 } 503 break; 504 case INTERNAL_ERROR: 505 default: 506 break; 507 } 508 509 STEP("printing exception/signal name") 510 511 st->print_cr("#"); 512 st->print("# "); 513 // Is it an OS exception/signal? 514 if (os::exception_name(_id, buf, sizeof(buf))) { 515 st->print("%s", buf); 516 st->print(" (0x%x)", _id); // signal number 517 st->print(" at pc=" PTR_FORMAT, p2i(_pc)); 518 } else { 519 if (should_report_bug(_id)) { 520 st->print("Internal Error"); 521 } else { 522 st->print("Out of Memory Error"); 523 } 524 if (_filename != NULL && _lineno > 0) { 525 #ifdef PRODUCT 526 // In product mode chop off pathname? 527 char separator = os::file_separator()[0]; 528 const char *p = strrchr(_filename, separator); 529 const char *file = p ? p+1 : _filename; 530 #else 531 const char *file = _filename; 532 #endif 533 st->print(" (%s:%d)", file, _lineno); 534 } else { 535 st->print(" (0x%x)", _id); 536 } 537 } 538 539 STEP("printing current thread and pid") 540 541 // process id, thread id 542 st->print(", pid=%d", os::current_process_id()); 543 st->print(", tid=" UINTX_FORMAT, os::current_thread_id()); 544 st->cr(); 545 546 STEP("printing error message") 547 548 if (should_report_bug(_id)) { // already printed the message. 549 // error message 550 if (strlen(_detail_msg) > 0) { 551 st->print_cr("# %s: %s", _message ? _message : "Error", _detail_msg); 552 } else if (_message) { 553 st->print_cr("# Error: %s", _message); 554 } 555 } 556 557 STEP("printing Java version string") 558 559 report_vm_version(st, buf, sizeof(buf)); 560 561 STEP("printing problematic frame") 562 563 // Print current frame if we have a context (i.e. it's a crash) 564 if (_context) { 565 st->print_cr("# Problematic frame:"); 566 st->print("# "); 567 frame fr = os::fetch_frame_from_context(_context); 568 fr.print_on_error(st, buf, sizeof(buf)); 569 st->cr(); 570 st->print_cr("#"); 571 } 572 573 STEP("printing core file information") 574 st->print("# "); 575 if (CreateCoredumpOnCrash) { 576 if (coredump_status) { 577 st->print("Core dump will be written. Default location: %s", coredump_message); 578 } else { 579 st->print("No core dump will be written. %s", coredump_message); 580 } 581 } else { 582 st->print("CreateCoredumpOnCrash turned off, no core file dumped"); 583 } 584 st->cr(); 585 st->print_cr("#"); 586 587 STEP("printing bug submit message") 588 589 if (should_report_bug(_id) && _verbose) { 590 print_bug_submit_message(st, _thread); 591 } 592 593 STEP("printing summary") 594 595 if (_verbose) { 596 st->cr(); 597 st->print_cr("--------------- S U M M A R Y ------------"); 598 st->cr(); 599 } 600 601 STEP("printing VM option summary") 602 603 if (_verbose) { 604 // VM options 605 Arguments::print_summary_on(st); 606 st->cr(); 607 } 608 609 STEP("printing summary machine and OS info") 610 611 if (_verbose) { 612 os::print_summary_info(st, buf, sizeof(buf)); 613 } 614 615 616 STEP("printing date and time") 617 618 if (_verbose) { 619 os::print_date_and_time(st, buf, sizeof(buf)); 620 } 621 622 STEP("printing thread") 623 624 if (_verbose) { 625 st->cr(); 626 st->print_cr("--------------- T H R E A D ---------------"); 627 st->cr(); 628 } 629 630 STEP("printing current thread") 631 632 // current thread 633 if (_verbose) { 634 if (_thread) { 635 st->print("Current thread (" PTR_FORMAT "): ", p2i(_thread)); 636 _thread->print_on_error(st, buf, sizeof(buf)); 637 st->cr(); 638 } else { 639 st->print_cr("Current thread is native thread"); 640 } 641 st->cr(); 642 } 643 644 STEP("printing current compile task") 645 646 if (_verbose && _thread && _thread->is_Compiler_thread()) { 647 CompilerThread* t = (CompilerThread*)_thread; 648 if (t->task()) { 649 st->cr(); 650 st->print_cr("Current CompileTask:"); 651 t->task()->print_line_on_error(st, buf, sizeof(buf)); 652 st->cr(); 653 } 654 } 655 656 657 STEP("printing stack bounds") 658 659 if (_verbose) { 660 st->print("Stack: "); 661 662 address stack_top; 663 size_t stack_size; 664 665 if (_thread) { 666 stack_top = _thread->stack_base(); 667 stack_size = _thread->stack_size(); 668 } else { 669 stack_top = os::current_stack_base(); 670 stack_size = os::current_stack_size(); 671 } 672 673 address stack_bottom = stack_top - stack_size; 674 st->print("[" PTR_FORMAT "," PTR_FORMAT "]", p2i(stack_bottom), p2i(stack_top)); 675 676 frame fr = _context ? os::fetch_frame_from_context(_context) 677 : os::current_frame(); 678 679 if (fr.sp()) { 680 st->print(", sp=" PTR_FORMAT, p2i(fr.sp())); 681 size_t free_stack_size = pointer_delta(fr.sp(), stack_bottom, 1024); 682 st->print(", free space=" SIZE_FORMAT "k", free_stack_size); 683 } 684 685 st->cr(); 686 } 687 688 STEP("printing native stack") 689 690 if (_verbose) { 691 if (os::platform_print_native_stack(st, _context, buf, sizeof(buf))) { 692 // We have printed the native stack in platform-specific code 693 // Windows/x64 needs special handling. 694 } else { 695 frame fr = _context ? os::fetch_frame_from_context(_context) 696 : os::current_frame(); 697 698 print_native_stack(st, fr, _thread, buf, sizeof(buf)); 699 } 700 } 701 702 STEP("printing Java stack") 703 704 if (_verbose && _thread && _thread->is_Java_thread()) { 705 print_stack_trace(st, (JavaThread*)_thread, buf, sizeof(buf)); 706 } 707 708 STEP("printing target Java thread stack") 709 710 // printing Java thread stack trace if it is involved in GC crash 711 if (_verbose && _thread && (_thread->is_Named_thread())) { 712 JavaThread* jt = ((NamedThread *)_thread)->processed_thread(); 713 if (jt != NULL) { 714 st->print_cr("JavaThread " PTR_FORMAT " (nid = %d) was being processed", p2i(jt), jt->osthread()->thread_id()); 715 print_stack_trace(st, jt, buf, sizeof(buf), true); 716 } 717 } 718 719 STEP("printing siginfo") 720 721 // signal no, signal code, address that caused the fault 722 if (_verbose && _siginfo) { 723 st->cr(); 724 os::print_siginfo(st, _siginfo); 725 st->cr(); 726 } 727 728 STEP("CDS archive access warning") 729 730 // Print an explicit hint if we crashed on access to the CDS archive. 731 if (_verbose && _siginfo) { 732 check_failing_cds_access(st, _siginfo); 733 st->cr(); 734 } 735 736 STEP("printing register info") 737 738 // decode register contents if possible 739 if (_verbose && _context && Universe::is_fully_initialized()) { 740 os::print_register_info(st, _context); 741 st->cr(); 742 } 743 744 STEP("printing registers, top of stack, instructions near pc") 745 746 // registers, top of stack, instructions near pc 747 if (_verbose && _context) { 748 os::print_context(st, _context); 749 st->cr(); 750 } 751 752 STEP("printing code blob if possible") 753 754 if (_verbose && _context) { 755 CodeBlob* cb = CodeCache::find_blob(_pc); 756 if (cb != NULL) { 757 if (Interpreter::contains(_pc)) { 758 // The interpreter CodeBlob is very large so try to print the codelet instead. 759 InterpreterCodelet* codelet = Interpreter::codelet_containing(_pc); 760 if (codelet != NULL) { 761 codelet->print_on(st); 762 Disassembler::decode(codelet->code_begin(), codelet->code_end(), st); 763 } 764 } else { 765 StubCodeDesc* desc = StubCodeDesc::desc_for(_pc); 766 if (desc != NULL) { 767 desc->print_on(st); 768 Disassembler::decode(desc->begin(), desc->end(), st); 769 } else if (_thread != NULL) { 770 // Disassembling nmethod will incur resource memory allocation, 771 // only do so when thread is valid. 772 ResourceMark rm(_thread); 773 Disassembler::decode(cb, st); 774 st->cr(); 775 } 776 } 777 } 778 } 779 780 STEP("printing VM operation") 781 782 if (_verbose && _thread && _thread->is_VM_thread()) { 783 VMThread* t = (VMThread*)_thread; 784 VM_Operation* op = t->vm_operation(); 785 if (op) { 786 op->print_on_error(st); 787 st->cr(); 788 st->cr(); 789 } 790 } 791 792 STEP("printing process") 793 794 if (_verbose) { 795 st->cr(); 796 st->print_cr("--------------- P R O C E S S ---------------"); 797 st->cr(); 798 } 799 800 STEP("printing all threads") 801 802 // all threads 803 if (_verbose && _thread) { 804 Threads::print_on_error(st, _thread, buf, sizeof(buf)); 805 st->cr(); 806 } 807 808 STEP("printing VM state") 809 810 if (_verbose) { 811 // Safepoint state 812 st->print("VM state:"); 813 814 if (SafepointSynchronize::is_synchronizing()) st->print("synchronizing"); 815 else if (SafepointSynchronize::is_at_safepoint()) st->print("at safepoint"); 816 else st->print("not at safepoint"); 817 818 // Also see if error occurred during initialization or shutdown 819 if (!Universe::is_fully_initialized()) { 820 st->print(" (not fully initialized)"); 821 } else if (VM_Exit::vm_exited()) { 822 st->print(" (shutting down)"); 823 } else { 824 st->print(" (normal execution)"); 825 } 826 st->cr(); 827 st->cr(); 828 } 829 830 STEP("printing owned locks on error") 831 832 // mutexes/monitors that currently have an owner 833 if (_verbose) { 834 print_owned_locks_on_error(st); 835 st->cr(); 836 } 837 838 STEP("printing number of OutOfMemoryError and StackOverflow exceptions") 839 840 if (_verbose && Exceptions::has_exception_counts()) { 841 st->print_cr("OutOfMemory and StackOverflow Exception counts:"); 842 Exceptions::print_exception_counts_on_error(st); 843 st->cr(); 844 } 845 846 STEP("printing compressed oops mode") 847 848 if (_verbose && UseCompressedOops) { 849 Universe::print_compressed_oops_mode(st); 850 if (UseCompressedClassPointers) { 851 Metaspace::print_compressed_class_space(st); 852 } 853 st->cr(); 854 } 855 856 STEP("printing heap information") 857 858 if (_verbose && Universe::is_fully_initialized()) { 859 Universe::heap()->print_on_error(st); 860 st->cr(); 861 st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page())); 862 st->cr(); 863 } 864 865 STEP("printing metaspace information") 866 867 if (_verbose && Universe::is_fully_initialized()) { 868 st->print_cr("Metaspace:"); 869 MetaspaceUtils::print_basic_report(st, 0); 870 } 871 872 STEP("printing code cache information") 873 874 if (_verbose && Universe::is_fully_initialized()) { 875 // print code cache information before vm abort 876 CodeCache::print_summary(st); 877 st->cr(); 878 } 879 880 STEP("printing ring buffers") 881 882 if (_verbose) { 883 Events::print_all(st); 884 st->cr(); 885 } 886 887 STEP("printing dynamic libraries") 888 889 if (_verbose) { 890 // dynamic libraries, or memory map 891 os::print_dll_info(st); 892 st->cr(); 893 } 894 895 STEP("printing native decoder state") 896 897 if (_verbose) { 898 Decoder::print_state_on(st); 899 st->cr(); 900 } 901 902 STEP("printing VM options") 903 904 if (_verbose) { 905 // VM options 906 Arguments::print_on(st); 907 st->cr(); 908 } 909 910 STEP("printing warning if internal testing API used") 911 912 if (WhiteBox::used()) { 913 st->print_cr("Unsupported internal testing APIs have been used."); 914 st->cr(); 915 } 916 917 STEP("printing log configuration") 918 if (_verbose){ 919 st->print_cr("Logging:"); 920 LogConfiguration::describe_current_configuration(st); 921 st->cr(); 922 } 923 924 STEP("printing all environment variables") 925 926 if (_verbose) { 927 os::print_environment_variables(st, env_list); 928 st->cr(); 929 } 930 931 STEP("printing signal handlers") 932 933 if (_verbose) { 934 os::print_signal_handlers(st, buf, sizeof(buf)); 935 st->cr(); 936 } 937 938 STEP("Native Memory Tracking") 939 if (_verbose) { 940 MemTracker::error_report(st); 941 } 942 943 STEP("printing system") 944 945 if (_verbose) { 946 st->cr(); 947 st->print_cr("--------------- S Y S T E M ---------------"); 948 st->cr(); 949 } 950 951 STEP("printing OS information") 952 953 if (_verbose) { 954 os::print_os_info(st); 955 st->cr(); 956 } 957 958 STEP("printing CPU info") 959 if (_verbose) { 960 os::print_cpu_info(st, buf, sizeof(buf)); 961 st->cr(); 962 } 963 964 STEP("printing memory info") 965 966 if (_verbose) { 967 os::print_memory_info(st); 968 st->cr(); 969 } 970 971 STEP("printing internal vm info") 972 973 if (_verbose) { 974 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); 975 st->cr(); 976 } 977 978 // print a defined marker to show that error handling finished correctly. 979 STEP("printing end marker") 980 981 if (_verbose) { 982 st->print_cr("END."); 983 } 984 985 END 986 987 # undef BEGIN 988 # undef STEP 989 # undef END 990 } 991 992 // Report for the vm_info_cmd. This prints out the information above omitting 993 // crash and thread specific information. If output is added above, it should be added 994 // here also, if it is safe to call during a running process. 995 void VMError::print_vm_info(outputStream* st) { 996 997 char buf[O_BUFLEN]; 998 report_vm_version(st, buf, sizeof(buf)); 999 1000 // STEP("printing summary") 1001 1002 st->cr(); 1003 st->print_cr("--------------- S U M M A R Y ------------"); 1004 st->cr(); 1005 1006 // STEP("printing VM option summary") 1007 1008 // VM options 1009 Arguments::print_summary_on(st); 1010 st->cr(); 1011 1012 // STEP("printing summary machine and OS info") 1013 1014 os::print_summary_info(st, buf, sizeof(buf)); 1015 1016 // STEP("printing date and time") 1017 1018 os::print_date_and_time(st, buf, sizeof(buf)); 1019 1020 // Skip: STEP("printing thread") 1021 1022 // STEP("printing process") 1023 1024 st->cr(); 1025 st->print_cr("--------------- P R O C E S S ---------------"); 1026 st->cr(); 1027 1028 // STEP("printing number of OutOfMemoryError and StackOverflow exceptions") 1029 1030 if (Exceptions::has_exception_counts()) { 1031 st->print_cr("OutOfMemory and StackOverflow Exception counts:"); 1032 Exceptions::print_exception_counts_on_error(st); 1033 st->cr(); 1034 } 1035 1036 // STEP("printing compressed oops mode") 1037 1038 if (UseCompressedOops) { 1039 Universe::print_compressed_oops_mode(st); 1040 if (UseCompressedClassPointers) { 1041 Metaspace::print_compressed_class_space(st); 1042 } 1043 st->cr(); 1044 } 1045 1046 // STEP("printing heap information") 1047 1048 if (Universe::is_fully_initialized()) { 1049 MutexLocker hl(Heap_lock); 1050 Universe::heap()->print_on_error(st); 1051 st->cr(); 1052 st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page())); 1053 st->cr(); 1054 } 1055 1056 // STEP("printing metaspace information") 1057 1058 if (Universe::is_fully_initialized()) { 1059 st->print_cr("Metaspace:"); 1060 MetaspaceUtils::print_basic_report(st, 0); 1061 } 1062 1063 // STEP("printing code cache information") 1064 1065 if (Universe::is_fully_initialized()) { 1066 // print code cache information before vm abort 1067 CodeCache::print_summary(st); 1068 st->cr(); 1069 } 1070 1071 // STEP("printing ring buffers") 1072 1073 Events::print_all(st); 1074 st->cr(); 1075 1076 // STEP("printing dynamic libraries") 1077 1078 // dynamic libraries, or memory map 1079 os::print_dll_info(st); 1080 st->cr(); 1081 1082 // STEP("printing VM options") 1083 1084 // VM options 1085 Arguments::print_on(st); 1086 st->cr(); 1087 1088 // STEP("printing warning if internal testing API used") 1089 1090 if (WhiteBox::used()) { 1091 st->print_cr("Unsupported internal testing APIs have been used."); 1092 st->cr(); 1093 } 1094 1095 // STEP("printing log configuration") 1096 st->print_cr("Logging:"); 1097 LogConfiguration::describe(st); 1098 st->cr(); 1099 1100 // STEP("printing all environment variables") 1101 1102 os::print_environment_variables(st, env_list); 1103 st->cr(); 1104 1105 // STEP("printing signal handlers") 1106 1107 os::print_signal_handlers(st, buf, sizeof(buf)); 1108 st->cr(); 1109 1110 // STEP("Native Memory Tracking") 1111 1112 MemTracker::error_report(st); 1113 1114 // STEP("printing system") 1115 1116 st->cr(); 1117 st->print_cr("--------------- S Y S T E M ---------------"); 1118 st->cr(); 1119 1120 // STEP("printing OS information") 1121 1122 os::print_os_info(st); 1123 st->cr(); 1124 1125 // STEP("printing CPU info") 1126 1127 os::print_cpu_info(st, buf, sizeof(buf)); 1128 st->cr(); 1129 1130 // STEP("printing memory info") 1131 1132 os::print_memory_info(st); 1133 st->cr(); 1134 1135 // STEP("printing internal vm info") 1136 1137 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); 1138 st->cr(); 1139 1140 // print a defined marker to show that error handling finished correctly. 1141 // STEP("printing end marker") 1142 1143 st->print_cr("END."); 1144 } 1145 1146 volatile intptr_t VMError::first_error_tid = -1; 1147 1148 // An error could happen before tty is initialized or after it has been 1149 // destroyed. 1150 // Please note: to prevent large stack allocations, the log- and 1151 // output-stream use a global scratch buffer for format printing. 1152 // (see VmError::report_and_die(). Access to those streams is synchronized 1153 // in VmError::report_and_die() - there is only one reporting thread at 1154 // any given time. 1155 fdStream VMError::out(defaultStream::output_fd()); 1156 fdStream VMError::log; // error log used by VMError::report_and_die() 1157 1158 /** Expand a pattern into a buffer starting at pos and open a file using constructed path */ 1159 static int expand_and_open(const char* pattern, char* buf, size_t buflen, size_t pos) { 1160 int fd = -1; 1161 if (Arguments::copy_expand_pid(pattern, strlen(pattern), &buf[pos], buflen - pos)) { 1162 // the O_EXCL flag will cause the open to fail if the file exists 1163 fd = open(buf, O_RDWR | O_CREAT | O_EXCL, 0666); 1164 } 1165 return fd; 1166 } 1167 1168 /** 1169 * Construct file name for a log file and return it's file descriptor. 1170 * Name and location depends on pattern, default_pattern params and access 1171 * permissions. 1172 */ 1173 static int prepare_log_file(const char* pattern, const char* default_pattern, char* buf, size_t buflen) { 1174 int fd = -1; 1175 1176 // If possible, use specified pattern to construct log file name 1177 if (pattern != NULL) { 1178 fd = expand_and_open(pattern, buf, buflen, 0); 1179 } 1180 1181 // Either user didn't specify, or the user's location failed, 1182 // so use the default name in the current directory 1183 if (fd == -1) { 1184 const char* cwd = os::get_current_directory(buf, buflen); 1185 if (cwd != NULL) { 1186 size_t pos = strlen(cwd); 1187 int fsep_len = jio_snprintf(&buf[pos], buflen-pos, "%s", os::file_separator()); 1188 pos += fsep_len; 1189 if (fsep_len > 0) { 1190 fd = expand_and_open(default_pattern, buf, buflen, pos); 1191 } 1192 } 1193 } 1194 1195 // try temp directory if it exists. 1196 if (fd == -1) { 1197 const char* tmpdir = os::get_temp_directory(); 1198 if (tmpdir != NULL && strlen(tmpdir) > 0) { 1199 int pos = jio_snprintf(buf, buflen, "%s%s", tmpdir, os::file_separator()); 1200 if (pos > 0) { 1201 fd = expand_and_open(default_pattern, buf, buflen, pos); 1202 } 1203 } 1204 } 1205 1206 return fd; 1207 } 1208 1209 int VMError::_id; 1210 const char* VMError::_message; 1211 char VMError::_detail_msg[1024]; 1212 Thread* VMError::_thread; 1213 address VMError::_pc; 1214 void* VMError::_siginfo; 1215 void* VMError::_context; 1216 const char* VMError::_filename; 1217 int VMError::_lineno; 1218 size_t VMError::_size; 1219 1220 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, 1221 void* context, const char* detail_fmt, ...) 1222 { 1223 va_list detail_args; 1224 va_start(detail_args, detail_fmt); 1225 report_and_die(sig, NULL, detail_fmt, detail_args, thread, pc, siginfo, context, NULL, 0, 0); 1226 va_end(detail_args); 1227 } 1228 1229 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, void* context) 1230 { 1231 report_and_die(thread, sig, pc, siginfo, context, "%s", ""); 1232 } 1233 1234 void VMError::report_and_die(const char* message, const char* detail_fmt, ...) 1235 { 1236 va_list detail_args; 1237 va_start(detail_args, detail_fmt); 1238 report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, NULL, NULL, NULL, NULL, NULL, 0, 0); 1239 va_end(detail_args); 1240 } 1241 1242 void VMError::report_and_die(const char* message) 1243 { 1244 report_and_die(message, "%s", ""); 1245 } 1246 1247 void VMError::report_and_die(Thread* thread, void* context, const char* filename, int lineno, const char* message, 1248 const char* detail_fmt, va_list detail_args) 1249 { 1250 report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, thread, NULL, NULL, context, filename, lineno, 0); 1251 } 1252 1253 void VMError::report_and_die(Thread* thread, const char* filename, int lineno, size_t size, 1254 VMErrorType vm_err_type, const char* detail_fmt, va_list detail_args) { 1255 report_and_die(vm_err_type, NULL, detail_fmt, detail_args, thread, NULL, NULL, NULL, filename, lineno, size); 1256 } 1257 1258 void VMError::report_and_die(int id, const char* message, const char* detail_fmt, va_list detail_args, 1259 Thread* thread, address pc, void* siginfo, void* context, const char* filename, 1260 int lineno, size_t size) 1261 { 1262 // Don't allocate large buffer on stack 1263 static char buffer[O_BUFLEN]; 1264 out.set_scratch_buffer(buffer, sizeof(buffer)); 1265 log.set_scratch_buffer(buffer, sizeof(buffer)); 1266 1267 // How many errors occurred in error handler when reporting first_error. 1268 static int recursive_error_count; 1269 1270 // We will first print a brief message to standard out (verbose = false), 1271 // then save detailed information in log file (verbose = true). 1272 static bool out_done = false; // done printing to standard out 1273 static bool log_done = false; // done saving error log 1274 static bool transmit_report_done = false; // done error reporting 1275 1276 if (SuppressFatalErrorMessage) { 1277 os::abort(CreateCoredumpOnCrash); 1278 } 1279 intptr_t mytid = os::current_thread_id(); 1280 if (first_error_tid == -1 && 1281 Atomic::cmpxchg(mytid, &first_error_tid, (intptr_t)-1) == -1) { 1282 1283 // Initialize time stamps to use the same base. 1284 out.time_stamp().update_to(1); 1285 log.time_stamp().update_to(1); 1286 1287 _id = id; 1288 _message = message; 1289 _thread = thread; 1290 _pc = pc; 1291 _siginfo = siginfo; 1292 _context = context; 1293 _filename = filename; 1294 _lineno = lineno; 1295 _size = size; 1296 jio_vsnprintf(_detail_msg, sizeof(_detail_msg), detail_fmt, detail_args); 1297 1298 // first time 1299 _error_reported = true; 1300 1301 reporting_started(); 1302 record_reporting_start_time(); 1303 1304 if (ShowMessageBoxOnError || PauseAtExit) { 1305 show_message_box(buffer, sizeof(buffer)); 1306 1307 // User has asked JVM to abort. Reset ShowMessageBoxOnError so the 1308 // WatcherThread can kill JVM if the error handler hangs. 1309 ShowMessageBoxOnError = false; 1310 } 1311 1312 os::check_dump_limit(buffer, sizeof(buffer)); 1313 1314 // reset signal handlers or exception filter; make sure recursive crashes 1315 // are handled properly. 1316 reset_signal_handlers(); 1317 1318 EventShutdown e; 1319 if (e.should_commit()) { 1320 e.set_reason("VM Error"); 1321 e.commit(); 1322 } 1323 1324 TRACE_VM_ERROR(); 1325 1326 } else { 1327 // If UseOsErrorReporting we call this for each level of the call stack 1328 // while searching for the exception handler. Only the first level needs 1329 // to be reported. 1330 if (UseOSErrorReporting && log_done) return; 1331 1332 // This is not the first error, see if it happened in a different thread 1333 // or in the same thread during error reporting. 1334 if (first_error_tid != mytid) { 1335 char msgbuf[64]; 1336 jio_snprintf(msgbuf, sizeof(msgbuf), 1337 "[thread " INTX_FORMAT " also had an error]", 1338 mytid); 1339 out.print_raw_cr(msgbuf); 1340 1341 // error reporting is not MT-safe, block current thread 1342 os::infinite_sleep(); 1343 1344 } else { 1345 if (recursive_error_count++ > 30) { 1346 out.print_raw_cr("[Too many errors, abort]"); 1347 os::die(); 1348 } 1349 1350 outputStream* const st = log.is_open() ? &log : &out; 1351 st->cr(); 1352 1353 // Timeout handling. 1354 if (_step_did_timeout) { 1355 // The current step had a timeout. Lets continue reporting with the next step. 1356 st->print_raw("[timeout occurred during error reporting in step \""); 1357 st->print_raw(_current_step_info); 1358 st->print_cr("\"] after " INT64_FORMAT " s.", 1359 (int64_t) 1360 ((get_current_timestamp() - _step_start_time) / TIMESTAMP_TO_SECONDS_FACTOR)); 1361 } else if (_reporting_did_timeout) { 1362 // We hit ErrorLogTimeout. Reporting will stop altogether. Let's wrap things 1363 // up, the process is about to be stopped by the WatcherThread. 1364 st->print_cr("------ Timeout during error reporting after " INT64_FORMAT " s. ------", 1365 (int64_t) 1366 ((get_current_timestamp() - _reporting_start_time) / TIMESTAMP_TO_SECONDS_FACTOR)); 1367 st->flush(); 1368 // Watcherthread is about to call os::die. Lets just wait. 1369 os::infinite_sleep(); 1370 } else { 1371 // Crash or assert during error reporting. Lets continue reporting with the next step. 1372 jio_snprintf(buffer, sizeof(buffer), 1373 "[error occurred during error reporting (%s), id 0x%x]", 1374 _current_step_info, _id); 1375 st->print_raw_cr(buffer); 1376 st->cr(); 1377 } 1378 } 1379 } 1380 1381 // print to screen 1382 if (!out_done) { 1383 report(&out, false); 1384 1385 out_done = true; 1386 1387 _current_step = 0; 1388 _current_step_info = ""; 1389 } 1390 1391 // print to error log file 1392 if (!log_done) { 1393 // see if log file is already open 1394 if (!log.is_open()) { 1395 // open log file 1396 int fd = prepare_log_file(ErrorFile, "hs_err_pid%p.log", buffer, sizeof(buffer)); 1397 if (fd != -1) { 1398 out.print_raw("# An error report file with more information is saved as:\n# "); 1399 out.print_raw_cr(buffer); 1400 1401 log.set_fd(fd); 1402 } else { 1403 out.print_raw_cr("# Can not save log file, dump to screen.."); 1404 log.set_fd(defaultStream::output_fd()); 1405 /* Error reporting currently needs dumpfile. 1406 * Maybe implement direct streaming in the future.*/ 1407 transmit_report_done = true; 1408 } 1409 } 1410 1411 report(&log, true); 1412 log_done = true; 1413 _current_step = 0; 1414 _current_step_info = ""; 1415 1416 // Run error reporting to determine whether or not to report the crash. 1417 if (!transmit_report_done && should_report_bug(_id)) { 1418 transmit_report_done = true; 1419 const int fd2 = ::dup(log.fd()); 1420 if (fd2 != -1) { 1421 FILE* const hs_err = ::fdopen(fd2, "r"); 1422 if (NULL != hs_err) { 1423 ErrorReporter er; 1424 er.call(hs_err, buffer, O_BUFLEN); 1425 ::fclose(hs_err); 1426 } 1427 } 1428 } 1429 1430 if (log.fd() != defaultStream::output_fd()) { 1431 close(log.fd()); 1432 } 1433 1434 log.set_fd(-1); 1435 } 1436 1437 static bool skip_replay = ReplayCompiles; // Do not overwrite file during replay 1438 if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) { 1439 skip_replay = true; 1440 ciEnv* env = ciEnv::current(); 1441 if (env != NULL) { 1442 int fd = prepare_log_file(ReplayDataFile, "replay_pid%p.log", buffer, sizeof(buffer)); 1443 if (fd != -1) { 1444 FILE* replay_data_file = os::open(fd, "w"); 1445 if (replay_data_file != NULL) { 1446 fileStream replay_data_stream(replay_data_file, /*need_close=*/true); 1447 env->dump_replay_data_unsafe(&replay_data_stream); 1448 out.print_raw("#\n# Compiler replay data is saved as:\n# "); 1449 out.print_raw_cr(buffer); 1450 } else { 1451 int e = errno; 1452 out.print_raw("#\n# Can't open file to dump replay data. Error: "); 1453 out.print_raw_cr(os::strerror(e)); 1454 } 1455 } 1456 } 1457 } 1458 1459 static bool skip_bug_url = !should_report_bug(_id); 1460 if (!skip_bug_url) { 1461 skip_bug_url = true; 1462 1463 out.print_raw_cr("#"); 1464 print_bug_submit_message(&out, _thread); 1465 } 1466 1467 static bool skip_OnError = false; 1468 if (!skip_OnError && OnError && OnError[0]) { 1469 skip_OnError = true; 1470 1471 // Flush output and finish logs before running OnError commands. 1472 ostream_abort(); 1473 1474 out.print_raw_cr("#"); 1475 out.print_raw ("# -XX:OnError=\""); 1476 out.print_raw (OnError); 1477 out.print_raw_cr("\""); 1478 1479 char* cmd; 1480 const char* ptr = OnError; 1481 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ 1482 out.print_raw ("# Executing "); 1483 #if defined(LINUX) || defined(_ALLBSD_SOURCE) 1484 out.print_raw ("/bin/sh -c "); 1485 #elif defined(SOLARIS) 1486 out.print_raw ("/usr/bin/sh -c "); 1487 #elif defined(_WINDOWS) 1488 out.print_raw ("cmd /C "); 1489 #endif 1490 out.print_raw ("\""); 1491 out.print_raw (cmd); 1492 out.print_raw_cr("\" ..."); 1493 1494 if (os::fork_and_exec(cmd) < 0) { 1495 out.print_cr("os::fork_and_exec failed: %s (%s=%d)", 1496 os::strerror(errno), os::errno_name(errno), errno); 1497 } 1498 } 1499 1500 // done with OnError 1501 OnError = NULL; 1502 } 1503 1504 if (!UseOSErrorReporting) { 1505 // os::abort() will call abort hooks, try it first. 1506 static bool skip_os_abort = false; 1507 if (!skip_os_abort) { 1508 skip_os_abort = true; 1509 bool dump_core = should_report_bug(_id); 1510 os::abort(dump_core && CreateCoredumpOnCrash, _siginfo, _context); 1511 } 1512 1513 // if os::abort() doesn't abort, try os::die(); 1514 os::die(); 1515 } 1516 } 1517 1518 /* 1519 * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this 1520 * ensures utilities such as jmap can observe the process is a consistent state. 1521 */ 1522 class VM_ReportJavaOutOfMemory : public VM_Operation { 1523 private: 1524 const char* _message; 1525 public: 1526 VM_ReportJavaOutOfMemory(const char* message) { _message = message; } 1527 VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; } 1528 void doit(); 1529 }; 1530 1531 void VM_ReportJavaOutOfMemory::doit() { 1532 // Don't allocate large buffer on stack 1533 static char buffer[O_BUFLEN]; 1534 1535 tty->print_cr("#"); 1536 tty->print_cr("# java.lang.OutOfMemoryError: %s", _message); 1537 tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError); 1538 1539 // make heap parsability 1540 Universe::heap()->ensure_parsability(false); // no need to retire TLABs 1541 1542 char* cmd; 1543 const char* ptr = OnOutOfMemoryError; 1544 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ 1545 tty->print("# Executing "); 1546 #if defined(LINUX) 1547 tty->print ("/bin/sh -c "); 1548 #elif defined(SOLARIS) 1549 tty->print ("/usr/bin/sh -c "); 1550 #endif 1551 tty->print_cr("\"%s\"...", cmd); 1552 1553 if (os::fork_and_exec(cmd) < 0) { 1554 tty->print_cr("os::fork_and_exec failed: %s (%s=%d)", 1555 os::strerror(errno), os::errno_name(errno), errno); 1556 } 1557 } 1558 } 1559 1560 void VMError::report_java_out_of_memory(const char* message) { 1561 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { 1562 MutexLocker ml(Heap_lock); 1563 VM_ReportJavaOutOfMemory op(message); 1564 VMThread::execute(&op); 1565 } 1566 } 1567 1568 void VMError::show_message_box(char *buf, int buflen) { 1569 bool yes; 1570 do { 1571 error_string(buf, buflen); 1572 yes = os::start_debugging(buf,buflen); 1573 } while (yes); 1574 } 1575 1576 // Timeout handling: check if a timeout happened (either a single step did 1577 // timeout or the whole of error reporting hit ErrorLogTimeout). Interrupt 1578 // the reporting thread if that is the case. 1579 bool VMError::check_timeout() { 1580 1581 if (ErrorLogTimeout == 0) { 1582 return false; 1583 } 1584 1585 // Do not check for timeouts if we still have a message box to show to the 1586 // user or if there are OnError handlers to be run. 1587 if (ShowMessageBoxOnError 1588 || (OnError != NULL && OnError[0] != '\0') 1589 || Arguments::abort_hook() != NULL) { 1590 return false; 1591 } 1592 1593 const jlong reporting_start_time_l = get_reporting_start_time(); 1594 const jlong now = get_current_timestamp(); 1595 // Timestamp is stored in nanos. 1596 if (reporting_start_time_l > 0) { 1597 const jlong end = reporting_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR; 1598 if (end <= now) { 1599 _reporting_did_timeout = true; 1600 interrupt_reporting_thread(); 1601 return true; // global timeout 1602 } 1603 } 1604 1605 const jlong step_start_time_l = get_step_start_time(); 1606 if (step_start_time_l > 0) { 1607 // A step times out after a quarter of the total timeout. Steps are mostly fast unless they 1608 // hang for some reason, so this simple rule allows for three hanging step and still 1609 // hopefully leaves time enough for the rest of the steps to finish. 1610 const jlong end = step_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR / 4; 1611 if (end <= now) { 1612 _step_did_timeout = true; 1613 interrupt_reporting_thread(); 1614 return false; // (Not a global timeout) 1615 } 1616 } 1617 1618 return false; 1619 1620 } 1621 1622 #ifndef PRODUCT 1623 typedef void (*voidfun_t)(); 1624 // Crash with an authentic sigfpe 1625 static void crash_with_sigfpe() { 1626 // generate a native synchronous SIGFPE where possible; 1627 // if that did not cause a signal (e.g. on ppc), just 1628 // raise the signal. 1629 volatile int x = 0; 1630 volatile int y = 1/x; 1631 #ifndef _WIN32 1632 // OSX implements raise(sig) incorrectly so we need to 1633 // explicitly target the current thread 1634 pthread_kill(pthread_self(), SIGFPE); 1635 #endif 1636 } // end: crash_with_sigfpe 1637 1638 // crash with sigsegv at non-null address. 1639 static void crash_with_segfault() { 1640 1641 char* const crash_addr = (char*) VMError::get_segfault_address(); 1642 *crash_addr = 'X'; 1643 1644 } // end: crash_with_segfault 1645 1646 void VMError::test_error_handler() { 1647 controlled_crash(ErrorHandlerTest); 1648 } 1649 1650 // crash in a controlled way: 1651 // how can be one of: 1652 // 1,2 - asserts 1653 // 3,4 - guarantee 1654 // 5-7 - fatal 1655 // 8 - vm_exit_out_of_memory 1656 // 9 - ShouldNotCallThis 1657 // 10 - ShouldNotReachHere 1658 // 11 - Unimplemented 1659 // 12,13 - (not guaranteed) crashes 1660 // 14 - SIGSEGV 1661 // 15 - SIGFPE 1662 void VMError::controlled_crash(int how) { 1663 if (how == 0) return; 1664 1665 // If asserts are disabled, use the corresponding guarantee instead. 1666 NOT_DEBUG(if (how <= 2) how += 2); 1667 1668 const char* const str = "hello"; 1669 const size_t num = (size_t)os::vm_page_size(); 1670 1671 const char* const eol = os::line_separator(); 1672 const char* const msg = "this message should be truncated during formatting"; 1673 char * const dataPtr = NULL; // bad data pointer 1674 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer 1675 1676 // Keep this in sync with test/hotspot/jtreg/runtime/ErrorHandling/ErrorHandler.java 1677 // which tests cases 1 thru 13. 1678 // Case 14 is tested by test/hotspot/jtreg/runtime/ErrorHandling/SafeFetchInErrorHandlingTest.java. 1679 // Case 15 is tested by test/hotspot/jtreg/runtime/ErrorHandling/SecondaryErrorTest.java. 1680 // Case 16 is tested by test/hotspot/jtreg/runtime/ErrorHandling/ThreadsListHandleInErrorHandlingTest.java. 1681 // Case 17 is tested by test/hotspot/jtreg/runtime/ErrorHandling/NestedThreadsListHandleInErrorHandlingTest.java. 1682 switch (how) { 1683 case 1: vmassert(str == NULL, "expected null"); break; 1684 case 2: vmassert(num == 1023 && *str == 'X', 1685 "num=" SIZE_FORMAT " str=\"%s\"", num, str); break; 1686 case 3: guarantee(str == NULL, "expected null"); break; 1687 case 4: guarantee(num == 1023 && *str == 'X', 1688 "num=" SIZE_FORMAT " str=\"%s\"", num, str); break; 1689 case 5: fatal("expected null"); break; 1690 case 6: fatal("num=" SIZE_FORMAT " str=\"%s\"", num, str); break; 1691 case 7: fatal("%s%s# %s%s# %s%s# %s%s# %s%s# " 1692 "%s%s# %s%s# %s%s# %s%s# %s%s# " 1693 "%s%s# %s%s# %s%s# %s%s# %s", 1694 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 1695 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 1696 msg, eol, msg, eol, msg, eol, msg, eol, msg); break; 1697 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate"); break; 1698 case 9: ShouldNotCallThis(); break; 1699 case 10: ShouldNotReachHere(); break; 1700 case 11: Unimplemented(); break; 1701 // There's no guarantee the bad data pointer will crash us 1702 // so "break" out to the ShouldNotReachHere(). 1703 case 12: *dataPtr = '\0'; break; 1704 // There's no guarantee the bad function pointer will crash us 1705 // so "break" out to the ShouldNotReachHere(). 1706 case 13: (*funcPtr)(); break; 1707 case 14: crash_with_segfault(); break; 1708 case 15: crash_with_sigfpe(); break; 1709 case 16: { 1710 ThreadsListHandle tlh; 1711 fatal("Force crash with an active ThreadsListHandle."); 1712 } 1713 case 17: { 1714 ThreadsListHandle tlh; 1715 { 1716 ThreadsListHandle tlh2; 1717 fatal("Force crash with a nested ThreadsListHandle."); 1718 } 1719 } 1720 1721 default: tty->print_cr("ERROR: %d: unexpected test_num value.", how); 1722 } 1723 tty->print_cr("VMError::controlled_crash: survived intentional crash. Did you suppress the assert?"); 1724 ShouldNotReachHere(); 1725 } 1726 #endif // !PRODUCT 1727