Wed, 09 Apr 2008 15:10:22 -0700
Merge
1 /*
2 * Copyright 2003-2007 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/_forte.cpp.incl"
28 // These name match the names reported by the forte quality kit
29 enum {
30 ticks_no_Java_frame = 0,
31 ticks_no_class_load = -1,
32 ticks_GC_active = -2,
33 ticks_unknown_not_Java = -3,
34 ticks_not_walkable_not_Java = -4,
35 ticks_unknown_Java = -5,
36 ticks_not_walkable_Java = -6,
37 ticks_unknown_state = -7,
38 ticks_thread_exit = -8,
39 ticks_deopt = -9,
40 ticks_safepoint = -10
41 };
43 //-------------------------------------------------------
45 // Native interfaces for use by Forte tools.
48 #ifndef IA64
50 class vframeStreamForte : public vframeStreamCommon {
51 public:
52 // constructor that starts with sender of frame fr (top_frame)
53 vframeStreamForte(JavaThread *jt, frame fr, bool stop_at_java_call_stub);
54 void forte_next();
55 };
58 static void is_decipherable_compiled_frame(frame* fr, RegisterMap* map,
59 bool* is_compiled_p, bool* is_walkable_p);
60 static bool is_decipherable_interpreted_frame(JavaThread* thread,
61 frame* fr,
62 methodOop* method_p,
63 int* bci_p);
68 vframeStreamForte::vframeStreamForte(JavaThread *jt,
69 frame fr,
70 bool stop_at_java_call_stub) : vframeStreamCommon(jt) {
72 _stop_at_java_call_stub = stop_at_java_call_stub;
73 _frame = fr;
75 // We must always have a valid frame to start filling
77 bool filled_in = fill_from_frame();
79 assert(filled_in, "invariant");
81 }
84 // Solaris SPARC Compiler1 needs an additional check on the grandparent
85 // of the top_frame when the parent of the top_frame is interpreted and
86 // the grandparent is compiled. However, in this method we do not know
87 // the relationship of the current _frame relative to the top_frame so
88 // we implement a more broad sanity check. When the previous callee is
89 // interpreted and the current sender is compiled, we verify that the
90 // current sender is also walkable. If it is not walkable, then we mark
91 // the current vframeStream as at the end.
92 void vframeStreamForte::forte_next() {
93 // handle frames with inlining
94 if (_mode == compiled_mode &&
95 vframeStreamCommon::fill_in_compiled_inlined_sender()) {
96 return;
97 }
99 // handle general case
101 int loop_count = 0;
102 int loop_max = MaxJavaStackTraceDepth * 2;
105 do {
107 loop_count++;
109 // By the time we get here we should never see unsafe but better
110 // safe then segv'd
112 if (loop_count > loop_max || !_frame.safe_for_sender(_thread)) {
113 _mode = at_end_mode;
114 return;
115 }
117 _frame = _frame.sender(&_reg_map);
119 } while (!fill_from_frame());
120 }
122 // Determine if 'fr' is a decipherable compiled frame. We are already
123 // assured that fr is for a java nmethod.
125 static bool is_decipherable_compiled_frame(frame* fr) {
127 assert(fr->cb() != NULL && fr->cb()->is_nmethod(), "invariant");
128 nmethod* nm = (nmethod*) fr->cb();
129 assert(nm->is_java_method(), "invariant");
131 // First try and find an exact PcDesc
133 PcDesc* pc_desc = nm->pc_desc_at(fr->pc());
135 // Did we find a useful PcDesc?
136 if (pc_desc != NULL &&
137 pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {
139 address probe_pc = fr->pc() + 1;
140 pc_desc = nm->pc_desc_near(probe_pc);
142 // Now do we have a useful PcDesc?
144 if (pc_desc != NULL &&
145 pc_desc->scope_decode_offset() == DebugInformationRecorder::serialized_null) {
146 // No debug information available for this pc
147 // vframeStream would explode if we try and walk the frames.
148 return false;
149 }
151 // This PcDesc is useful however we must adjust the frame's pc
152 // so that the vframeStream lookups will use this same pc
154 fr->set_pc(pc_desc->real_pc(nm));
155 }
157 return true;
158 }
160 // Determine if 'fr' is a walkable interpreted frame. Returns false
161 // if it is not. *method_p, and *bci_p are not set when false is
162 // returned. *method_p is non-NULL if frame was executing a Java
163 // method. *bci_p is != -1 if a valid BCI in the Java method could
164 // be found.
165 // Note: this method returns true when a valid Java method is found
166 // even if a valid BCI cannot be found.
168 static bool is_decipherable_interpreted_frame(JavaThread* thread,
169 frame* fr,
170 methodOop* method_p,
171 int* bci_p) {
172 assert(fr->is_interpreted_frame(), "just checking");
174 // top frame is an interpreted frame
175 // check if it is walkable (i.e. valid methodOop and valid bci)
177 // Because we may be racing a gc thread the method and/or bci
178 // of a valid interpreter frame may look bad causing us to
179 // fail the is_interpreted_frame_valid test. If the thread
180 // is in any of the following states we are assured that the
181 // frame is in fact valid and we must have hit the race.
183 JavaThreadState state = thread->thread_state();
184 bool known_valid = (state == _thread_in_native ||
185 state == _thread_in_vm ||
186 state == _thread_blocked );
188 if (known_valid || fr->is_interpreted_frame_valid(thread)) {
190 // The frame code should completely validate the frame so that
191 // references to methodOop and bci are completely safe to access
192 // If they aren't the frame code should be fixed not this
193 // code. However since gc isn't locked out the values could be
194 // stale. This is a race we can never completely win since we can't
195 // lock out gc so do one last check after retrieving their values
196 // from the frame for additional safety
198 methodOop method = fr->interpreter_frame_method();
200 // We've at least found a method.
201 // NOTE: there is something to be said for the approach that
202 // if we don't find a valid bci then the method is not likely
203 // a valid method. Then again we may have caught an interpreter
204 // frame in the middle of construction and the bci field is
205 // not yet valid.
207 *method_p = method;
209 // See if gc may have invalidated method since we validated frame
211 if (!Universe::heap()->is_valid_method(method)) return false;
213 intptr_t bcx = fr->interpreter_frame_bcx();
215 int bci = method->validate_bci_from_bcx(bcx);
217 // note: bci is set to -1 if not a valid bci
218 *bci_p = bci;
219 return true;
220 }
222 return false;
223 }
226 // Determine if 'fr' can be used to find an initial Java frame.
227 // Return false if it can not find a fully decipherable Java frame
228 // (in other words a frame that isn't safe to use in a vframe stream).
229 // Obviously if it can't even find a Java frame false will also be returned.
230 //
231 // If we find a Java frame decipherable or not then by definition we have
232 // identified a method and that will be returned to the caller via method_p.
233 // If we can determine a bci that is returned also. (Hmm is it possible
234 // to return a method and bci and still return false? )
235 //
236 // The initial Java frame we find (if any) is return via initial_frame_p.
237 //
239 static bool find_initial_Java_frame(JavaThread* thread,
240 frame* fr,
241 frame* initial_frame_p,
242 methodOop* method_p,
243 int* bci_p) {
245 // It is possible that for a frame containing an nmethod
246 // we can capture the method but no bci. If we get no
247 // bci the frame isn't walkable but the method is usable.
248 // Therefore we init the returned methodOop to NULL so the
249 // caller can make the distinction.
251 *method_p = NULL;
253 // On the initial call to this method the frame we get may not be
254 // recognizable to us. This should only happen if we are in a JRT_LEAF
255 // or something called by a JRT_LEAF method.
259 frame candidate = *fr;
261 // If the starting frame we were given has no codeBlob associated with
262 // it see if we can find such a frame because only frames with codeBlobs
263 // are possible Java frames.
265 if (fr->cb() == NULL) {
267 // See if we can find a useful frame
268 int loop_count;
269 int loop_max = MaxJavaStackTraceDepth * 2;
270 RegisterMap map(thread, false);
272 for (loop_count = 0; loop_count < loop_max; loop_count++) {
273 if (!candidate.safe_for_sender(thread)) return false;
274 candidate = candidate.sender(&map);
275 if (candidate.cb() != NULL) break;
276 }
277 if (candidate.cb() == NULL) return false;
278 }
280 // We have a frame known to be in the codeCache
281 // We will hopefully be able to figure out something to do with it.
282 int loop_count;
283 int loop_max = MaxJavaStackTraceDepth * 2;
284 RegisterMap map(thread, false);
286 for (loop_count = 0; loop_count < loop_max; loop_count++) {
288 if (candidate.is_first_frame()) {
289 // If initial frame is frame from StubGenerator and there is no
290 // previous anchor, there are no java frames associated with a method
291 return false;
292 }
294 if (candidate.is_interpreted_frame()) {
295 if (is_decipherable_interpreted_frame(thread, &candidate, method_p, bci_p)) {
296 *initial_frame_p = candidate;
297 return true;
298 }
300 // Hopefully we got some data
301 return false;
302 }
304 if (candidate.cb()->is_nmethod()) {
306 nmethod* nm = (nmethod*) candidate.cb();
307 *method_p = nm->method();
309 // If the frame isn't fully decipherable then the default
310 // value for the bci is a signal that we don't have a bci.
311 // If we have a decipherable frame this bci value will
312 // not be used.
314 *bci_p = -1;
316 *initial_frame_p = candidate;
318 // Native wrapper code is trivial to decode by vframeStream
320 if (nm->is_native_method()) return true;
322 // If it isn't decipherable then we have found a pc that doesn't
323 // have a PCDesc that can get us a bci however we did find
324 // a method
326 if (!is_decipherable_compiled_frame(&candidate)) {
327 return false;
328 }
330 // is_decipherable_compiled_frame may modify candidate's pc
331 *initial_frame_p = candidate;
333 return true;
334 }
336 // Must be some stub frame that we don't care about
338 if (!candidate.safe_for_sender(thread)) return false;
339 candidate = candidate.sender(&map);
341 // If it isn't in the code cache something is wrong
342 // since once we find a frame in the code cache they
343 // all should be there.
345 if (candidate.cb() == NULL) return false;
347 }
349 return false;
351 }
354 // call frame copied from old .h file and renamed
355 typedef struct {
356 jint lineno; // line number in the source file
357 jmethodID method_id; // method executed in this frame
358 } ASGCT_CallFrame;
360 // call trace copied from old .h file and renamed
361 typedef struct {
362 JNIEnv *env_id; // Env where trace was recorded
363 jint num_frames; // number of frames in this trace
364 ASGCT_CallFrame *frames; // frames
365 } ASGCT_CallTrace;
367 static void forte_fill_call_trace_given_top(JavaThread* thd,
368 ASGCT_CallTrace* trace,
369 int depth,
370 frame top_frame) {
371 NoHandleMark nhm;
373 frame initial_Java_frame;
374 methodOop method;
375 int bci;
376 int count;
378 count = 0;
379 assert(trace->frames != NULL, "trace->frames must be non-NULL");
381 bool fully_decipherable = find_initial_Java_frame(thd, &top_frame, &initial_Java_frame, &method, &bci);
383 // The frame might not be walkable but still recovered a method
384 // (e.g. an nmethod with no scope info for the pc
386 if (method == NULL) return;
388 CollectedHeap* ch = Universe::heap();
390 // The method is not stored GC safe so see if GC became active
391 // after we entered AsyncGetCallTrace() and before we try to
392 // use the methodOop.
393 // Yes, there is still a window after this check and before
394 // we use methodOop below, but we can't lock out GC so that
395 // has to be an acceptable risk.
396 if (!ch->is_valid_method(method)) {
397 trace->num_frames = ticks_GC_active; // -2
398 return;
399 }
401 // We got a Java frame however it isn't fully decipherable
402 // so it won't necessarily be safe to use it for the
403 // initial frame in the vframe stream.
405 if (!fully_decipherable) {
406 // Take whatever method the top-frame decoder managed to scrape up.
407 // We look further at the top frame only if non-safepoint
408 // debugging information is available.
409 count++;
410 trace->num_frames = count;
411 trace->frames[0].method_id = method->find_jmethod_id_or_null();
412 if (!method->is_native()) {
413 trace->frames[0].lineno = bci;
414 } else {
415 trace->frames[0].lineno = -3;
416 }
418 if (!initial_Java_frame.safe_for_sender(thd)) return;
420 RegisterMap map(thd, false);
421 initial_Java_frame = initial_Java_frame.sender(&map);
422 }
424 vframeStreamForte st(thd, initial_Java_frame, false);
426 for (; !st.at_end() && count < depth; st.forte_next(), count++) {
427 bci = st.bci();
428 method = st.method();
430 // The method is not stored GC safe so see if GC became active
431 // after we entered AsyncGetCallTrace() and before we try to
432 // use the methodOop.
433 // Yes, there is still a window after this check and before
434 // we use methodOop below, but we can't lock out GC so that
435 // has to be an acceptable risk.
436 if (!ch->is_valid_method(method)) {
437 // we throw away everything we've gathered in this sample since
438 // none of it is safe
439 trace->num_frames = ticks_GC_active; // -2
440 return;
441 }
443 trace->frames[count].method_id = method->find_jmethod_id_or_null();
444 if (!method->is_native()) {
445 trace->frames[count].lineno = bci;
446 } else {
447 trace->frames[count].lineno = -3;
448 }
449 }
450 trace->num_frames = count;
451 return;
452 }
455 // Forte Analyzer AsyncGetCallTrace() entry point. Currently supported
456 // on Linux X86, Solaris SPARC and Solaris X86.
457 //
458 // Async-safe version of GetCallTrace being called from a signal handler
459 // when a LWP gets interrupted by SIGPROF but the stack traces are filled
460 // with different content (see below).
461 //
462 // This function must only be called when JVM/TI
463 // CLASS_LOAD events have been enabled since agent startup. The enabled
464 // event will cause the jmethodIDs to be allocated at class load time.
465 // The jmethodIDs cannot be allocated in a signal handler because locks
466 // cannot be grabbed in a signal handler safely.
467 //
468 // void (*AsyncGetCallTrace)(ASGCT_CallTrace *trace, jint depth, void* ucontext)
469 //
470 // Called by the profiler to obtain the current method call stack trace for
471 // a given thread. The thread is identified by the env_id field in the
472 // ASGCT_CallTrace structure. The profiler agent should allocate a ASGCT_CallTrace
473 // structure with enough memory for the requested stack depth. The VM fills in
474 // the frames buffer and the num_frames field.
475 //
476 // Arguments:
477 //
478 // trace - trace data structure to be filled by the VM.
479 // depth - depth of the call stack trace.
480 // ucontext - ucontext_t of the LWP
481 //
482 // ASGCT_CallTrace:
483 // typedef struct {
484 // JNIEnv *env_id;
485 // jint num_frames;
486 // ASGCT_CallFrame *frames;
487 // } ASGCT_CallTrace;
488 //
489 // Fields:
490 // env_id - ID of thread which executed this trace.
491 // num_frames - number of frames in the trace.
492 // (< 0 indicates the frame is not walkable).
493 // frames - the ASGCT_CallFrames that make up this trace. Callee followed by callers.
494 //
495 // ASGCT_CallFrame:
496 // typedef struct {
497 // jint lineno;
498 // jmethodID method_id;
499 // } ASGCT_CallFrame;
500 //
501 // Fields:
502 // 1) For Java frame (interpreted and compiled),
503 // lineno - bci of the method being executed or -1 if bci is not available
504 // method_id - jmethodID of the method being executed
505 // 2) For native method
506 // lineno - (-3)
507 // method_id - jmethodID of the method being executed
509 extern "C" {
510 void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) {
512 // This is if'd out because we no longer use thread suspension.
513 // However if someone wanted to backport this to a 5.0 jvm then this
514 // code would be important.
515 #if 0
516 if (SafepointSynchronize::is_synchronizing()) {
517 // The safepoint mechanism is trying to synchronize all the threads.
518 // Since this can involve thread suspension, it is not safe for us
519 // to be here. We can reduce the deadlock risk window by quickly
520 // returning to the SIGPROF handler. However, it is still possible
521 // for VMThread to catch us here or in the SIGPROF handler. If we
522 // are suspended while holding a resource and another thread blocks
523 // on that resource in the SIGPROF handler, then we will have a
524 // three-thread deadlock (VMThread, this thread, the other thread).
525 trace->num_frames = ticks_safepoint; // -10
526 return;
527 }
528 #endif
530 JavaThread* thread;
532 if (trace->env_id == NULL ||
533 (thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL ||
534 thread->is_exiting()) {
536 // bad env_id, thread has exited or thread is exiting
537 trace->num_frames = ticks_thread_exit; // -8
538 return;
539 }
541 if (thread->in_deopt_handler()) {
542 // thread is in the deoptimization handler so return no frames
543 trace->num_frames = ticks_deopt; // -9
544 return;
545 }
547 assert(JavaThread::current() == thread,
548 "AsyncGetCallTrace must be called by the current interrupted thread");
550 if (!JvmtiExport::should_post_class_load()) {
551 trace->num_frames = ticks_no_class_load; // -1
552 return;
553 }
555 if (Universe::heap()->is_gc_active()) {
556 trace->num_frames = ticks_GC_active; // -2
557 return;
558 }
560 switch (thread->thread_state()) {
561 case _thread_new:
562 case _thread_uninitialized:
563 case _thread_new_trans:
564 // We found the thread on the threads list above, but it is too
565 // young to be useful so return that there are no Java frames.
566 trace->num_frames = 0;
567 break;
568 case _thread_in_native:
569 case _thread_in_native_trans:
570 case _thread_blocked:
571 case _thread_blocked_trans:
572 case _thread_in_vm:
573 case _thread_in_vm_trans:
574 {
575 frame fr;
577 // param isInJava == false - indicate we aren't in Java code
578 if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, false)) {
579 trace->num_frames = ticks_unknown_not_Java; // -3 unknown frame
580 } else {
581 if (!thread->has_last_Java_frame()) {
582 trace->num_frames = 0; // No Java frames
583 } else {
584 trace->num_frames = ticks_not_walkable_not_Java; // -4 non walkable frame by default
585 forte_fill_call_trace_given_top(thread, trace, depth, fr);
587 // This assert would seem to be valid but it is not.
588 // It would be valid if we weren't possibly racing a gc
589 // thread. A gc thread can make a valid interpreted frame
590 // look invalid. It's a small window but it does happen.
591 // The assert is left here commented out as a reminder.
592 // assert(trace->num_frames != ticks_not_walkable_not_Java, "should always be walkable");
594 }
595 }
596 }
597 break;
598 case _thread_in_Java:
599 case _thread_in_Java_trans:
600 {
601 frame fr;
603 // param isInJava == true - indicate we are in Java code
604 if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, true)) {
605 trace->num_frames = ticks_unknown_Java; // -5 unknown frame
606 } else {
607 trace->num_frames = ticks_not_walkable_Java; // -6, non walkable frame by default
608 forte_fill_call_trace_given_top(thread, trace, depth, fr);
609 }
610 }
611 break;
612 default:
613 // Unknown thread state
614 trace->num_frames = ticks_unknown_state; // -7
615 break;
616 }
617 }
620 #ifndef _WINDOWS
621 // Support for the Forte(TM) Peformance Tools collector.
622 //
623 // The method prototype is derived from libcollector.h. For more
624 // information, please see the libcollect man page.
626 // Method to let libcollector know about a dynamically loaded function.
627 // Because it is weakly bound, the calls become NOP's when the library
628 // isn't present.
629 void collector_func_load(char* name,
630 void* null_argument_1,
631 void* null_argument_2,
632 void *vaddr,
633 int size,
634 int zero_argument,
635 void* null_argument_3);
636 #pragma weak collector_func_load
637 #define collector_func_load(x0,x1,x2,x3,x4,x5,x6) \
638 ( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),0 : 0 )
639 #endif // !_WINDOWS
641 } // end extern "C"
642 #endif // !IA64
644 void Forte::register_stub(const char* name, address start, address end) {
645 #if !defined(_WINDOWS) && !defined(IA64)
646 assert(pointer_delta(end, start, sizeof(jbyte)) < INT_MAX,
647 "Code size exceeds maximum range")
649 collector_func_load((char*)name, NULL, NULL, start,
650 pointer_delta(end, start, sizeof(jbyte)), 0, NULL);
651 #endif // !_WINDOWS && !IA64
652 }