duke@435: /*
coleenp@4037:  * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
duke@435:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435:  *
duke@435:  * This code is free software; you can redistribute it and/or modify it
duke@435:  * under the terms of the GNU General Public License version 2 only, as
duke@435:  * published by the Free Software Foundation.
duke@435:  *
duke@435:  * This code is distributed in the hope that it will be useful, but WITHOUT
duke@435:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
duke@435:  * version 2 for more details (a copy is included in the LICENSE file that
duke@435:  * accompanied this code).
duke@435:  *
duke@435:  * You should have received a copy of the GNU General Public License version
duke@435:  * 2 along with this work; if not, write to the Free Software Foundation,
duke@435:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435:  *
trims@1907:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907:  * or visit www.oracle.com if you need additional information or have any
trims@1907:  * questions.
duke@435:  *
duke@435:  */
duke@435: 
stefank@2314: #ifndef SHARE_VM_PRIMS_JVMTIENVBASE_HPP
stefank@2314: #define SHARE_VM_PRIMS_JVMTIENVBASE_HPP
stefank@2314: 
stefank@2314: #include "classfile/classLoader.hpp"
stefank@2314: #include "prims/jvmtiEnvThreadState.hpp"
stefank@2314: #include "prims/jvmtiEventController.hpp"
stefank@2314: #include "prims/jvmtiThreadState.hpp"
stefank@2314: #include "runtime/fieldDescriptor.hpp"
stefank@2314: #include "runtime/frame.hpp"
stefank@2314: #include "runtime/handles.inline.hpp"
stefank@2314: #include "runtime/thread.hpp"
stefank@2314: #include "runtime/vm_operations.hpp"
stefank@2314: #include "utilities/growableArray.hpp"
jprovino@4542: #include "utilities/macros.hpp"
duke@435: 
duke@435: //
duke@435: // Forward Declarations
duke@435: //
duke@435: 
duke@435: class JvmtiEnv;
duke@435: class JvmtiThreadState;
duke@435: class JvmtiRawMonitor; // for jvmtiEnv.hpp
duke@435: class JvmtiEventControllerPrivate;
duke@435: class JvmtiTagMap;
duke@435: 
duke@435: 
duke@435: 
duke@435: // One JvmtiEnv object is created per jvmti attachment;
duke@435: // done via JNI GetEnv() call. Multiple attachments are
duke@435: // allowed in jvmti.
duke@435: 
zgu@3900: class JvmtiEnvBase : public CHeapObj<mtInternal> {
duke@435: 
duke@435:  private:
duke@435: 
jprovino@4165: #if INCLUDE_JVMTI
duke@435:   static JvmtiEnvBase*     _head_environment;  // head of environment list
jprovino@4165: #endif // INCLUDE_JVMTI
duke@435: 
duke@435:   static bool              _globally_initialized;
duke@435:   static jvmtiPhase        _phase;
duke@435:   static volatile int      _dying_thread_env_iteration_count;
duke@435: 
duke@435:  public:
duke@435: 
duke@435:   enum {
duke@435:     JDK15_JVMTI_VERSION = JVMTI_VERSION_1_0 +  33,  /* version: 1.0.33  */
kamg@2330:     JDK16_JVMTI_VERSION = JVMTI_VERSION_1_1 + 102,  /* version: 1.1.102 */
sspitsyn@4230:     JDK17_JVMTI_VERSION = JVMTI_VERSION_1_2 +   2   /* version: 1.2.2   */
duke@435:   };
duke@435: 
duke@435:   static jvmtiPhase  get_phase()                    { return _phase; }
duke@435:   static void  set_phase(jvmtiPhase phase)          { _phase = phase; }
duke@435:   static bool is_vm_live()                          { return _phase == JVMTI_PHASE_LIVE; }
duke@435: 
duke@435:   static void entering_dying_thread_env_iteration() { ++_dying_thread_env_iteration_count; }
duke@435:   static void leaving_dying_thread_env_iteration()  { --_dying_thread_env_iteration_count; }
duke@435:   static bool is_inside_dying_thread_env_iteration(){ return _dying_thread_env_iteration_count > 0; }
duke@435: 
duke@435:  private:
duke@435: 
duke@435:   enum {
duke@435:       JVMTI_MAGIC    = 0x71EE,
duke@435:       DISPOSED_MAGIC = 0xDEFC,
duke@435:       BAD_MAGIC      = 0xDEAD
duke@435:   };
duke@435: 
duke@435:   jvmtiEnv _jvmti_external;
duke@435:   jint _magic;
dcubed@1556:   jint _version;  // version value passed to JNI GetEnv()
duke@435:   JvmtiEnvBase* _next;
duke@435:   bool _is_retransformable;
duke@435:   const void *_env_local_storage;     // per env agent allocated data.
duke@435:   jvmtiEventCallbacks _event_callbacks;
duke@435:   jvmtiExtEventCallbacks _ext_event_callbacks;
duke@435:   JvmtiTagMap* _tag_map;
duke@435:   JvmtiEnvEventEnable _env_event_enable;
duke@435:   jvmtiCapabilities _current_capabilities;
duke@435:   jvmtiCapabilities _prohibited_capabilities;
duke@435:   volatile bool _class_file_load_hook_ever_enabled;
duke@435:   static volatile bool _needs_clean_up;
duke@435:   char** _native_method_prefixes;
duke@435:   int    _native_method_prefix_count;
duke@435: 
duke@435:  protected:
dcubed@1556:   JvmtiEnvBase(jint version);
duke@435:   ~JvmtiEnvBase();
duke@435:   void dispose();
duke@435:   void env_dispose();
duke@435: 
duke@435:   void set_env_local_storage(const void* data)     { _env_local_storage = data; }
duke@435:   const void* get_env_local_storage()              { return _env_local_storage; }
duke@435: 
duke@435:   void record_class_file_load_hook_enabled();
duke@435:   void record_first_time_class_file_load_hook_enabled();
duke@435: 
duke@435:   char** get_native_method_prefixes()              { return _native_method_prefixes; }
duke@435:   int    get_native_method_prefix_count()          { return _native_method_prefix_count; }
duke@435:   jvmtiError set_native_method_prefixes(jint prefix_count, char** prefixes);
duke@435: 
duke@435:  private:
duke@435:   friend class JvmtiEventControllerPrivate;
duke@435:   void initialize();
duke@435:   void set_event_callbacks(const jvmtiEventCallbacks* callbacks, jint size_of_callbacks);
duke@435:   static void globally_initialize();
duke@435:   static void periodic_clean_up();
duke@435: 
duke@435:   friend class JvmtiEnvIterator;
duke@435:   JvmtiEnv* next_environment()                     { return (JvmtiEnv*)_next; }
duke@435:   void set_next_environment(JvmtiEnvBase* env)     { _next = env; }
jprovino@4165:   static JvmtiEnv* head_environment()              {
jprovino@4165:     JVMTI_ONLY(return (JvmtiEnv*)_head_environment);
jprovino@4165:     NOT_JVMTI(return NULL);
jprovino@4165:   }
duke@435: 
duke@435:  public:
duke@435: 
dcubed@1046:   bool is_valid();
duke@435: 
dcubed@1556:   bool use_version_1_0_semantics();  // agent asked for version 1.0
dcubed@1556:   bool use_version_1_1_semantics();  // agent asked for version 1.1
kamg@2330:   bool use_version_1_2_semantics();  // agent asked for version 1.2
dcubed@1556: 
duke@435:   bool is_retransformable()                        { return _is_retransformable; }
duke@435: 
duke@435:   static ByteSize jvmti_external_offset() {
duke@435:     return byte_offset_of(JvmtiEnvBase, _jvmti_external);
duke@435:   };
duke@435: 
duke@435:   static JvmtiEnv* JvmtiEnv_from_jvmti_env(jvmtiEnv *env) {
duke@435:     return (JvmtiEnv*)((intptr_t)env - in_bytes(jvmti_external_offset()));
duke@435:   };
duke@435: 
duke@435:   jvmtiCapabilities *get_capabilities()             { return &_current_capabilities; }
duke@435: 
duke@435:   jvmtiCapabilities *get_prohibited_capabilities()  { return &_prohibited_capabilities; }
duke@435: 
duke@435:   static char** get_all_native_method_prefixes(int* count_ptr);
duke@435: 
duke@435:   // This test will answer true when all environments have been disposed and some have
duke@435:   // not yet been deallocated.  As a result, this test should only be used as an
duke@435:   // optimization for the no environment case.
duke@435:   static bool environments_might_exist() {
duke@435:     return head_environment() != NULL;
duke@435:   }
duke@435: 
duke@435:   static void check_for_periodic_clean_up();
duke@435: 
duke@435:   JvmtiEnvEventEnable *env_event_enable() {
duke@435:     return &_env_event_enable;
duke@435:   }
duke@435: 
duke@435:   jvmtiError allocate(jlong size, unsigned char** mem_ptr) {
duke@435:     if (size < 0) {
duke@435:       return JVMTI_ERROR_ILLEGAL_ARGUMENT;
duke@435:     }
duke@435:     if (size == 0) {
duke@435:       *mem_ptr = NULL;
duke@435:     } else {
zgu@3900:       *mem_ptr = (unsigned char *)os::malloc((size_t)size, mtInternal);
duke@435:       if (*mem_ptr == NULL) {
duke@435:         return JVMTI_ERROR_OUT_OF_MEMORY;
duke@435:       }
duke@435:     }
duke@435:     return JVMTI_ERROR_NONE;
duke@435:   }
duke@435: 
duke@435:   jvmtiError deallocate(unsigned char* mem) {
duke@435:     if (mem != NULL) {
zgu@3900:       os::free(mem, mtInternal);
duke@435:     }
duke@435:     return JVMTI_ERROR_NONE;
duke@435:   }
duke@435: 
duke@435: 
duke@435:   // Memory functions
duke@435:   unsigned char* jvmtiMalloc(jlong size);  // don't use this - call allocate
duke@435: 
duke@435:   // method to create a local handle
duke@435:   jobject jni_reference(Handle hndl) {
duke@435:     return JNIHandles::make_local(hndl());
duke@435:   }
duke@435: 
duke@435:   // method to create a local handle.
duke@435:   // This function allows caller to specify which
duke@435:   // threads local handle table to use.
duke@435:   jobject jni_reference(JavaThread *thread, Handle hndl) {
duke@435:     return JNIHandles::make_local(thread, hndl());
duke@435:   }
duke@435: 
duke@435:   // method to destroy a local handle
duke@435:   void destroy_jni_reference(jobject jobj) {
duke@435:     JNIHandles::destroy_local(jobj);
duke@435:   }
duke@435: 
duke@435:   // method to destroy a local handle.
duke@435:   // This function allows caller to specify which
duke@435:   // threads local handle table to use although currently it is
duke@435:   // not used.
duke@435:   void destroy_jni_reference(JavaThread *thread, jobject jobj) {
duke@435:     destroy_jni_reference(jobj);
duke@435:   }
duke@435: 
duke@435:   jvmtiEnv* jvmti_external() { return &_jvmti_external; };
duke@435: 
duke@435: // Event Dispatch
duke@435: 
duke@435:   bool has_callback(jvmtiEvent event_type) {
duke@435:     assert(event_type >= JVMTI_MIN_EVENT_TYPE_VAL &&
duke@435:            event_type <= JVMTI_MAX_EVENT_TYPE_VAL, "checking");
duke@435:     return ((void**)&_event_callbacks)[event_type-JVMTI_MIN_EVENT_TYPE_VAL] != NULL;
duke@435:   }
duke@435: 
duke@435:   jvmtiEventCallbacks* callbacks() {
duke@435:     return &_event_callbacks;
duke@435:   }
duke@435: 
duke@435:   jvmtiExtEventCallbacks* ext_callbacks() {
duke@435:     return &_ext_event_callbacks;
duke@435:   }
duke@435: 
duke@435:   void set_tag_map(JvmtiTagMap* tag_map) {
duke@435:     _tag_map = tag_map;
duke@435:   }
duke@435: 
duke@435:   JvmtiTagMap* tag_map() {
duke@435:     return _tag_map;
duke@435:   }
duke@435: 
duke@435: 
duke@435:   // return true if event is enabled globally or for any thread
duke@435:   // True only if there is a callback for it.
duke@435:   bool is_enabled(jvmtiEvent event_type) {
duke@435:     return _env_event_enable.is_enabled(event_type);
duke@435:   }
duke@435: 
duke@435: // Random Utilities
duke@435: 
duke@435:  protected:
duke@435:   // helper methods for creating arrays of global JNI Handles from local Handles
duke@435:   // allocated into environment specific storage
duke@435:   jobject * new_jobjectArray(int length, Handle *handles);
duke@435:   jthread * new_jthreadArray(int length, Handle *handles);
duke@435:   jthreadGroup * new_jthreadGroupArray(int length, Handle *handles);
duke@435: 
duke@435:   // convert from JNIHandle to JavaThread *
duke@435:   JavaThread  * get_JavaThread(jthread jni_thread);
duke@435: 
coleenp@4037:   // convert to a jni jclass from a non-null Klass*
coleenp@4037:   jclass get_jni_class_non_null(Klass* k);
duke@435: 
duke@435:   jint count_locked_objects(JavaThread *java_thread, Handle hobj);
duke@435:   jvmtiError get_locked_objects_in_frame(JavaThread *calling_thread,
duke@435:                                    JavaThread* java_thread,
duke@435:                                    javaVFrame *jvf,
duke@435:                                    GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitors_list,
duke@435:                                    jint depth);
duke@435:   vframe* vframeFor(JavaThread* java_thread, jint depth);
duke@435: 
duke@435:  public:
duke@435:   // get a field descriptor for the specified class and field
coleenp@4037:   static bool get_field_descriptor(Klass* k, jfieldID field, fieldDescriptor* fd);
duke@435:   // test for suspend - most (all?) of these should go away
duke@435:   static bool is_thread_fully_suspended(JavaThread *thread,
duke@435:                                         bool wait_for_suspend,
duke@435:                                         uint32_t *bits);
duke@435: 
duke@435: 
duke@435:   // JVMTI API helper functions which are called at safepoint or thread is suspended.
duke@435:   jvmtiError get_frame_count(JvmtiThreadState *state, jint *count_ptr);
duke@435:   jvmtiError get_frame_location(JavaThread* java_thread, jint depth,
duke@435:                                               jmethodID* method_ptr, jlocation* location_ptr);
duke@435:   jvmtiError get_object_monitor_usage(JavaThread *calling_thread,
duke@435:                                                     jobject object, jvmtiMonitorUsage* info_ptr);
duke@435:   jvmtiError get_stack_trace(JavaThread *java_thread,
duke@435:                                            jint stack_depth, jint max_count,
duke@435:                                            jvmtiFrameInfo* frame_buffer, jint* count_ptr);
duke@435:   jvmtiError get_current_contended_monitor(JavaThread *calling_thread,
duke@435:                                                          JavaThread *java_thread,
duke@435:                                                          jobject *monitor_ptr);
duke@435:   jvmtiError get_owned_monitors(JavaThread *calling_thread, JavaThread* java_thread,
duke@435:                           GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list);
duke@435:   jvmtiError check_top_frame(JavaThread* current_thread, JavaThread* java_thread,
duke@435:                              jvalue value, TosState tos, Handle* ret_ob_h);
duke@435:   jvmtiError force_early_return(JavaThread* java_thread, jvalue value, TosState tos);
duke@435: };
duke@435: 
duke@435: // This class is the only safe means of iterating through environments.
duke@435: // Note that this iteratation includes invalid environments pending
duke@435: // deallocation -- in fact, some uses depend on this behavior.
duke@435: 
duke@435: class JvmtiEnvIterator : public StackObj {
duke@435:  private:
duke@435:   bool _entry_was_marked;
duke@435:  public:
duke@435:   JvmtiEnvIterator() {
duke@435:     if (Threads::number_of_threads() == 0) {
duke@435:       _entry_was_marked = false; // we are single-threaded, no need
duke@435:     } else {
duke@435:       Thread::current()->entering_jvmti_env_iteration();
duke@435:       _entry_was_marked = true;
duke@435:     }
duke@435:   }
duke@435:   ~JvmtiEnvIterator() {
duke@435:     if (_entry_was_marked) {
duke@435:       Thread::current()->leaving_jvmti_env_iteration();
duke@435:     }
duke@435:   }
duke@435:   JvmtiEnv* first()                 { return JvmtiEnvBase::head_environment(); }
duke@435:   JvmtiEnv* next(JvmtiEnvBase* env) { return env->next_environment(); }
duke@435: };
duke@435: 
duke@435: 
duke@435: // VM operation to get monitor information with stack depth.
duke@435: class VM_GetOwnedMonitorInfo : public VM_Operation {
duke@435: private:
duke@435:   JvmtiEnv *_env;
duke@435:   JavaThread* _calling_thread;
duke@435:   JavaThread *_java_thread;
duke@435:   jvmtiError _result;
duke@435:   GrowableArray<jvmtiMonitorStackDepthInfo*> *_owned_monitors_list;
duke@435: 
duke@435: public:
duke@435:   VM_GetOwnedMonitorInfo(JvmtiEnv* env, JavaThread* calling_thread,
duke@435:                                    JavaThread* java_thread,
duke@435:                                    GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitor_list) {
duke@435:     _env = env;
duke@435:     _calling_thread = calling_thread;
duke@435:     _java_thread = java_thread;
duke@435:     _owned_monitors_list = owned_monitor_list;
duke@435:     _result = JVMTI_ERROR_NONE;
duke@435:   }
duke@435:   VMOp_Type type() const { return VMOp_GetOwnedMonitorInfo; }
duke@435:   void doit() {
duke@435:     ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread, _java_thread,
duke@435:                                                          _owned_monitors_list);
duke@435:   }
duke@435:   jvmtiError result() { return _result; }
duke@435: };
duke@435: 
duke@435: 
duke@435: // VM operation to get object monitor usage.
duke@435: class VM_GetObjectMonitorUsage : public VM_Operation {
duke@435: private:
duke@435:   JvmtiEnv *_env;
duke@435:   jobject _object;
duke@435:   JavaThread* _calling_thread;
duke@435:   jvmtiMonitorUsage* _info_ptr;
duke@435:   jvmtiError _result;
duke@435: 
duke@435: public:
duke@435:   VM_GetObjectMonitorUsage(JvmtiEnv *env, JavaThread* calling_thread, jobject object, jvmtiMonitorUsage* info_ptr) {
duke@435:     _env = env;
duke@435:     _object = object;
duke@435:     _calling_thread = calling_thread;
duke@435:     _info_ptr = info_ptr;
duke@435:   }
duke@435:   VMOp_Type type() const { return VMOp_GetObjectMonitorUsage; }
duke@435:   jvmtiError result() { return _result; }
duke@435:   void doit() {
duke@435:     _result = ((JvmtiEnvBase*) _env)->get_object_monitor_usage(_calling_thread, _object, _info_ptr);
duke@435:   }
duke@435: 
duke@435: };
duke@435: 
duke@435: // VM operation to get current contended monitor.
duke@435: class VM_GetCurrentContendedMonitor : public VM_Operation {
duke@435: private:
duke@435:   JvmtiEnv *_env;
duke@435:   JavaThread *_calling_thread;
duke@435:   JavaThread *_java_thread;
duke@435:   jobject *_owned_monitor_ptr;
duke@435:   jvmtiError _result;
duke@435: 
duke@435: public:
duke@435:   VM_GetCurrentContendedMonitor(JvmtiEnv *env, JavaThread *calling_thread, JavaThread *java_thread, jobject *mon_ptr) {
duke@435:     _env = env;
duke@435:     _calling_thread = calling_thread;
duke@435:     _java_thread = java_thread;
duke@435:     _owned_monitor_ptr = mon_ptr;
duke@435:   }
duke@435:   VMOp_Type type() const { return VMOp_GetCurrentContendedMonitor; }
duke@435:   jvmtiError result() { return _result; }
duke@435:   void doit() {
duke@435:     _result = ((JvmtiEnvBase *)_env)->get_current_contended_monitor(_calling_thread,_java_thread,_owned_monitor_ptr);
duke@435:   }
duke@435: };
duke@435: 
duke@435: // VM operation to get stack trace at safepoint.
duke@435: class VM_GetStackTrace : public VM_Operation {
duke@435: private:
duke@435:   JvmtiEnv *_env;
duke@435:   JavaThread *_java_thread;
duke@435:   jint _start_depth;
duke@435:   jint _max_count;
duke@435:   jvmtiFrameInfo *_frame_buffer;
duke@435:   jint *_count_ptr;
duke@435:   jvmtiError _result;
duke@435: 
duke@435: public:
duke@435:   VM_GetStackTrace(JvmtiEnv *env, JavaThread *java_thread,
duke@435:                    jint start_depth, jint max_count,
duke@435:                    jvmtiFrameInfo* frame_buffer, jint* count_ptr) {
duke@435:     _env = env;
duke@435:     _java_thread = java_thread;
duke@435:     _start_depth = start_depth;
duke@435:     _max_count = max_count;
duke@435:     _frame_buffer = frame_buffer;
duke@435:     _count_ptr = count_ptr;
duke@435:   }
duke@435:   jvmtiError result() { return _result; }
duke@435:   VMOp_Type type() const { return VMOp_GetStackTrace; }
duke@435:   void doit() {
duke@435:     _result = ((JvmtiEnvBase *)_env)->get_stack_trace(_java_thread,
duke@435:                                                       _start_depth, _max_count,
duke@435:                                                       _frame_buffer, _count_ptr);
duke@435:   }
duke@435: };
duke@435: 
duke@435: // forward declaration
duke@435: struct StackInfoNode;
duke@435: 
duke@435: // VM operation to get stack trace at safepoint.
duke@435: class VM_GetMultipleStackTraces : public VM_Operation {
duke@435: private:
duke@435:   JvmtiEnv *_env;
duke@435:   jint _max_frame_count;
duke@435:   jvmtiStackInfo *_stack_info;
duke@435:   jvmtiError _result;
duke@435:   int _frame_count_total;
duke@435:   struct StackInfoNode *_head;
duke@435: 
duke@435:   JvmtiEnvBase *env()                 { return (JvmtiEnvBase *)_env; }
duke@435:   jint max_frame_count()              { return _max_frame_count; }
duke@435:   struct StackInfoNode *head()        { return _head; }
duke@435:   void set_head(StackInfoNode *head)  { _head = head; }
duke@435: 
duke@435: protected:
duke@435:   void set_result(jvmtiError result)  { _result = result; }
duke@435:   void fill_frames(jthread jt, JavaThread *thr, oop thread_oop);
duke@435:   void allocate_and_fill_stacks(jint thread_count);
duke@435: 
duke@435: public:
duke@435:   VM_GetMultipleStackTraces(JvmtiEnv *env, jint max_frame_count) {
duke@435:     _env = env;
duke@435:     _max_frame_count = max_frame_count;
duke@435:     _frame_count_total = 0;
duke@435:     _head = NULL;
duke@435:     _result = JVMTI_ERROR_NONE;
duke@435:   }
duke@435:   VMOp_Type type() const             { return VMOp_GetMultipleStackTraces; }
duke@435:   jvmtiStackInfo *stack_info()       { return _stack_info; }
duke@435:   jvmtiError result()                { return _result; }
duke@435: };
duke@435: 
duke@435: 
duke@435: // VM operation to get stack trace at safepoint.
duke@435: class VM_GetAllStackTraces : public VM_GetMultipleStackTraces {
duke@435: private:
duke@435:   JavaThread *_calling_thread;
duke@435:   jint _final_thread_count;
duke@435: 
duke@435: public:
duke@435:   VM_GetAllStackTraces(JvmtiEnv *env, JavaThread *calling_thread,
duke@435:                        jint max_frame_count)
duke@435:       : VM_GetMultipleStackTraces(env, max_frame_count) {
duke@435:     _calling_thread = calling_thread;
duke@435:   }
duke@435:   VMOp_Type type() const          { return VMOp_GetAllStackTraces; }
duke@435:   void doit();
duke@435:   jint final_thread_count()       { return _final_thread_count; }
duke@435: };
duke@435: 
duke@435: // VM operation to get stack trace at safepoint.
duke@435: class VM_GetThreadListStackTraces : public VM_GetMultipleStackTraces {
duke@435: private:
duke@435:   jint _thread_count;
duke@435:   const jthread* _thread_list;
duke@435: 
duke@435: public:
duke@435:   VM_GetThreadListStackTraces(JvmtiEnv *env, jint thread_count, const jthread* thread_list, jint max_frame_count)
duke@435:       : VM_GetMultipleStackTraces(env, max_frame_count) {
duke@435:     _thread_count = thread_count;
duke@435:     _thread_list = thread_list;
duke@435:   }
duke@435:   VMOp_Type type() const { return VMOp_GetThreadListStackTraces; }
duke@435:   void doit();
duke@435: };
duke@435: 
duke@435: 
duke@435: // VM operation to count stack frames at safepoint.
duke@435: class VM_GetFrameCount : public VM_Operation {
duke@435: private:
duke@435:   JvmtiEnv *_env;
duke@435:   JvmtiThreadState *_state;
duke@435:   jint *_count_ptr;
duke@435:   jvmtiError _result;
duke@435: 
duke@435: public:
duke@435:   VM_GetFrameCount(JvmtiEnv *env, JvmtiThreadState *state, jint *count_ptr) {
duke@435:     _env = env;
duke@435:     _state = state;
duke@435:     _count_ptr = count_ptr;
duke@435:   }
duke@435:   VMOp_Type type() const { return VMOp_GetFrameCount; }
duke@435:   jvmtiError result()    { return _result; }
duke@435:   void doit() {
duke@435:     _result = ((JvmtiEnvBase*)_env)->get_frame_count(_state, _count_ptr);
duke@435:   }
duke@435: };
duke@435: 
duke@435: // VM operation to frame location at safepoint.
duke@435: class VM_GetFrameLocation : public VM_Operation {
duke@435: private:
duke@435:   JvmtiEnv *_env;
duke@435:   JavaThread* _java_thread;
duke@435:   jint _depth;
duke@435:   jmethodID* _method_ptr;
duke@435:   jlocation* _location_ptr;
duke@435:   jvmtiError _result;
duke@435: 
duke@435: public:
duke@435:   VM_GetFrameLocation(JvmtiEnv *env, JavaThread* java_thread, jint depth,
duke@435:                       jmethodID* method_ptr, jlocation* location_ptr) {
duke@435:     _env = env;
duke@435:     _java_thread = java_thread;
duke@435:     _depth = depth;
duke@435:     _method_ptr = method_ptr;
duke@435:     _location_ptr = location_ptr;
duke@435:   }
duke@435:   VMOp_Type type() const { return VMOp_GetFrameLocation; }
duke@435:   jvmtiError result()    { return _result; }
duke@435:   void doit() {
duke@435:     _result = ((JvmtiEnvBase*)_env)->get_frame_location(_java_thread, _depth,
duke@435:                                                         _method_ptr, _location_ptr);
duke@435:   }
duke@435: };
duke@435: 
duke@435: 
duke@435: // ResourceTracker
duke@435: //
duke@435: // ResourceTracker works a little like a ResourceMark. All allocates
duke@435: // using the resource tracker are recorded. If an allocate using the
duke@435: // resource tracker fails the destructor will free any resources
duke@435: // that were allocated using the tracker.
duke@435: // The motive for this class is to avoid messy error recovery code
duke@435: // in situations where multiple allocations are done in sequence. If
duke@435: // the second or subsequent allocation fails it avoids any code to
duke@435: // release memory allocated in the previous calls.
duke@435: //
duke@435: // Usage :-
duke@435: //   ResourceTracker rt(env);
duke@435: //   :
duke@435: //   err = rt.allocate(1024, &ptr);
duke@435: 
duke@435: class ResourceTracker : public StackObj {
duke@435:  private:
duke@435:   JvmtiEnv* _env;
duke@435:   GrowableArray<unsigned char*> *_allocations;
duke@435:   bool _failed;
duke@435:  public:
duke@435:   ResourceTracker(JvmtiEnv* env);
duke@435:   ~ResourceTracker();
duke@435:   jvmtiError allocate(jlong size, unsigned char** mem_ptr);
duke@435:   unsigned char* allocate(jlong size);
duke@435:   char* strdup(const char* str);
duke@435: };
duke@435: 
duke@435: 
duke@435: // Jvmti monitor closure to collect off stack monitors.
duke@435: class JvmtiMonitorClosure: public MonitorClosure {
duke@435:  private:
duke@435:   JavaThread *_java_thread;
duke@435:   JavaThread *_calling_thread;
duke@435:   GrowableArray<jvmtiMonitorStackDepthInfo*> *_owned_monitors_list;
duke@435:   jvmtiError _error;
duke@435:   JvmtiEnvBase *_env;
duke@435: 
duke@435:  public:
duke@435:   JvmtiMonitorClosure(JavaThread* thread, JavaThread *calling_thread,
duke@435:                       GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors,
duke@435:                       JvmtiEnvBase *env) {
duke@435:     _java_thread = thread;
duke@435:     _calling_thread = calling_thread;
duke@435:     _owned_monitors_list = owned_monitors;
duke@435:     _error = JVMTI_ERROR_NONE;
duke@435:     _env = env;
duke@435:   }
duke@435:   void do_monitor(ObjectMonitor* mon);
duke@435:   jvmtiError error() { return _error;}
duke@435: };
duke@435: 
stefank@2314: #endif // SHARE_VM_PRIMS_JVMTIENVBASE_HPP