1 /*
2 * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "jvm.h"
27 #include "code/codeCache.hpp"
28 #include "compiler/compileBroker.hpp"
29 #include "compiler/disassembler.hpp"
30 #include "gc/shared/gcConfig.hpp"
31 #include "logging/logConfiguration.hpp"
32 #include "jfr/jfrEvents.hpp"
33 #include "memory/resourceArea.hpp"
34 #include "prims/whitebox.hpp"
35 #include "runtime/arguments.hpp"
36 #include "runtime/atomic.hpp"
37 #include "runtime/frame.inline.hpp"
38 #include "runtime/init.hpp"
39 #include "runtime/os.hpp"
40 #include "runtime/thread.inline.hpp"
41 #include "runtime/threadSMR.hpp"
42 #include "runtime/vmThread.hpp"
43 #include "runtime/vm_operations.hpp"
44 #include "runtime/vm_version.hpp"
45 #include "runtime/flags/jvmFlag.hpp"
46 #include "services/memTracker.hpp"
47 #include "utilities/debug.hpp"
48 #include "utilities/decoder.hpp"
49 #include "utilities/defaultStream.hpp"
50 #include "utilities/events.hpp"
51 #include "utilities/vmError.hpp"
52 #include "utilities/macros.hpp"
53 #if INCLUDE_JFR
54 #include "jfr/jfr.hpp"
55 #endif
56
57 #ifndef PRODUCT
58 #include <signal.h>
59 #endif // PRODUCT
60
61 bool VMError::_error_reported = false;
62
63 // call this when the VM is dying--it might loosen some asserts
64 bool VMError::is_error_reported() { return _error_reported; }
65
66 // returns an address which is guaranteed to generate a SIGSEGV on read,
67 // for test purposes, which is not NULL and contains bits in every word
68 void* VMError::get_segfault_address() {
69 return (void*)
70 #ifdef _LP64
71 0xABC0000000000ABCULL;
72 #else
73 0x00000ABC;
74 #endif
75 }
76
77 // List of environment variables that should be reported in error log file.
78 const char *env_list[] = {
79 // All platforms
80 "JAVA_HOME", "JRE_HOME", "JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "CLASSPATH",
81 "JAVA_COMPILER", "PATH", "USERNAME",
82
83 // Env variables that are defined on Solaris/Linux/BSD
84 "LD_LIBRARY_PATH", "LD_PRELOAD", "SHELL", "DISPLAY",
85 "HOSTTYPE", "OSTYPE", "ARCH", "MACHTYPE",
86
87 // defined on AIX
88 "LIBPATH", "LDR_PRELOAD", "LDR_PRELOAD64",
89
90 // defined on Linux
91 "LD_ASSUME_KERNEL", "_JAVA_SR_SIGNUM",
92
93 // defined on Darwin
94 "DYLD_LIBRARY_PATH", "DYLD_FALLBACK_LIBRARY_PATH",
95 "DYLD_FRAMEWORK_PATH", "DYLD_FALLBACK_FRAMEWORK_PATH",
96 "DYLD_INSERT_LIBRARIES",
97
98 // defined on Windows
99 "OS", "PROCESSOR_IDENTIFIER", "_ALT_JAVA_HOME_DIR",
100
101 (const char *)0
102 };
103
104 // A simple parser for -XX:OnError, usage:
105 // ptr = OnError;
106 // while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr) != NULL)
107 // ... ...
108 static char* next_OnError_command(char* buf, int buflen, const char** ptr) {
109 if (ptr == NULL || *ptr == NULL) return NULL;
110
111 const char* cmd = *ptr;
112
113 // skip leading blanks or ';'
114 while (*cmd == ' ' || *cmd == ';') cmd++;
115
116 if (*cmd == '\0') return NULL;
117
118 const char * cmdend = cmd;
119 while (*cmdend != '\0' && *cmdend != ';') cmdend++;
120
121 Arguments::copy_expand_pid(cmd, cmdend - cmd, buf, buflen);
122
123 *ptr = (*cmdend == '\0' ? cmdend : cmdend + 1);
124 return buf;
125 }
126
127 static void print_bug_submit_message(outputStream *out, Thread *thread) {
128 if (out == NULL) return;
129 out->print_raw_cr("# If you would like to submit a bug report, please visit:");
130 out->print_raw ("# ");
131 out->print_raw_cr(Arguments::java_vendor_url_bug());
132 // If the crash is in native code, encourage user to submit a bug to the
133 // provider of that code.
134 if (thread && thread->is_Java_thread() &&
135 !thread->is_hidden_from_external_view()) {
136 JavaThread* jt = (JavaThread*)thread;
137 if (jt->thread_state() == _thread_in_native) {
138 out->print_cr("# The crash happened outside the Java Virtual Machine in native code.\n# See problematic frame for where to report the bug.");
139 }
140 }
141 out->print_raw_cr("#");
142 }
143
144 bool VMError::coredump_status;
145 char VMError::coredump_message[O_BUFLEN];
146
147 void VMError::record_coredump_status(const char* message, bool status) {
148 coredump_status = status;
149 strncpy(coredump_message, message, sizeof(coredump_message));
150 coredump_message[sizeof(coredump_message)-1] = 0;
151 }
152
153 // Return a string to describe the error
154 char* VMError::error_string(char* buf, int buflen) {
155 char signame_buf[64];
156 const char *signame = os::exception_name(_id, signame_buf, sizeof(signame_buf));
157
158 if (signame) {
159 jio_snprintf(buf, buflen,
160 "%s (0x%x) at pc=" PTR_FORMAT ", pid=%d, tid=" UINTX_FORMAT,
161 signame, _id, _pc,
162 os::current_process_id(), os::current_thread_id());
163 } else if (_filename != NULL && _lineno > 0) {
164 // skip directory names
165 char separator = os::file_separator()[0];
166 const char *p = strrchr(_filename, separator);
167 int n = jio_snprintf(buf, buflen,
168 "Internal Error at %s:%d, pid=%d, tid=" UINTX_FORMAT,
169 p ? p + 1 : _filename, _lineno,
170 os::current_process_id(), os::current_thread_id());
171 if (n >= 0 && n < buflen && _message) {
172 if (strlen(_detail_msg) > 0) {
173 jio_snprintf(buf + n, buflen - n, "%s%s: %s",
174 os::line_separator(), _message, _detail_msg);
175 } else {
176 jio_snprintf(buf + n, buflen - n, "%sError: %s",
177 os::line_separator(), _message);
178 }
179 }
180 } else {
181 jio_snprintf(buf, buflen,
182 "Internal Error (0x%x), pid=%d, tid=" UINTX_FORMAT,
183 _id, os::current_process_id(), os::current_thread_id());
184 }
185
186 return buf;
187 }
188
189 void VMError::print_stack_trace(outputStream* st, JavaThread* jt,
190 char* buf, int buflen, bool verbose) {
191 #ifdef ZERO
192 if (jt->zero_stack()->sp() && jt->top_zero_frame()) {
193 // StackFrameStream uses the frame anchor, which may not have
194 // been set up. This can be done at any time in Zero, however,
195 // so if it hasn't been set up then we just set it up now and
196 // clear it again when we're done.
197 bool has_last_Java_frame = jt->has_last_Java_frame();
198 if (!has_last_Java_frame)
199 jt->set_last_Java_frame();
200 st->print("Java frames:");
201 st->cr();
202
203 // Print the frames
204 StackFrameStream sfs(jt);
205 for(int i = 0; !sfs.is_done(); sfs.next(), i++) {
206 sfs.current()->zero_print_on_error(i, st, buf, buflen);
207 st->cr();
208 }
209
210 // Reset the frame anchor if necessary
211 if (!has_last_Java_frame)
212 jt->reset_last_Java_frame();
213 }
214 #else
215 if (jt->has_last_Java_frame()) {
216 st->print_cr("Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)");
217 for(StackFrameStream sfs(jt); !sfs.is_done(); sfs.next()) {
218 sfs.current()->print_on_error(st, buf, buflen, verbose);
219 st->cr();
220 }
221 }
222 #endif // ZERO
223 }
224
225 void VMError::print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) {
226
227 // see if it's a valid frame
228 if (fr.pc()) {
229 st->print_cr("Native frames: (J=compiled Java code, A=aot compiled Java code, j=interpreted, Vv=VM code, C=native code)");
230
231 int count = 0;
232 while (count++ < StackPrintLimit) {
233 fr.print_on_error(st, buf, buf_size);
234 if (fr.pc()) { // print source file and line, if available
235 char buf[128];
236 int line_no;
237 if (Decoder::get_source_info(fr.pc(), buf, sizeof(buf), &line_no)) {
238 st->print(" (%s:%d)", buf, line_no);
239 }
240 }
241 st->cr();
242 // Compiled code may use EBP register on x86 so it looks like
243 // non-walkable C frame. Use frame.sender() for java frames.
244 if (t && t->is_Java_thread()) {
245 // Catch very first native frame by using stack address.
246 // For JavaThread stack_base and stack_size should be set.
247 if (!t->on_local_stack((address)(fr.real_fp() + 1))) {
248 break;
249 }
250 if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) {
251 RegisterMap map((JavaThread*)t, false); // No update
252 fr = fr.sender(&map);
253 } else {
254 // is_first_C_frame() does only simple checks for frame pointer,
255 // it will pass if java compiled code has a pointer in EBP.
256 if (os::is_first_C_frame(&fr)) break;
257 fr = os::get_sender_for_C_frame(&fr);
258 }
259 } else {
260 if (os::is_first_C_frame(&fr)) break;
261 fr = os::get_sender_for_C_frame(&fr);
262 }
263 }
264
265 if (count > StackPrintLimit) {
266 st->print_cr("...<more frames>...");
267 }
268
269 st->cr();
270 }
271 }
272
273 static void print_oom_reasons(outputStream* st) {
274 st->print_cr("# Possible reasons:");
275 st->print_cr("# The system is out of physical RAM or swap space");
276 if (UseCompressedOops) {
277 st->print_cr("# The process is running with CompressedOops enabled, and the Java Heap may be blocking the growth of the native heap");
278 }
279 if (LogBytesPerWord == 2) {
280 st->print_cr("# In 32 bit mode, the process size limit was hit");
281 }
282 st->print_cr("# Possible solutions:");
283 st->print_cr("# Reduce memory load on the system");
284 st->print_cr("# Increase physical memory or swap space");
285 st->print_cr("# Check if swap backing store is full");
286 if (LogBytesPerWord == 2) {
287 st->print_cr("# Use 64 bit Java on a 64 bit OS");
288 }
289 st->print_cr("# Decrease Java heap size (-Xmx/-Xms)");
290 st->print_cr("# Decrease number of Java threads");
291 st->print_cr("# Decrease Java thread stack sizes (-Xss)");
292 st->print_cr("# Set larger code cache with -XX:ReservedCodeCacheSize=");
293 if (UseCompressedOops) {
294 switch (Universe::narrow_oop_mode()) {
295 case Universe::UnscaledNarrowOop:
296 st->print_cr("# JVM is running with Unscaled Compressed Oops mode in which the Java heap is");
297 st->print_cr("# placed in the first 4GB address space. The Java Heap base address is the");
298 st->print_cr("# maximum limit for the native heap growth. Please use -XX:HeapBaseMinAddress");
299 st->print_cr("# to set the Java Heap base and to place the Java Heap above 4GB virtual address.");
300 break;
301 case Universe::ZeroBasedNarrowOop:
302 st->print_cr("# JVM is running with Zero Based Compressed Oops mode in which the Java heap is");
303 st->print_cr("# placed in the first 32GB address space. The Java Heap base address is the");
304 st->print_cr("# maximum limit for the native heap growth. Please use -XX:HeapBaseMinAddress");
305 st->print_cr("# to set the Java Heap base and to place the Java Heap above 32GB virtual address.");
306 break;
307 default:
308 break;
309 }
310 }
311 st->print_cr("# This output file may be truncated or incomplete.");
312 }
313
314 static void report_vm_version(outputStream* st, char* buf, int buflen) {
315 // VM version
316 st->print_cr("#");
317 JDK_Version::current().to_string(buf, buflen);
318 const char* runtime_name = JDK_Version::runtime_name() != NULL ?
319 JDK_Version::runtime_name() : "";
320 const char* runtime_version = JDK_Version::runtime_version() != NULL ?
321 JDK_Version::runtime_version() : "";
322 const char* jdk_debug_level = VM_Version::printable_jdk_debug_level() != NULL ?
323 VM_Version::printable_jdk_debug_level() : "";
324
325 st->print_cr("# JRE version: %s (%s) (%sbuild %s)", runtime_name, buf,
326 jdk_debug_level, runtime_version);
327
328 // This is the long version with some default settings added
329 st->print_cr("# Java VM: %s (%s%s, %s%s%s%s%s, %s, %s)",
330 VM_Version::vm_name(),
331 jdk_debug_level,
332 VM_Version::vm_release(),
333 VM_Version::vm_info_string(),
334 TieredCompilation ? ", tiered" : "",
335 #if INCLUDE_JVMCI
336 EnableJVMCI ? ", jvmci" : "",
337 UseJVMCICompiler ? ", jvmci compiler" : "",
338 #else
339 "", "",
340 #endif
341 UseCompressedOops ? ", compressed oops" : "",
342 GCConfig::hs_err_name(),
343 VM_Version::vm_platform_string()
344 );
345 }
346
347 // This is the main function to report a fatal error. Only one thread can
348 // call this function, so we don't need to worry about MT-safety. But it's
349 // possible that the error handler itself may crash or die on an internal
350 // error, for example, when the stack/heap is badly damaged. We must be
351 // able to handle recursive errors that happen inside error handler.
352 //
353 // Error reporting is done in several steps. If a crash or internal error
354 // occurred when reporting an error, the nested signal/exception handler
355 // can skip steps that are already (or partially) done. Error reporting will
356 // continue from the next step. This allows us to retrieve and print
357 // information that may be unsafe to get after a fatal error. If it happens,
358 // you may find nested report_and_die() frames when you look at the stack
359 // in a debugger.
360 //
361 // In general, a hang in error handler is much worse than a crash or internal
362 // error, as it's harder to recover from a hang. Deadlock can happen if we
363 // try to grab a lock that is already owned by current thread, or if the
364 // owner is blocked forever (e.g. in os::infinite_sleep()). If possible, the
365 // error handler and all the functions it called should avoid grabbing any
366 // lock. An important thing to notice is that memory allocation needs a lock.
367 //
368 // We should avoid using large stack allocated buffers. Many errors happen
369 // when stack space is already low. Making things even worse is that there
370 // could be nested report_and_die() calls on stack (see above). Only one
371 // thread can report error, so large buffers are statically allocated in data
372 // segment.
373
374 int VMError::_current_step;
375 const char* VMError::_current_step_info;
376
377 volatile jlong VMError::_reporting_start_time = -1;
378 volatile bool VMError::_reporting_did_timeout = false;
379 volatile jlong VMError::_step_start_time = -1;
380 volatile bool VMError::_step_did_timeout = false;
381
382 // Helper, return current timestamp for timeout handling.
383 jlong VMError::get_current_timestamp() {
384 return os::javaTimeNanos();
385 }
386 // Factor to translate the timestamp to seconds.
387 #define TIMESTAMP_TO_SECONDS_FACTOR (1000 * 1000 * 1000)
388
389 void VMError::record_reporting_start_time() {
390 const jlong now = get_current_timestamp();
391 Atomic::store(now, &_reporting_start_time);
392 }
393
394 jlong VMError::get_reporting_start_time() {
395 return Atomic::load(&_reporting_start_time);
396 }
397
398 void VMError::record_step_start_time() {
399 const jlong now = get_current_timestamp();
400 Atomic::store(now, &_step_start_time);
401 }
402
403 jlong VMError::get_step_start_time() {
404 return Atomic::load(&_step_start_time);
405 }
406
407 void VMError::report(outputStream* st, bool _verbose) {
408
409 # define BEGIN if (_current_step == 0) { _current_step = __LINE__;
410 # define STEP(s) } if (_current_step < __LINE__) { _current_step = __LINE__; _current_step_info = s; \
411 record_step_start_time(); _step_did_timeout = false;
412 # define END }
413
414 // don't allocate large buffer on stack
415 static char buf[O_BUFLEN];
416
417 BEGIN
418
419 STEP("printing fatal error message")
420
421 st->print_cr("#");
422 if (should_report_bug(_id)) {
423 st->print_cr("# A fatal error has been detected by the Java Runtime Environment:");
424 } else {
425 st->print_cr("# There is insufficient memory for the Java "
426 "Runtime Environment to continue.");
427 }
428
429 #ifndef PRODUCT
430 // Error handler self tests
431
432 // test secondary error handling. Test it twice, to test that resetting
433 // error handler after a secondary crash works.
434 STEP("test secondary crash 1")
435 if (_verbose && TestCrashInErrorHandler != 0) {
436 st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...",
437 TestCrashInErrorHandler);
438 controlled_crash(TestCrashInErrorHandler);
439 }
440
441 STEP("test secondary crash 2")
442 if (_verbose && TestCrashInErrorHandler != 0) {
443 st->print_cr("Will crash now (TestCrashInErrorHandler=" UINTX_FORMAT ")...",
444 TestCrashInErrorHandler);
445 controlled_crash(TestCrashInErrorHandler);
446 }
447
448 // TestUnresponsiveErrorHandler: We want to test both step timeouts and global timeout.
449 // Step to global timeout ratio is 4:1, so in order to be absolutely sure we hit the
450 // global timeout, let's execute the timeout step five times.
451 // See corresponding test in test/runtime/ErrorHandling/TimeoutInErrorHandlingTest.java
452 #define TIMEOUT_TEST_STEP STEP("test unresponsive error reporting step") \
453 if (_verbose && TestUnresponsiveErrorHandler) { os::infinite_sleep(); }
454 TIMEOUT_TEST_STEP
455 TIMEOUT_TEST_STEP
456 TIMEOUT_TEST_STEP
457 TIMEOUT_TEST_STEP
458 TIMEOUT_TEST_STEP
459
460 STEP("test safefetch in error handler")
461 // test whether it is safe to use SafeFetch32 in Crash Handler. Test twice
462 // to test that resetting the signal handler works correctly.
463 if (_verbose && TestSafeFetchInErrorHandler) {
464 st->print_cr("Will test SafeFetch...");
465 if (CanUseSafeFetch32()) {
466 int* const invalid_pointer = (int*) get_segfault_address();
467 const int x = 0x76543210;
468 int i1 = SafeFetch32(invalid_pointer, x);
469 int i2 = SafeFetch32(invalid_pointer, x);
470 if (i1 == x && i2 == x) {
471 st->print_cr("SafeFetch OK."); // Correctly deflected and returned default pattern
472 } else {
473 st->print_cr("??");
474 }
475 } else {
476 st->print_cr("not possible; skipped.");
477 }
478 }
479 #endif // PRODUCT
480
481 STEP("printing type of error")
482
483 switch(static_cast<unsigned int>(_id)) {
484 case OOM_MALLOC_ERROR:
485 case OOM_MMAP_ERROR:
486 if (_size) {
487 st->print("# Native memory allocation ");
488 st->print((_id == (int)OOM_MALLOC_ERROR) ? "(malloc) failed to allocate " :
489 "(mmap) failed to map ");
490 jio_snprintf(buf, sizeof(buf), SIZE_FORMAT, _size);
491 st->print("%s", buf);
492 st->print(" bytes");
493 if (strlen(_detail_msg) > 0) {
494 st->print(" for ");
495 st->print("%s", _detail_msg);
496 }
497 st->cr();
498 } else {
499 if (strlen(_detail_msg) > 0) {
500 st->print("# ");
501 st->print_cr("%s", _detail_msg);
502 }
503 }
504 // In error file give some solutions
505 if (_verbose) {
506 print_oom_reasons(st);
507 } else {
508 return; // that's enough for the screen
509 }
510 break;
511 case INTERNAL_ERROR:
512 default:
513 break;
514 }
515
516 STEP("printing exception/signal name")
517
518 st->print_cr("#");
519 st->print("# ");
520 // Is it an OS exception/signal?
521 if (os::exception_name(_id, buf, sizeof(buf))) {
522 st->print("%s", buf);
523 st->print(" (0x%x)", _id); // signal number
524 st->print(" at pc=" PTR_FORMAT, p2i(_pc));
525 } else {
526 if (should_report_bug(_id)) {
527 st->print("Internal Error");
528 } else {
529 st->print("Out of Memory Error");
530 }
531 if (_filename != NULL && _lineno > 0) {
532 #ifdef PRODUCT
533 // In product mode chop off pathname?
534 char separator = os::file_separator()[0];
535 const char *p = strrchr(_filename, separator);
536 const char *file = p ? p+1 : _filename;
537 #else
538 const char *file = _filename;
539 #endif
540 st->print(" (%s:%d)", file, _lineno);
541 } else {
542 st->print(" (0x%x)", _id);
543 }
544 }
545
546 STEP("printing current thread and pid")
547
548 // process id, thread id
549 st->print(", pid=%d", os::current_process_id());
550 st->print(", tid=" UINTX_FORMAT, os::current_thread_id());
551 st->cr();
552
553 STEP("printing error message")
554
555 if (should_report_bug(_id)) { // already printed the message.
556 // error message
557 if (strlen(_detail_msg) > 0) {
558 st->print_cr("# %s: %s", _message ? _message : "Error", _detail_msg);
559 } else if (_message) {
560 st->print_cr("# Error: %s", _message);
561 }
562 }
563
564 STEP("printing Java version string")
565
566 report_vm_version(st, buf, sizeof(buf));
567
568 STEP("printing problematic frame")
569
570 // Print current frame if we have a context (i.e. it's a crash)
571 if (_context) {
572 st->print_cr("# Problematic frame:");
573 st->print("# ");
574 frame fr = os::fetch_frame_from_context(_context);
575 fr.print_on_error(st, buf, sizeof(buf));
576 st->cr();
577 st->print_cr("#");
578 }
579
580 STEP("printing core file information")
581 st->print("# ");
582 if (CreateCoredumpOnCrash) {
583 if (coredump_status) {
584 st->print("Core dump will be written. Default location: %s", coredump_message);
585 } else {
586 st->print("No core dump will be written. %s", coredump_message);
587 }
588 } else {
589 st->print("CreateCoredumpOnCrash turned off, no core file dumped");
590 }
591 st->cr();
592 st->print_cr("#");
593
594 STEP("printing bug submit message")
595
596 if (should_report_bug(_id) && _verbose) {
597 print_bug_submit_message(st, _thread);
598 }
599
600 STEP("printing summary")
601
602 if (_verbose) {
603 st->cr();
604 st->print_cr("--------------- S U M M A R Y ------------");
605 st->cr();
606 }
607
608 STEP("printing VM option summary")
609
610 if (_verbose) {
611 // VM options
612 Arguments::print_summary_on(st);
613 st->cr();
614 }
615
616 STEP("printing summary machine and OS info")
617
618 if (_verbose) {
619 os::print_summary_info(st, buf, sizeof(buf));
620 }
621
622
623 STEP("printing date and time")
624
625 if (_verbose) {
626 os::print_date_and_time(st, buf, sizeof(buf));
627 }
628
629 STEP("printing thread")
630
631 if (_verbose) {
632 st->cr();
633 st->print_cr("--------------- T H R E A D ---------------");
634 st->cr();
635 }
636
637 STEP("printing current thread")
638
639 // current thread
640 if (_verbose) {
641 if (_thread) {
642 st->print("Current thread (" PTR_FORMAT "): ", p2i(_thread));
643 _thread->print_on_error(st, buf, sizeof(buf));
644 st->cr();
645 } else {
646 st->print_cr("Current thread is native thread");
647 }
648 st->cr();
649 }
650
651 STEP("printing current compile task")
652
653 if (_verbose && _thread && _thread->is_Compiler_thread()) {
654 CompilerThread* t = (CompilerThread*)_thread;
655 if (t->task()) {
656 st->cr();
657 st->print_cr("Current CompileTask:");
658 t->task()->print_line_on_error(st, buf, sizeof(buf));
659 st->cr();
660 }
661 }
662
663
664 STEP("printing stack bounds")
665
666 if (_verbose) {
667 st->print("Stack: ");
668
669 address stack_top;
670 size_t stack_size;
671
672 if (_thread) {
673 stack_top = _thread->stack_base();
674 stack_size = _thread->stack_size();
675 } else {
676 stack_top = os::current_stack_base();
677 stack_size = os::current_stack_size();
678 }
679
680 address stack_bottom = stack_top - stack_size;
681 st->print("[" PTR_FORMAT "," PTR_FORMAT "]", p2i(stack_bottom), p2i(stack_top));
682
683 frame fr = _context ? os::fetch_frame_from_context(_context)
684 : os::current_frame();
685
686 if (fr.sp()) {
687 st->print(", sp=" PTR_FORMAT, p2i(fr.sp()));
688 size_t free_stack_size = pointer_delta(fr.sp(), stack_bottom, 1024);
689 st->print(", free space=" SIZE_FORMAT "k", free_stack_size);
690 }
691
692 st->cr();
693 }
694
695 STEP("printing native stack")
696
697 if (_verbose) {
698 if (os::platform_print_native_stack(st, _context, buf, sizeof(buf))) {
699 // We have printed the native stack in platform-specific code
700 // Windows/x64 needs special handling.
701 } else {
702 frame fr = _context ? os::fetch_frame_from_context(_context)
703 : os::current_frame();
704
705 print_native_stack(st, fr, _thread, buf, sizeof(buf));
706 }
707 }
708
709 STEP("printing Java stack")
710
711 if (_verbose && _thread && _thread->is_Java_thread()) {
712 print_stack_trace(st, (JavaThread*)_thread, buf, sizeof(buf));
713 }
714
715 STEP("printing target Java thread stack")
716
717 // printing Java thread stack trace if it is involved in GC crash
718 if (_verbose && _thread && (_thread->is_Named_thread())) {
719 JavaThread* jt = ((NamedThread *)_thread)->processed_thread();
720 if (jt != NULL) {
721 st->print_cr("JavaThread " PTR_FORMAT " (nid = %d) was being processed", p2i(jt), jt->osthread()->thread_id());
722 print_stack_trace(st, jt, buf, sizeof(buf), true);
723 }
724 }
725
726 STEP("printing siginfo")
727
728 // signal no, signal code, address that caused the fault
729 if (_verbose && _siginfo) {
730 st->cr();
731 os::print_siginfo(st, _siginfo);
732 st->cr();
733 }
734
735 STEP("CDS archive access warning")
736
737 // Print an explicit hint if we crashed on access to the CDS archive.
738 if (_verbose && _siginfo) {
739 check_failing_cds_access(st, _siginfo);
740 st->cr();
741 }
742
743 STEP("printing register info")
744
745 // decode register contents if possible
746 if (_verbose && _context && Universe::is_fully_initialized()) {
747 os::print_register_info(st, _context);
748 st->cr();
749 }
750
751 STEP("printing registers, top of stack, instructions near pc")
752
753 // registers, top of stack, instructions near pc
754 if (_verbose && _context) {
755 os::print_context(st, _context);
756 st->cr();
757 }
758
759 STEP("inspecting top of stack")
760
761 // decode stack contents if possible
762 if (_verbose && _context && Universe::is_fully_initialized()) {
763 frame fr = os::fetch_frame_from_context(_context);
764 const int slots = 8;
765 const intptr_t *start = fr.sp();
766 const intptr_t *end = start + slots;
767 if (is_aligned(start, sizeof(intptr_t)) && os::is_readable_range(start, end)) {
768 st->print_cr("Stack slot to memory mapping:");
769 for (int i = 0; i < slots; ++i) {
770 st->print("stack at sp + %d slots: ", i);
771 os::print_location(st, *(start + i));
772 }
773 }
774 st->cr();
775 }
776
777 STEP("printing code blob if possible")
778
779 if (_verbose && _context) {
780 CodeBlob* cb = CodeCache::find_blob(_pc);
781 if (cb != NULL) {
782 if (Interpreter::contains(_pc)) {
783 // The interpreter CodeBlob is very large so try to print the codelet instead.
784 InterpreterCodelet* codelet = Interpreter::codelet_containing(_pc);
785 if (codelet != NULL) {
786 codelet->print_on(st);
787 Disassembler::decode(codelet->code_begin(), codelet->code_end(), st);
788 }
789 } else {
790 StubCodeDesc* desc = StubCodeDesc::desc_for(_pc);
791 if (desc != NULL) {
792 desc->print_on(st);
793 Disassembler::decode(desc->begin(), desc->end(), st);
794 } else if (_thread != NULL) {
795 // Disassembling nmethod will incur resource memory allocation,
796 // only do so when thread is valid.
797 ResourceMark rm(_thread);
798 Disassembler::decode(cb, st);
799 st->cr();
800 }
801 }
802 }
803 }
804
805 STEP("printing VM operation")
806
807 if (_verbose && _thread && _thread->is_VM_thread()) {
808 VMThread* t = (VMThread*)_thread;
809 VM_Operation* op = t->vm_operation();
810 if (op) {
811 op->print_on_error(st);
812 st->cr();
813 st->cr();
814 }
815 }
816
817 STEP("printing process")
818
819 if (_verbose) {
820 st->cr();
821 st->print_cr("--------------- P R O C E S S ---------------");
822 st->cr();
823 }
824
825 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", 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", 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, true) < 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