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