Thu, 20 Nov 2008 16:56:09 -0800
6684579: SoftReference processing can be made more efficient
Summary: For current soft-ref clearing policies, we can decide at marking time if a soft-reference will definitely not be cleared, postponing the decision of whether it will definitely be cleared to the final reference processing phase. This can be especially beneficial in the case of concurrent collectors where the marking is usually concurrent but reference processing is usually not.
Reviewed-by: jmasa
1 /*
2 * Copyright 2003-2008 Sun Microsystems, Inc. All Rights Reserved.
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 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
25 # include "incls/_precompiled.incl"
26 # include "incls/_vmError.cpp.incl"
28 // List of environment variables that should be reported in error log file.
29 const char *env_list[] = {
30 // All platforms
31 "JAVA_HOME", "JRE_HOME", "JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "CLASSPATH",
32 "JAVA_COMPILER", "PATH", "USERNAME",
34 // Env variables that are defined on Solaris/Linux
35 "LD_LIBRARY_PATH", "LD_PRELOAD", "SHELL", "DISPLAY",
36 "HOSTTYPE", "OSTYPE", "ARCH", "MACHTYPE",
38 // defined on Linux
39 "LD_ASSUME_KERNEL", "_JAVA_SR_SIGNUM",
41 // defined on Windows
42 "OS", "PROCESSOR_IDENTIFIER", "_ALT_JAVA_HOME_DIR",
44 (const char *)0
45 };
47 // Fatal error handler for internal errors and crashes.
48 //
49 // The default behavior of fatal error handler is to print a brief message
50 // to standard out (defaultStream::output_fd()), then save detailed information
51 // into an error report file (hs_err_pid<pid>.log) and abort VM. If multiple
52 // threads are having troubles at the same time, only one error is reported.
53 // The thread that is reporting error will abort VM when it is done, all other
54 // threads are blocked forever inside report_and_die().
56 // Constructor for crashes
57 VMError::VMError(Thread* thread, int sig, address pc, void* siginfo, void* context) {
58 _thread = thread;
59 _id = sig;
60 _pc = pc;
61 _siginfo = siginfo;
62 _context = context;
64 _verbose = false;
65 _current_step = 0;
66 _current_step_info = NULL;
68 _message = "";
69 _filename = NULL;
70 _lineno = 0;
72 _size = 0;
73 }
75 // Constructor for internal errors
76 VMError::VMError(Thread* thread, const char* message, const char* filename, int lineno) {
77 _thread = thread;
78 _id = internal_error; // set it to a value that's not an OS exception/signal
79 _filename = filename;
80 _lineno = lineno;
81 _message = message;
83 _verbose = false;
84 _current_step = 0;
85 _current_step_info = NULL;
87 _pc = NULL;
88 _siginfo = NULL;
89 _context = NULL;
91 _size = 0;
92 }
94 // Constructor for OOM errors
95 VMError::VMError(Thread* thread, size_t size, const char* message, const char* filename, int lineno) {
96 _thread = thread;
97 _id = oom_error; // set it to a value that's not an OS exception/signal
98 _filename = filename;
99 _lineno = lineno;
100 _message = message;
102 _verbose = false;
103 _current_step = 0;
104 _current_step_info = NULL;
106 _pc = NULL;
107 _siginfo = NULL;
108 _context = NULL;
110 _size = size;
111 }
114 // Constructor for non-fatal errors
115 VMError::VMError(const char* message) {
116 _thread = NULL;
117 _id = internal_error; // set it to a value that's not an OS exception/signal
118 _filename = NULL;
119 _lineno = 0;
120 _message = message;
122 _verbose = false;
123 _current_step = 0;
124 _current_step_info = NULL;
126 _pc = NULL;
127 _siginfo = NULL;
128 _context = NULL;
130 _size = 0;
131 }
133 // -XX:OnError=<string>, where <string> can be a list of commands, separated
134 // by ';'. "%p" is replaced by current process id (pid); "%%" is replaced by
135 // a single "%". Some examples:
136 //
137 // -XX:OnError="pmap %p" // show memory map
138 // -XX:OnError="gcore %p; dbx - %p" // dump core and launch debugger
139 // -XX:OnError="cat hs_err_pid%p.log | mail my_email@sun.com"
140 // -XX:OnError="kill -9 %p" // ?#!@#
142 // A simple parser for -XX:OnError, usage:
143 // ptr = OnError;
144 // while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr) != NULL)
145 // ... ...
146 static char* next_OnError_command(char* buf, int buflen, const char** ptr) {
147 if (ptr == NULL || *ptr == NULL) return NULL;
149 const char* cmd = *ptr;
151 // skip leading blanks or ';'
152 while (*cmd == ' ' || *cmd == ';') cmd++;
154 if (*cmd == '\0') return NULL;
156 const char * cmdend = cmd;
157 while (*cmdend != '\0' && *cmdend != ';') cmdend++;
159 Arguments::copy_expand_pid(cmd, cmdend - cmd, buf, buflen);
161 *ptr = (*cmdend == '\0' ? cmdend : cmdend + 1);
162 return buf;
163 }
166 static void print_bug_submit_message(outputStream *out, Thread *thread) {
167 if (out == NULL) return;
168 out->print_raw_cr("# If you would like to submit a bug report, please visit:");
169 out->print_raw ("# ");
170 out->print_raw_cr(Arguments::java_vendor_url_bug());
171 // If the crash is in native code, encourage user to submit a bug to the
172 // provider of that code.
173 if (thread && thread->is_Java_thread() &&
174 !thread->is_hidden_from_external_view()) {
175 JavaThread* jt = (JavaThread*)thread;
176 if (jt->thread_state() == _thread_in_native) {
177 out->print_cr("# The crash happened outside the Java Virtual Machine in native code.\n# See problematic frame for where to report the bug.");
178 }
179 }
180 out->print_raw_cr("#");
181 }
184 // Return a string to describe the error
185 char* VMError::error_string(char* buf, int buflen) {
186 char signame_buf[64];
187 const char *signame = os::exception_name(_id, signame_buf, sizeof(signame_buf));
189 if (signame) {
190 jio_snprintf(buf, buflen,
191 "%s (0x%x) at pc=" PTR_FORMAT ", pid=%d, tid=" UINTX_FORMAT,
192 signame, _id, _pc,
193 os::current_process_id(), os::current_thread_id());
194 } else {
195 if (_filename != NULL && _lineno > 0) {
196 // skip directory names
197 char separator = os::file_separator()[0];
198 const char *p = strrchr(_filename, separator);
200 jio_snprintf(buf, buflen,
201 "Internal Error at %s:%d, pid=%d, tid=" UINTX_FORMAT " \nError: %s",
202 p ? p + 1 : _filename, _lineno,
203 os::current_process_id(), os::current_thread_id(),
204 _message ? _message : "");
205 } else {
206 jio_snprintf(buf, buflen,
207 "Internal Error (0x%x), pid=%d, tid=" UINTX_FORMAT,
208 _id, os::current_process_id(), os::current_thread_id());
209 }
210 }
212 return buf;
213 }
216 // This is the main function to report a fatal error. Only one thread can
217 // call this function, so we don't need to worry about MT-safety. But it's
218 // possible that the error handler itself may crash or die on an internal
219 // error, for example, when the stack/heap is badly damaged. We must be
220 // able to handle recursive errors that happen inside error handler.
221 //
222 // Error reporting is done in several steps. If a crash or internal error
223 // occurred when reporting an error, the nested signal/exception handler
224 // can skip steps that are already (or partially) done. Error reporting will
225 // continue from the next step. This allows us to retrieve and print
226 // information that may be unsafe to get after a fatal error. If it happens,
227 // you may find nested report_and_die() frames when you look at the stack
228 // in a debugger.
229 //
230 // In general, a hang in error handler is much worse than a crash or internal
231 // error, as it's harder to recover from a hang. Deadlock can happen if we
232 // try to grab a lock that is already owned by current thread, or if the
233 // owner is blocked forever (e.g. in os::infinite_sleep()). If possible, the
234 // error handler and all the functions it called should avoid grabbing any
235 // lock. An important thing to notice is that memory allocation needs a lock.
236 //
237 // We should avoid using large stack allocated buffers. Many errors happen
238 // when stack space is already low. Making things even worse is that there
239 // could be nested report_and_die() calls on stack (see above). Only one
240 // thread can report error, so large buffers are statically allocated in data
241 // segment.
243 void VMError::report(outputStream* st) {
244 # define BEGIN if (_current_step == 0) { _current_step = 1;
245 # define STEP(n, s) } if (_current_step < n) { _current_step = n; _current_step_info = s;
246 # define END }
248 // don't allocate large buffer on stack
249 static char buf[O_BUFLEN];
251 BEGIN
253 STEP(10, "(printing fatal error message)")
255 st->print_cr("#");
256 st->print_cr("# A fatal error has been detected by the Java Runtime Environment:");
258 STEP(15, "(printing type of error)")
260 switch(_id) {
261 case oom_error:
262 st->print_cr("#");
263 st->print("# java.lang.OutOfMemoryError: ");
264 if (_size) {
265 st->print("requested ");
266 sprintf(buf,SIZE_FORMAT,_size);
267 st->print(buf);
268 st->print(" bytes");
269 if (_message != NULL) {
270 st->print(" for ");
271 st->print(_message);
272 }
273 st->print_cr(". Out of swap space?");
274 } else {
275 if (_message != NULL)
276 st->print_cr(_message);
277 }
278 break;
279 case internal_error:
280 default:
281 break;
282 }
284 STEP(20, "(printing exception/signal name)")
286 st->print_cr("#");
287 st->print("# ");
288 // Is it an OS exception/signal?
289 if (os::exception_name(_id, buf, sizeof(buf))) {
290 st->print("%s", buf);
291 st->print(" (0x%x)", _id); // signal number
292 st->print(" at pc=" PTR_FORMAT, _pc);
293 } else {
294 st->print("Internal Error");
295 if (_filename != NULL && _lineno > 0) {
296 #ifdef PRODUCT
297 // In product mode chop off pathname?
298 char separator = os::file_separator()[0];
299 const char *p = strrchr(_filename, separator);
300 const char *file = p ? p+1 : _filename;
301 #else
302 const char *file = _filename;
303 #endif
304 size_t len = strlen(file);
305 size_t buflen = sizeof(buf);
307 strncpy(buf, file, buflen);
308 if (len + 10 < buflen) {
309 sprintf(buf + len, ":" SIZE_FORMAT, _lineno);
310 }
311 st->print(" (%s)", buf);
312 } else {
313 st->print(" (0x%x)", _id);
314 }
315 }
317 STEP(30, "(printing current thread and pid)")
319 // process id, thread id
320 st->print(", pid=%d", os::current_process_id());
321 st->print(", tid=" UINTX_FORMAT, os::current_thread_id());
322 st->cr();
324 STEP(40, "(printing error message)")
326 // error message
327 if (_message && _message[0] != '\0') {
328 st->print_cr("# Error: %s", _message);
329 }
331 STEP(50, "(printing Java version string)")
333 // VM version
334 st->print_cr("#");
335 st->print_cr("# Java VM: %s (%s %s %s %s)",
336 Abstract_VM_Version::vm_name(),
337 Abstract_VM_Version::vm_release(),
338 Abstract_VM_Version::vm_info_string(),
339 Abstract_VM_Version::vm_platform_string(),
340 UseCompressedOops ? "compressed oops" : ""
341 );
343 STEP(60, "(printing problematic frame)")
345 // Print current frame if we have a context (i.e. it's a crash)
346 if (_context) {
347 st->print_cr("# Problematic frame:");
348 st->print("# ");
349 frame fr = os::fetch_frame_from_context(_context);
350 fr.print_on_error(st, buf, sizeof(buf));
351 st->cr();
352 st->print_cr("#");
353 }
355 STEP(65, "(printing bug submit message)")
357 if (_verbose) print_bug_submit_message(st, _thread);
359 STEP(70, "(printing thread)" )
361 if (_verbose) {
362 st->cr();
363 st->print_cr("--------------- T H R E A D ---------------");
364 st->cr();
365 }
367 STEP(80, "(printing current thread)" )
369 // current thread
370 if (_verbose) {
371 if (_thread) {
372 st->print("Current thread (" PTR_FORMAT "): ", _thread);
373 _thread->print_on_error(st, buf, sizeof(buf));
374 st->cr();
375 } else {
376 st->print_cr("Current thread is native thread");
377 }
378 st->cr();
379 }
381 STEP(90, "(printing siginfo)" )
383 // signal no, signal code, address that caused the fault
384 if (_verbose && _siginfo) {
385 os::print_siginfo(st, _siginfo);
386 st->cr();
387 }
389 STEP(100, "(printing registers, top of stack, instructions near pc)")
391 // registers, top of stack, instructions near pc
392 if (_verbose && _context) {
393 os::print_context(st, _context);
394 st->cr();
395 }
397 STEP(110, "(printing stack bounds)" )
399 if (_verbose) {
400 st->print("Stack: ");
402 address stack_top;
403 size_t stack_size;
405 if (_thread) {
406 stack_top = _thread->stack_base();
407 stack_size = _thread->stack_size();
408 } else {
409 stack_top = os::current_stack_base();
410 stack_size = os::current_stack_size();
411 }
413 address stack_bottom = stack_top - stack_size;
414 st->print("[" PTR_FORMAT "," PTR_FORMAT "]", stack_bottom, stack_top);
416 frame fr = _context ? os::fetch_frame_from_context(_context)
417 : os::current_frame();
419 if (fr.sp()) {
420 st->print(", sp=" PTR_FORMAT, fr.sp());
421 st->print(", free space=%dk",
422 ((intptr_t)fr.sp() - (intptr_t)stack_bottom) >> 10);
423 }
425 st->cr();
426 }
428 STEP(120, "(printing native stack)" )
430 if (_verbose) {
431 frame fr = _context ? os::fetch_frame_from_context(_context)
432 : os::current_frame();
434 // see if it's a valid frame
435 if (fr.pc()) {
436 st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)");
438 int count = 0;
440 while (count++ < StackPrintLimit) {
441 fr.print_on_error(st, buf, sizeof(buf));
442 st->cr();
443 if (os::is_first_C_frame(&fr)) break;
444 fr = os::get_sender_for_C_frame(&fr);
445 }
447 if (count > StackPrintLimit) {
448 st->print_cr("...<more frames>...");
449 }
451 st->cr();
452 }
453 }
455 STEP(130, "(printing Java stack)" )
457 if (_verbose && _thread && _thread->is_Java_thread()) {
458 JavaThread* jt = (JavaThread*)_thread;
459 if (jt->has_last_Java_frame()) {
460 st->print_cr("Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)");
461 for(StackFrameStream sfs(jt); !sfs.is_done(); sfs.next()) {
462 sfs.current()->print_on_error(st, buf, sizeof(buf));
463 st->cr();
464 }
465 }
466 }
468 STEP(140, "(printing VM operation)" )
470 if (_verbose && _thread && _thread->is_VM_thread()) {
471 VMThread* t = (VMThread*)_thread;
472 VM_Operation* op = t->vm_operation();
473 if (op) {
474 op->print_on_error(st);
475 st->cr();
476 st->cr();
477 }
478 }
480 STEP(150, "(printing current compile task)" )
482 if (_verbose && _thread && _thread->is_Compiler_thread()) {
483 CompilerThread* t = (CompilerThread*)_thread;
484 if (t->task()) {
485 st->cr();
486 st->print_cr("Current CompileTask:");
487 t->task()->print_line_on_error(st, buf, sizeof(buf));
488 st->cr();
489 }
490 }
492 STEP(160, "(printing process)" )
494 if (_verbose) {
495 st->cr();
496 st->print_cr("--------------- P R O C E S S ---------------");
497 st->cr();
498 }
500 STEP(170, "(printing all threads)" )
502 // all threads
503 if (_verbose && _thread) {
504 Threads::print_on_error(st, _thread, buf, sizeof(buf));
505 st->cr();
506 }
508 STEP(175, "(printing VM state)" )
510 if (_verbose) {
511 // Safepoint state
512 st->print("VM state:");
514 if (SafepointSynchronize::is_synchronizing()) st->print("synchronizing");
515 else if (SafepointSynchronize::is_at_safepoint()) st->print("at safepoint");
516 else st->print("not at safepoint");
518 // Also see if error occurred during initialization or shutdown
519 if (!Universe::is_fully_initialized()) {
520 st->print(" (not fully initialized)");
521 } else if (VM_Exit::vm_exited()) {
522 st->print(" (shutting down)");
523 } else {
524 st->print(" (normal execution)");
525 }
526 st->cr();
527 st->cr();
528 }
530 STEP(180, "(printing owned locks on error)" )
532 // mutexes/monitors that currently have an owner
533 if (_verbose) {
534 print_owned_locks_on_error(st);
535 st->cr();
536 }
538 STEP(190, "(printing heap information)" )
540 if (_verbose && Universe::is_fully_initialized()) {
541 // print heap information before vm abort
542 Universe::print_on(st);
543 st->cr();
544 }
546 STEP(200, "(printing dynamic libraries)" )
548 if (_verbose) {
549 // dynamic libraries, or memory map
550 os::print_dll_info(st);
551 st->cr();
552 }
554 STEP(210, "(printing VM options)" )
556 if (_verbose) {
557 // VM options
558 Arguments::print_on(st);
559 st->cr();
560 }
562 STEP(220, "(printing environment variables)" )
564 if (_verbose) {
565 os::print_environment_variables(st, env_list, buf, sizeof(buf));
566 st->cr();
567 }
569 STEP(225, "(printing signal handlers)" )
571 if (_verbose) {
572 os::print_signal_handlers(st, buf, sizeof(buf));
573 st->cr();
574 }
576 STEP(230, "" )
578 if (_verbose) {
579 st->cr();
580 st->print_cr("--------------- S Y S T E M ---------------");
581 st->cr();
582 }
584 STEP(240, "(printing OS information)" )
586 if (_verbose) {
587 os::print_os_info(st);
588 st->cr();
589 }
591 STEP(250, "(printing CPU info)" )
592 if (_verbose) {
593 os::print_cpu_info(st);
594 st->cr();
595 }
597 STEP(260, "(printing memory info)" )
599 if (_verbose) {
600 os::print_memory_info(st);
601 st->cr();
602 }
604 STEP(270, "(printing internal vm info)" )
606 if (_verbose) {
607 st->print_cr("vm_info: %s", Abstract_VM_Version::internal_vm_info_string());
608 st->cr();
609 }
611 STEP(280, "(printing date and time)" )
613 if (_verbose) {
614 os::print_date_and_time(st);
615 st->cr();
616 }
618 END
620 # undef BEGIN
621 # undef STEP
622 # undef END
623 }
626 void VMError::report_and_die() {
627 // Don't allocate large buffer on stack
628 static char buffer[O_BUFLEN];
630 // First error, and its thread id. We must be able to handle native thread,
631 // so use thread id instead of Thread* to identify thread.
632 static VMError* first_error;
633 static jlong first_error_tid;
635 // An error could happen before tty is initialized or after it has been
636 // destroyed. Here we use a very simple unbuffered fdStream for printing.
637 // Only out.print_raw() and out.print_raw_cr() should be used, as other
638 // printing methods need to allocate large buffer on stack. To format a
639 // string, use jio_snprintf() with a static buffer or use staticBufferStream.
640 static fdStream out(defaultStream::output_fd());
642 // How many errors occurred in error handler when reporting first_error.
643 static int recursive_error_count;
645 // We will first print a brief message to standard out (verbose = false),
646 // then save detailed information in log file (verbose = true).
647 static bool out_done = false; // done printing to standard out
648 static bool log_done = false; // done saving error log
649 static fdStream log; // error log
651 if (SuppressFatalErrorMessage) {
652 os::abort();
653 }
654 jlong mytid = os::current_thread_id();
655 if (first_error == NULL &&
656 Atomic::cmpxchg_ptr(this, &first_error, NULL) == NULL) {
658 // first time
659 first_error_tid = mytid;
660 set_error_reported();
662 if (ShowMessageBoxOnError) {
663 show_message_box(buffer, sizeof(buffer));
665 // User has asked JVM to abort. Reset ShowMessageBoxOnError so the
666 // WatcherThread can kill JVM if the error handler hangs.
667 ShowMessageBoxOnError = false;
668 }
670 // reset signal handlers or exception filter; make sure recursive crashes
671 // are handled properly.
672 reset_signal_handlers();
674 } else {
675 // This is not the first error, see if it happened in a different thread
676 // or in the same thread during error reporting.
677 if (first_error_tid != mytid) {
678 jio_snprintf(buffer, sizeof(buffer),
679 "[thread " INT64_FORMAT " also had an error]",
680 mytid);
681 out.print_raw_cr(buffer);
683 // error reporting is not MT-safe, block current thread
684 os::infinite_sleep();
686 } else {
687 if (recursive_error_count++ > 30) {
688 out.print_raw_cr("[Too many errors, abort]");
689 os::die();
690 }
692 jio_snprintf(buffer, sizeof(buffer),
693 "[error occurred during error reporting %s, id 0x%x]",
694 first_error ? first_error->_current_step_info : "",
695 _id);
696 if (log.is_open()) {
697 log.cr();
698 log.print_raw_cr(buffer);
699 log.cr();
700 } else {
701 out.cr();
702 out.print_raw_cr(buffer);
703 out.cr();
704 }
705 }
706 }
708 // print to screen
709 if (!out_done) {
710 first_error->_verbose = false;
712 staticBufferStream sbs(buffer, sizeof(buffer), &out);
713 first_error->report(&sbs);
715 out_done = true;
717 first_error->_current_step = 0; // reset current_step
718 first_error->_current_step_info = ""; // reset current_step string
719 }
721 // print to error log file
722 if (!log_done) {
723 first_error->_verbose = true;
725 // see if log file is already open
726 if (!log.is_open()) {
727 // open log file
728 int fd = -1;
730 if (ErrorFile != NULL) {
731 bool copy_ok =
732 Arguments::copy_expand_pid(ErrorFile, strlen(ErrorFile), buffer, sizeof(buffer));
733 if (copy_ok) {
734 fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC, 0666);
735 }
736 }
738 if (fd == -1) {
739 const char *cwd = os::get_current_directory(buffer, sizeof(buffer));
740 size_t len = strlen(cwd);
741 // either user didn't specify, or the user's location failed,
742 // so use the default name in the current directory
743 jio_snprintf(&buffer[len], sizeof(buffer)-len, "%shs_err_pid%u.log",
744 os::file_separator(), os::current_process_id());
745 fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC, 0666);
746 }
748 if (fd == -1) {
749 // try temp directory
750 const char * tmpdir = os::get_temp_directory();
751 jio_snprintf(buffer, sizeof(buffer), "%shs_err_pid%u.log",
752 (tmpdir ? tmpdir : ""), os::current_process_id());
753 fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC, 0666);
754 }
756 if (fd != -1) {
757 out.print_raw("# An error report file with more information is saved as:\n# ");
758 out.print_raw_cr(buffer);
759 os::set_error_file(buffer);
761 log.set_fd(fd);
762 } else {
763 out.print_raw_cr("# Can not save log file, dump to screen..");
764 log.set_fd(defaultStream::output_fd());
765 }
766 }
768 staticBufferStream sbs(buffer, O_BUFLEN, &log);
769 first_error->report(&sbs);
770 first_error->_current_step = 0; // reset current_step
771 first_error->_current_step_info = ""; // reset current_step string
773 if (log.fd() != defaultStream::output_fd()) {
774 close(log.fd());
775 }
777 log.set_fd(-1);
778 log_done = true;
779 }
782 static bool skip_OnError = false;
783 if (!skip_OnError && OnError && OnError[0]) {
784 skip_OnError = true;
786 out.print_raw_cr("#");
787 out.print_raw ("# -XX:OnError=\"");
788 out.print_raw (OnError);
789 out.print_raw_cr("\"");
791 char* cmd;
792 const char* ptr = OnError;
793 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){
794 out.print_raw ("# Executing ");
795 #if defined(LINUX)
796 out.print_raw ("/bin/sh -c ");
797 #elif defined(SOLARIS)
798 out.print_raw ("/usr/bin/sh -c ");
799 #endif
800 out.print_raw ("\"");
801 out.print_raw (cmd);
802 out.print_raw_cr("\" ...");
804 os::fork_and_exec(cmd);
805 }
807 // done with OnError
808 OnError = NULL;
809 }
811 static bool skip_bug_url = false;
812 if (!skip_bug_url) {
813 skip_bug_url = true;
815 out.print_raw_cr("#");
816 print_bug_submit_message(&out, _thread);
817 }
819 if (!UseOSErrorReporting) {
820 // os::abort() will call abort hooks, try it first.
821 static bool skip_os_abort = false;
822 if (!skip_os_abort) {
823 skip_os_abort = true;
824 os::abort();
825 }
827 // if os::abort() doesn't abort, try os::die();
828 os::die();
829 }
830 }
832 /*
833 * OnOutOfMemoryError scripts/commands executed while VM is a safepoint - this
834 * ensures utilities such as jmap can observe the process is a consistent state.
835 */
836 class VM_ReportJavaOutOfMemory : public VM_Operation {
837 private:
838 VMError *_err;
839 public:
840 VM_ReportJavaOutOfMemory(VMError *err) { _err = err; }
841 VMOp_Type type() const { return VMOp_ReportJavaOutOfMemory; }
842 void doit();
843 };
845 void VM_ReportJavaOutOfMemory::doit() {
846 // Don't allocate large buffer on stack
847 static char buffer[O_BUFLEN];
849 tty->print_cr("#");
850 tty->print_cr("# java.lang.OutOfMemoryError: %s", _err->message());
851 tty->print_cr("# -XX:OnOutOfMemoryError=\"%s\"", OnOutOfMemoryError);
853 // make heap parsability
854 Universe::heap()->ensure_parsability(false); // no need to retire TLABs
856 char* cmd;
857 const char* ptr = OnOutOfMemoryError;
858 while ((cmd = next_OnError_command(buffer, sizeof(buffer), &ptr)) != NULL){
859 tty->print("# Executing ");
860 #if defined(LINUX)
861 tty->print ("/bin/sh -c ");
862 #elif defined(SOLARIS)
863 tty->print ("/usr/bin/sh -c ");
864 #endif
865 tty->print_cr("\"%s\"...", cmd);
867 os::fork_and_exec(cmd);
868 }
869 }
871 void VMError::report_java_out_of_memory() {
872 if (OnOutOfMemoryError && OnOutOfMemoryError[0]) {
873 MutexLocker ml(Heap_lock);
874 VM_ReportJavaOutOfMemory op(this);
875 VMThread::execute(&op);
876 }
877 }