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