Mercurial > hg > truffle
annotate src/share/vm/utilities/vmError.cpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | 24b9c7f4cae6 |
| children | a1b8cf9cf970 |
| 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() : ""; | |
| 456 st->print_cr("# JRE version: %s (%s)", runtime_name, buf); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
56
diff
changeset
|
457 st->print_cr("# Java VM: %s (%s %s %s %s)", |
| 0 | 458 Abstract_VM_Version::vm_name(), |
| 459 Abstract_VM_Version::vm_release(), | |
| 460 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
|
461 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
|
462 UseCompressedOops ? "compressed oops" : "" |
| 0 | 463 ); |
| 464 | |
| 465 STEP(60, "(printing problematic frame)") | |
| 466 | |
| 467 // Print current frame if we have a context (i.e. it's a crash) | |
| 468 if (_context) { | |
| 469 st->print_cr("# Problematic frame:"); | |
| 470 st->print("# "); | |
| 471 frame fr = os::fetch_frame_from_context(_context); | |
| 472 fr.print_on_error(st, buf, sizeof(buf)); | |
| 473 st->cr(); | |
| 474 st->print_cr("#"); | |
| 475 } | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
476 STEP(63, "(printing core file information)") |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
477 st->print("# "); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
478 if (coredump_status) { |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
479 st->print("Core dump written. Default location: %s", coredump_message); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
480 } else { |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
481 st->print("Failed to write core dump. %s", coredump_message); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
482 } |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
483 st->print_cr(""); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
484 st->print_cr("#"); |
| 0 | 485 |
| 486 STEP(65, "(printing bug submit message)") | |
| 487 | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
488 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
|
489 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
|
490 } |
| 0 | 491 |
| 492 STEP(70, "(printing thread)" ) | |
| 493 | |
| 494 if (_verbose) { | |
| 495 st->cr(); | |
| 496 st->print_cr("--------------- T H R E A D ---------------"); | |
| 497 st->cr(); | |
| 498 } | |
| 499 | |
| 500 STEP(80, "(printing current thread)" ) | |
| 501 | |
| 502 // current thread | |
| 503 if (_verbose) { | |
| 504 if (_thread) { | |
| 505 st->print("Current thread (" PTR_FORMAT "): ", _thread); | |
| 506 _thread->print_on_error(st, buf, sizeof(buf)); | |
| 507 st->cr(); | |
| 508 } else { | |
| 509 st->print_cr("Current thread is native thread"); | |
| 510 } | |
| 511 st->cr(); | |
| 512 } | |
| 513 | |
| 514 STEP(90, "(printing siginfo)" ) | |
| 515 | |
| 516 // signal no, signal code, address that caused the fault | |
| 517 if (_verbose && _siginfo) { | |
| 518 os::print_siginfo(st, _siginfo); | |
| 519 st->cr(); | |
| 520 } | |
| 521 | |
| 522 STEP(100, "(printing registers, top of stack, instructions near pc)") | |
| 523 | |
| 524 // registers, top of stack, instructions near pc | |
| 525 if (_verbose && _context) { | |
| 526 os::print_context(st, _context); | |
| 527 st->cr(); | |
| 528 } | |
| 529 | |
| 1907 | 530 STEP(105, "(printing register info)") |
| 531 | |
| 532 // decode register contents if possible | |
| 533 if (_verbose && _context && Universe::is_fully_initialized()) { | |
| 534 os::print_register_info(st, _context); | |
| 535 st->cr(); | |
| 536 } | |
| 537 | |
| 0 | 538 STEP(110, "(printing stack bounds)" ) |
| 539 | |
| 540 if (_verbose) { | |
| 541 st->print("Stack: "); | |
| 542 | |
| 543 address stack_top; | |
| 544 size_t stack_size; | |
| 545 | |
| 546 if (_thread) { | |
| 547 stack_top = _thread->stack_base(); | |
| 548 stack_size = _thread->stack_size(); | |
| 549 } else { | |
| 550 stack_top = os::current_stack_base(); | |
| 551 stack_size = os::current_stack_size(); | |
| 552 } | |
| 553 | |
| 554 address stack_bottom = stack_top - stack_size; | |
| 555 st->print("[" PTR_FORMAT "," PTR_FORMAT "]", stack_bottom, stack_top); | |
| 556 | |
| 557 frame fr = _context ? os::fetch_frame_from_context(_context) | |
| 558 : os::current_frame(); | |
| 559 | |
| 560 if (fr.sp()) { | |
| 561 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
|
562 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
|
563 st->print(", free space=" SIZE_FORMAT "k", free_stack_size); |
| 0 | 564 } |
| 565 | |
| 566 st->cr(); | |
| 567 } | |
| 568 | |
| 569 STEP(120, "(printing native stack)" ) | |
| 570 | |
| 571 if (_verbose) { | |
| 572 frame fr = _context ? os::fetch_frame_from_context(_context) | |
| 573 : os::current_frame(); | |
| 574 | |
| 575 // see if it's a valid frame | |
| 576 if (fr.pc()) { | |
| 577 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)"); | |
| 578 | |
|
2022
2d4762ec74af
7003748: Decode C stack frames when symbols are presented (PhoneHome project)
zgu
parents:
1972
diff
changeset
|
579 |
| 0 | 580 int count = 0; |
| 581 while (count++ < StackPrintLimit) { | |
| 582 fr.print_on_error(st, buf, sizeof(buf)); | |
| 583 st->cr(); | |
| 584 if (os::is_first_C_frame(&fr)) break; | |
| 585 fr = os::get_sender_for_C_frame(&fr); | |
| 586 } | |
| 587 | |
| 588 if (count > StackPrintLimit) { | |
| 589 st->print_cr("...<more frames>..."); | |
| 590 } | |
| 591 | |
| 592 st->cr(); | |
| 593 } | |
| 594 } | |
| 595 | |
| 596 STEP(130, "(printing Java stack)" ) | |
| 597 | |
| 598 if (_verbose && _thread && _thread->is_Java_thread()) { | |
| 1384 | 599 print_stack_trace(st, (JavaThread*)_thread, buf, sizeof(buf)); |
| 0 | 600 } |
| 601 | |
|
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
602 STEP(135, "(printing target Java thread stack)" ) |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
603 |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
604 // printing Java thread stack trace if it is involved in GC crash |
| 1907 | 605 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
|
606 JavaThread* jt = ((NamedThread *)_thread)->processed_thread(); |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
607 if (jt != NULL) { |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
608 st->print_cr("JavaThread " PTR_FORMAT " (nid = " UINTX_FORMAT ") was being processed", jt, jt->osthread()->thread_id()); |
| 1384 | 609 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
|
610 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
611 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1010
diff
changeset
|
612 |
| 0 | 613 STEP(140, "(printing VM operation)" ) |
| 614 | |
| 615 if (_verbose && _thread && _thread->is_VM_thread()) { | |
| 616 VMThread* t = (VMThread*)_thread; | |
| 617 VM_Operation* op = t->vm_operation(); | |
| 618 if (op) { | |
| 619 op->print_on_error(st); | |
| 620 st->cr(); | |
| 621 st->cr(); | |
| 622 } | |
| 623 } | |
| 624 | |
| 625 STEP(150, "(printing current compile task)" ) | |
| 626 | |
| 627 if (_verbose && _thread && _thread->is_Compiler_thread()) { | |
| 628 CompilerThread* t = (CompilerThread*)_thread; | |
| 629 if (t->task()) { | |
| 630 st->cr(); | |
| 631 st->print_cr("Current CompileTask:"); | |
| 632 t->task()->print_line_on_error(st, buf, sizeof(buf)); | |
| 633 st->cr(); | |
| 634 } | |
| 635 } | |
| 636 | |
| 637 STEP(160, "(printing process)" ) | |
| 638 | |
| 639 if (_verbose) { | |
| 640 st->cr(); | |
| 641 st->print_cr("--------------- P R O C E S S ---------------"); | |
| 642 st->cr(); | |
| 643 } | |
| 644 | |
| 645 STEP(170, "(printing all threads)" ) | |
| 646 | |
| 647 // all threads | |
| 648 if (_verbose && _thread) { | |
| 649 Threads::print_on_error(st, _thread, buf, sizeof(buf)); | |
| 650 st->cr(); | |
| 651 } | |
| 652 | |
| 653 STEP(175, "(printing VM state)" ) | |
| 654 | |
| 655 if (_verbose) { | |
| 656 // Safepoint state | |
| 657 st->print("VM state:"); | |
| 658 | |
| 659 if (SafepointSynchronize::is_synchronizing()) st->print("synchronizing"); | |
| 660 else if (SafepointSynchronize::is_at_safepoint()) st->print("at safepoint"); | |
| 661 else st->print("not at safepoint"); | |
| 662 | |
| 663 // Also see if error occurred during initialization or shutdown | |
| 664 if (!Universe::is_fully_initialized()) { | |
| 665 st->print(" (not fully initialized)"); | |
| 666 } else if (VM_Exit::vm_exited()) { | |
| 667 st->print(" (shutting down)"); | |
| 668 } else { | |
| 669 st->print(" (normal execution)"); | |
| 670 } | |
| 671 st->cr(); | |
| 672 st->cr(); | |
| 673 } | |
| 674 | |
| 675 STEP(180, "(printing owned locks on error)" ) | |
| 676 | |
| 677 // mutexes/monitors that currently have an owner | |
| 678 if (_verbose) { | |
| 679 print_owned_locks_on_error(st); | |
| 680 st->cr(); | |
| 681 } | |
| 682 | |
| 683 STEP(190, "(printing heap information)" ) | |
| 684 | |
| 685 if (_verbose && Universe::is_fully_initialized()) { | |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
3960
diff
changeset
|
686 // 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
|
687 // 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
|
688 // extended (i.e., more detailed) version. |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
3960
diff
changeset
|
689 Universe::print_on(st, true /* extended */); |
| 0 | 690 st->cr(); |
| 5984 | 691 |
| 692 Universe::heap()->barrier_set()->print_on(st); | |
| 693 st->cr(); | |
| 694 | |
| 695 st->print_cr("Polling page: " INTPTR_FORMAT, os::get_polling_page()); | |
| 696 st->cr(); | |
| 0 | 697 } |
| 698 | |
| 1907 | 699 STEP(195, "(printing code cache information)" ) |
| 700 | |
| 701 if (_verbose && Universe::is_fully_initialized()) { | |
| 702 // print code cache information before vm abort | |
| 703 CodeCache::print_bounds(st); | |
| 704 st->cr(); | |
| 705 } | |
| 706 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
707 STEP(200, "(printing ring buffers)" ) |
|
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 if (_verbose) { |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
710 Events::print_all(st); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
711 st->cr(); |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
712 } |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
713 |
|
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4803
diff
changeset
|
714 STEP(205, "(printing dynamic libraries)" ) |
| 0 | 715 |
| 716 if (_verbose) { | |
| 717 // dynamic libraries, or memory map | |
| 718 os::print_dll_info(st); | |
| 719 st->cr(); | |
| 720 } | |
| 721 | |
| 722 STEP(210, "(printing VM options)" ) | |
| 723 | |
| 724 if (_verbose) { | |
| 725 // VM options | |
| 726 Arguments::print_on(st); | |
| 727 st->cr(); | |
| 728 } | |
| 729 | |
| 5915 | 730 STEP(215, "(printing warning if internal testing API used)" ) |
| 731 | |
| 732 if (WhiteBox::used()) { | |
| 733 st->print_cr("Unsupported internal testing APIs have been used."); | |
| 734 st->cr(); | |
| 735 } | |
| 736 | |
| 0 | 737 STEP(220, "(printing environment variables)" ) |
| 738 | |
| 739 if (_verbose) { | |
| 740 os::print_environment_variables(st, env_list, buf, sizeof(buf)); | |
| 741 st->cr(); | |
| 742 } | |
| 743 | |
| 744 STEP(225, "(printing signal handlers)" ) | |
| 745 | |
| 746 if (_verbose) { | |
| 747 os::print_signal_handlers(st, buf, sizeof(buf)); | |
| 748 st->cr(); | |
| 749 } | |
| 750 | |
| 751 STEP(230, "" ) | |
| 752 | |
| 753 if (_verbose) { | |
| 754 st->cr(); | |
| 755 st->print_cr("--------------- S Y S T E M ---------------"); | |
| 756 st->cr(); | |
| 757 } | |
| 758 | |
| 759 STEP(240, "(printing OS information)" ) | |
| 760 | |
| 761 if (_verbose) { | |
| 762 os::print_os_info(st); | |
| 763 st->cr(); | |
| 764 } | |
| 765 | |
| 766 STEP(250, "(printing CPU info)" ) | |
| 767 if (_verbose) { | |
| 768 os::print_cpu_info(st); | |
| 769 st->cr(); | |
| 770 } | |
| 771 | |
| 772 STEP(260, "(printing memory info)" ) | |
| 773 | |
| 774 if (_verbose) { | |
| 775 os::print_memory_info(st); | |
| 776 st->cr(); | |
| 777 } | |
| 778 | |
| 779 STEP(270, "(printing internal vm info)" ) | |
| 780 | |
| 781 if (_verbose) { | |
| 782 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string()); | |
| 783 st->cr(); | |
| 784 } | |
| 785 | |
| 786 STEP(280, "(printing date and time)" ) | |
| 787 | |
| 788 if (_verbose) { | |
| 789 os::print_date_and_time(st); | |
| 790 st->cr(); | |
| 791 } | |
| 792 | |
| 793 END | |
| 794 | |
| 795 # undef BEGIN | |
| 796 # undef STEP | |
| 797 # undef END | |
| 798 } | |
| 799 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
800 VMError* volatile VMError::first_error = NULL; |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
801 volatile jlong VMError::first_error_tid = -1; |
| 0 | 802 |
| 803 void VMError::report_and_die() { | |
| 804 // Don't allocate large buffer on stack | |
| 805 static char buffer[O_BUFLEN]; | |
| 806 | |
| 807 // An error could happen before tty is initialized or after it has been | |
| 808 // destroyed. Here we use a very simple unbuffered fdStream for printing. | |
| 809 // Only out.print_raw() and out.print_raw_cr() should be used, as other | |
| 810 // printing methods need to allocate large buffer on stack. To format a | |
| 811 // string, use jio_snprintf() with a static buffer or use staticBufferStream. | |
| 812 static fdStream out(defaultStream::output_fd()); | |
| 813 | |
| 814 // How many errors occurred in error handler when reporting first_error. | |
| 815 static int recursive_error_count; | |
| 816 | |
| 817 // We will first print a brief message to standard out (verbose = false), | |
| 818 // then save detailed information in log file (verbose = true). | |
| 819 static bool out_done = false; // done printing to standard out | |
| 820 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
|
821 static bool transmit_report_done = false; // done error reporting |
| 0 | 822 static fdStream log; // error log |
| 823 | |
| 6197 | 824 // disble NMT to avoid further exception |
| 825 MemTracker::shutdown(MemTracker::NMT_error_reporting); | |
| 826 | |
| 0 | 827 if (SuppressFatalErrorMessage) { |
| 828 os::abort(); | |
| 829 } | |
| 830 jlong mytid = os::current_thread_id(); | |
| 831 if (first_error == NULL && | |
| 832 Atomic::cmpxchg_ptr(this, &first_error, NULL) == NULL) { | |
| 833 | |
| 834 // first time | |
| 835 first_error_tid = mytid; | |
| 836 set_error_reported(); | |
| 837 | |
|
2302
da091bb67459
7022037: Pause when exiting if debugger is attached on windows
sla
parents:
2204
diff
changeset
|
838 if (ShowMessageBoxOnError || PauseAtExit) { |
| 0 | 839 show_message_box(buffer, sizeof(buffer)); |
| 840 | |
| 841 // User has asked JVM to abort. Reset ShowMessageBoxOnError so the | |
| 842 // WatcherThread can kill JVM if the error handler hangs. | |
| 843 ShowMessageBoxOnError = false; | |
| 844 } | |
| 845 | |
|
2204
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
846 // 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
|
847 os::check_or_create_dump(_siginfo, _context, buffer, sizeof(buffer)); |
|
63d374c54045
7014918: Improve core/minidump handling in Hotspot
ctornqvi
parents:
2199
diff
changeset
|
848 |
| 0 | 849 // reset signal handlers or exception filter; make sure recursive crashes |
| 850 // are handled properly. | |
| 851 reset_signal_handlers(); | |
| 852 | |
| 853 } else { | |
|
511
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
854 // 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
|
855 // 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
|
856 // to be reported. |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
857 if (UseOSErrorReporting && log_done) return; |
|
dabd8d202164
4997835: RFE: crash dump will only be created when running w/ -XX:+ShowMessageBoxOnError
coleenp
parents:
473
diff
changeset
|
858 |
| 0 | 859 // This is not the first error, see if it happened in a different thread |
| 860 // or in the same thread during error reporting. | |
| 861 if (first_error_tid != mytid) { | |
| 862 jio_snprintf(buffer, sizeof(buffer), | |
| 863 "[thread " INT64_FORMAT " also had an error]", | |
| 864 mytid); | |
| 865 out.print_raw_cr(buffer); | |
| 866 | |
| 867 // error reporting is not MT-safe, block current thread | |
| 868 os::infinite_sleep(); | |
| 869 | |
| 870 } else { | |
| 871 if (recursive_error_count++ > 30) { | |
| 872 out.print_raw_cr("[Too many errors, abort]"); | |
| 873 os::die(); | |
| 874 } | |
| 875 | |
| 876 jio_snprintf(buffer, sizeof(buffer), | |
| 877 "[error occurred during error reporting %s, id 0x%x]", | |
| 878 first_error ? first_error->_current_step_info : "", | |
| 879 _id); | |
| 880 if (log.is_open()) { | |
| 881 log.cr(); | |
| 882 log.print_raw_cr(buffer); | |
| 883 log.cr(); | |
| 884 } else { | |
| 885 out.cr(); | |
| 886 out.print_raw_cr(buffer); | |
| 887 out.cr(); | |
| 888 } | |
| 889 } | |
| 890 } | |
| 891 | |
| 892 // print to screen | |
| 893 if (!out_done) { | |
| 894 first_error->_verbose = false; | |
| 895 | |
| 896 staticBufferStream sbs(buffer, sizeof(buffer), &out); | |
| 897 first_error->report(&sbs); | |
| 898 | |
| 899 out_done = true; | |
| 900 | |
| 901 first_error->_current_step = 0; // reset current_step | |
| 902 first_error->_current_step_info = ""; // reset current_step string | |
| 903 } | |
| 904 | |
| 905 // print to error log file | |
| 906 if (!log_done) { | |
| 907 first_error->_verbose = true; | |
| 908 | |
| 909 // see if log file is already open | |
| 910 if (!log.is_open()) { | |
| 911 // open log file | |
| 912 int fd = -1; | |
| 913 | |
| 914 if (ErrorFile != NULL) { | |
| 915 bool copy_ok = | |
| 916 Arguments::copy_expand_pid(ErrorFile, strlen(ErrorFile), buffer, sizeof(buffer)); | |
| 917 if (copy_ok) { | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
918 fd = open(buffer, O_RDWR | O_CREAT | O_TRUNC, 0666); |
| 0 | 919 } |
| 920 } | |
| 921 | |
| 922 if (fd == -1) { | |
| 923 const char *cwd = os::get_current_directory(buffer, sizeof(buffer)); | |
| 924 size_t len = strlen(cwd); | |
| 925 // either user didn't specify, or the user's location failed, | |
| 926 // so use the default name in the current directory | |
| 927 jio_snprintf(&buffer[len], sizeof(buffer)-len, "%shs_err_pid%u.log", | |
| 928 os::file_separator(), os::current_process_id()); | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
929 fd = open(buffer, O_RDWR | O_CREAT | O_TRUNC, 0666); |
| 0 | 930 } |
| 931 | |
| 932 if (fd == -1) { | |
| 933 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
|
934 // 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
|
935 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
|
936 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
|
937 tmpdir, os::file_separator(), os::current_process_id()); |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
938 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
|
939 } |
| 0 | 940 } |
| 941 | |
| 942 if (fd != -1) { | |
| 943 out.print_raw("# An error report file with more information is saved as:\n# "); | |
| 944 out.print_raw_cr(buffer); | |
| 945 os::set_error_file(buffer); | |
| 946 | |
| 947 log.set_fd(fd); | |
| 948 } else { | |
| 949 out.print_raw_cr("# Can not save log file, dump to screen.."); | |
| 950 log.set_fd(defaultStream::output_fd()); | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
951 /* Error reporting currently needs dumpfile. |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
952 * Maybe implement direct streaming in the future.*/ |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
953 transmit_report_done = true; |
| 0 | 954 } |
| 955 } | |
| 956 | |
| 957 staticBufferStream sbs(buffer, O_BUFLEN, &log); | |
| 958 first_error->report(&sbs); | |
| 959 first_error->_current_step = 0; // reset current_step | |
| 960 first_error->_current_step_info = ""; // reset current_step string | |
| 961 | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
962 // 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
|
963 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
|
964 transmit_report_done = true; |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
965 FILE* hs_err = ::fdopen(log.fd(), "r"); |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
966 if (NULL != hs_err) { |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
967 ErrorReporter er; |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
968 er.call(hs_err, buffer, O_BUFLEN); |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
969 } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
970 } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
2130
diff
changeset
|
971 |
| 0 | 972 if (log.fd() != defaultStream::output_fd()) { |
| 973 close(log.fd()); | |
| 974 } | |
| 975 | |
| 976 log.set_fd(-1); | |
| 977 log_done = true; | |
| 978 } | |
| 979 | |
| 980 | |
| 981 static bool skip_OnError = false; | |
| 982 if (!skip_OnError && OnError && OnError[0]) { | |
| 983 skip_OnError = true; | |
| 984 | |
| 985 out.print_raw_cr("#"); | |
| 986 out.print_raw ("# -XX:OnError=\""); | |
| 987 out.print_raw (OnError); | |
| 988 out.print_raw_cr("\""); | |
| 989 | |
| 990 char* cmd; | |
| 991 const char* ptr = OnError; | |
| 992 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ | |
| 993 out.print_raw ("# Executing "); | |
| 3960 | 994 #if defined(LINUX) || defined(_ALLBSD_SOURCE) |
| 0 | 995 out.print_raw ("/bin/sh -c "); |
| 996 #elif defined(SOLARIS) | |
| 997 out.print_raw ("/usr/bin/sh -c "); | |
| 998 #endif | |
| 999 out.print_raw ("\""); | |
| 1000 out.print_raw (cmd); | |
| 1001 out.print_raw_cr("\" ..."); | |
| 1002 | |
| 1003 os::fork_and_exec(cmd); | |
| 1004 } | |
| 1005 | |
| 1006 // done with OnError | |
| 1007 OnError = NULL; | |
| 1008 } | |
| 1009 | |
|
2095
36c186bcc085
6302804: Hotspot VM dies ungraceful death when C heap is exhausted in various places.
coleenp
parents:
2022
diff
changeset
|
1010 static bool skip_bug_url = !should_report_bug(first_error->_id); |
| 0 | 1011 if (!skip_bug_url) { |
| 1012 skip_bug_url = true; | |
| 1013 | |
| 1014 out.print_raw_cr("#"); | |
| 1015 print_bug_submit_message(&out, _thread); | |
| 1016 } | |
| 1017 | |
| 1018 if (!UseOSErrorReporting) { | |
| 1019 // os::abort() will call abort hooks, try it first. | |
| 1020 static bool skip_os_abort = false; | |
| 1021 if (!skip_os_abort) { | |
| 1022 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
|
1023 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
|
1024 os::abort(dump_core); |
| 0 | 1025 } |
| 1026 | |
| 1027 // if os::abort() doesn't abort, try os::die(); | |
| 1028 os::die(); | |
| 1029 } | |
| 1030 } | |
| 1031 | |
| 1032 /* | |
| 1033 * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this | |
| 1034 * ensures utilities such as jmap can observe the process is a consistent state. | |
| 1035 */ | |
| 1036 class VM_ReportJavaOutOfMemory : public VM_Operation { | |
| 1037 private: | |
| 1038 VMError *_err; | |
| 1039 public: | |
| 1040 VM_ReportJavaOutOfMemory(VMError *err) { _err = err; } | |
| 1041 VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; } | |
| 1042 void doit(); | |
| 1043 }; | |
| 1044 | |
| 1045 void VM_ReportJavaOutOfMemory::doit() { | |
| 1046 // Don't allocate large buffer on stack | |
| 1047 static char buffer[O_BUFLEN]; | |
| 1048 | |
| 1049 tty->print_cr("#"); | |
| 1050 tty->print_cr("# java.lang.OutOfMemoryError: %s", _err->message()); | |
| 1051 tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError); | |
| 1052 | |
| 1053 // make heap parsability | |
| 1054 Universe::heap()->ensure_parsability(false); // no need to retire TLABs | |
| 1055 | |
| 1056 char* cmd; | |
| 1057 const char* ptr = OnOutOfMemoryError; | |
| 1058 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){ | |
| 1059 tty->print("# Executing "); | |
| 1060 #if defined(LINUX) | |
| 1061 tty->print ("/bin/sh -c "); | |
| 1062 #elif defined(SOLARIS) | |
| 1063 tty->print ("/usr/bin/sh -c "); | |
| 1064 #endif | |
| 1065 tty->print_cr("\"%s\"...", cmd); | |
| 1066 | |
| 1067 os::fork_and_exec(cmd); | |
| 1068 } | |
| 1069 } | |
| 1070 | |
| 1071 void VMError::report_java_out_of_memory() { | |
| 1072 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) { | |
| 1073 MutexLocker ml(Heap_lock); | |
| 1074 VM_ReportJavaOutOfMemory op(this); | |
| 1075 VMThread::execute(&op); | |
| 1076 } | |
| 1077 } |