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