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