Mercurial > hg > truffle
annotate src/share/vm/utilities/vmError.cpp @ 14649:f6301b007a16
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | 183bd5c00828 |
| children | d8041d695d19 e0365e7b7454 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
11060
068b406e307f
7060111: race condition in VMError::report_and_die()
fparain
parents:
10208
diff
changeset
|
2 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "compiler/compileBroker.hpp" | |
| 27 #include "gc_interface/collectedHeap.hpp" | |
| 5915 | 28 #include "prims/whitebox.hpp" |
| 1972 | 29 #include "runtime/arguments.hpp" |
| 30 #include "runtime/frame.inline.hpp" | |
| 31 #include "runtime/init.hpp" | |
| 32 #include "runtime/os.hpp" | |
| 33 #include "runtime/thread.hpp" | |
| 34 #include "runtime/vmThread.hpp" | |
| 35 #include "runtime/vm_operations.hpp" | |
| 6197 | 36 #include "services/memTracker.hpp" |
| 1972 | 37 #include "utilities/debug.hpp" |
|
2022
2d4762ec74af
7003748: Decode C stack frames when symbols are presented (PhoneHome project)
zgu
parents:
1972
diff
changeset
|
38 #include "utilities/decoder.hpp" |
| 1972 | 39 #include "utilities/defaultStream.hpp" |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
40 #include "utilities/errorReporter.hpp" |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
41 #include "utilities/events.hpp" |
| 1972 | 42 #include "utilities/top.hpp" |
| 43 #include "utilities/vmError.hpp" | |
| 0 | 44 |
| 45 // List of environment variables that should be reported in error log file. | |
| 46 const char *env_list[] = { | |
| 47 // All platforms | |
| 48 "JAVA_HOME", "JRE_HOME", "JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "CLASSPATH", | |
| 49 "JAVA_COMPILER", "PATH", "USERNAME", | |
| 50 | |
| 3960 | 51 // Env variables that are defined on Solaris/Linux/BSD |
| 0 | 52 "LD_LIBRARY_PATH", "LD_PRELOAD", "SHELL", "DISPLAY", |
| 53 "HOSTTYPE", "OSTYPE", "ARCH", "MACHTYPE", | |
| 54 | |
| 55 // defined on Linux | |
| 56 "LD_ASSUME_KERNEL", "_JAVA_SR_SIGNUM", | |
| 57 | |
| 3960 | 58 // defined on Darwin |
| 59 "DYLD_LIBRARY_PATH", "DYLD_FALLBACK_LIBRARY_PATH", | |
| 60 "DYLD_FRAMEWORK_PATH", "DYLD_FALLBACK_FRAMEWORK_PATH", | |
| 61 "DYLD_INSERT_LIBRARIES", | |
| 62 | |
| 0 | 63 // defined on Windows |
| 64 "OS", "PROCESSOR_IDENTIFIER", "_ALT_JAVA_HOME_DIR", | |
| 65 | |
| 66 (const char *)0 | |
| 67 }; | |
| 68 | |
| 69 // Fatal error handler for internal errors and crashes. | |
| 70 // | |
| 71 // The default behavior of fatal error handler is to print a brief message | |
| 72 // to standard out (defaultStream::output_fd()), then save detailed information | |
| 73 // into an error report file (hs_err_pid<pid>.log) and abort VM. If multiple | |
| 74 // threads are having troubles at the same time, only one error is reported. | |
| 75 // The thread that is reporting error will abort VM when it is done, all other | |
| 76 // threads are blocked forever inside report_and_die(). | |
| 77 | |
| 78 // Constructor for crashes | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
79 VMError::VMError(Thread* thread, unsigned int sig, address pc, void* siginfo, void* context) { |
| 0 | 80 _thread = thread; |
| 81 _id = sig; | |
| 82 _pc = pc; | |
| 83 _siginfo = siginfo; | |
| 84 _context = context; | |
| 85 | |
| 86 _verbose = false; | |
| 87 _current_step = 0; | |
| 88 _current_step_info = NULL; | |
| 89 | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
90 _message = NULL; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
91 _detail_msg = NULL; |
| 0 | 92 _filename = NULL; |
| 93 _lineno = 0; | |
| 94 | |
| 95 _size = 0; | |
| 96 } | |
| 97 | |
| 98 // Constructor for internal errors | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
99 VMError::VMError(Thread* thread, const char* filename, int lineno, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
100 const char* message, const char * detail_msg) |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
101 { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
102 _thread = thread; |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
103 _id = INTERNAL_ERROR; // Value that's not an OS exception/signal |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
104 _filename = filename; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
105 _lineno = lineno; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
106 _message = message; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
107 _detail_msg = detail_msg; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
108 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
109 _verbose = false; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
110 _current_step = 0; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
111 _current_step_info = NULL; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
112 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
113 _pc = NULL; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
114 _siginfo = NULL; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
115 _context = NULL; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
116 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
117 _size = 0; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
118 } |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
119 |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
120 // Constructor for OOM errors |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
121 VMError::VMError(Thread* thread, const char* filename, int lineno, size_t size, |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
122 VMErrorType vm_err_type, const char* message) { |
| 0 | 123 _thread = thread; |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
124 _id = vm_err_type; // Value that's not an OS exception/signal |
| 0 | 125 _filename = filename; |
| 126 _lineno = lineno; | |
| 127 _message = message; | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
128 _detail_msg = NULL; |
| 0 | 129 |
| 130 _verbose = false; | |
| 131 _current_step = 0; | |
| 132 _current_step_info = NULL; | |
| 133 | |
| 134 _pc = NULL; | |
| 135 _siginfo = NULL; | |
| 136 _context = NULL; | |
| 137 | |
| 138 _size = size; | |
| 139 } | |
| 140 | |
| 141 | |
| 142 // Constructor for non-fatal errors | |
| 143 VMError::VMError(const char* message) { | |
| 144 _thread = NULL; | |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
145 _id = INTERNAL_ERROR; // Value that's not an OS exception/signal |
| 0 | 146 _filename = NULL; |
| 147 _lineno = 0; | |
| 148 _message = message; | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
149 _detail_msg = NULL; |
| 0 | 150 |
| 151 _verbose = false; | |
| 152 _current_step = 0; | |
| 153 _current_step_info = NULL; | |
| 154 | |
| 155 _pc = NULL; | |
| 156 _siginfo = NULL; | |
| 157 _context = NULL; | |
| 158 | |
| 159 _size = 0; | |
| 160 } | |
| 161 | |
| 162 // -XX:OnError=<string>, where <string> can be a list of commands, separated | |
| 163 // by ';'. "%p" is replaced by current process id (pid); "%%" is replaced by | |
| 164 // a single "%". Some examples: | |
| 165 // | |
| 166 // -XX:OnError="pmap %p" // show memory map | |
| 167 // -XX:OnError="gcore %p; dbx - %p" // dump core and launch debugger | |
| 168 // -XX:OnError="cat hs_err_pid%p.log | mail my_email@sun.com" | |
| 169 // -XX:OnError="kill -9 %p" // ?#!@# | |
| 170 | |
| 171 // A simple parser for -XX:OnError, usage: | |
| 172 // ptr = OnError; | |
| 173 // while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr) != NULL) | |
| 174 // ... ... | |
| 175 static char* next_OnError_command(char* buf, int buflen, const char** ptr) { | |
| 176 if (ptr == NULL || *ptr == NULL) return NULL; | |
| 177 | |
| 178 const char* cmd = *ptr; | |
| 179 | |
| 180 // skip leading blanks or ';' | |
| 181 while (*cmd == ' ' || *cmd == ';') cmd++; | |
| 182 | |
| 183 if (*cmd == '\0') return NULL; | |
| 184 | |
| 185 const char * cmdend = cmd; | |
| 186 while (*cmdend != '\0' && *cmdend != ';') cmdend++; | |
| 187 | |
| 188 Arguments::copy_expand_pid(cmd, cmdend - cmd, buf, buflen); | |
| 189 | |
| 190 *ptr = (*cmdend == '\0' ? cmdend : cmdend + 1); | |
| 191 return buf; | |
| 192 } | |
| 193 | |
| 194 | |
| 195 static void print_bug_submit_message(outputStream *out, Thread *thread) { | |
| 196 if (out == NULL) return; | |
| 197 out->print_raw_cr("# If you would like to submit a bug report, please visit:"); | |
| 198 out->print_raw ("# "); | |
| 199 out->print_raw_cr(Arguments::java_vendor_url_bug()); | |
| 200 // If the crash is in native code, encourage user to submit a bug to the | |
| 201 // provider of that code. | |
|
56
31d829b33f26
6549844: Wording problems in "An unexpected error ..."
coleenp
parents:
0
diff
changeset
|
202 if (thread && thread->is_Java_thread() && |
|
31d829b33f26
6549844: Wording problems in "An unexpected error ..."
coleenp
parents:
0
diff
changeset
|
203 !thread->is_hidden_from_external_view()) { |
| 0 | 204 JavaThread* jt = (JavaThread*)thread; |
| 205 if (jt->thread_state() == _thread_in_native) { | |
| 206 out->print_cr("# The crash happened outside the Java Virtual Machine in native code.\n# See problematic frame for where to report the bug."); | |
| 207 } | |
| 208 } | |
| 209 out->print_raw_cr("#"); | |
| 210 } | |
| 211 | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
212 bool VMError::coredump_status; |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
213 char VMError::coredump_message[O_BUFLEN]; |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
214 |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
215 void VMError::report_coredump_status(const char* message, bool status) { |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
216 coredump_status = status; |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
217 strncpy(coredump_message, message, sizeof(coredump_message)); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
218 coredump_message[sizeof(coredump_message)-1] = 0; |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
219 } |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
220 |
| 0 | 221 |
| 222 // Return a string to describe the error | |
| 223 char* VMError::error_string(char* buf, int buflen) { | |
| 224 char signame_buf[64]; | |
| 225 const char *signame = os::exception_name(_id, signame_buf, sizeof(signame_buf)); | |
| 226 | |
| 227 if (signame) { | |
| 228 jio_snprintf(buf, buflen, | |
| 229 "%s (0x%x) at pc=" PTR_FORMAT ", pid=%d, tid=" UINTX_FORMAT, | |
| 230 signame, _id, _pc, | |
| 231 os::current_process_id(), os::current_thread_id()); | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
232 } else if (_filename != NULL && _lineno > 0) { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
233 // skip directory names |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
234 char separator = os::file_separator()[0]; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
235 const char *p = strrchr(_filename, separator); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
236 int n = jio_snprintf(buf, buflen, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
237 "Internal Error at %s:%d, pid=%d, tid=" UINTX_FORMAT, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
238 p ? p + 1 : _filename, _lineno, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
239 os::current_process_id(), os::current_thread_id()); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
240 if (n >= 0 && n < buflen && _message) { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
241 if (_detail_msg) { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
242 jio_snprintf(buf + n, buflen - n, "%s%s: %s", |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
243 os::line_separator(), _message, _detail_msg); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
244 } else { |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
245 jio_snprintf(buf + n, buflen - n, "%sError: %s", |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
246 os::line_separator(), _message); |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
247 } |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
248 } |
| 0 | 249 } else { |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
250 jio_snprintf(buf, buflen, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
251 "Internal Error (0x%x), pid=%d, tid=" UINTX_FORMAT, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
252 _id, os::current_process_id(), os::current_thread_id()); |
| 0 | 253 } |
| 254 | |
| 255 return buf; | |
| 256 } | |
| 257 | |
| 1384 | 258 void VMError::print_stack_trace(outputStream* st, JavaThread* jt, |
| 259 char* buf, int buflen, bool verbose) { | |
| 260 #ifdef ZERO | |
| 261 if (jt->zero_stack()->sp() && jt->top_zero_frame()) { | |
| 262 // StackFrameStream uses the frame anchor, which may not have | |
| 263 // been set up. This can be done at any time in Zero, however, | |
| 264 // so if it hasn't been set up then we just set it up now and | |
| 265 // clear it again when we're done. | |
| 266 bool has_last_Java_frame = jt->has_last_Java_frame(); | |
| 267 if (!has_last_Java_frame) | |
| 268 jt->set_last_Java_frame(); | |
| 269 st->print("Java frames:"); | |
| 270 | |
| 271 // If the top frame is a Shark frame and the frame anchor isn't | |
| 272 // set up then it's possible that the information in the frame | |
| 273 // is garbage: it could be from a previous decache, or it could | |
| 274 // simply have never been written. So we print a warning... | |
| 275 StackFrameStream sfs(jt); | |
| 276 if (!has_last_Java_frame && !sfs.is_done()) { | |
| 277 if (sfs.current()->zeroframe()->is_shark_frame()) { | |
| 278 st->print(" (TOP FRAME MAY BE JUNK)"); | |
| 279 } | |
| 280 } | |
| 281 st->cr(); | |
| 282 | |
| 283 // Print the frames | |
| 284 for(int i = 0; !sfs.is_done(); sfs.next(), i++) { | |
| 285 sfs.current()->zero_print_on_error(i, st, buf, buflen); | |
| 286 st->cr(); | |
| 287 } | |
| 288 | |
| 289 // Reset the frame anchor if necessary | |
| 290 if (!has_last_Java_frame) | |
| 291 jt->reset_last_Java_frame(); | |
| 292 } | |
| 293 #else | |
| 294 if (jt->has_last_Java_frame()) { | |
| 295 st->print_cr("Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)"); | |
| 296 for(StackFrameStream sfs(jt); !sfs.is_done(); sfs.next()) { | |
| 297 sfs.current()->print_on_error(st, buf, buflen, verbose); | |
| 298 st->cr(); | |
| 299 } | |
| 300 } | |
| 301 #endif // ZERO | |
| 302 } | |
| 0 | 303 |
| 304 // This is the main function to report a fatal error. Only one thread can | |
| 305 // call this function, so we don't need to worry about MT-safety. But it's | |
| 306 // possible that the error handler itself may crash or die on an internal | |
| 307 // error, for example, when the stack/heap is badly damaged. We must be | |
| 308 // able to handle recursive errors that happen inside error handler. | |
| 309 // | |
| 310 // Error reporting is done in several steps. If a crash or internal error | |
| 311 // occurred when reporting an error, the nested signal/exception handler | |
| 312 // can skip steps that are already (or partially) done. Error reporting will | |
| 313 // continue from the next step. This allows us to retrieve and print | |
| 314 // information that may be unsafe to get after a fatal error. If it happens, | |
| 315 // you may find nested report_and_die() frames when you look at the stack | |
| 316 // in a debugger. | |
| 317 // | |
| 318 // In general, a hang in error handler is much worse than a crash or internal | |
| 319 // error, as it's harder to recover from a hang. Deadlock can happen if we | |
| 320 // try to grab a lock that is already owned by current thread, or if the | |
| 321 // owner is blocked forever (e.g. in os::infinite_sleep()). If possible, the | |
| 322 // error handler and all the functions it called should avoid grabbing any | |
| 323 // lock. An important thing to notice is that memory allocation needs a lock. | |
| 324 // | |
| 325 // We should avoid using large stack allocated buffers. Many errors happen | |
| 326 // when stack space is already low. Making things even worse is that there | |
| 327 // could be nested report_and_die() calls on stack (see above). Only one | |
| 328 // thread can report error, so large buffers are statically allocated in data | |
| 329 // segment. | |
| 330 | |
| 331 void VMError::report(outputStream* st) { | |
| 332 # define BEGIN if (_current_step == 0) { _current_step = 1; | |
| 333 # define STEP(n, s) } if (_current_step < n) { _current_step = n; _current_step_info = s; | |
| 334 # define END } | |
| 335 | |
| 336 // don't allocate large buffer on stack | |
| 337 static char buf[O_BUFLEN]; | |
| 338 | |
| 339 BEGIN | |
| 340 | |
|
56
31d829b33f26
6549844: Wording problems in "An unexpected error ..."
coleenp
parents:
0
diff
changeset
|
341 STEP(10, "(printing fatal error message)") |
| 0 | 342 |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
343 st->print_cr("#"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
344 if (should_report_bug(_id)) { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
345 st->print_cr("# A fatal error has been detected by the Java Runtime Environment:"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
346 } else { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
347 st->print_cr("# There is insufficient memory for the Java " |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
348 "Runtime Environment to continue."); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
349 } |
| 0 | 350 |
| 351 STEP(15, "(printing type of error)") | |
| 352 | |
| 353 switch(_id) { | |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
354 case OOM_MALLOC_ERROR: |
|
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
355 case OOM_MMAP_ERROR: |
| 0 | 356 if (_size) { |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
357 st->print("# Native memory allocation "); |
|
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
358 st->print((_id == (int)OOM_MALLOC_ERROR) ? "(malloc) failed to allocate " : |
|
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
359 "(mmap) failed to map "); |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
360 jio_snprintf(buf, sizeof(buf), SIZE_FORMAT, _size); |
| 0 | 361 st->print(buf); |
| 362 st->print(" bytes"); | |
| 363 if (_message != NULL) { | |
| 364 st->print(" for "); | |
| 365 st->print(_message); | |
| 366 } | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
367 st->cr(); |
| 0 | 368 } else { |
| 369 if (_message != NULL) | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
370 st->print("# "); |
| 0 | 371 st->print_cr(_message); |
| 372 } | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
373 // In error file give some solutions |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
374 if (_verbose) { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
375 st->print_cr("# Possible reasons:"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
376 st->print_cr("# The system is out of physical RAM or swap space"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
377 st->print_cr("# In 32 bit mode, the process size limit was hit"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
378 st->print_cr("# Possible solutions:"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
379 st->print_cr("# Reduce memory load on the system"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
380 st->print_cr("# Increase physical memory or swap space"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
381 st->print_cr("# Check if swap backing store is full"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
382 st->print_cr("# Use 64 bit Java on a 64 bit OS"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
383 st->print_cr("# Decrease Java heap size (-Xmx/-Xms)"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
384 st->print_cr("# Decrease number of Java threads"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
385 st->print_cr("# Decrease Java thread stack sizes (-Xss)"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
386 st->print_cr("# Set larger code cache with -XX:ReservedCodeCacheSize="); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
387 st->print_cr("# This output file may be truncated or incomplete."); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
388 } else { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
389 return; // that's enough for the screen |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
390 } |
| 0 | 391 break; |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
9076
diff
changeset
|
392 case INTERNAL_ERROR: |
| 0 | 393 default: |
| 394 break; | |
| 395 } | |
| 396 | |
| 397 STEP(20, "(printing exception/signal name)") | |
| 398 | |
| 399 st->print_cr("#"); | |
| 400 st->print("# "); | |
| 401 // Is it an OS exception/signal? | |
| 402 if (os::exception_name(_id, buf, sizeof(buf))) { | |
| 403 st->print("%s", buf); | |
| 404 st->print(" (0x%x)", _id); // signal number | |
| 405 st->print(" at pc=" PTR_FORMAT, _pc); | |
| 406 } else { | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
407 if (should_report_bug(_id)) { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
408 st->print("Internal Error"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
409 } else { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
410 st->print("Out of Memory Error"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
411 } |
| 0 | 412 if (_filename != NULL && _lineno > 0) { |
| 413 #ifdef PRODUCT | |
| 414 // In product mode chop off pathname? | |
| 415 char separator = os::file_separator()[0]; | |
| 416 const char *p = strrchr(_filename, separator); | |
| 417 const char *file = p ? p+1 : _filename; | |
| 418 #else | |
| 419 const char *file = _filename; | |
| 420 #endif | |
| 421 size_t len = strlen(file); | |
| 422 size_t buflen = sizeof(buf); | |
| 423 | |
| 424 strncpy(buf, file, buflen); | |
| 425 if (len + 10 < buflen) { | |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
511
diff
changeset
|
426 sprintf(buf + len, ":%d", _lineno); |
| 0 | 427 } |
| 428 st->print(" (%s)", buf); | |
| 429 } else { | |
| 430 st->print(" (0x%x)", _id); | |
| 431 } | |
| 432 } | |
| 433 | |
| 434 STEP(30, "(printing current thread and pid)") | |
| 435 | |
| 436 // process id, thread id | |
| 437 st->print(", pid=%d", os::current_process_id()); | |
| 438 st->print(", tid=" UINTX_FORMAT, os::current_thread_id()); | |
| 439 st->cr(); | |
| 440 | |
| 441 STEP(40, "(printing error message)") | |
| 442 | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
443 if (should_report_bug(_id)) { // already printed the message. |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
444 // error message |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
445 if (_detail_msg) { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
446 st->print_cr("# %s: %s", _message ? _message : "Error", _detail_msg); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
447 } else if (_message) { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
448 st->print_cr("# Error: %s", _message); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
449 } |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
450 } |
| 0 | 451 |
| 452 STEP(50, "(printing Java version string)") | |
| 453 | |
| 454 // VM version | |
| 455 st->print_cr("#"); | |
|
473
3ad2b8576c4a
6689685: Hotspot crash error message should include libraries version
coleenp
parents:
420
diff
changeset
|
456 JDK_Version::current().to_string(buf, sizeof(buf)); |
| 6181 | 457 const char* runtime_name = JDK_Version::runtime_name() != NULL ? |
| 458 JDK_Version::runtime_name() : ""; | |
|
6921
a1b8cf9cf970
8002078: hs_err_pid file should report full JDK version string
sla
parents:
6198
diff
changeset
|
459 const char* runtime_version = JDK_Version::runtime_version() != NULL ? |
|
a1b8cf9cf970
8002078: hs_err_pid file should report full JDK version string
sla
parents:
6198
diff
changeset
|
460 JDK_Version::runtime_version() : ""; |
|
a1b8cf9cf970
8002078: hs_err_pid file should report full JDK version string
sla
parents:
6198
diff
changeset
|
461 st->print_cr("# JRE version: %s (%s) (build %s)", runtime_name, buf, runtime_version); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
56
diff
changeset
|
462 st->print_cr("# Java VM: %s (%s %s %s %s)", |
| 0 | 463 Abstract_VM_Version::vm_name(), |
| 464 Abstract_VM_Version::vm_release(), | |
| 465 Abstract_VM_Version::vm_info_string(), | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
56
diff
changeset
|
466 Abstract_VM_Version::vm_platform_string(), |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
56
diff
changeset
|
467 UseCompressedOops ? "compressed oops" : "" |
| 0 | 468 ); |
| 469 | |
| 470 STEP(60, "(printing problematic frame)") | |
| 471 | |
| 472 // Print current frame if we have a context (i.e. it's a crash) | |
| 473 if (_context) { | |
| 474 st->print_cr("# Problematic frame:"); | |
| 475 st->print("# "); | |
| 476 frame fr = os::fetch_frame_from_context(_context); | |
| 477 fr.print_on_error(st, buf, sizeof(buf)); | |
| 478 st->cr(); | |
| 479 st->print_cr("#"); | |
| 480 } | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
481 STEP(63, "(printing core file information)") |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
482 st->print("# "); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
483 if (coredump_status) { |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
484 st->print("Core dump written. Default location: %s", coredump_message); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
485 } else { |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
486 st->print("Failed to write core dump. %s", coredump_message); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
487 } |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
488 st->print_cr(""); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
489 st->print_cr("#"); |
| 0 | 490 |
| 491 STEP(65, "(printing bug submit message)") | |
| 492 | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
493 if (should_report_bug(_id) && _verbose) { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
494 print_bug_submit_message(st, _thread); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
495 } |
| 0 | 496 |
| 497 STEP(70, "(printing thread)" ) | |
| 498 | |
| 499 if (_verbose) { | |
| 500 st->cr(); | |
| 501 st->print_cr("--------------- T H R E A D ---------------"); | |
| 502 st->cr(); | |
| 503 } | |
| 504 | |
| 505 STEP(80, "(printing current thread)" ) | |
| 506 | |
| 507 // current thread | |
| 508 if (_verbose) { | |
| 509 if (_thread) { | |
| 510 st->print("Current thread (" PTR_FORMAT "): ", _thread); | |
| 511 _thread->print_on_error(st, buf, sizeof(buf)); | |
| 512 st->cr(); | |
| 513 } else { | |
| 514 st->print_cr("Current thread is native thread"); | |
| 515 } | |
| 516 st->cr(); | |
| 517 } | |
| 518 | |
| 519 STEP(90, "(printing siginfo)" ) | |
| 520 | |
| 521 // signal no, signal code, address that caused the fault | |
| 522 if (_verbose && _siginfo) { | |
| 523 os::print_siginfo(st, _siginfo); | |
| 524 st->cr(); | |
| 525 } | |
| 526 | |
| 527 STEP(100, "(printing registers, top of stack, instructions near pc)") | |
| 528 | |
| 529 // registers, top of stack, instructions near pc | |
| 530 if (_verbose && _context) { | |
| 531 os::print_context(st, _context); | |
| 532 st->cr(); | |
| 533 } | |
| 534 | |
| 1907 | 535 STEP(105, "(printing register info)") |
| 536 | |
| 537 // decode register contents if possible | |
| 538 if (_verbose && _context && Universe::is_fully_initialized()) { | |
| 539 os::print_register_info(st, _context); | |
| 540 st->cr(); | |
| 541 } | |
| 542 | |
| 0 | 543 STEP(110, "(printing stack bounds)" ) |
| 544 | |
| 545 if (_verbose) { | |
| 546 st->print("Stack: "); | |
| 547 | |
| 548 address stack_top; | |
| 549 size_t stack_size; | |
| 550 | |
| 551 if (_thread) { | |
| 552 stack_top = _thread->stack_base(); | |
| 553 stack_size = _thread->stack_size(); | |
| 554 } else { | |
| 555 stack_top = os::current_stack_base(); | |
| 556 stack_size = os::current_stack_size(); | |
| 557 } | |
| 558 | |
| 559 address stack_bottom = stack_top - stack_size; | |
| 560 st->print("[" PTR_FORMAT "," PTR_FORMAT "]", stack_bottom, stack_top); | |
| 561 | |
| 562 frame fr = _context ? os::fetch_frame_from_context(_context) | |
| 563 : os::current_frame(); | |
| 564 | |
| 565 if (fr.sp()) { | |
| 566 st->print(", sp=" PTR_FORMAT, fr.sp()); | |
|
1684
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
567 size_t free_stack_size = pointer_delta(fr.sp(), stack_bottom, 1024); |
|
66c5dadb4d61
6973308: Missing zero length check before repne scas in check_klass_subtype_slow_path()
kvn
parents:
1552
diff
changeset
|
568 st->print(", free space=" SIZE_FORMAT "k", free_stack_size); |
| 0 | 569 } |
| 570 | |
| 571 st->cr(); | |
| 572 } | |
| 573 | |
| 574 STEP(120, "(printing native stack)" ) | |
| 575 | |
| 576 if (_verbose) { | |
|
12199
38f750491293
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
12075
diff
changeset
|
577 if (os::platform_print_native_stack(st, _context, buf, sizeof(buf))) { |
|
38f750491293
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
12075
diff
changeset
|
578 // We have printed the native stack in platform-specific code |
|
38f750491293
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
12075
diff
changeset
|
579 // Windows/x64 needs special handling. |
|
38f750491293
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
12075
diff
changeset
|
580 } else { |
| 0 | 581 frame fr = _context ? os::fetch_frame_from_context(_context) |
| 582 : os::current_frame(); | |
| 583 | |
| 584 // see if it's a valid frame | |
| 585 if (fr.pc()) { | |
| 586 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)"); | |
| 587 | |
|
2022
2d4762ec74af
7003748: Decode C stack frames when symbols are presented (PhoneHome project)
zgu
parents:
1972
diff
changeset
|
588 |
| 0 | 589 int count = 0; |
| 590 while (count++ < StackPrintLimit) { | |
| 591 fr.print_on_error(st, buf, sizeof(buf)); | |
| 592 st->cr(); | |
|
12075
4b2838704fd5
8021898: Broken JIT compiler optimization for loop unswitching
kvn
parents:
11093
diff
changeset
|
593 // Compiled code may use EBP register on x86 so it looks like |
|
4b2838704fd5
8021898: Broken JIT compiler optimization for loop unswitching
kvn
parents:
11093
diff
changeset
|
594 // non-walkable C frame. Use frame.sender() for java frames. |
|
4b2838704fd5
8021898: Broken JIT compiler optimization for loop unswitching
kvn
parents:
11093
diff
changeset
|
595 if (_thread && _thread->is_Java_thread() && fr.is_java_frame()) { |
|
4b2838704fd5
8021898: Broken JIT compiler optimization for loop unswitching
kvn
parents:
11093
diff
changeset
|
596 RegisterMap map((JavaThread*)_thread, false); // No update |
|
4b2838704fd5
8021898: Broken JIT compiler optimization for loop unswitching
kvn
parents:
11093
diff
changeset
|
597 fr = fr.sender(&map); |
|
4b2838704fd5
8021898: Broken JIT compiler optimization for loop unswitching
kvn
parents:
11093
diff
changeset
|
598 continue; |
|
4b2838704fd5
8021898: Broken JIT compiler optimization for loop unswitching
kvn
parents:
11093
diff
changeset
|
599 } |
| 0 | 600 if (os::is_first_C_frame(&fr)) break; |
| 601 fr = os::get_sender_for_C_frame(&fr); | |
| 602 } | |
| 603 | |
| 604 if (count > StackPrintLimit) { | |
| 605 st->print_cr("...<more frames>..."); | |
| 606 } | |
| 607 | |
| 608 st->cr(); | |
| 609 } | |
| 610 } | |
|
12199
38f750491293
8022335: Native stack walk while generating hs_err does not work on Windows x64
iklam
parents:
12075
diff
changeset
|
611 } |
| 0 | 612 |
| 613 STEP(130, "(printing Java stack)" ) | |
| 614 | |
| 615 if (_verbose && _thread && _thread->is_Java_thread()) { | |
| 1384 | 616 print_stack_trace(st, (JavaThread*)_thread, buf, sizeof(buf)); |
| 0 | 617 } |
| 618 | |
|
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
619 STEP(135, "(printing target Java thread stack)" ) |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
620 |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
621 // printing Java thread stack trace if it is involved in GC crash |
| 1907 | 622 if (_verbose && _thread && (_thread->is_Named_thread())) { |
|
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
623 JavaThread* jt = ((NamedThread *)_thread)->processed_thread(); |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
624 if (jt != NULL) { |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
625 st->print_cr("JavaThread " PTR_FORMAT " (nid = " UINTX_FORMAT ") was being processed", jt, jt->osthread()->thread_id()); |
| 1384 | 626 print_stack_trace(st, jt, buf, sizeof(buf), true); |
|
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
627 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
628 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
629 |
| 0 | 630 STEP(140, "(printing VM operation)" ) |
| 631 | |
| 632 if (_verbose && _thread && _thread->is_VM_thread()) { | |
| 633 VMThread* t = (VMThread*)_thread; | |
| 634 VM_Operation* op = t->vm_operation(); | |
| 635 if (op) { | |
| 636 op->print_on_error(st); | |
| 637 st->cr(); | |
| 638 st->cr(); | |
| 639 } | |
| 640 } | |
| 641 | |
| 642 STEP(150, "(printing current compile task)" ) | |
| 643 | |
| 644 if (_verbose && _thread && _thread->is_Compiler_thread()) { | |
| 645 CompilerThread* t = (CompilerThread*)_thread; | |
| 646 if (t->task()) { | |
| 647 st->cr(); | |
| 648 st->print_cr("Current CompileTask:"); | |
| 649 t->task()->print_line_on_error(st, buf, sizeof(buf)); | |
| 650 st->cr(); | |
| 651 } | |
| 652 } | |
| 653 | |
| 654 STEP(160, "(printing process)" ) | |
| 655 | |
| 656 if (_verbose) { | |
| 657 st->cr(); | |
| 658 st->print_cr("--------------- P R O C E S S ---------------"); | |
| 659 st->cr(); | |
| 660 } | |
| 661 | |
| 662 STEP(170, "(printing all threads)" ) | |
| 663 | |
| 664 // all threads | |
| 665 if (_verbose && _thread) { | |
| 666 Threads::print_on_error(st, _thread, buf, sizeof(buf)); | |
| 667 st->cr(); | |
| 668 } | |
| 669 | |
| 670 STEP(175, "(printing VM state)" ) | |
| 671 | |
| 672 if (_verbose) { | |
| 673 // Safepoint state | |
| 674 st->print("VM state:"); | |
| 675 | |
| 676 if (SafepointSynchronize::is_synchronizing()) st->print("synchronizing"); | |
| 677 else if (SafepointSynchronize::is_at_safepoint()) st->print("at safepoint"); | |
| 678 else st->print("not at safepoint"); | |
| 679 | |
| 680 // Also see if error occurred during initialization or shutdown | |
| 681 if (!Universe::is_fully_initialized()) { | |
| 682 st->print(" (not fully initialized)"); | |
| 683 } else if (VM_Exit::vm_exited()) { | |
| 684 st->print(" (shutting down)"); | |
| 685 } else { | |
| 686 st->print(" (normal execution)"); | |
| 687 } | |
| 688 st->cr(); | |
| 689 st->cr(); | |
| 690 } | |
| 691 | |
| 692 STEP(180, "(printing owned locks on error)" ) | |
| 693 | |
| 694 // mutexes/monitors that currently have an owner | |
| 695 if (_verbose) { | |
| 696 print_owned_locks_on_error(st); | |
| 697 st->cr(); | |
| 698 } | |
| 699 | |
| 700 STEP(190, "(printing heap information)" ) | |
| 701 | |
| 702 if (_verbose && Universe::is_fully_initialized()) { | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8032
diff
changeset
|
703 Universe::heap()->print_on_error(st); |
| 5984 | 704 st->cr(); |
| 705 | |
| 706 st->print_cr("Polling page: " INTPTR_FORMAT, os::get_polling_page()); | |
| 707 st->cr(); | |
| 0 | 708 } |
| 709 | |
| 1907 | 710 STEP(195, "(printing code cache information)" ) |
| 711 | |
| 712 if (_verbose && Universe::is_fully_initialized()) { | |
| 713 // print code cache information before vm abort | |
|
7595
9deda4d8e126
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
6972
diff
changeset
|
714 CodeCache::print_summary(st); |
| 1907 | 715 st->cr(); |
| 716 } | |
| 717 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
718 STEP(200, "(printing ring buffers)" ) |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
719 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
720 if (_verbose) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
721 Events::print_all(st); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
722 st->cr(); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
723 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
724 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
725 STEP(205, "(printing dynamic libraries)" ) |
| 0 | 726 |
| 727 if (_verbose) { | |
| 728 // dynamic libraries, or memory map | |
| 729 os::print_dll_info(st); | |
| 730 st->cr(); | |
| 731 } | |
| 732 | |
| 733 STEP(210, "(printing VM options)" ) | |
| 734 | |
| 735 if (_verbose) { | |
| 736 // VM options | |
| 737 Arguments::print_on(st); | |
| 738 st->cr(); | |
| 739 } | |
| 740 | |
| 5915 | 741 STEP(215, "(printing warning if internal testing API used)" ) |
| 742 | |
| 743 if (WhiteBox::used()) { | |
| 744 st->print_cr("Unsupported internal testing APIs have been used."); | |
| 745 st->cr(); | |
| 746 } | |
| 747 | |
| 0 | 748 STEP(220, "(printing environment variables)" ) |
| 749 | |
| 750 if (_verbose) { | |
| 751 os::print_environment_variables(st, env_list, buf, sizeof(buf)); | |
| 752 st->cr(); | |
| 753 } | |
| 754 | |
| 755 STEP(225, "(printing signal handlers)" ) | |
| 756 | |
| 757 if (_verbose) { | |
| 758 os::print_signal_handlers(st, buf, sizeof(buf)); | |
| 759 st->cr(); | |
| 760 } | |
| 761 | |
| 762 STEP(230, "" ) | |
| 763 | |
| 764 if (_verbose) { | |
| 765 st->cr(); | |
| 766 st->print_cr("--------------- S Y S T E M ---------------"); | |
| 767 st->cr(); | |
| 768 } | |
| 769 | |
| 770 STEP(240, "(printing OS information)" ) | |
| 771 | |
| 772 if (_verbose) { | |
| 773 os::print_os_info(st); | |
| 774 st->cr(); | |
| 775 } | |
| 776 | |
| 777 STEP(250, "(printing CPU info)" ) | |
| 778 if (_verbose) { | |
| 779 os::print_cpu_info(st); | |
| 780 st->cr(); | |
| 781 } | |
| 782 | |
| 783 STEP(260, "(printing memory info)" ) | |
| 784 | |
| 785 if (_verbose) { | |
| 786 os::print_memory_info(st); | |
| 787 st->cr(); | |
| 788 } | |
| 789 | |
| 790 STEP(270, "(printing internal vm info)" ) | |
| 791 | |
| 792 if (_verbose) { | |
| 793 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); | |
| 794 st->cr(); | |
| 795 } | |
| 796 | |
| 797 STEP(280, "(printing date and time)" ) | |
| 798 | |
| 799 if (_verbose) { | |
| 800 os::print_date_and_time(st); | |
| 801 st->cr(); | |
| 802 } | |
| 803 | |
| 804 END | |
| 805 | |
| 806 # undef BEGIN | |
| 807 # undef STEP | |
| 808 # undef END | |
| 809 } | |
| 810 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
811 VMError* volatile VMError::first_error = NULL; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
812 volatile jlong VMError::first_error_tid = -1; |
| 0 | 813 |
|
11060
068b406e307f
7060111: race condition in VMError::report_and_die()
fparain
parents:
10208
diff
changeset
|
814 // An error could happen before tty is initialized or after it has been |
|
068b406e307f
7060111: race condition in VMError::report_and_die()
fparain
parents:
10208
diff
changeset
|
815 // destroyed. Here we use a very simple unbuffered fdStream for printing. |
|
068b406e307f
7060111: race condition in VMError::report_and_die()
fparain
parents:
10208
diff
changeset
|
816 // Only out.print_raw() and out.print_raw_cr() should be used, as other |
|
068b406e307f
7060111: race condition in VMError::report_and_die()
fparain
parents:
10208
diff
changeset
|
817 // printing methods need to allocate large buffer on stack. To format a |
|
068b406e307f
7060111: race condition in VMError::report_and_die()
fparain
parents:
10208
diff
changeset
|
818 // string, use jio_snprintf() with a static buffer or use staticBufferStream. |
|
068b406e307f
7060111: race condition in VMError::report_and_die()
fparain
parents:
10208
diff
changeset
|
819 fdStream VMError::out(defaultStream::output_fd()); |
|
068b406e307f
7060111: race condition in VMError::report_and_die()
fparain
parents:
10208
diff
changeset
|
820 fdStream VMError::log; // error log used by VMError::report_and_die() |
|
068b406e307f
7060111: race condition in VMError::report_and_die()
fparain
parents:
10208
diff
changeset
|
821 |
|
10195
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
822 /** Expand a pattern into a buffer starting at pos and open a file using constructed path */ |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
823 static int expand_and_open(const char* pattern, char* buf, size_t buflen, size_t pos) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
824 int fd = -1; |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
825 if (Arguments::copy_expand_pid(pattern, strlen(pattern), &buf[pos], buflen - pos)) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
826 fd = open(buf, O_RDWR | O_CREAT | O_TRUNC, 0666); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
827 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
828 return fd; |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
829 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
830 |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
831 /** |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
832 * Construct file name for a log file and return it's file descriptor. |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
833 * Name and location depends on pattern, default_pattern params and access |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
834 * permissions. |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
835 */ |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
836 static int prepare_log_file(const char* pattern, const char* default_pattern, char* buf, size_t buflen) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
837 int fd = -1; |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
838 |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
839 // If possible, use specified pattern to construct log file name |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
840 if (pattern != NULL) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
841 fd = expand_and_open(pattern, buf, buflen, 0); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
842 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
843 |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
844 // Either user didn't specify, or the user's location failed, |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
845 // so use the default name in the current directory |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
846 if (fd == -1) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
847 const char* cwd = os::get_current_directory(buf, buflen); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
848 if (cwd != NULL) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
849 size_t pos = strlen(cwd); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
850 int fsep_len = jio_snprintf(&buf[pos], buflen-pos, "%s", os::file_separator()); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
851 pos += fsep_len; |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
852 if (fsep_len > 0) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
853 fd = expand_and_open(default_pattern, buf, buflen, pos); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
854 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
855 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
856 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
857 |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
858 // try temp directory if it exists. |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
859 if (fd == -1) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
860 const char* tmpdir = os::get_temp_directory(); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
861 if (tmpdir != NULL && strlen(tmpdir) > 0) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
862 int pos = jio_snprintf(buf, buflen, "%s%s", tmpdir, os::file_separator()); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
863 if (pos > 0) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
864 fd = expand_and_open(default_pattern, buf, buflen, pos); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
865 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
866 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
867 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
868 |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
869 return fd; |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
870 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
871 |
| 0 | 872 void VMError::report_and_die() { |
| 873 // Don't allocate large buffer on stack | |
| 874 static char buffer[O_BUFLEN]; | |
| 875 | |
| 876 // How many errors occurred in error handler when reporting first_error. | |
| 877 static int recursive_error_count; | |
| 878 | |
| 879 // We will first print a brief message to standard out (verbose = false), | |
| 880 // then save detailed information in log file (verbose = true). | |
| 881 static bool out_done = false; // done printing to standard out | |
| 882 static bool log_done = false; // done saving error log | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
883 static bool transmit_report_done = false; // done error reporting |
| 0 | 884 |
| 6197 | 885 // disble NMT to avoid further exception |
| 886 MemTracker::shutdown(MemTracker::NMT_error_reporting); | |
| 887 | |
| 0 | 888 if (SuppressFatalErrorMessage) { |
| 889 os::abort(); | |
| 890 } | |
| 891 jlong mytid = os::current_thread_id(); | |
| 892 if (first_error == NULL && | |
| 893 Atomic::cmpxchg_ptr(this, &first_error, NULL) == NULL) { | |
| 894 | |
| 895 // first time | |
| 896 first_error_tid = mytid; | |
| 897 set_error_reported(); | |
| 898 | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
899 if (ShowMessageBoxOnError || PauseAtExit) { |
| 0 | 900 show_message_box(buffer, sizeof(buffer)); |
| 901 | |
| 902 // User has asked JVM to abort. Reset ShowMessageBoxOnError so the | |
| 903 // WatcherThread can kill JVM if the error handler hangs. | |
| 904 ShowMessageBoxOnError = false; | |
| 905 } | |
| 906 | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
907 // Write a minidump on Windows, check core dump limits on Linux/Solaris |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
908 os::check_or_create_dump(_siginfo, _context, buffer, sizeof(buffer)); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
909 |
| 0 | 910 // reset signal handlers or exception filter; make sure recursive crashes |
| 911 // are handled properly. | |
| 912 reset_signal_handlers(); | |
| 913 | |
| 914 } else { | |
|
511
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
915 // If UseOsErrorReporting we call this for each level of the call stack |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
916 // while searching for the exception handler. Only the first level needs |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
917 // to be reported. |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
918 if (UseOSErrorReporting && log_done) return; |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
919 |
| 0 | 920 // This is not the first error, see if it happened in a different thread |
| 921 // or in the same thread during error reporting. | |
| 922 if (first_error_tid != mytid) { | |
| 11093 | 923 char msgbuf[64]; |
| 924 jio_snprintf(msgbuf, sizeof(msgbuf), | |
| 0 | 925 "[thread " INT64_FORMAT " also had an error]", |
| 926 mytid); | |
| 11093 | 927 out.print_raw_cr(msgbuf); |
| 0 | 928 |
| 929 // error reporting is not MT-safe, block current thread | |
| 930 os::infinite_sleep(); | |
| 931 | |
| 932 } else { | |
| 933 if (recursive_error_count++ > 30) { | |
| 934 out.print_raw_cr("[Too many errors, abort]"); | |
| 935 os::die(); | |
| 936 } | |
| 937 | |
| 938 jio_snprintf(buffer, sizeof(buffer), | |
| 939 "[error occurred during error reporting %s, id 0x%x]", | |
| 940 first_error ? first_error->_current_step_info : "", | |
| 941 _id); | |
| 942 if (log.is_open()) { | |
| 943 log.cr(); | |
| 944 log.print_raw_cr(buffer); | |
| 945 log.cr(); | |
| 946 } else { | |
| 947 out.cr(); | |
| 948 out.print_raw_cr(buffer); | |
| 949 out.cr(); | |
| 950 } | |
| 951 } | |
| 952 } | |
| 953 | |
| 954 // print to screen | |
| 955 if (!out_done) { | |
| 956 first_error->_verbose = false; | |
| 957 | |
| 958 staticBufferStream sbs(buffer, sizeof(buffer), &out); | |
| 959 first_error->report(&sbs); | |
| 960 | |
| 961 out_done = true; | |
| 962 | |
| 963 first_error->_current_step = 0; // reset current_step | |
| 964 first_error->_current_step_info = ""; // reset current_step string | |
| 965 } | |
| 966 | |
| 967 // print to error log file | |
| 968 if (!log_done) { | |
| 969 first_error->_verbose = true; | |
| 970 | |
| 971 // see if log file is already open | |
| 972 if (!log.is_open()) { | |
| 973 // open log file | |
|
10195
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
974 int fd = prepare_log_file(ErrorFile, "hs_err_pid%p.log", buffer, sizeof(buffer)); |
| 0 | 975 if (fd != -1) { |
| 976 out.print_raw("# An error report file with more information is saved as:\n# "); | |
| 977 out.print_raw_cr(buffer); | |
| 978 os::set_error_file(buffer); | |
| 979 | |
| 980 log.set_fd(fd); | |
| 981 } else { | |
| 982 out.print_raw_cr("# Can not save log file, dump to screen.."); | |
| 983 log.set_fd(defaultStream::output_fd()); | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
984 /* Error reporting currently needs dumpfile. |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
985 * Maybe implement direct streaming in the future.*/ |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
986 transmit_report_done = true; |
| 0 | 987 } |
| 988 } | |
| 989 | |
| 990 staticBufferStream sbs(buffer, O_BUFLEN, &log); | |
| 991 first_error->report(&sbs); | |
| 992 first_error->_current_step = 0; // reset current_step | |
| 993 first_error->_current_step_info = ""; // reset current_step string | |
| 994 | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
995 // Run error reporting to determine whether or not to report the crash. |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
996 if (!transmit_report_done && should_report_bug(first_error->_id)) { |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
997 transmit_report_done = true; |
|
10195
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
998 FILE* hs_err = os::open(log.fd(), "r"); |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
999 if (NULL != hs_err) { |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
1000 ErrorReporter er; |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
1001 er.call(hs_err, buffer, O_BUFLEN); |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
1002 } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
1003 } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
1004 |
| 0 | 1005 if (log.fd() != defaultStream::output_fd()) { |
| 1006 close(log.fd()); | |
| 1007 } | |
| 1008 | |
| 1009 log.set_fd(-1); | |
| 1010 log_done = true; | |
| 1011 } | |
| 1012 | |
| 1013 | |
| 1014 static bool skip_OnError = false; | |
| 1015 if (!skip_OnError && OnError && OnError[0]) { | |
| 1016 skip_OnError = true; | |
| 1017 | |
| 1018 out.print_raw_cr("#"); | |
| 1019 out.print_raw ("# -XX:OnError=\""); | |
| 1020 out.print_raw (OnError); | |
| 1021 out.print_raw_cr("\""); | |
| 1022 | |
| 1023 char* cmd; | |
| 1024 const char* ptr = OnError; | |
| 1025 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ | |
| 1026 out.print_raw ("# Executing "); | |
| 3960 | 1027 #if defined(LINUX) || defined(_ALLBSD_SOURCE) |
| 0 | 1028 out.print_raw ("/bin/sh -c "); |
| 1029 #elif defined(SOLARIS) | |
| 1030 out.print_raw ("/usr/bin/sh -c "); | |
| 1031 #endif | |
| 1032 out.print_raw ("\""); | |
| 1033 out.print_raw (cmd); | |
| 1034 out.print_raw_cr("\" ..."); | |
| 1035 | |
| 1036 os::fork_and_exec(cmd); | |
| 1037 } | |
| 1038 | |
| 1039 // done with OnError | |
| 1040 OnError = NULL; | |
| 1041 } | |
| 1042 | |
| 14232 | 1043 static bool skip_replay = ReplayCompiles; // Do not overwrite file during replay |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1044 if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1045 skip_replay = true; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1046 ciEnv* env = ciEnv::current(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1047 if (env != NULL) { |
|
10195
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1048 int fd = prepare_log_file(ReplayDataFile, "replay_pid%p.log", buffer, sizeof(buffer)); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1049 if (fd != -1) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1050 FILE* replay_data_file = os::open(fd, "w"); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1051 if (replay_data_file != NULL) { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1052 fileStream replay_data_stream(replay_data_file, /*need_close=*/true); |
|
12865
5cc2d82aa82a
8024943: ciReplay: fails to dump replay data during safepointing
vlivanov
parents:
12199
diff
changeset
|
1053 env->dump_replay_data_unsafe(&replay_data_stream); |
|
10195
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1054 out.print_raw("#\n# Compiler replay data is saved as:\n# "); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1055 out.print_raw_cr(buffer); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1056 } else { |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1057 out.print_raw("#\n# Can't open file to dump replay data. Error: "); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1058 out.print_raw_cr(strerror(os::get_last_error())); |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1059 } |
|
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
9076
diff
changeset
|
1060 } |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1061 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1062 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1063 |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
1064 static bool skip_bug_url = !should_report_bug(first_error->_id); |
| 0 | 1065 if (!skip_bug_url) { |
| 1066 skip_bug_url = true; | |
| 1067 | |
| 1068 out.print_raw_cr("#"); | |
| 1069 print_bug_submit_message(&out, _thread); | |
| 1070 } | |
| 1071 | |
| 1072 if (!UseOSErrorReporting) { | |
| 1073 // os::abort() will call abort hooks, try it first. | |
| 1074 static bool skip_os_abort = false; | |
| 1075 if (!skip_os_abort) { | |
| 1076 skip_os_abort = true; | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
1077 bool dump_core = should_report_bug(first_error->_id); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
1078 os::abort(dump_core); |
| 0 | 1079 } |
| 1080 | |
| 1081 // if os::abort() doesn't abort, try os::die(); | |
| 1082 os::die(); | |
| 1083 } | |
| 1084 } | |
| 1085 | |
| 1086 /* | |
| 1087 * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this | |
| 1088 * ensures utilities such as jmap can observe the process is a consistent state. | |
| 1089 */ | |
| 1090 class VM_ReportJavaOutOfMemory : public VM_Operation { | |
| 1091 private: | |
| 1092 VMError *_err; | |
| 1093 public: | |
| 1094 VM_ReportJavaOutOfMemory(VMError *err) { _err = err; } | |
| 1095 VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; } | |
| 1096 void doit(); | |
| 1097 }; | |
| 1098 | |
| 1099 void VM_ReportJavaOutOfMemory::doit() { | |
| 1100 // Don't allocate large buffer on stack | |
| 1101 static char buffer[O_BUFLEN]; | |
| 1102 | |
| 1103 tty->print_cr("#"); | |
| 1104 tty->print_cr("# java.lang.OutOfMemoryError: %s", _err->message()); | |
| 1105 tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError); | |
| 1106 | |
| 1107 // make heap parsability | |
| 1108 Universe::heap()->ensure_parsability(false); // no need to retire TLABs | |
| 1109 | |
| 1110 char* cmd; | |
| 1111 const char* ptr = OnOutOfMemoryError; | |
| 1112 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ | |
| 1113 tty->print("# Executing "); | |
| 1114 #if defined(LINUX) | |
| 1115 tty->print ("/bin/sh -c "); | |
| 1116 #elif defined(SOLARIS) | |
| 1117 tty->print ("/usr/bin/sh -c "); | |
| 1118 #endif | |
| 1119 tty->print_cr("\"%s\"...", cmd); | |
| 1120 | |
| 1121 os::fork_and_exec(cmd); | |
| 1122 } | |
| 1123 } | |
| 1124 | |
| 1125 void VMError::report_java_out_of_memory() { | |
| 1126 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { | |
| 1127 MutexLocker ml(Heap_lock); | |
| 1128 VM_ReportJavaOutOfMemory op(this); | |
| 1129 VMThread::execute(&op); | |
| 1130 } | |
| 1131 } |