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