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 top of stack info")
 752 
 753      // decode stack contents if possible
 754      if (_verbose && _context && Universe::is_fully_initialized()) {
 755        frame fr = os::fetch_frame_from_context(_context);
 756        const int slots = 8;
 757        const intptr_t *start = fr.sp();
 758        const intptr_t *end = start + slots;
 759        if (is_aligned(start, sizeof(intptr_t)) && os::is_readable_range(start, end)) {
 760          st->print_cr("Stack slot to memory mapping:");
 761          for (int i = 0; i < slots; ++i) {
 762            st->print("stack at sp + %d slots: ", i);
 763            os::print_location(st, *(start + i));
 764          }
 765        }
 766        st->cr();
 767      }
 768 
 769   STEP("printing registers, top of stack, instructions near pc")
 770 
 771      // registers, top of stack, instructions near pc
 772      if (_verbose && _context) {
 773        os::print_context(st, _context);
 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   STEP("printing all threads")
 826 
 827      // all threads
 828      if (_verbose && _thread) {
 829        Threads::print_on_error(st, _thread, buf, sizeof(buf));
 830        st->cr();
 831      }
 832 
 833   STEP("printing VM state")
 834 
 835      if (_verbose) {
 836        // Safepoint state
 837        st->print("VM state:");
 838 
 839        if (SafepointSynchronize::is_synchronizing()) st->print("synchronizing");
 840        else if (SafepointSynchronize::is_at_safepoint()) st->print("at safepoint");
 841        else st->print("not at safepoint");
 842 
 843        // Also see if error occurred during initialization or shutdown
 844        if (!Universe::is_fully_initialized()) {
 845          st->print(" (not fully initialized)");
 846        } else if (VM_Exit::vm_exited()) {
 847          st->print(" (shutting down)");
 848        } else {
 849          st->print(" (normal execution)");
 850        }
 851        st->cr();
 852        st->cr();
 853      }
 854 
 855   STEP("printing owned locks on error")
 856 
 857      // mutexes/monitors that currently have an owner
 858      if (_verbose) {
 859        print_owned_locks_on_error(st);
 860        st->cr();
 861      }
 862 
 863   STEP("printing number of OutOfMemoryError and StackOverflow exceptions")
 864 
 865      if (_verbose && Exceptions::has_exception_counts()) {
 866        st->print_cr("OutOfMemory and StackOverflow Exception counts:");
 867        Exceptions::print_exception_counts_on_error(st);
 868        st->cr();
 869      }
 870 
 871   STEP("printing compressed oops mode")
 872 
 873      if (_verbose && UseCompressedOops) {
 874        Universe::print_compressed_oops_mode(st);
 875        if (UseCompressedClassPointers) {
 876          Metaspace::print_compressed_class_space(st);
 877        }
 878        st->cr();
 879      }
 880 
 881   STEP("printing heap information")
 882 
 883      if (_verbose && Universe::is_fully_initialized()) {
 884        Universe::heap()->print_on_error(st);
 885        st->cr();
 886        st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page()));
 887        st->cr();
 888      }
 889 
 890   STEP("printing metaspace information")
 891 
 892      if (_verbose && Universe::is_fully_initialized()) {
 893        st->print_cr("Metaspace:");
 894        MetaspaceUtils::print_basic_report(st, 0);
 895      }
 896 
 897   STEP("printing code cache information")
 898 
 899      if (_verbose && Universe::is_fully_initialized()) {
 900        // print code cache information before vm abort
 901        CodeCache::print_summary(st);
 902        st->cr();
 903      }
 904 
 905   STEP("printing ring buffers")
 906 
 907      if (_verbose) {
 908        Events::print_all(st);
 909        st->cr();
 910      }
 911 
 912   STEP("printing dynamic libraries")
 913 
 914      if (_verbose) {
 915        // dynamic libraries, or memory map
 916        os::print_dll_info(st);
 917        st->cr();
 918      }
 919 
 920   STEP("printing native decoder state")
 921 
 922      if (_verbose) {
 923        Decoder::print_state_on(st);
 924        st->cr();
 925      }
 926 
 927   STEP("printing VM options")
 928 
 929      if (_verbose) {
 930        // VM options
 931        Arguments::print_on(st);
 932        st->cr();
 933      }
 934 
 935   STEP("printing flags")
 936 
 937     if (_verbose) {
 938       JVMFlag::printFlags(
 939         st,
 940         true, // with comments
 941         false, // no ranges
 942         true); // skip defaults
 943       st->cr();
 944     }
 945 
 946   STEP("printing warning if internal testing API used")
 947 
 948      if (WhiteBox::used()) {
 949        st->print_cr("Unsupported internal testing APIs have been used.");
 950        st->cr();
 951      }
 952 
 953   STEP("printing log configuration")
 954     if (_verbose){
 955       st->print_cr("Logging:");
 956       LogConfiguration::describe_current_configuration(st);
 957       st->cr();
 958     }
 959 
 960   STEP("printing all environment variables")
 961 
 962      if (_verbose) {
 963        os::print_environment_variables(st, env_list);
 964        st->cr();
 965      }
 966 
 967   STEP("printing signal handlers")
 968 
 969      if (_verbose) {
 970        os::print_signal_handlers(st, buf, sizeof(buf));
 971        st->cr();
 972      }
 973 
 974   STEP("Native Memory Tracking")
 975      if (_verbose) {
 976        MemTracker::error_report(st);
 977      }
 978 
 979   STEP("printing system")
 980 
 981      if (_verbose) {
 982        st->cr();
 983        st->print_cr("---------------  S Y S T E M  ---------------");
 984        st->cr();
 985      }
 986 
 987   STEP("printing OS information")
 988 
 989      if (_verbose) {
 990        os::print_os_info(st);
 991        st->cr();
 992      }
 993 
 994   STEP("printing CPU info")
 995      if (_verbose) {
 996        os::print_cpu_info(st, buf, sizeof(buf));
 997        st->cr();
 998      }
 999 
