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/vmOperations.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 /** Expand a pattern into a buffer starting at pos and open a file using constructed path */ 1193 static int expand_and_open(const char* pattern, char* buf, size_t buflen, size_t pos) { 1194 int fd = -1; 1195 if (Arguments::copy_expand_pid(pattern, strlen(pattern), &buf[pos], buflen - pos)) { 1196 // the O_EXCL flag will cause the open to fail if the file exists 1197 fd = open(buf, O_RDWR | O_CREAT | O_EXCL, 0666); 1198 } 1199 return fd; 1200 } 1201 1202 /** 1203 * Construct file name for a log file and return it's file descriptor. 1204 * Name and location depends on pattern, default_pattern params and access 1205 * permissions. 1206 */ 1207 static int prepare_log_file(const char* pattern, const char* default_pattern, char* buf, size_t buflen) { 1208 int fd = -1; 1209 1210 // If possible, use specified pattern to construct log file name 1211 if (pattern != NULL) { 1212 fd = expand_and_open(pattern, buf, buflen, 0); 1213 } 1214 1215 // Either user didn't specify, or the user's location failed, 1216 // so use the default name in the current directory 1217 if (fd == -1) { 1218 const char* cwd = os::get_current_directory(buf, buflen); 1219 if (cwd != NULL) { 1220 size_t pos = strlen(cwd); 1221 int fsep_len = jio_snprintf(&buf[pos], buflen-pos, "%s", os::file_separator()); 1222 pos += fsep_len; 1223 if (fsep_len > 0) { 1224 fd = expand_and_open(default_pattern, buf, buflen, pos); 1225 } 1226 } 1227 } 1228 1229 // try temp directory if it exists. 1230 if (fd == -1) { 1231 const char* tmpdir = os::get_temp_directory(); 1232 if (tmpdir != NULL && strlen(tmpdir) > 0) { 1233 int pos = jio_snprintf(buf, buflen, "%s%s", tmpdir, os::file_separator()); 1234 if (pos > 0) { 1235 fd = expand_and_open(default_pattern, buf, buflen, pos); 1236 } 1237 } 1238 } 1239 1240 return fd; 1241 } 1242 1243 int VMError::_id; 1244 const char* VMError::_message; 1245 char VMError::_detail_msg[1024]; 1246 Thread* VMError::_thread; 1247 address VMError::_pc; 1248 void* VMError::_siginfo; 1249 void* VMError::_context; 1250 const char* VMError::_filename; 1251 int VMError::_lineno; 1252 size_t VMError::_size; 1253 1254 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, 1255 void* context, const char* detail_fmt, ...) 1256 { 1257 va_list detail_args; 1258 va_start(detail_args, detail_fmt); 1259 report_and_die(sig, NULL, detail_fmt, detail_args, thread, pc, siginfo, context, NULL, 0, 0); 1260 va_end(detail_args); 1261 } 1262 1263 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, void* context) 1264 { 1265 report_and_die(thread, sig, pc, siginfo, context, "%s", ""); 1266 } 1267 1268 void VMError::report_and_die(const char* message, const char* detail_fmt, ...) 1269 { 1270 va_list detail_args; 1271 va_start(detail_args, detail_fmt); 1272 report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, NULL, NULL, NULL, NULL, NULL, 0, 0); 1273 va_end(detail_args); 1274 } 1275 1276 void VMError::report_and_die(const char* message) 1277 { 1278 report_and_die(message, "%s", ""); 1279 } 1280 1281 void VMError::report_and_die(Thread* thread, void* context, const char* filename, int lineno, const char* message, 1282 const char* detail_fmt, va_list detail_args) 1283 { 1284 report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, thread, NULL, NULL, context, filename, lineno, 0); 1285 } 1286 1287 void VMError::report_and_die(Thread* thread, const char* filename, int lineno, size_t size, 1288 VMErrorType vm_err_type, const char* detail_fmt, va_list detail_args) { 1289 report_and_die(vm_err_type, NULL, detail_fmt, detail_args, thread, NULL, NULL, NULL, filename, lineno, size); 1290 } 1291 1292 void VMError::report_and_die(int id, const char* message, const char* detail_fmt, va_list detail_args, 1293 Thread* thread, address pc, void* siginfo, void* context, const char* filename, 1294 int lineno, size_t size) 1295 { 1296 // A single scratch buffer to be used from here on. 1297 // Do not rely on it being preserved across function calls. 1298 static char buffer[O_BUFLEN]; 1299 1300 // File descriptor to tty to print an error summary to. 1301 // Hard wired to stdout; see JDK-8215004 (compatibility concerns). 1302 static const int fd_out = 1; 1303 1304 // File descriptor to the error log file. 1305 static int fd_log = -1; 1306 1307 // Use local fdStream objects only. Do not use global instances whose initialization 1308 // relies on dynamic initialization (see JDK-8214975). Do not rely on these instances 1309 // to carry over into recursions or invocations from other threads. 1310 fdStream out(fd_out); 1311 out.set_scratch_buffer(buffer, sizeof(buffer)); 1312 1313 fdStream log(fd_log); // May or may not be open at this point. 1314 log.set_scratch_buffer(buffer, sizeof(buffer)); 1315 1316 // How many errors occurred in error handler when reporting first_error. 1317 static int recursive_error_count; 1318 1319 // We will first print a brief message to standard out (verbose = false), 1320 // then save detailed information in log file (verbose = true). 1321 static bool out_done = false; // done printing to standard out 1322 static bool log_done = false; // done saving error log 1323 1324 if (SuppressFatalErrorMessage) { 1325 os::abort(CreateCoredumpOnCrash); 1326 } 1327 intptr_t mytid = os::current_thread_id(); 1328 if (first_error_tid == -1 && 1329 Atomic::cmpxchg(mytid, &first_error_tid, (intptr_t)-1) == -1) { 1330 1331 // Initialize time stamps to use the same base. 1332 out.time_stamp().update_to(1); 1333 log.time_stamp().update_to(1); 1334 1335 _id = id; 1336 _message = message; 1337 _thread = thread; 1338 _pc = pc; 1339 _siginfo = siginfo; 1340 _context = context; 1341 _filename = filename; 1342 _lineno = lineno; 1343 _size = size; 1344 jio_vsnprintf(_detail_msg, sizeof(_detail_msg), detail_fmt, detail_args); 1345 1346 // first time 1347 _error_reported = true; 1348 1349 reporting_started(); 1350 record_reporting_start_time(); 1351 1352 if (ShowMessageBoxOnError || PauseAtExit) { 1353 show_message_box(buffer, sizeof(buffer)); 1354 1355 // User has asked JVM to abort. Reset ShowMessageBoxOnError so the 1356 // WatcherThread can kill JVM if the error handler hangs. 1357 ShowMessageBoxOnError = false; 1358 } 1359 1360 os::check_dump_limit(buffer, sizeof(buffer)); 1361 1362 // reset signal handlers or exception filter; make sure recursive crashes 1363 // are handled properly. 1364 reset_signal_handlers(); 1365 1366 EventShutdown e; 1367 if (e.should_commit()) { 1368 e.set_reason("VM Error"); 1369 e.commit(); 1370 } 1371 1372 JFR_ONLY(Jfr::on_vm_shutdown(true);) 1373 1374 } else { 1375 // If UseOsErrorReporting we call this for each level of the call stack 1376 // while searching for the exception handler. Only the first level needs 1377 // to be reported. 1378 if (UseOSErrorReporting && log_done) return; 1379 1380 // This is not the first error, see if it happened in a different thread 1381 // or in the same thread during error reporting. 1382 if (first_error_tid != mytid) { 1383 char msgbuf[64]; 1384 jio_snprintf(msgbuf, sizeof(msgbuf), 1385 "[thread " INTX_FORMAT " also had an error]", 1386 mytid); 1387 out.print_raw_cr(msgbuf); 1388 1389 // error reporting is not MT-safe, block current thread 1390 os::infinite_sleep(); 1391 1392 } else { 1393 if (recursive_error_count++ > 30) { 1394 out.print_raw_cr("[Too many errors, abort]"); 1395 os::die(); 1396 } 1397 1398 outputStream* const st = log.is_open() ? &log : &out; 1399 st->cr(); 1400 1401 // Timeout handling. 1402 if (_step_did_timeout) { 1403 // The current step had a timeout. Lets continue reporting with the next step. 1404 st->print_raw("[timeout occurred during error reporting in step \""); 1405 st->print_raw(_current_step_info); 1406 st->print_cr("\"] after " INT64_FORMAT " s.", 1407 (int64_t) 1408 ((get_current_timestamp() - _step_start_time) / TIMESTAMP_TO_SECONDS_FACTOR)); 1409 } else if (_reporting_did_timeout) { 1410 // We hit ErrorLogTimeout. Reporting will stop altogether. Let's wrap things 1411 // up, the process is about to be stopped by the WatcherThread. 1412 st->print_cr("------ Timeout during error reporting after " INT64_FORMAT " s. ------", 1413 (int64_t) 1414 ((get_current_timestamp() - _reporting_start_time) / TIMESTAMP_TO_SECONDS_FACTOR)); 1415 st->flush(); 1416 // Watcherthread is about to call os::die. Lets just wait. 1417 os::infinite_sleep(); 1418 } else { 1419 // Crash or assert during error reporting. Lets continue reporting with the next step. 1420 stringStream ss(buffer, sizeof(buffer)); 1421 // Note: this string does get parsed by a number of jtreg tests, 1422 // see hotspot/jtreg/runtime/ErrorHandling. 1423 ss.print("[error occurred during error reporting (%s), id 0x%x", 1424 _current_step_info, id); 1425 char signal_name[64]; 1426 if (os::exception_name(id, signal_name, sizeof(signal_name))) { 1427 ss.print(", %s (0x%x) at pc=" PTR_FORMAT, signal_name, id, p2i(pc)); 1428 } else { 1429 if (should_report_bug(id)) { 1430 ss.print(", Internal Error (%s:%d)", 1431 filename == NULL ? "??" : filename, lineno); 1432 } else { 1433 ss.print(", Out of Memory Error (%s:%d)", 1434 filename == NULL ? "??" : filename, lineno); 1435 } 1436 } 1437 ss.print("]"); 1438 st->print_raw_cr(buffer); 1439 st->cr(); 1440 } 1441 } 1442 } 1443 1444 // print to screen 1445 if (!out_done) { 1446 report(&out, false); 1447 1448 out_done = true; 1449 1450 _current_step = 0; 1451 _current_step_info = ""; 1452 } 1453 1454 // print to error log file 1455 if (!log_done) { 1456 // see if log file is already open 1457 if (!log.is_open()) { 1458 // open log file 1459 fd_log = prepare_log_file(ErrorFile, "hs_err_pid%p.log", buffer, sizeof(buffer)); 1460 if (fd_log != -1) { 1461 out.print_raw("# An error report file with more information is saved as:\n# "); 1462 out.print_raw_cr(buffer); 1463 1464 log.set_fd(fd_log); 1465 } else { 1466 out.print_raw_cr("# Can not save log file, dump to screen.."); 1467 log.set_fd(fd_out); 1468 } 1469 } 1470 1471 report(&log, true); 1472 log_done = true; 1473 _current_step = 0; 1474 _current_step_info = ""; 1475 1476 if (fd_log != fd_out) { 1477 close(fd_log); 1478 } 1479 1480 fd_log = -1; 1481 log.set_fd(-1); 1482 } 1483 1484 static bool skip_replay = ReplayCompiles; // Do not overwrite file during replay 1485 if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) { 1486 skip_replay = true; 1487 ciEnv* env = ciEnv::current(); 1488 if (env != NULL) { 1489 int fd = prepare_log_file(ReplayDataFile, "replay_pid%p.log", buffer, sizeof(buffer)); 1490 if (fd != -1) { 1491 FILE* replay_data_file = os::open(fd, "w"); 1492 if (replay_data_file != NULL) { 1493 fileStream replay_data_stream(replay_data_file, /*need_close=*/true); 1494 env->dump_replay_data_unsafe(&replay_data_stream); 1495 out.print_raw("#\n# Compiler replay data is saved as:\n# "); 1496 out.print_raw_cr(buffer); 1497 } else { 1498 int e = errno; 1499 out.print_raw("#\n# Can't open file to dump replay data. Error: "); 1500 out.print_raw_cr(os::strerror(e)); 1501 } 1502 } 1503 } 1504 } 1505 1506 static bool skip_bug_url = !should_report_bug(_id); 1507 if (!skip_bug_url) { 1508 skip_bug_url = true; 1509 1510 out.print_raw_cr("#"); 1511 print_bug_submit_message(&out, _thread); 1512 } 1513 1514 static bool skip_OnError = false; 1515 if (!skip_OnError && OnError && OnError[0]) { 1516 skip_OnError = true; 1517 1518 // Flush output and finish logs before running OnError commands. 1519 ostream_abort(); 1520 1521 out.print_raw_cr("#"); 1522 out.print_raw ("# -XX:OnError=\""); 1523 out.print_raw (OnError); 1524 out.print_raw_cr("\""); 1525 1526 char* cmd; 1527 const char* ptr = OnError; 1528 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ 1529 out.print_raw ("# Executing "); 1530 #if defined(LINUX) || defined(_ALLBSD_SOURCE) 1531 out.print_raw ("/bin/sh -c "); 1532 #elif defined(SOLARIS) 1533 out.print_raw ("/usr/bin/sh -c "); 1534 #elif defined(_WINDOWS) 1535 out.print_raw ("cmd /C "); 1536 #endif 1537 out.print_raw ("\""); 1538 out.print_raw (cmd); 1539 out.print_raw_cr("\" ..."); 1540 1541 if (os::fork_and_exec(cmd) < 0) { 1542 out.print_cr("os::fork_and_exec failed: %s (%s=%d)", 1543 os::strerror(errno), os::errno_name(errno), errno); 1544 } 1545 } 1546 1547 // done with OnError 1548 OnError = NULL; 1549 } 1550 1551 if (!UseOSErrorReporting) { 1552 // os::abort() will call abort hooks, try it first. 1553 static bool skip_os_abort = false; 1554 if (!skip_os_abort) { 1555 skip_os_abort = true; 1556 bool dump_core = should_report_bug(_id); 1557 os::abort(dump_core && CreateCoredumpOnCrash, _siginfo, _context); 1558 } 1559 1560 // if os::abort() doesn't abort, try os::die(); 1561 os::die(); 1562 } 1563 } 1564 1565 /* 1566 * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this 1567 * ensures utilities such as jmap can observe the process is a consistent state. 1568 */ 1569 class VM_ReportJavaOutOfMemory : public VM_Operation { 1570 private: 1571 const char* _message; 1572 public: 1573 VM_ReportJavaOutOfMemory(const char* message) { _message = message; } 1574 VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; } 1575 void doit(); 1576 }; 1577 1578 void VM_ReportJavaOutOfMemory::doit() { 1579 // Don't allocate large buffer on stack 1580 static char buffer[O_BUFLEN]; 1581 1582 tty->print_cr("#"); 1583 tty->print_cr("# java.lang.OutOfMemoryError: %s", _message); 1584 tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError); 1585 1586 // make heap parsability 1587 Universe::heap()->ensure_parsability(false); // no need to retire TLABs 1588 1589 char* cmd; 1590 const char* ptr = OnOutOfMemoryError; 1591 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ 1592 tty->print("# Executing "); 1593 #if defined(LINUX) 1594 tty->print ("/bin/sh -c "); 1595 #elif defined(SOLARIS) 1596 tty->print ("/usr/bin/sh -c "); 1597 #endif 1598 tty->print_cr("\"%s\"...", cmd); 1599 1600 if (os::fork_and_exec(cmd, true) < 0) { 1601 tty->print_cr("os::fork_and_exec failed: %s (%s=%d)", 1602 os::strerror(errno), os::errno_name(errno), errno); 1603 } 1604 } 1605 } 1606 1607 void VMError::report_java_out_of_memory(const char* message) { 1608 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { 1609 MutexLocker ml(Heap_lock); 1610 VM_ReportJavaOutOfMemory op(message); 1611 VMThread::execute(&op); 1612 } 1613 } 1614 1615 void VMError::show_message_box(char *buf, int buflen) { 1616 bool yes; 1617 do { 1618 error_string(buf, buflen); 1619 yes = os::start_debugging(buf,buflen); 1620 } while (yes); 1621 } 1622 1623 // Timeout handling: check if a timeout happened (either a single step did 1624 // timeout or the whole of error reporting hit ErrorLogTimeout). Interrupt 1625 // the reporting thread if that is the case. 1626 bool VMError::check_timeout() { 1627 1628 if (ErrorLogTimeout == 0) { 1629 return false; 1630 } 1631 1632 // Do not check for timeouts if we still have a message box to show to the 1633 // user or if there are OnError handlers to be run. 1634 if (ShowMessageBoxOnError 1635 || (OnError != NULL && OnError[0] != '\0') 1636 || Arguments::abort_hook() != NULL) { 1637 return false; 1638 } 1639 1640 const jlong reporting_start_time_l = get_reporting_start_time(); 1641 const jlong now = get_current_timestamp(); 1642 // Timestamp is stored in nanos. 1643 if (reporting_start_time_l > 0) { 1644 const jlong end = reporting_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR; 1645 if (end <= now) { 1646 _reporting_did_timeout = true; 1647 interrupt_reporting_thread(); 1648 return true; // global timeout 1649 } 1650 } 1651 1652 const jlong step_start_time_l = get_step_start_time(); 1653 if (step_start_time_l > 0) { 1654 // A step times out after a quarter of the total timeout. Steps are mostly fast unless they 1655 // hang for some reason, so this simple rule allows for three hanging step and still 1656 // hopefully leaves time enough for the rest of the steps to finish. 1657 const jlong end = step_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR / 4; 1658 if (end <= now) { 1659 _step_did_timeout = true; 1660 interrupt_reporting_thread(); 1661 return false; // (Not a global timeout) 1662 } 1663 } 1664 1665 return false; 1666 1667 } 1668 1669 #ifndef PRODUCT 1670 #if defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140 1671 #pragma error_messages(off, SEC_NULL_PTR_DEREF) 1672 #endif 1673 typedef void (*voidfun_t)(); 1674 // Crash with an authentic sigfpe 1675 static void crash_with_sigfpe() { 1676 // generate a native synchronous SIGFPE where possible; 1677 // if that did not cause a signal (e.g. on ppc), just 1678 // raise the signal. 1679 volatile int x = 0; 1680 volatile int y = 1/x; 1681 #ifndef _WIN32 1682 // OSX implements raise(sig) incorrectly so we need to 1683 // explicitly target the current thread 1684 pthread_kill(pthread_self(), SIGFPE); 1685 #endif 1686 } // end: crash_with_sigfpe 1687 1688 // crash with sigsegv at non-null address. 1689 static void crash_with_segfault() { 1690 1691 char* const crash_addr = (char*) VMError::get_segfault_address(); 1692 *crash_addr = 'X'; 1693 1694 } // end: crash_with_segfault 1695 1696 void VMError::test_error_handler() { 1697 controlled_crash(ErrorHandlerTest); 1698 } 1699 1700 // crash in a controlled way: 1701 // how can be one of: 1702 // 1,2 - asserts 1703 // 3,4 - guarantee 1704 // 5-7 - fatal 1705 // 8 - vm_exit_out_of_memory 1706 // 9 - ShouldNotCallThis 1707 // 10 - ShouldNotReachHere 1708 // 11 - Unimplemented 1709 // 12,13 - (not guaranteed) crashes 1710 // 14 - SIGSEGV 1711 // 15 - SIGFPE 1712 void VMError::controlled_crash(int how) { 1713 if (how == 0) return; 1714 1715 // If asserts are disabled, use the corresponding guarantee instead. 1716 NOT_DEBUG(if (how <= 2) how += 2); 1717 1718 const char* const str = "hello"; 1719 const size_t num = (size_t)os::vm_page_size(); 1720 1721 const char* const eol = os::line_separator(); 1722 const char* const msg = "this message should be truncated during formatting"; 1723 char * const dataPtr = NULL; // bad data pointer 1724 const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer 1725 1726 // Keep this in sync with test/hotspot/jtreg/runtime/ErrorHandling/ErrorHandler.java 1727 // which tests cases 1 thru 13. 1728 // Case 14 is tested by test/hotspot/jtreg/runtime/ErrorHandling/SafeFetchInErrorHandlingTest.java. 1729 // Case 15 is tested by test/hotspot/jtreg/runtime/ErrorHandling/SecondaryErrorTest.java. 1730 // Case 16 is tested by test/hotspot/jtreg/runtime/ErrorHandling/ThreadsListHandleInErrorHandlingTest.java. 1731 // Case 17 is tested by test/hotspot/jtreg/runtime/ErrorHandling/NestedThreadsListHandleInErrorHandlingTest.java. 1732 1733 // We grab Threads_lock to keep ThreadsSMRSupport::print_info_on() 1734 // from racing with Threads::add() or Threads::remove() as we 1735 // generate the hs_err_pid file. This makes our ErrorHandling tests 1736 // more stable. 1737 MutexLockerEx ml(Threads_lock->owned_by_self() ? NULL : Threads_lock, Mutex::_no_safepoint_check_flag); 1738 1739 switch (how) { 1740 case 1: vmassert(str == NULL, "expected null"); break; 1741 case 2: vmassert(num == 1023 && *str == 'X', 1742 "num=" SIZE_FORMAT " str=\"%s\"", num, str); break; 1743 case 3: guarantee(str == NULL, "expected null"); break; 1744 case 4: guarantee(num == 1023 && *str == 'X', 1745 "num=" SIZE_FORMAT " str=\"%s\"", num, str); break; 1746 case 5: fatal("expected null"); break; 1747 case 6: fatal("num=" SIZE_FORMAT " str=\"%s\"", num, str); break; 1748 case 7: fatal("%s%s# %s%s# %s%s# %s%s# %s%s# " 1749 "%s%s# %s%s# %s%s# %s%s# %s%s# " 1750 "%s%s# %s%s# %s%s# %s%s# %s", 1751 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 1752 msg, eol, msg, eol, msg, eol, msg, eol, msg, eol, 1753 msg, eol, msg, eol, msg, eol, msg, eol, msg); break; 1754 case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate"); break; 1755 case 9: ShouldNotCallThis(); break; 1756 case 10: ShouldNotReachHere(); break; 1757 case 11: Unimplemented(); break; 1758 // There's no guarantee the bad data pointer will crash us 1759 // so "break" out to the ShouldNotReachHere(). 1760 case 12: *dataPtr = '\0'; break; 1761 // There's no guarantee the bad function pointer will crash us 1762 // so "break" out to the ShouldNotReachHere(). 1763 case 13: (*funcPtr)(); break; 1764 case 14: crash_with_segfault(); break; 1765 case 15: crash_with_sigfpe(); break; 1766 case 16: { 1767 ThreadsListHandle tlh; 1768 fatal("Force crash with an active ThreadsListHandle."); 1769 } 1770 case 17: { 1771 ThreadsListHandle tlh; 1772 { 1773 ThreadsListHandle tlh2; 1774 fatal("Force crash with a nested ThreadsListHandle."); 1775 } 1776 } 1777 1778 default: tty->print_cr("ERROR: %d: unexpected test_num value.", how); 1779 } 1780 tty->print_cr("VMError::controlled_crash: survived intentional crash. Did you suppress the assert?"); 1781 ShouldNotReachHere(); 1782 } 1783 #endif // !PRODUCT 1784