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 // 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