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