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