Mercurial > hg > truffle
annotate src/share/vm/utilities/vmError.cpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | a1b8cf9cf970 |
| children | 679e6584c177 9deda4d8e126 |
| 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()) { | |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
3960
diff
changeset
|
688 // Print heap information before vm abort. As we'd like as much |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
3960
diff
changeset
|
689 // information as possible in the report we ask for the |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
3960
diff
changeset
|
690 // extended (i.e., more detailed) version. |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
3960
diff
changeset
|
691 Universe::print_on(st, true /* extended */); |
| 0 | 692 st->cr(); |
| 5984 | 693 |
| 694 Universe::heap()->barrier_set()->print_on(st); | |
| 695 st->cr(); | |
| 696 | |
| 697 st->print_cr("Polling page: " INTPTR_FORMAT, os::get_polling_page()); | |
| 698 st->cr(); | |
| 0 | 699 } |
| 700 | |
| 1907 | 701 STEP(195, "(printing code cache information)" ) |
| 702 | |
| 703 if (_verbose && Universe::is_fully_initialized()) { | |
| 704 // print code cache information before vm abort | |
| 705 CodeCache::print_bounds(st); | |
| 706 st->cr(); | |
| 707 } | |
| 708 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
709 STEP(200, "(printing ring buffers)" ) |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
710 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
711 if (_verbose) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
712 Events::print_all(st); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
713 st->cr(); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
714 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
715 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
716 STEP(205, "(printing dynamic libraries)" ) |
| 0 | 717 |
| 718 if (_verbose) { | |
| 719 // dynamic libraries, or memory map | |
| 720 os::print_dll_info(st); | |
| 721 st->cr(); | |
| 722 } | |
| 723 | |
| 724 STEP(210, "(printing VM options)" ) | |
| 725 | |
| 726 if (_verbose) { | |
| 727 // VM options | |
| 728 Arguments::print_on(st); | |
| 729 st->cr(); | |
| 730 } | |
| 731 | |
| 5915 | 732 STEP(215, "(printing warning if internal testing API used)" ) |
| 733 | |
| 734 if (WhiteBox::used()) { | |
| 735 st->print_cr("Unsupported internal testing APIs have been used."); | |
| 736 st->cr(); | |
| 737 } | |
| 738 | |
| 0 | 739 STEP(220, "(printing environment variables)" ) |
| 740 | |
| 741 if (_verbose) { | |
| 742 os::print_environment_variables(st, env_list, buf, sizeof(buf)); | |
| 743 st->cr(); | |
| 744 } | |
| 745 | |
| 746 STEP(225, "(printing signal handlers)" ) | |
| 747 | |
| 748 if (_verbose) { | |
| 749 os::print_signal_handlers(st, buf, sizeof(buf)); | |
| 750 st->cr(); | |
| 751 } | |
| 752 | |
| 753 STEP(230, "" ) | |
| 754 | |
| 755 if (_verbose) { | |
| 756 st->cr(); | |
| 757 st->print_cr("--------------- S Y S T E M ---------------"); | |
| 758 st->cr(); | |
| 759 } | |
| 760 | |
| 761 STEP(240, "(printing OS information)" ) | |
| 762 | |
| 763 if (_verbose) { | |
| 764 os::print_os_info(st); | |
| 765 st->cr(); | |
| 766 } | |
| 767 | |
| 768 STEP(250, "(printing CPU info)" ) | |
| 769 if (_verbose) { | |
| 770 os::print_cpu_info(st); | |
| 771 st->cr(); | |
| 772 } | |
| 773 | |
| 774 STEP(260, "(printing memory info)" ) | |
| 775 | |
| 776 if (_verbose) { | |
| 777 os::print_memory_info(st); | |
| 778 st->cr(); | |
| 779 } | |
| 780 | |
| 781 STEP(270, "(printing internal vm info)" ) | |
| 782 | |
| 783 if (_verbose) { | |
| 784 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); | |
| 785 st->cr(); | |
| 786 } | |
| 787 | |
| 788 STEP(280, "(printing date and time)" ) | |
| 789 | |
| 790 if (_verbose) { | |
| 791 os::print_date_and_time(st); | |
| 792 st->cr(); | |
| 793 } | |
| 794 | |
| 795 END | |
| 796 | |
| 797 # undef BEGIN | |
| 798 # undef STEP | |
| 799 # undef END | |
| 800 } | |
| 801 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
802 VMError* volatile VMError::first_error = NULL; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
803 volatile jlong VMError::first_error_tid = -1; |
| 0 | 804 |
| 805 void VMError::report_and_die() { | |
| 806 // Don't allocate large buffer on stack | |
| 807 static char buffer[O_BUFLEN]; | |
| 808 | |
| 809 // An error could happen before tty is initialized or after it has been | |
| 810 // destroyed. Here we use a very simple unbuffered fdStream for printing. | |
| 811 // Only out.print_raw() and out.print_raw_cr() should be used, as other | |
| 812 // printing methods need to allocate large buffer on stack. To format a | |
| 813 // string, use jio_snprintf() with a static buffer or use staticBufferStream. | |
| 814 static fdStream out(defaultStream::output_fd()); | |
| 815 | |
| 816 // How many errors occurred in error handler when reporting first_error. | |
| 817 static int recursive_error_count; | |
| 818 | |
| 819 // We will first print a brief message to standard out (verbose = false), | |
| 820 // then save detailed information in log file (verbose = true). | |
| 821 static bool out_done = false; // done printing to standard out | |
| 822 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
|
823 static bool transmit_report_done = false; // done error reporting |
| 0 | 824 static fdStream log; // error log |
| 825 | |
| 6197 | 826 // disble NMT to avoid further exception |
| 827 MemTracker::shutdown(MemTracker::NMT_error_reporting); | |
| 828 | |
| 0 | 829 if (SuppressFatalErrorMessage) { |
| 830 os::abort(); | |
| 831 } | |
| 832 jlong mytid = os::current_thread_id(); | |
| 833 if (first_error == NULL && | |
| 834 Atomic::cmpxchg_ptr(this, &first_error, NULL) == NULL) { | |
| 835 | |
| 836 // first time | |
| 837 first_error_tid = mytid; | |
| 838 set_error_reported(); | |
| 839 | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
840 if (ShowMessageBoxOnError || PauseAtExit) { |
| 0 | 841 show_message_box(buffer, sizeof(buffer)); |
| 842 | |
| 843 // User has asked JVM to abort. Reset ShowMessageBoxOnError so the | |
| 844 // WatcherThread can kill JVM if the error handler hangs. | |
| 845 ShowMessageBoxOnError = false; | |
| 846 } | |
| 847 | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
848 // 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
|
849 os::check_or_create_dump(_siginfo, _context, buffer, sizeof(buffer)); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
850 |
| 0 | 851 // reset signal handlers or exception filter; make sure recursive crashes |
| 852 // are handled properly. | |
| 853 reset_signal_handlers(); | |
| 854 | |
| 855 } else { | |
|
511
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
856 // 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
|
857 // 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
|
858 // to be reported. |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
859 if (UseOSErrorReporting && log_done) return; |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
860 |
| 0 | 861 // This is not the first error, see if it happened in a different thread |
| 862 // or in the same thread during error reporting. | |
| 863 if (first_error_tid != mytid) { | |
| 864 jio_snprintf(buffer, sizeof(buffer), | |
| 865 "[thread " INT64_FORMAT " also had an error]", | |
| 866 mytid); | |
| 867 out.print_raw_cr(buffer); | |
| 868 | |
| 869 // error reporting is not MT-safe, block current thread | |
| 870 os::infinite_sleep(); | |
| 871 | |
| 872 } else { | |
| 873 if (recursive_error_count++ > 30) { | |
| 874 out.print_raw_cr("[Too many errors, abort]"); | |
| 875 os::die(); | |
| 876 } | |
| 877 | |
| 878 jio_snprintf(buffer, sizeof(buffer), | |
| 879 "[error occurred during error reporting %s, id 0x%x]", | |
| 880 first_error ? first_error->_current_step_info : "", | |
| 881 _id); | |
| 882 if (log.is_open()) { | |
| 883 log.cr(); | |
| 884 log.print_raw_cr(buffer); | |
| 885 log.cr(); | |
| 886 } else { | |
| 887 out.cr(); | |
| 888 out.print_raw_cr(buffer); | |
| 889 out.cr(); | |
| 890 } | |
| 891 } | |
| 892 } | |
| 893 | |
| 894 // print to screen | |
| 895 if (!out_done) { | |
| 896 first_error->_verbose = false; | |
| 897 | |
| 898 staticBufferStream sbs(buffer, sizeof(buffer), &out); | |
| 899 first_error->report(&sbs); | |
| 900 | |
| 901 out_done = true; | |
| 902 | |
| 903 first_error->_current_step = 0; // reset current_step | |
| 904 first_error->_current_step_info = ""; // reset current_step string | |
| 905 } | |
| 906 | |
| 907 // print to error log file | |
| 908 if (!log_done) { | |
| 909 first_error->_verbose = true; | |
| 910 | |
| 911 // see if log file is already open | |
| 912 if (!log.is_open()) { | |
| 913 // open log file | |
| 914 int fd = -1; | |
| 915 | |
| 916 if (ErrorFile != NULL) { | |
| 917 bool copy_ok = | |
| 918 Arguments::copy_expand_pid(ErrorFile, strlen(ErrorFile), buffer, sizeof(buffer)); | |
| 919 if (copy_ok) { | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
920 fd = open(buffer, O_RDWR | O_CREAT | O_TRUNC, 0666); |
| 0 | 921 } |
| 922 } | |
| 923 | |
| 924 if (fd == -1) { | |
| 925 const char *cwd = os::get_current_directory(buffer, sizeof(buffer)); | |
| 926 size_t len = strlen(cwd); | |
| 927 // either user didn't specify, or the user's location failed, | |
| 928 // so use the default name in the current directory | |
| 929 jio_snprintf(&buffer[len], sizeof(buffer)-len, "%shs_err_pid%u.log", | |
| 930 os::file_separator(), os::current_process_id()); | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
931 fd = open(buffer, O_RDWR | O_CREAT | O_TRUNC, 0666); |
| 0 | 932 } |
| 933 | |
| 934 if (fd == -1) { | |
| 935 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
|
936 // 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
|
937 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
|
938 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
|
939 tmpdir, os::file_separator(), os::current_process_id()); |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
940 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
|
941 } |
| 0 | 942 } |
| 943 | |
| 944 if (fd != -1) { | |
| 945 out.print_raw("# An error report file with more information is saved as:\n# "); | |
| 946 out.print_raw_cr(buffer); | |
| 947 os::set_error_file(buffer); | |
| 948 | |
| 949 log.set_fd(fd); | |
| 950 } else { | |
| 951 out.print_raw_cr("# Can not save log file, dump to screen.."); | |
| 952 log.set_fd(defaultStream::output_fd()); | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
953 /* Error reporting currently needs dumpfile. |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
954 * Maybe implement direct streaming in the future.*/ |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
955 transmit_report_done = true; |
| 0 | 956 } |
| 957 } | |
| 958 | |
| 959 staticBufferStream sbs(buffer, O_BUFLEN, &log); | |
| 960 first_error->report(&sbs); | |
| 961 first_error->_current_step = 0; // reset current_step | |
| 962 first_error->_current_step_info = ""; // reset current_step string | |
| 963 | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
964 // 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
|
965 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
|
966 transmit_report_done = true; |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
967 FILE* hs_err = ::fdopen(log.fd(), "r"); |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
968 if (NULL != hs_err) { |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
969 ErrorReporter er; |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
970 er.call(hs_err, buffer, O_BUFLEN); |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
971 } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
972 } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
973 |
| 0 | 974 if (log.fd() != defaultStream::output_fd()) { |
| 975 close(log.fd()); | |
| 976 } | |
| 977 | |
| 978 log.set_fd(-1); | |
| 979 log_done = true; | |
| 980 } | |
| 981 | |
| 982 | |
| 983 static bool skip_OnError = false; | |
| 984 if (!skip_OnError && OnError && OnError[0]) { | |
| 985 skip_OnError = true; | |
| 986 | |
| 987 out.print_raw_cr("#"); | |
| 988 out.print_raw ("# -XX:OnError=\""); | |
| 989 out.print_raw (OnError); | |
| 990 out.print_raw_cr("\""); | |
| 991 | |
| 992 char* cmd; | |
| 993 const char* ptr = OnError; | |
| 994 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ | |
| 995 out.print_raw ("# Executing "); | |
| 3960 | 996 #if defined(LINUX) || defined(_ALLBSD_SOURCE) |
| 0 | 997 out.print_raw ("/bin/sh -c "); |
| 998 #elif defined(SOLARIS) | |
| 999 out.print_raw ("/usr/bin/sh -c "); | |
| 1000 #endif | |
| 1001 out.print_raw ("\""); | |
| 1002 out.print_raw (cmd); | |
| 1003 out.print_raw_cr("\" ..."); | |
| 1004 | |
| 1005 os::fork_and_exec(cmd); | |
| 1006 } | |
| 1007 | |
| 1008 // done with OnError | |
| 1009 OnError = NULL; | |
| 1010 } | |
| 1011 | |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1012 static bool skip_replay = false; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1013 if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1014 skip_replay = true; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1015 ciEnv* env = ciEnv::current(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1016 if (env != NULL) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1017 env->dump_replay_data(); |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1018 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1019 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6921
diff
changeset
|
1020 |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
1021 static bool skip_bug_url = !should_report_bug(first_error->_id); |
| 0 | 1022 if (!skip_bug_url) { |
| 1023 skip_bug_url = true; | |
| 1024 | |
| 1025 out.print_raw_cr("#"); | |
| 1026 print_bug_submit_message(&out, _thread); | |
| 1027 } | |
| 1028 | |
| 1029 if (!UseOSErrorReporting) { | |
| 1030 // os::abort() will call abort hooks, try it first. | |
| 1031 static bool skip_os_abort = false; | |
| 1032 if (!skip_os_abort) { | |
| 1033 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
|
1034 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
|
1035 os::abort(dump_core); |
| 0 | 1036 } |
| 1037 | |
| 1038 // if os::abort() doesn't abort, try os::die(); | |
| 1039 os::die(); | |
| 1040 } | |
| 1041 } | |
| 1042 | |
| 1043 /* | |
| 1044 * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this | |
| 1045 * ensures utilities such as jmap can observe the process is a consistent state. | |
| 1046 */ | |
| 1047 class VM_ReportJavaOutOfMemory : public VM_Operation { | |
| 1048 private: | |
| 1049 VMError *_err; | |
| 1050 public: | |
| 1051 VM_ReportJavaOutOfMemory(VMError *err) { _err = err; } | |
| 1052 VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; } | |
| 1053 void doit(); | |
| 1054 }; | |
| 1055 | |
| 1056 void VM_ReportJavaOutOfMemory::doit() { | |
| 1057 // Don't allocate large buffer on stack | |
| 1058 static char buffer[O_BUFLEN]; | |
| 1059 | |
| 1060 tty->print_cr("#"); | |
| 1061 tty->print_cr("# java.lang.OutOfMemoryError: %s", _err->message()); | |
| 1062 tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError); | |
| 1063 | |
| 1064 // make heap parsability | |
| 1065 Universe::heap()->ensure_parsability(false); // no need to retire TLABs | |
| 1066 | |
| 1067 char* cmd; | |
| 1068 const char* ptr = OnOutOfMemoryError; | |
| 1069 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ | |
| 1070 tty->print("# Executing "); | |
| 1071 #if defined(LINUX) | |
| 1072 tty->print ("/bin/sh -c "); | |
| 1073 #elif defined(SOLARIS) | |
| 1074 tty->print ("/usr/bin/sh -c "); | |
| 1075 #endif | |
| 1076 tty->print_cr("\"%s\"...", cmd); | |
| 1077 | |
| 1078 os::fork_and_exec(cmd); | |
| 1079 } | |
| 1080 } | |
| 1081 | |
| 1082 void VMError::report_java_out_of_memory() { | |
| 1083 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { | |
| 1084 MutexLocker ml(Heap_lock); | |
| 1085 VM_ReportJavaOutOfMemory op(this); | |
| 1086 VMThread::execute(&op); | |
| 1087 } | |
| 1088 } |