1000   STEP("printing memory info")
1001 
1002      if (_verbose) {
1003        os::print_memory_info(st);
1004        st->cr();
1005      }
1006 
1007   STEP("printing internal vm info")
1008 
1009      if (_verbose) {
1010        st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string());
1011        st->cr();
1012      }
1013 
1014   // print a defined marker to show that error handling finished correctly.
1015   STEP("printing end marker")
1016 
1017      if (_verbose) {
1018        st->print_cr("END.");
1019      }
1020 
1021   END
1022 
1023 # undef BEGIN
1024 # undef STEP
1025 # undef END
1026 }
1027 
1028 // Report for the vm_info_cmd. This prints out the information above omitting
1029 // crash and thread specific information.  If output is added above, it should be added
1030 // here also, if it is safe to call during a running process.
1031 void VMError::print_vm_info(outputStream* st) {
1032 
1033   char buf[O_BUFLEN];
1034   report_vm_version(st, buf, sizeof(buf));
1035 
1036   // STEP("printing summary")
1037 
1038   st->cr();
1039   st->print_cr("---------------  S U M M A R Y ------------");
1040   st->cr();
1041 
1042   // STEP("printing VM option summary")
1043 
1044   // VM options
1045   Arguments::print_summary_on(st);
1046   st->cr();
1047 
1048   // STEP("printing summary machine and OS info")
1049 
1050   os::print_summary_info(st, buf, sizeof(buf));
1051 
1052   // STEP("printing date and time")
1053 
1054   os::print_date_and_time(st, buf, sizeof(buf));
1055 
1056   // Skip: STEP("printing thread")
1057 
1058   // STEP("printing process")
1059 
1060   st->cr();
1061   st->print_cr("---------------  P R O C E S S  ---------------");
1062   st->cr();
1063 
1064   // STEP("printing number of OutOfMemoryError and StackOverflow exceptions")
1065 
1066   if (Exceptions::has_exception_counts()) {
1067     st->print_cr("OutOfMemory and StackOverflow Exception counts:");
1068     Exceptions::print_exception_counts_on_error(st);
1069     st->cr();
1070   }
1071 
1072   // STEP("printing compressed oops mode")
1073 
1074   if (UseCompressedOops) {
1075     Universe::print_compressed_oops_mode(st);
1076     if (UseCompressedClassPointers) {
1077       Metaspace::print_compressed_class_space(st);
1078     }
1079     st->cr();
1080   }
1081 
1082   // STEP("printing heap information")
1083 
1084   if (Universe::is_fully_initialized()) {
1085     MutexLocker hl(Heap_lock);
1086     Universe::heap()->print_on_error(st);
1087     st->cr();
1088     st->print_cr("Polling page: " INTPTR_FORMAT, p2i(os::get_polling_page()));
1089     st->cr();
1090   }
1091 
1092   // STEP("printing metaspace information")
1093 
1094   if (Universe::is_fully_initialized()) {
1095     st->print_cr("Metaspace:");
1096     MetaspaceUtils::print_basic_report(st, 0);
1097   }
1098 
1099   // STEP("printing code cache information")
1100 
1101   if (Universe::is_fully_initialized()) {
1102     // print code cache information before vm abort
1103     CodeCache::print_summary(st);
1104     st->cr();
1105   }
1106 
1107   // STEP("printing ring buffers")
1108 
1109   Events::print_all(st);
1110   st->cr();
1111 
1112   // STEP("printing dynamic libraries")
1113 
1114   // dynamic libraries, or memory map
1115   os::print_dll_info(st);
1116   st->cr();
1117 
1118   // STEP("printing VM options")
1119 
1120   // VM options
1121   Arguments::print_on(st);
1122   st->cr();
1123 
1124   // STEP("printing warning if internal testing API used")
1125 
1126   if (WhiteBox::used()) {
1127     st->print_cr("Unsupported internal testing APIs have been used.");
1128     st->cr();
1129   }
1130 
1131   // STEP("printing log configuration")
1132   st->print_cr("Logging:");
1133   LogConfiguration::describe(st);
1134   st->cr();
1135 
1136   // STEP("printing all environment variables")
1137 
1138   os::print_environment_variables(st, env_list);
1139   st->cr();
1140 
1141   // STEP("printing signal handlers")
1142 
1143   os::print_signal_handlers(st, buf, sizeof(buf));
1144   st->cr();
1145 
1146   // STEP("Native Memory Tracking")
1147 
1148   MemTracker::error_report(st);
1149 
1150   // STEP("printing system")
1151 
1152   st->cr();
1153   st->print_cr("---------------  S Y S T E M  ---------------");
1154   st->cr();
1155 
1156   // STEP("printing OS information")
1157 
1158   os::print_os_info(st);
1159   st->cr();
1160 
1161   // STEP("printing CPU info")
1162 
1163   os::print_cpu_info(st, buf, sizeof(buf));
1164   st->cr();
1165 
1166   // STEP("printing memory info")
1167 
1168   os::print_memory_info(st);
1169   st->cr();
1170 
1171   // STEP("printing internal vm info")
1172 
1173   st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string());
1174   st->cr();
1175 
1176   // print a defined marker to show that error handling finished correctly.
1177   // STEP("printing end marker")
1178 
1179   st->print_cr("END.");
1180 }
1181 
1182 volatile intptr_t VMError::first_error_tid = -1;
1183 
1184 // An error could happen before tty is initialized or after it has been
1185 // destroyed.
1186 // Please note: to prevent large stack allocations, the log- and
1187 // output-stream use a global scratch buffer for format printing.
1188 // (see VmError::report_and_die(). Access to those streams is synchronized
1189 // in  VmError::report_and_die() - there is only one reporting thread at
1190 // any given time.
1191 fdStream VMError::out(defaultStream::output_fd());
1192 fdStream VMError::log; // error log used by VMError::report_and_die()
1193 
1194 /** Expand a pattern into a buffer starting at pos and open a file using constructed path */
1195 static int expand_and_open(const char* pattern, char* buf, size_t buflen, size_t pos) {
1196   int fd = -1;
1197   if (Arguments::copy_expand_pid(pattern, strlen(pattern), &buf[pos], buflen - pos)) {
1198     // the O_EXCL flag will cause the open to fail if the file exists
1199     fd = open(buf, O_RDWR | O_CREAT | O_EXCL, 0666);
1200   }
1201   return fd;
1202 }
1203 
1204 /**
1205  * Construct file name for a log file and return it's file descriptor.
1206  * Name and location depends on pattern, default_pattern params and access
1207  * permissions.
1208  */
1209 static int prepare_log_file(const char* pattern, const char* default_pattern, char* buf, size_t buflen) {
1210   int fd = -1;
1211 
1212   // If possible, use specified pattern to construct log file name
1213   if (pattern != NULL) {
1214     fd = expand_and_open(pattern, buf, buflen, 0);
1215   }
1216 
1217   // Either user didn't specify, or the user's location failed,
1218   // so use the default name in the current directory
1219   if (fd == -1) {
1220     const char* cwd = os::get_current_directory(buf, buflen);
1221     if (cwd != NULL) {
1222       size_t pos = strlen(cwd);
1223       int fsep_len = jio_snprintf(&buf[pos], buflen-pos, "%s", os::file_separator());
1224       pos += fsep_len;
1225       if (fsep_len > 0) {
1226         fd = expand_and_open(default_pattern, buf, buflen, pos);
1227       }
1228     }
1229   }
1230 
1231    // try temp directory if it exists.
1232    if (fd == -1) {
1233      const char* tmpdir = os::get_temp_directory();
1234      if (tmpdir != NULL && strlen(tmpdir) > 0) {
1235        int pos = jio_snprintf(buf, buflen, "%s%s", tmpdir, os::file_separator());
1236        if (pos > 0) {
1237          fd = expand_and_open(default_pattern, buf, buflen, pos);
1238        }
1239      }
1240    }
1241 
1242   return fd;
1243 }
1244 
1245 int         VMError::_id;
1246 const char* VMError::_message;
1247 char        VMError::_detail_msg[1024];
1248 Thread*     VMError::_thread;
1249 address     VMError::_pc;
1250 void*       VMError::_siginfo;
1251 void*       VMError::_context;
1252 const char* VMError::_filename;
1253 int         VMError::_lineno;
1254 size_t      VMError::_size;
1255 
1256 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo,
1257                              void* context, const char* detail_fmt, ...)
1258 {
1259   va_list detail_args;
1260   va_start(detail_args, detail_fmt);
1261   report_and_die(sig, NULL, detail_fmt, detail_args, thread, pc, siginfo, context, NULL, 0, 0);
1262   va_end(detail_args);
1263 }
1264 
1265 void VMError::report_and_die(Thread* thread, unsigned int sig, address pc, void* siginfo, void* context)
1266 {
1267   report_and_die(thread, sig, pc, siginfo, context, "%s", "");
1268 }
1269 
1270 void VMError::report_and_die(const char* message, const char* detail_fmt, ...)
1271 {
1272   va_list detail_args;
1273   va_start(detail_args, detail_fmt);
1274   report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, NULL, NULL, NULL, NULL, NULL, 0, 0);
1275   va_end(detail_args);
1276 }
1277 
1278 void VMError::report_and_die(const char* message)
1279 {
1280   report_and_die(message, "%s", "");
1281 }
1282 
1283 void VMError::report_and_die(Thread* thread, void* context, const char* filename, int lineno, const char* message,
1284                              const char* detail_fmt, va_list detail_args)
1285 {
1286   report_and_die(INTERNAL_ERROR, message, detail_fmt, detail_args, thread, NULL, NULL, context, filename, lineno, 0);
1287 }
1288 
1289 void VMError::report_and_die(Thread* thread, const char* filename, int lineno, size_t size,
1290                              VMErrorType vm_err_type, const char* detail_fmt, va_list detail_args) {
1291   report_and_die(vm_err_type, NULL, detail_fmt, detail_args, thread, NULL, NULL, NULL, filename, lineno, size);
1292 }
1293 
1294 void VMError::report_and_die(int id, const char* message, const char* detail_fmt, va_list detail_args,
1295                              Thread* thread, address pc, void* siginfo, void* context, const char* filename,
1296                              int lineno, size_t size)
1297 {
1298   // Don't allocate large buffer on stack
1299   static char buffer[O_BUFLEN];
1300   out.set_scratch_buffer(buffer, sizeof(buffer));
1301   log.set_scratch_buffer(buffer, sizeof(buffer));
1302 
1303   // How many errors occurred in error handler when reporting first_error.
1304   static int recursive_error_count;
1305 
1306   // We will first print a brief message to standard out (verbose = false),
1307   // then save detailed information in log file (verbose = true).
1308   static bool out_done = false;         // done printing to standard out
1309   static bool log_done = false;         // done saving error log
1310 
1311   if (SuppressFatalErrorMessage) {
1312       os::abort(CreateCoredumpOnCrash);
1313   }
1314   intptr_t mytid = os::current_thread_id();
1315   if (first_error_tid == -1 &&
1316       Atomic::cmpxchg(mytid, &first_error_tid, (intptr_t)-1) == -1) {
1317 
1318     // Initialize time stamps to use the same base.
1319     out.time_stamp().update_to(1);
1320     log.time_stamp().update_to(1);
1321 
1322     _id = id;
1323     _message = message;
1324     _thread = thread;
1325     _pc = pc;
1326     _siginfo = siginfo;
1327     _context = context;
1328     _filename = filename;
1329     _lineno = lineno;
1330     _size = size;
1331     jio_vsnprintf(_detail_msg, sizeof(_detail_msg), detail_fmt, detail_args);
1332 
1333     // first time
1334     _error_reported = true;
1335 
1336     reporting_started();
1337     record_reporting_start_time();
1338 
1339     if (ShowMessageBoxOnError || PauseAtExit) {
1340       show_message_box(buffer, sizeof(buffer));
1341 
1342       // User has asked JVM to abort. Reset ShowMessageBoxOnError so the
1343       // WatcherThread can kill JVM if the error handler hangs.
1344       ShowMessageBoxOnError = false;
1345     }
1346 
1347     os::check_dump_limit(buffer, sizeof(buffer));
1348 
1349     // reset signal handlers or exception filter; make sure recursive crashes
1350     // are handled properly.
1351     reset_signal_handlers();
1352 
1353     EventShutdown e;
1354     if (e.should_commit()) {
1355       e.set_reason("VM Error");
1356       e.commit();
1357     }
1358 
1359     JFR_ONLY(Jfr::on_vm_shutdown(true);)
1360 
1361   } else {
1362     // If UseOsErrorReporting we call this for each level of the call stack
1363     // while searching for the exception handler.  Only the first level needs
1364     // to be reported.
1365     if (UseOSErrorReporting && log_done) return;
1366 
1367     // This is not the first error, see if it happened in a different thread
1368     // or in the same thread during error reporting.
1369     if (first_error_tid != mytid) {
1370       char msgbuf[64];
1371       jio_snprintf(msgbuf, sizeof(msgbuf),
1372                    "[thread " INTX_FORMAT " also had an error]",
1373                    mytid);
1374       out.print_raw_cr(msgbuf);
1375 
1376       // error reporting is not MT-safe, block current thread
1377       os::infinite_sleep();
1378 
1379     } else {
1380       if (recursive_error_count++ > 30) {
1381         out.print_raw_cr("[Too many errors, abort]");
1382         os::die();
1383       }
1384 
1385       outputStream* const st = log.is_open() ? &log : &out;
1386       st->cr();
1387 
1388       // Timeout handling.
1389       if (_step_did_timeout) {
1390         // The current step had a timeout. Lets continue reporting with the next step.
1391         st->print_raw("[timeout occurred during error reporting in step \"");
1392         st->print_raw(_current_step_info);
1393         st->print_cr("\"] after " INT64_FORMAT " s.",
1394                      (int64_t)
1395                      ((get_current_timestamp() - _step_start_time) / TIMESTAMP_TO_SECONDS_FACTOR));
1396       } else if (_reporting_did_timeout) {
1397         // We hit ErrorLogTimeout. Reporting will stop altogether. Let's wrap things
1398         // up, the process is about to be stopped by the WatcherThread.
1399         st->print_cr("------ Timeout during error reporting after " INT64_FORMAT " s. ------",
1400                      (int64_t)
1401                      ((get_current_timestamp() - _reporting_start_time) / TIMESTAMP_TO_SECONDS_FACTOR));
1402         st->flush();
1403         // Watcherthread is about to call os::die. Lets just wait.
1404         os::infinite_sleep();
1405       } else {
1406         // Crash or assert during error reporting. Lets continue reporting with the next step.
1407         stringStream ss(buffer, sizeof(buffer));
1408         // Note: this string does get parsed by a number of jtreg tests,
1409         // see hotspot/jtreg/runtime/ErrorHandling.
1410         ss.print("[error occurred during error reporting (%s), id 0x%x",
1411                    _current_step_info, id);
1412         char signal_name[64];
1413         if (os::exception_name(id, signal_name, sizeof(signal_name))) {
1414           ss.print(", %s (0x%x) at pc=" PTR_FORMAT, signal_name, id, p2i(pc));
1415         } else {
1416           if (should_report_bug(id)) {
1417             ss.print(", Internal Error (%s:%d)",
1418               filename == NULL ? "??" : filename, lineno);
1419           } else {
1420             ss.print(", Out of Memory Error (%s:%d)",
1421               filename == NULL ? "??" : filename, lineno);
1422           }
1423         }
1424         ss.print("]");
1425         st->print_raw_cr(buffer);
1426         st->cr();
1427       }
1428     }
1429   }
1430 
1431   // print to screen
1432   if (!out_done) {
1433     report(&out, false);
1434 
1435     out_done = true;
1436 
1437     _current_step = 0;
1438     _current_step_info = "";
1439   }
1440 
1441   // print to error log file
1442   if (!log_done) {
1443     // see if log file is already open
1444     if (!log.is_open()) {
1445       // open log file
1446       int fd = prepare_log_file(ErrorFile, "hs_err_pid%p.log", buffer, sizeof(buffer));
1447       if (fd != -1) {
1448         out.print_raw("# An error report file with more information is saved as:\n# ");
1449         out.print_raw_cr(buffer);
1450 
1451         log.set_fd(fd);
1452       } else {
1453         out.print_raw_cr("# Can not save log file, dump to screen..");
1454         log.set_fd(defaultStream::output_fd());
1455       }
1456     }
1457 
1458     report(&log, true);
1459     log_done = true;
1460     _current_step = 0;
1461     _current_step_info = "";
1462 
1463     if (log.fd() != defaultStream::output_fd()) {
1464       close(log.fd());
1465     }
1466 
1467     log.set_fd(-1);
1468   }
1469 
1470   static bool skip_replay = ReplayCompiles; // Do not overwrite file during replay
1471   if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) {
1472     skip_replay = true;
1473     ciEnv* env = ciEnv::current();
1474     if (env != NULL) {
1475       int fd = prepare_log_file(ReplayDataFile, "replay_pid%p.log", buffer, sizeof(buffer));
1476       if (fd != -1) {
1477         FILE* replay_data_file = os::open(fd, "w");
1478         if (replay_data_file != NULL) {
1479           fileStream replay_data_stream(replay_data_file, /*need_close=*/true);
1480           env->dump_replay_data_unsafe(&replay_data_stream);
1481           out.print_raw("#\n# Compiler replay data is saved as:\n# ");
1482           out.print_raw_cr(buffer);
1483         } else {
1484           int e = errno;
1485           out.print_raw("#\n# Can't open file to dump replay data. Error: ");
1486           out.print_raw_cr(os::strerror(e));
1487         }
1488       }
1489     }
1490   }
1491 
1492   static bool skip_bug_url = !should_report_bug(_id);
1493   if (!skip_bug_url) {
1494     skip_bug_url = true;
1495 
1496     out.print_raw_cr("#");
1497     print_bug_submit_message(&out, _thread);
1498   }
1499 
1500   static bool skip_OnError = false;
1501   if (!skip_OnError && OnError && OnError[0]) {
1502     skip_OnError = true;
1503 
1504     // Flush output and finish logs before running OnError commands.
1505     ostream_abort();
1506 
1507     out.print_raw_cr("#");
1508     out.print_raw   ("# -XX:OnError=\"");
1509     out.print_raw   (OnError);
1510     out.print_raw_cr("\"");
1511 
1512     char* cmd;
1513     const char* ptr = OnError;
1514     while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){
1515       out.print_raw   ("#   Executing ");
1516 #if defined(LINUX) || defined(_ALLBSD_SOURCE)
1517       out.print_raw   ("/bin/sh -c ");
1518 #elif defined(SOLARIS)
1519       out.print_raw   ("/usr/bin/sh -c ");
1520 #elif defined(_WINDOWS)
1521       out.print_raw   ("cmd /C ");
1522 #endif
1523       out.print_raw   ("\"");
1524       out.print_raw   (cmd);
1525       out.print_raw_cr("\" ...");
1526 
1527       if (os::fork_and_exec(cmd) < 0) {
1528         out.print_cr("os::fork_and_exec failed: %s (%s=%d)",
1529                      os::strerror(errno), os::errno_name(errno), errno);
1530       }
1531     }
1532 
1533     // done with OnError
1534     OnError = NULL;
1535   }
1536 
1537   if (!UseOSErrorReporting) {
1538     // os::abort() will call abort hooks, try it first.
1539     static bool skip_os_abort = false;
1540     if (!skip_os_abort) {
1541       skip_os_abort = true;
1542       bool dump_core = should_report_bug(_id);
1543       os::abort(dump_core && CreateCoredumpOnCrash, _siginfo, _context);
1544     }
1545 
1546     // if os::abort() doesn't abort, try os::die();
1547     os::die();
1548   }
1549 }
1550 
1551 /*
1552  * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this
1553  * ensures utilities such as jmap can observe the process is a consistent state.
1554  */
1555 class VM_ReportJavaOutOfMemory : public VM_Operation {
1556  private:
1557   const char* _message;
1558  public:
1559   VM_ReportJavaOutOfMemory(const char* message) { _message = message; }
1560   VMOp_Type type() const                        { return VMOp_ReportJavaOutOfMemory; }
1561   void doit();
1562 };
1563 
1564 void VM_ReportJavaOutOfMemory::doit() {
1565   // Don't allocate large buffer on stack
1566   static char buffer[O_BUFLEN];
1567 
1568   tty->print_cr("#");
1569   tty->print_cr("# java.lang.OutOfMemoryError: %s", _message);
1570   tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError);
1571 
1572   // make heap parsability
1573   Universe::heap()->ensure_parsability(false);  // no need to retire TLABs
1574 
1575   char* cmd;
1576   const char* ptr = OnOutOfMemoryError;
1577   while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){
1578     tty->print("#   Executing ");
1579 #if defined(LINUX)
1580     tty->print  ("/bin/sh -c ");
1581 #elif defined(SOLARIS)
1582     tty->print  ("/usr/bin/sh -c ");
1583 #endif
1584     tty->print_cr("\"%s\"...", cmd);
1585 
1586     if (os::fork_and_exec(cmd) < 0) {
1587       tty->print_cr("os::fork_and_exec failed: %s (%s=%d)",
1588                      os::strerror(errno), os::errno_name(errno), errno);
1589     }
1590   }
1591 }
1592 
1593 void VMError::report_java_out_of_memory(const char* message) {
1594   if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
1595     MutexLocker ml(Heap_lock);
1596     VM_ReportJavaOutOfMemory op(message);
1597     VMThread::execute(&op);
1598   }
1599 }
1600 
1601 void VMError::show_message_box(char *buf, int buflen) {
1602   bool yes;
1603   do {
1604     error_string(buf, buflen);
1605     yes = os::start_debugging(buf,buflen);
1606   } while (yes);
1607 }
1608 
1609 // Timeout handling: check if a timeout happened (either a single step did
1610 // timeout or the whole of error reporting hit ErrorLogTimeout). Interrupt
1611 // the reporting thread if that is the case.
1612 bool VMError::check_timeout() {
1613 
1614   if (ErrorLogTimeout == 0) {
1615     return false;
1616   }
1617 
1618   // Do not check for timeouts if we still have a message box to show to the
1619   // user or if there are OnError handlers to be run.
1620   if (ShowMessageBoxOnError
1621       || (OnError != NULL && OnError[0] != '\0')
1622       || Arguments::abort_hook() != NULL) {
1623     return false;
1624   }
1625 
1626   const jlong reporting_start_time_l = get_reporting_start_time();
1627   const jlong now = get_current_timestamp();
1628   // Timestamp is stored in nanos.
1629   if (reporting_start_time_l > 0) {
1630     const jlong end = reporting_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR;
1631     if (end <= now) {
1632       _reporting_did_timeout = true;
1633       interrupt_reporting_thread();
1634       return true; // global timeout
1635     }
1636   }
1637 
1638   const jlong step_start_time_l = get_step_start_time();
1639   if (step_start_time_l > 0) {
1640     // A step times out after a quarter of the total timeout. Steps are mostly fast unless they
1641     // hang for some reason, so this simple rule allows for three hanging step and still
1642     // hopefully leaves time enough for the rest of the steps to finish.
1643     const jlong end = step_start_time_l + (jlong)ErrorLogTimeout * TIMESTAMP_TO_SECONDS_FACTOR / 4;
1644     if (end <= now) {
1645       _step_did_timeout = true;
1646       interrupt_reporting_thread();
1647       return false; // (Not a global timeout)
1648     }
1649   }
1650 
1651   return false;
1652 
1653 }
1654 
1655 #ifndef PRODUCT
1656 #if defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x5140
1657 #pragma error_messages(off, SEC_NULL_PTR_DEREF)
1658 #endif
1659 typedef void (*voidfun_t)();
1660 // Crash with an authentic sigfpe
1661 static void crash_with_sigfpe() {
1662   // generate a native synchronous SIGFPE where possible;
1663   // if that did not cause a signal (e.g. on ppc), just
1664   // raise the signal.
1665   volatile int x = 0;
1666   volatile int y = 1/x;
1667 #ifndef _WIN32
1668   // OSX implements raise(sig) incorrectly so we need to
1669   // explicitly target the current thread
1670   pthread_kill(pthread_self(), SIGFPE);
1671 #endif
1672 } // end: crash_with_sigfpe
1673 
1674 // crash with sigsegv at non-null address.
1675 static void crash_with_segfault() {
1676 
1677   char* const crash_addr = (char*) VMError::get_segfault_address();
1678   *crash_addr = 'X';
1679 
1680 } // end: crash_with_segfault
1681 
1682 void VMError::test_error_handler() {
1683   controlled_crash(ErrorHandlerTest);
1684 }
1685 
1686 // crash in a controlled way:
1687 // how can be one of:
1688 // 1,2 - asserts
1689 // 3,4 - guarantee
1690 // 5-7 - fatal
1691 // 8 - vm_exit_out_of_memory
1692 // 9 - ShouldNotCallThis
1693 // 10 - ShouldNotReachHere
1694 // 11 - Unimplemented
1695 // 12,13 - (not guaranteed) crashes
1696 // 14 - SIGSEGV
1697 // 15 - SIGFPE
1698 void VMError::controlled_crash(int how) {
1699   if (how == 0) return;
1700 
1701   // If asserts are disabled, use the corresponding guarantee instead.
1702   NOT_DEBUG(if (how <= 2) how += 2);
1703 
1704   const char* const str = "hello";
1705   const size_t      num = (size_t)os::vm_page_size();
1706 
1707   const char* const eol = os::line_separator();
1708   const char* const msg = "this message should be truncated during formatting";
1709   char * const dataPtr = NULL;  // bad data pointer
1710   const void (*funcPtr)(void) = (const void(*)()) 0xF;  // bad function pointer
1711 
1712   // Keep this in sync with test/hotspot/jtreg/runtime/ErrorHandling/ErrorHandler.java
1713   // which tests cases 1 thru 13.
1714   // Case 14 is tested by test/hotspot/jtreg/runtime/ErrorHandling/SafeFetchInErrorHandlingTest.java.
1715   // Case 15 is tested by test/hotspot/jtreg/runtime/ErrorHandling/SecondaryErrorTest.java.
1716   // Case 16 is tested by test/hotspot/jtreg/runtime/ErrorHandling/ThreadsListHandleInErrorHandlingTest.java.
1717   // Case 17 is tested by test/hotspot/jtreg/runtime/ErrorHandling/NestedThreadsListHandleInErrorHandlingTest.java.
1718 
1719   // We grab Threads_lock to keep ThreadsSMRSupport::print_info_on()
1720   // from racing with Threads::add() or Threads::remove() as we
1721   // generate the hs_err_pid file. This makes our ErrorHandling tests
1722   // more stable.
1723   MutexLockerEx ml(Threads_lock->owned_by_self() ? NULL : Threads_lock, Mutex::_no_safepoint_check_flag);
1724 
1725   switch (how) {
1726     case  1: vmassert(str == NULL, "expected null"); break;
1727     case  2: vmassert(num == 1023 && *str == 'X',
1728                       "num=" SIZE_FORMAT " str=\"%s\"", num, str); break;
1729     case  3: guarantee(str == NULL, "expected null"); break;
1730     case  4: guarantee(num == 1023 && *str == 'X',
1731                        "num=" SIZE_FORMAT " str=\"%s\"", num, str); break;
1732     case  5: fatal("expected null"); break;
1733     case  6: fatal("num=" SIZE_FORMAT " str=\"%s\"", num, str); break;
1734     case  7: fatal("%s%s#    %s%s#    %s%s#    %s%s#    %s%s#    "
1735                    "%s%s#    %s%s#    %s%s#    %s%s#    %s%s#    "
1736                    "%s%s#    %s%s#    %s%s#    %s%s#    %s",
1737                    msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
1738                    msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
1739                    msg, eol, msg, eol, msg, eol, msg, eol, msg); break;
1740     case  8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate"); break;
1741     case  9: ShouldNotCallThis(); break;
1742     case 10: ShouldNotReachHere(); break;
1743     case 11: Unimplemented(); break;
1744     // There's no guarantee the bad data pointer will crash us
1745     // so "break" out to the ShouldNotReachHere().
1746     case 12: *dataPtr = '\0'; break;
1747     // There's no guarantee the bad function pointer will crash us
1748     // so "break" out to the ShouldNotReachHere().
1749     case 13: (*funcPtr)(); break;
1750     case 14: crash_with_segfault(); break;
1751     case 15: crash_with_sigfpe(); break;
1752     case 16: {
1753       ThreadsListHandle tlh;
1754       fatal("Force crash with an active ThreadsListHandle.");
1755     }
1756     case 17: {
1757       ThreadsListHandle tlh;
1758       {
1759         ThreadsListHandle tlh2;
1760         fatal("Force crash with a nested ThreadsListHandle.");
1761       }
1762     }
1763 
1764     default: tty->print_cr("ERROR: %d: unexpected test_num value.", how);
1765   }
1766   tty->print_cr("VMError::controlled_crash: survived intentional crash. Did you suppress the assert?");
1767   ShouldNotReachHere();
1768 }
1769 #endif // !PRODUCT
1770