Mercurial > hg > truffle
annotate src/share/vm/utilities/vmError.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | 89e4d67fdd2a |
| children | 836a62f43af9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
2 * Copyright (c) 2003, 2012, 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; |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
103 _id = internal_error; // Value that's not an OS exception/signal |
|
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, |
|
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
122 const char* message) { |
| 0 | 123 _thread = thread; |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
diff
changeset
|
124 _id = oom_error; // 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; | |
|
1490
f03d0a26bf83
6888954: argument formatting for assert() and friends
jcoomes
parents:
1384
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) { | |
| 354 case oom_error: | |
| 355 if (_size) { | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
356 st->print("# Native memory allocation (malloc) failed to allocate "); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
357 jio_snprintf(buf, sizeof(buf), SIZE_FORMAT, _size); |
| 0 | 358 st->print(buf); |
| 359 st->print(" bytes"); | |
| 360 if (_message != NULL) { | |
| 361 st->print(" for "); | |
| 362 st->print(_message); | |
| 363 } | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
364 st->cr(); |
| 0 | 365 } else { |
| 366 if (_message != NULL) | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
367 st->print("# "); |
| 0 | 368 st->print_cr(_message); |
| 369 } | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
370 // 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
|
371 if (_verbose) { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
372 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
|
373 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
|
374 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
|
375 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
|
376 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
|
377 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
|
378 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
|
379 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
|
380 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
|
381 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
|
382 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
|
383 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
|
384 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
|
385 } else { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
386 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
|
387 } |
| 0 | 388 break; |
| 389 case internal_error: | |
| 390 default: | |
| 391 break; | |
| 392 } | |
| 393 | |
| 394 STEP(20, "(printing exception/signal name)") | |
| 395 | |
| 396 st->print_cr("#"); | |
| 397 st->print("# "); | |
| 398 // Is it an OS exception/signal? | |
| 399 if (os::exception_name(_id, buf, sizeof(buf))) { | |
| 400 st->print("%s", buf); | |
| 401 st->print(" (0x%x)", _id); // signal number | |
| 402 st->print(" at pc=" PTR_FORMAT, _pc); | |
| 403 } else { | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
404 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
|
405 st->print("Internal Error"); |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
406 } else { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
407 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
|
408 } |
| 0 | 409 if (_filename != NULL && _lineno > 0) { |
| 410 #ifdef PRODUCT | |
| 411 // In product mode chop off pathname? | |
| 412 char separator = os::file_separator()[0]; | |
| 413 const char *p = strrchr(_filename, separator); | |
| 414 const char *file = p ? p+1 : _filename; | |
| 415 #else | |
| 416 const char *file = _filename; | |
| 417 #endif | |
| 418 size_t len = strlen(file); | |
| 419 size_t buflen = sizeof(buf); | |
| 420 | |
| 421 strncpy(buf, file, buflen); | |
| 422 if (len + 10 < buflen) { | |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
511
diff
changeset
|
423 sprintf(buf + len, ":%d", _lineno); |
| 0 | 424 } |
| 425 st->print(" (%s)", buf); | |
| 426 } else { | |
| 427 st->print(" (0x%x)", _id); | |
| 428 } | |
| 429 } | |
| 430 | |
| 431 STEP(30, "(printing current thread and pid)") | |
| 432 | |
| 433 // process id, thread id | |
| 434 st->print(", pid=%d", os::current_process_id()); | |
| 435 st->print(", tid=" UINTX_FORMAT, os::current_thread_id()); | |
| 436 st->cr(); | |
| 437 | |
| 438 STEP(40, "(printing error message)") | |
| 439 | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
440 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
|
441 // error message |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
442 if (_detail_msg) { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
443 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
|
444 } else if (_message) { |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
445 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
|
446 } |
|
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
447 } |
| 0 | 448 |
| 449 STEP(50, "(printing Java version string)") | |
| 450 | |
| 451 // VM version | |
| 452 st->print_cr("#"); | |
|
473
3ad2b8576c4a
6689685: Hotspot crash error message should include libraries version
coleenp
parents:
420
diff
changeset
|
453 JDK_Version::current().to_string(buf, sizeof(buf)); |
| 6181 | 454 const char* runtime_name = JDK_Version::runtime_name() != NULL ? |
| 455 JDK_Version::runtime_name() : ""; | |
|
6921
a1b8cf9cf970
8002078: hs_err_pid file should report full JDK version string
sla
parents:
6198
diff
changeset
|
456 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
|
457 JDK_Version::runtime_version() : ""; |
|
a1b8cf9cf970
8002078: hs_err_pid file should report full JDK version string
sla
parents:
6198
diff
changeset
|
458 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
|
459 st->print_cr("# Java VM: %s (%s %s %s %s)", |
| 0 | 460 Abstract_VM_Version::vm_name(), |
| 461 Abstract_VM_Version::vm_release(), | |
| 462 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
|
463 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
|
464 UseCompressedOops ? "compressed oops" : "" |
| 0 | 465 ); |
| 466 | |
| 467 STEP(60, "(printing problematic frame)") | |
| 468 | |
| 469 // Print current frame if we have a context (i.e. it's a crash) | |
| 470 if (_context) { | |
| 471 st->print_cr("# Problematic frame:"); | |
| 472 st->print("# "); | |
| 473 frame fr = os::fetch_frame_from_context(_context); | |
| 474 fr.print_on_error(st, buf, sizeof(buf)); | |
| 475 st->cr(); | |
| 476 st->print_cr("#"); | |
| 477 } | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
478 STEP(63, "(printing core file information)") |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
479 st->print("# "); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
480 if (coredump_status) { |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
481 st->print("Core dump written. Default location: %s", coredump_message); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
482 } else { |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
483 st->print("Failed to write core dump. %s", coredump_message); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
484 } |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
485 st->print_cr(""); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
486 st->print_cr("#"); |
| 0 | 487 |
| 488 STEP(65, "(printing bug submit message)") | |
| 489 | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
490 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
|
491 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
|
492 } |
| 0 | 493 |
| 494 STEP(70, "(printing thread)" ) | |
| 495 | |
| 496 if (_verbose) { | |
| 497 st->cr(); | |
| 498 st->print_cr("--------------- T H R E A D ---------------"); | |
| 499 st->cr(); | |
| 500 } | |
| 501 | |
| 502 STEP(80, "(printing current thread)" ) | |
| 503 | |
| 504 // current thread | |
| 505 if (_verbose) { | |
| 506 if (_thread) { | |
| 507 st->print("Current thread (" PTR_FORMAT "): ", _thread); | |
| 508 _thread->print_on_error(st, buf, sizeof(buf)); | |
| 509 st->cr(); | |
| 510 } else { | |
| 511 st->print_cr("Current thread is native thread"); | |
| 512 } | |
| 513 st->cr(); | |
| 514 } | |
| 515 | |
| 516 STEP(90, "(printing siginfo)" ) | |
| 517 | |
| 518 // signal no, signal code, address that caused the fault | |
| 519 if (_verbose && _siginfo) { | |
| 520 os::print_siginfo(st, _siginfo); | |
| 521 st->cr(); | |
| 522 } | |
| 523 | |
| 524 STEP(100, "(printing registers, top of stack, instructions near pc)") | |
| 525 | |
| 526 // registers, top of stack, instructions near pc | |
| 527 if (_verbose && _context) { | |
| 528 os::print_context(st, _context); | |
| 529 st->cr(); | |
| 530 } | |
| 531 | |
| 1907 | 532 STEP(105, "(printing register info)") |
| 533 | |
| 534 // decode register contents if possible | |
| 535 if (_verbose && _context && Universe::is_fully_initialized()) { | |
| 536 os::print_register_info(st, _context); | |
| 537 st->cr(); | |
| 538 } | |
| 539 | |
| 0 | 540 STEP(110, "(printing stack bounds)" ) |
| 541 | |
| 542 if (_verbose) { | |
| 543 st->print("Stack: "); | |
| 544 | |
| 545 address stack_top; | |
| 546 size_t stack_size; | |
| 547 | |
| 548 if (_thread) { | |
| 549 stack_top = _thread->stack_base(); | |
| 550 stack_size = _thread->stack_size(); | |
| 551 } else { | |
| 552 stack_top = os::current_stack_base(); | |
| 553 stack_size = os::current_stack_size(); | |
| 554 } | |
| 555 | |
| 556 address stack_bottom = stack_top - stack_size; | |
| 557 st->print("[" PTR_FORMAT "," PTR_FORMAT "]", stack_bottom, stack_top); | |
| 558 | |
| 559 frame fr = _context ? os::fetch_frame_from_context(_context) | |
| 560 : os::current_frame(); | |
| 561 | |
| 562 if (fr.sp()) { | |
| 563 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
|
564 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
|
565 st->print(", free space=" SIZE_FORMAT "k", free_stack_size); |
| 0 | 566 } |
| 567 | |
| 568 st->cr(); | |
| 569 } | |
| 570 | |
| 571 STEP(120, "(printing native stack)" ) | |
| 572 | |
| 573 if (_verbose) { | |
| 574 frame fr = _context ? os::fetch_frame_from_context(_context) | |
| 575 : os::current_frame(); | |
| 576 | |
| 577 // see if it's a valid frame | |
| 578 if (fr.pc()) { | |
| 579 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)"); | |
| 580 | |
|
2022
2d4762ec74af
7003748: Decode C stack frames when symbols are presented (PhoneHome project)
zgu
parents:
1972
diff
changeset
|
581 |
| 0 | 582 int count = 0; |
| 583 while (count++ < StackPrintLimit) { | |
| 584 fr.print_on_error(st, buf, sizeof(buf)); | |
| 585 st->cr(); | |
| 586 if (os::is_first_C_frame(&fr)) break; | |
| 587 fr = os::get_sender_for_C_frame(&fr); | |
| 588 } | |
| 589 | |
| 590 if (count > StackPrintLimit) { | |
| 591 st->print_cr("...<more frames>..."); | |
| 592 } | |
| 593 | |
| 594 st->cr(); | |
| 595 } | |
| 596 } | |
| 597 | |
| 598 STEP(130, "(printing Java stack)" ) | |
| 599 | |
| 600 if (_verbose && _thread && _thread->is_Java_thread()) { | |
| 1384 | 601 print_stack_trace(st, (JavaThread*)_thread, buf, sizeof(buf)); |
| 0 | 602 } |
| 603 | |
|
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
604 STEP(135, "(printing target Java thread stack)" ) |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
605 |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
606 // printing Java thread stack trace if it is involved in GC crash |
| 1907 | 607 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
|
608 JavaThread* jt = ((NamedThread *)_thread)->processed_thread(); |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
609 if (jt != NULL) { |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
610 st->print_cr("JavaThread " PTR_FORMAT " (nid = " UINTX_FORMAT ") was being processed", jt, jt->osthread()->thread_id()); |
| 1384 | 611 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
|
612 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
613 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
614 |
| 0 | 615 STEP(140, "(printing VM operation)" ) |
| 616 | |
| 617 if (_verbose && _thread && _thread->is_VM_thread()) { | |
| 618 VMThread* t = (VMThread*)_thread; | |
| 619 VM_Operation* op = t->vm_operation(); | |
| 620 if (op) { | |
| 621 op->print_on_error(st); | |
| 622 st->cr(); | |
| 623 st->cr(); | |
| 624 } | |
| 625 } | |
| 626 | |
| 627 STEP(150, "(printing current compile task)" ) | |
| 628 | |
| 629 if (_verbose && _thread && _thread->is_Compiler_thread()) { | |
| 630 CompilerThread* t = (CompilerThread*)_thread; | |
| 631 if (t->task()) { | |
| 632 st->cr(); | |
| 633 st->print_cr("Current CompileTask:"); | |
| 634 t->task()->print_line_on_error(st, buf, sizeof(buf)); | |
| 635 st->cr(); | |
| 636 } | |
| 637 } | |
| 638 | |
| 639 STEP(160, "(printing process)" ) | |
| 640 | |
| 641 if (_verbose) { | |
| 642 st->cr(); | |
| 643 st->print_cr("--------------- P R O C E S S ---------------"); | |
| 644 st->cr(); | |
| 645 } | |
| 646 | |
| 647 STEP(170, "(printing all threads)" ) | |
| 648 | |
| 649 // all threads | |
| 650 if (_verbose && _thread) { | |
| 651 Threads::print_on_error(st, _thread, buf, sizeof(buf)); | |
| 652 st->cr(); | |
| 653 } | |
| 654 | |
| 655 STEP(175, "(printing VM state)" ) | |
| 656 | |
| 657 if (_verbose) { | |
| 658 // Safepoint state | |
| 659 st->print("VM state:"); | |
| 660 | |
| 661 if (SafepointSynchronize::is_synchronizing()) st->print("synchronizing"); | |
| 662 else if (SafepointSynchronize::is_at_safepoint()) st->print("at safepoint"); | |
| 663 else st->print("not at safepoint"); | |
| 664 | |
| 665 // Also see if error occurred during initialization or shutdown | |
| 666 if (!Universe::is_fully_initialized()) { | |
| 667 st->print(" (not fully initialized)"); | |
| 668 } else if (VM_Exit::vm_exited()) { | |
| 669 st->print(" (shutting down)"); | |
| 670 } else { | |
| 671 st->print(" (normal execution)"); | |
| 672 } | |
| 673 st->cr(); | |
| 674 st->cr(); | |
| 675 } | |
| 676 | |
| 677 STEP(180, "(printing owned locks on error)" ) | |
| 678 | |
| 679 // mutexes/monitors that currently have an owner | |
| 680 if (_verbose) { | |
| 681 print_owned_locks_on_error(st); | |
| 682 st->cr(); | |
| 683 } | |
| 684 | |
| 685 STEP(190, "(printing heap information)" ) | |
| 686 | |
| 687 if (_verbose && Universe::is_fully_initialized()) { | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8032
diff
changeset
|
688 Universe::heap()->print_on_error(st); |
| 5984 | 689 st->cr(); |
| 690 | |
| 691 st->print_cr("Polling page: " INTPTR_FORMAT, os::get_polling_page()); | |
| 692 st->cr(); | |
| 0 | 693 } |
| 694 | |
| 1907 | 695 STEP(195, "(printing code cache information)" ) |
| 696 | |
| 697 if (_verbose && Universe::is_fully_initialized()) { | |
| 698 // print code cache information before vm abort | |
|
7595
9deda4d8e126
8005204: Code Cache Reduction: command line options implementation
vladidan
parents:
6972
diff
changeset
|
699 CodeCache::print_summary(st); |
| 1907 | 700 st->cr(); |
| 701 } | |
| 702 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
703 STEP(200, "(printing ring buffers)" ) |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
704 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
705 if (_verbose) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
706 Events::print_all(st); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
707 st->cr(); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
708 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
709 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
710 STEP(205, "(printing dynamic libraries)" ) |
| 0 | 711 |
| 712 if (_verbose) { | |
| 713 // dynamic libraries, or memory map | |
| 714 os::print_dll_info(st); | |
| 715 st->cr(); | |
| 716 } | |
| 717 | |
| 718 STEP(210, "(printing VM options)" ) | |
| 719 | |
| 720 if (_verbose) { | |
| 721 // VM options | |
| 722 Arguments::print_on(st); | |
| 723 st->cr(); | |
| 724 } | |
| 725 | |
| 5915 | 726 STEP(215, "(printing warning if internal testing API used)" ) |
| 727 | |
| 728 if (WhiteBox::used()) { | |
| 729 st->print_cr("Unsupported internal testing APIs have been used."); | |
| 730 st->cr(); | |
| 731 } | |
| 732 | |
| 0 | 733 STEP(220, "(printing environment variables)" ) |
| 734 | |
| 735 if (_verbose) { | |
| 736 os::print_environment_variables(st, env_list, buf, sizeof(buf)); | |
| 737 st->cr(); | |
| 738 } | |
| 739 | |
| 740 STEP(225, "(printing signal handlers)" ) | |
| 741 | |
| 742 if (_verbose) { | |
| 743 os::print_signal_handlers(st, buf, sizeof(buf)); | |
| 744 st->cr(); | |
| 745 } | |
| 746 | |
| 747 STEP(230, "" ) | |
| 748 | |
| 749 if (_verbose) { | |
| 750 st->cr(); | |
| 751 st->print_cr("--------------- S Y S T E M ---------------"); | |
| 752 st->cr(); | |
| 753 } | |
| 754 | |
| 755 STEP(240, "(printing OS information)" ) | |
| 756 | |
| 757 if (_verbose) { | |
| 758 os::print_os_info(st); | |
| 759 st->cr(); | |
| 760 } | |
| 761 | |
| 762 STEP(250, "(printing CPU info)" ) | |
| 763 if (_verbose) { | |
| 764 os::print_cpu_info(st); | |
| 765 st->cr(); | |
| 766 } | |
| 767 | |
| 768 STEP(260, "(printing memory info)" ) | |
| 769 | |
| 770 if (_verbose) { | |
| 771 os::print_memory_info(st); | |
| 772 st->cr(); | |
| 773 } | |
| 774 | |
| 775 STEP(270, "(printing internal vm info)" ) | |
| 776 | |
| 777 if (_verbose) { | |
| 778 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); | |
| 779 st->cr(); | |
| 780 } | |
| 781 | |
| 782 STEP(280, "(printing date and time)" ) | |
| 783 | |
| 784 if (_verbose) { | |
| 785 os::print_date_and_time(st); | |
| 786 st->cr(); | |
| 787 } | |
| 788 | |
| 789 END | |
| 790 | |
| 791 # undef BEGIN | |
| 792 # undef STEP | |
| 793 # undef END | |
| 794 } | |
| 795 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
796 VMError* volatile VMError::first_error = NULL; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
797 volatile jlong VMError::first_error_tid = -1; |
| 0 | 798 |
| 799 void VMError::report_and_die() { | |
| 800 // Don't allocate large buffer on stack | |
| 801 static char buffer[O_BUFLEN]; | |
| 802 | |
| 803 // An error could happen before tty is initialized or after it has been | |
| 804 // destroyed. Here we use a very simple unbuffered fdStream for printing. | |
| 805 // Only out.print_raw() and out.print_raw_cr() should be used, as other | |
| 806 // printing methods need to allocate large buffer on stack. To format a | |
| 807 // string, use jio_snprintf() with a static buffer or use staticBufferStream. | |
| 808 static fdStream out(defaultStream::output_fd()); | |
| 809 | |
| 810 // How many errors occurred in error handler when reporting first_error. | |
| 811 static int recursive_error_count; | |
| 812 | |
| 813 // We will first print a brief message to standard out (verbose = false), | |
| 814 // then save detailed information in log file (verbose = true). | |
| 815 static bool out_done = false; // done printing to standard out | |
| 816 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
|
817 static bool transmit_report_done = false; // done error reporting |
| 0 | 818 static fdStream log; // error log |
| 819 | |
| 6197 | 820 // disble NMT to avoid further exception |
| 821 MemTracker::shutdown(MemTracker::NMT_error_reporting); | |
| 822 | |
| 0 | 823 if (SuppressFatalErrorMessage) { |
| 824 os::abort(); | |
| 825 } | |
| 826 jlong mytid = os::current_thread_id(); | |
| 827 if (first_error == NULL && | |
| 828 Atomic::cmpxchg_ptr(this, &first_error, NULL) == NULL) { | |
| 829 | |
| 830 // first time | |
| 831 first_error_tid = mytid; | |
| 832 set_error_reported(); | |
| 833 | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
834 if (ShowMessageBoxOnError || PauseAtExit) { |
| 0 | 835 show_message_box(buffer, sizeof(buffer)); |
| 836 | |
| 837 // User has asked JVM to abort. Reset ShowMessageBoxOnError so the | |
| 838 // WatcherThread can kill JVM if the error handler hangs. | |
| 839 ShowMessageBoxOnError = false; | |
| 840 } | |
| 841 | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
842 // 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
|
843 os::check_or_create_dump(_siginfo, _context, buffer, sizeof(buffer)); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
844 |
| 0 | 845 // reset signal handlers or exception filter; make sure recursive crashes |
| 846 // are handled properly. | |
| 847 reset_signal_handlers(); | |
| 848 | |
| 849 } else { | |
|
511
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
850 // 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
|
851 // 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
|
852 // to be reported. |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
853 if (UseOSErrorReporting && log_done) return; |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
854 |
| 0 | 855 // This is not the first error, see if it happened in a different thread |
| 856 // or in the same thread during error reporting. | |
| 857 if (first_error_tid != mytid) { | |
| 858 jio_snprintf(buffer, sizeof(buffer), | |
| 859 "[thread " INT64_FORMAT " also had an error]", | |
| 860 mytid); | |
| 861 out.print_raw_cr(buffer); | |
| 862 | |
| 863 // error reporting is not MT-safe, block current thread | |
| 864 os::infinite_sleep(); | |
| 865 | |
| 866 } else { | |
| 867 if (recursive_error_count++ > 30) { | |
| 868 out.print_raw_cr("[Too many errors, abort]"); | |
| 869 os::die(); | |
| 870 } | |
| 871 | |
| 872 jio_snprintf(buffer, sizeof(buffer), | |
| 873 "[error occurred during error reporting %s, id 0x%x]", | |
| 874 first_error ? first_error->_current_step_info : "", | |
| 875 _id); | |
| 876 if (log.is_open()) { | |
| 877 log.cr(); | |
| 878 log.print_raw_cr(buffer); | |
| 879 log.cr(); | |
| 880 } else { | |
| 881 out.cr(); | |
| 882 out.print_raw_cr(buffer); | |
| 883 out.cr(); | |
| 884 } | |
| 885 } | |
| 886 } | |
| 887 | |
| 888 // print to screen | |
| 889 if (!out_done) { | |
| 890 first_error->_verbose = false; | |
| 891 | |
| 892 staticBufferStream sbs(buffer, sizeof(buffer), &out); | |
| 893 first_error->report(&sbs); | |
| 894 | |
| 895 out_done = true; | |
| 896 | |
| 897 first_error->_current_step = 0; // reset current_step | |
| 898 first_error->_current_step_info = ""; // reset current_step string | |
| 899 } | |
| 900 | |
| 901 // print to error log file | |
| 902 if (!log_done) { | |
| 903 first_error->_verbose = true; | |
| 904 | |
| 905 // see if log file is already open | |
| 906 if (!log.is_open()) { | |
| 907 // open log file | |
| 908 int fd = -1; | |
| 909 | |
| 910 if (ErrorFile != NULL) { | |
| 911 bool copy_ok = | |
| 912 Arguments::copy_expand_pid(ErrorFile, strlen(ErrorFile), buffer, sizeof(buffer)); | |
| 913 if (copy_ok) { | |
| 8032 | 914 fd = open(buffer, O_RDWR | O_CREAT | O_TRUNC, 0666); |
| 0 | 915 } |
| 916 } | |
| 917 | |
| 918 if (fd == -1) { | |
| 919 const char *cwd = os::get_current_directory(buffer, sizeof(buffer)); | |
| 920 size_t len = strlen(cwd); | |
| 921 // either user didn't specify, or the user's location failed, | |
| 922 // so use the default name in the current directory | |
| 923 jio_snprintf(&buffer[len], sizeof(buffer)-len, "%shs_err_pid%u.log", | |
| 924 os::file_separator(), os::current_process_id()); | |
| 8032 | 925 fd = open(buffer, O_RDWR | O_CREAT | O_TRUNC, 0666); |
| 0 | 926 } |
| 927 | |
| 928 if (fd == -1) { | |
| 929 const char * tmpdir = os::get_temp_directory(); | |
|
2130
34d64ad817f4
7009828: Fix for 6938627 breaks visualvm monitoring when -Djava.io.tmpdir is defined
coleenp
parents:
2095
diff
changeset
|
930 // try temp directory if it exists. |
|
34d64ad817f4
7009828: Fix for 6938627 breaks visualvm monitoring when -Djava.io.tmpdir is defined
coleenp
parents:
2095
diff
changeset
|
931 if (tmpdir != NULL && tmpdir[0] != '\0') { |
|
34d64ad817f4
7009828: Fix for 6938627 breaks visualvm monitoring when -Djava.io.tmpdir is defined
coleenp
parents:
2095
diff
changeset
|
932 jio_snprintf(buffer, sizeof(buffer), "%s%shs_err_pid%u.log", |
|
34d64ad817f4
7009828: Fix for 6938627 breaks visualvm monitoring when -Djava.io.tmpdir is defined
coleenp
parents:
2095
diff
changeset
|
933 tmpdir, os::file_separator(), os::current_process_id()); |
| 8032 | 934 fd = open(buffer, O_RDWR | O_CREAT | O_TRUNC, 0666); |
|
2130
34d64ad817f4
7009828: Fix for 6938627 breaks visualvm monitoring when -Djava.io.tmpdir is defined
coleenp
parents:
2095
diff
changeset
|
935 } |
| 0 | 936 } |
| 937 | |
| 938 if (fd != -1) { | |
| 939 out.print_raw("# An error report file with more information is saved as:\n# "); | |
| 940 out.print_raw_cr(buffer); | |
| 941 os::set_error_file(buffer); | |
| 942 | |
| 943 log.set_fd(fd); | |
| 944 } else { | |
| 945 out.print_raw_cr("# Can not save log file, dump to screen.."); | |
| 946 log.set_fd(defaultStream::output_fd()); | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
947 /* Error reporting currently needs dumpfile. |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
948 * Maybe implement direct streaming in the future.*/ |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
949 transmit_report_done = true; |
| 0 | 950 } |
| 951 } | |
| 952 | |
| 953 staticBufferStream sbs(buffer, O_BUFLEN, &log); | |
| 954 first_error->report(&sbs); | |
| 955 first_error->_current_step = 0; // reset current_step | |
| 956 first_error->_current_step_info = ""; // reset current_step string | |
| 957 | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
958 // 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
|
959 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
|
960 transmit_report_done = true; |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
961 FILE* hs_err = ::fdopen(log.fd(), "r"); |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
962 if (NULL != hs_err) { |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
963 ErrorReporter er; |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
964 er.call(hs_err, buffer, O_BUFLEN); |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
965 } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
966 } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
967 |
| 0 | 968 if (log.fd() != defaultStream::output_fd()) { |
| 969 close(log.fd()); | |
| 970 } | |
| 971 | |
| 972 log.set_fd(-1); | |
| 973 log_done = true; | |
| 974 } | |
| 975 | |
| 976 | |
| 977 static bool skip_OnError = false; | |
| 978 if (!skip_OnError && OnError && OnError[0]) { | |
| 979 skip_OnError = true; | |
| 980 | |
| 981 out.print_raw_cr("#"); | |
| 982 out.print_raw ("# -XX:OnError=\""); | |
| 983 out.print_raw (OnError); | |
| 984 out.print_raw_cr("\""); | |
| 985 | |
| 986 char* cmd; | |
| 987 const char* ptr = OnError; | |
| 988 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ | |
| 989 out.print_raw ("# Executing "); | |
| 3960 | 990 #if defined(LINUX) || defined(_ALLBSD_SOURCE) |
| 0 | 991 out.print_raw ("/bin/sh -c "); |
| 992 #elif defined(SOLARIS) | |
| 993 out.print_raw ("/usr/bin/sh -c "); | |
| 994 #endif | |
| 995 out.print_raw ("\""); | |
| 996 out.print_raw (cmd); | |
| 997 out.print_raw_cr("\" ..."); | |
| 998 | |
| 999 os::fork_and_exec(cmd); | |
| 1000 } | |
| 1001 | |
| 1002 // done with OnError | |
| 1003 OnError = NULL; | |
| 1004 } | |
| 1005 | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1006 static bool skip_replay = false; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1007 if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1008 skip_replay = true; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1009 ciEnv* env = ciEnv::current(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1010 if (env != NULL) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1011 env->dump_replay_data(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1012 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1013 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1014 |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
1015 static bool skip_bug_url = !should_report_bug(first_error->_id); |
| 0 | 1016 if (!skip_bug_url) { |
| 1017 skip_bug_url = true; | |
| 1018 | |
| 1019 out.print_raw_cr("#"); | |
| 1020 print_bug_submit_message(&out, _thread); | |
| 1021 } | |
| 1022 | |
| 1023 if (!UseOSErrorReporting) { | |
| 1024 // os::abort() will call abort hooks, try it first. | |
| 1025 static bool skip_os_abort = false; | |
| 1026 if (!skip_os_abort) { | |
| 1027 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
|
1028 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
|
1029 os::abort(dump_core); |
| 0 | 1030 } |
| 1031 | |
| 1032 // if os::abort() doesn't abort, try os::die(); | |
| 1033 os::die(); | |
| 1034 } | |
| 1035 } | |
| 1036 | |
| 1037 /* | |
| 1038 * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this | |
| 1039 * ensures utilities such as jmap can observe the process is a consistent state. | |
| 1040 */ | |
| 1041 class VM_ReportJavaOutOfMemory : public VM_Operation { | |
| 1042 private: | |
| 1043 VMError *_err; | |
| 1044 public: | |
| 1045 VM_ReportJavaOutOfMemory(VMError *err) { _err = err; } | |
| 1046 VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; } | |
| 1047 void doit(); | |
| 1048 }; | |
| 1049 | |
| 1050 void VM_ReportJavaOutOfMemory::doit() { | |
| 1051 // Don't allocate large buffer on stack | |
| 1052 static char buffer[O_BUFLEN]; | |
| 1053 | |
| 1054 tty->print_cr("#"); | |
| 1055 tty->print_cr("# java.lang.OutOfMemoryError: %s", _err->message()); | |
| 1056 tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError); | |
| 1057 | |
| 1058 // make heap parsability | |
| 1059 Universe::heap()->ensure_parsability(false); // no need to retire TLABs | |
| 1060 | |
| 1061 char* cmd; | |
| 1062 const char* ptr = OnOutOfMemoryError; | |
| 1063 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ | |
| 1064 tty->print("# Executing "); | |
| 1065 #if defined(LINUX) | |
| 1066 tty->print ("/bin/sh -c "); | |
| 1067 #elif defined(SOLARIS) | |
| 1068 tty->print ("/usr/bin/sh -c "); | |
| 1069 #endif | |
| 1070 tty->print_cr("\"%s\"...", cmd); | |
| 1071 | |
| 1072 os::fork_and_exec(cmd); | |
| 1073 } | |
| 1074 } | |
| 1075 | |
| 1076 void VMError::report_java_out_of_memory() { | |
| 1077 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { | |
| 1078 MutexLocker ml(Heap_lock); | |
| 1079 VM_ReportJavaOutOfMemory op(this); | |
| 1080 VMThread::execute(&op); | |
| 1081 } | |
| 1082 } |