src/share/vm/prims/jvmtiExport.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File hotspot-npg Sdiff src/share/vm/prims

src/share/vm/prims/jvmtiExport.hpp

Print this page




  29 #include "memory/allocation.hpp"
  30 #include "memory/iterator.hpp"
  31 #include "oops/oop.hpp"
  32 #include "oops/oopsHierarchy.hpp"
  33 #include "runtime/frame.hpp"
  34 #include "runtime/handles.hpp"
  35 #include "utilities/globalDefinitions.hpp"
  36 #include "utilities/growableArray.hpp"
  37 
  38 // Must be included after jvmti.h.
  39 #include "code/jvmticmlr.h"
  40 
  41 // Forward declarations
  42 
  43 class JvmtiEventControllerPrivate;
  44 class JvmtiManageCapabilities;
  45 class JvmtiEnv;
  46 class JvmtiThreadState;
  47 class AttachOperation;
  48 
  49 #ifndef JVMTI_KERNEL
  50 #define JVMTI_SUPPORT_FLAG(key)                                         \
  51   private:                                                              \
  52   static bool  _##key;                                                  \
  53   public:                                                               \
  54   inline static void set_##key(bool on)       { _##key = (on != 0); }   \
  55   inline static bool key()                    { return _##key; }
  56 #else  // JVMTI_KERNEL
  57 #define JVMTI_SUPPORT_FLAG(key)                                           \
  58   private:                                                                \
  59   const static bool _##key = false;                                       \
  60   public:                                                                 \
  61   inline static void set_##key(bool on)       { report_unsupported(on); } \
  62   inline static bool key()                    { return _##key; }
  63 #endif // JVMTI_KERNEL
  64 
  65 
  66 // This class contains the JVMTI interface for the rest of hotspot.
  67 //
  68 class JvmtiExport : public AllStatic {
  69   friend class VMStructs;
  70  private:


  71   static int         _field_access_count;
  72   static int         _field_modification_count;
  73 
  74   static bool        _can_access_local_variables;
  75   static bool        _can_hotswap_or_post_breakpoint;
  76   static bool        _can_modify_any_class;
  77   static bool        _can_walk_any_space;

  78 
  79   JVMTI_SUPPORT_FLAG(can_get_source_debug_extension)
  80   JVMTI_SUPPORT_FLAG(can_maintain_original_method_order)
  81   JVMTI_SUPPORT_FLAG(can_post_interpreter_events)
  82   JVMTI_SUPPORT_FLAG(can_post_on_exceptions)
  83   JVMTI_SUPPORT_FLAG(can_post_breakpoint)
  84   JVMTI_SUPPORT_FLAG(can_post_field_access)
  85   JVMTI_SUPPORT_FLAG(can_post_field_modification)
  86   JVMTI_SUPPORT_FLAG(can_post_method_entry)
  87   JVMTI_SUPPORT_FLAG(can_post_method_exit)
  88   JVMTI_SUPPORT_FLAG(can_pop_frame)
  89   JVMTI_SUPPORT_FLAG(can_force_early_return)
  90 
  91   friend class JvmtiEventControllerPrivate;  // should only modify these flags
  92   JVMTI_SUPPORT_FLAG(should_post_single_step)
  93   JVMTI_SUPPORT_FLAG(should_post_field_access)
  94   JVMTI_SUPPORT_FLAG(should_post_field_modification)
  95   JVMTI_SUPPORT_FLAG(should_post_class_load)
  96   JVMTI_SUPPORT_FLAG(should_post_class_prepare)
  97   JVMTI_SUPPORT_FLAG(should_post_class_unload)


 108   JVMTI_SUPPORT_FLAG(should_post_garbage_collection_finish)
 109   JVMTI_SUPPORT_FLAG(should_post_on_exceptions)
 110 
 111   // ------ the below maybe don't have to be (but are for now)
 112   // fixed conditions here ------------
 113   // any events can be enabled
 114   JVMTI_SUPPORT_FLAG(should_post_thread_life)
 115   JVMTI_SUPPORT_FLAG(should_post_object_free)
 116   JVMTI_SUPPORT_FLAG(should_post_resource_exhausted)
 117 
 118   // we are holding objects on the heap - need to talk to GC - e.g.
 119   // breakpoint info
 120   JVMTI_SUPPORT_FLAG(should_clean_up_heap_objects)
 121   JVMTI_SUPPORT_FLAG(should_post_vm_object_alloc)
 122 
 123   // If flag cannot be implemented, give an error if on=true
 124   static void report_unsupported(bool on);
 125 
 126   // these should only be called by the friend class
 127   friend class JvmtiManageCapabilities;
 128   inline static void set_can_modify_any_class(bool on)                 { _can_modify_any_class = (on != 0); }
 129   inline static void set_can_access_local_variables(bool on)           { _can_access_local_variables = (on != 0); }
 130   inline static void set_can_hotswap_or_post_breakpoint(bool on)       { _can_hotswap_or_post_breakpoint = (on != 0); }
 131   inline static void set_can_walk_any_space(bool on)                   { _can_walk_any_space = (on != 0); }








 132 
 133   enum {
 134     JVMTI_VERSION_MASK   = 0x70000000,
 135     JVMTI_VERSION_VALUE  = 0x30000000,
 136     JVMDI_VERSION_VALUE  = 0x20000000
 137   };
 138 
 139   static void post_field_modification(JavaThread *thread, Method* method, address location,
 140                                       KlassHandle field_klass, Handle object, jfieldID field,
 141                                       char sig_type, jvalue *value);
 142 
 143 
 144   // posts a DynamicCodeGenerated event (internal/private implementation).
 145   // The public post_dynamic_code_generated* functions make use of the
 146   // internal implementation.  Also called from JvmtiDeferredEvent::post()
 147   static void post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN;
 148 
 149  private:
 150 
 151   // GenerateEvents support to allow posting of CompiledMethodLoad and
 152   // DynamicCodeGenerated events for a given environment.
 153   friend class JvmtiCodeBlobEvents;
 154 
 155   static void post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length,
 156                                         const void *code_begin, const jint map_length,
 157                                         const jvmtiAddrLocationMap* map) KERNEL_RETURN;
 158   static void post_dynamic_code_generated(JvmtiEnv* env, const char *name, const void *code_begin,
 159                                           const void *code_end) KERNEL_RETURN;
 160 
 161   // The RedefineClasses() API breaks some invariants in the "regular"
 162   // system. For example, there are sanity checks when GC'ing nmethods
 163   // that require the containing class to be unloading. However, when a
 164   // method is redefined, the old method and nmethod can become GC'able
 165   // without the containing class unloading. The state of becoming
 166   // GC'able can be asynchronous to the RedefineClasses() call since
 167   // the old method may still be running and cannot be GC'ed until
 168   // after all old invocations have finished. Additionally, a method
 169   // that has not been redefined may have an nmethod that depends on
 170   // the redefined method. The dependent nmethod will get deopted in
 171   // this case and may also be GC'able without the containing class
 172   // being unloaded.
 173   //
 174   // This flag indicates whether RedefineClasses() has ever redefined
 175   // one or more classes during the lifetime of the VM. The flag should
 176   // only be set by the friend class and can be queried by other sub
 177   // systems as needed to relax invariant checks.
 178   static bool _has_redefined_a_class;
 179   friend class VM_RedefineClasses;
 180   inline static void set_has_redefined_a_class() {
 181     _has_redefined_a_class = true;
 182   }
 183 
 184   // Flag to indicate if the compiler has recorded all dependencies. When the
 185   // can_redefine_classes capability is enabled in the OnLoad phase then the compiler
 186   // records all dependencies from startup. However if the capability is first
 187   // enabled some time later then the dependencies recorded by the compiler
 188   // are incomplete. This flag is used by RedefineClasses to know if the
 189   // dependency information is complete or not.
 190   static bool _all_dependencies_are_recorded;
 191 
 192  public:
 193   inline static bool has_redefined_a_class() {
 194     return _has_redefined_a_class;

 195   }
 196 
 197   inline static bool all_dependencies_are_recorded() {
 198     return _all_dependencies_are_recorded;
 199   }
 200 
 201   inline static void set_all_dependencies_are_recorded(bool on) {
 202     _all_dependencies_are_recorded = (on != 0);
 203   }
 204 
 205 
 206   // let JVMTI know that the JVM_OnLoad code is running
 207   static void enter_onload_phase();
 208 
 209   // let JVMTI know that the VM isn't up yet (and JVM_OnLoad code isn't running)
 210   static void enter_primordial_phase();
 211 
 212   // let JVMTI know that the VM isn't up yet but JNI is live
 213   static void enter_start_phase();
 214 
 215   // let JVMTI know that the VM is fully up and running now
 216   static void enter_live_phase();
 217 
 218   // ------ can_* conditions (below) are set at OnLoad and never changed ------------
 219   inline static bool can_modify_any_class()                       { return _can_modify_any_class; }
 220   inline static bool can_access_local_variables()                 { return _can_access_local_variables; }
 221   inline static bool can_hotswap_or_post_breakpoint()             { return _can_hotswap_or_post_breakpoint; }
 222   inline static bool can_walk_any_space()                         { return _can_walk_any_space; }












 223 
 224   // field access management
 225   static address  get_field_access_count_addr();
 226 
 227   // field modification management
 228   static address  get_field_modification_count_addr();
 229 
 230   // -----------------
 231 
 232   static bool is_jvmti_version(jint version)                      { return (version & JVMTI_VERSION_MASK) == JVMTI_VERSION_VALUE; }
 233   static bool is_jvmdi_version(jint version)                      { return (version & JVMTI_VERSION_MASK) == JVMDI_VERSION_VALUE; }
 234   static jint get_jvmti_interface(JavaVM *jvm, void **penv, jint version);






 235   static void decode_version_values(jint version, int * major, int * minor,
 236                                     int * micro);
 237 
 238   // single stepping management methods
 239   static void at_single_stepping_point(JavaThread *thread, Method* method, address location) KERNEL_RETURN;
 240   static void expose_single_stepping(JavaThread *thread) KERNEL_RETURN;
 241   static bool hide_single_stepping(JavaThread *thread) KERNEL_RETURN_(false);
 242 
 243   // Methods that notify the debugger that something interesting has happened in the VM.
 244   static void post_vm_start              ();
 245   static void post_vm_initialized        ();
 246   static void post_vm_death              ();
 247 
 248   static void post_single_step           (JavaThread *thread, Method* method, address location) KERNEL_RETURN;
 249   static void post_raw_breakpoint        (JavaThread *thread, Method* method, address location) KERNEL_RETURN;
 250 
 251   static void post_exception_throw       (JavaThread *thread, Method* method, address location, oop exception) KERNEL_RETURN;
 252   static void notice_unwind_due_to_exception (JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) KERNEL_RETURN;
 253 
 254   static oop jni_GetField_probe          (JavaThread *thread, jobject jobj,
 255     oop obj, Klass* klass, jfieldID fieldID, bool is_static)
 256     KERNEL_RETURN_(NULL);
 257   static oop jni_GetField_probe_nh       (JavaThread *thread, jobject jobj,
 258     oop obj, Klass* klass, jfieldID fieldID, bool is_static)
 259     KERNEL_RETURN_(NULL);
 260   static void post_field_access_by_jni   (JavaThread *thread, oop obj,
 261     Klass* klass, jfieldID fieldID, bool is_static) KERNEL_RETURN;
 262   static void post_field_access          (JavaThread *thread, Method* method,
 263     address location, KlassHandle field_klass, Handle object, jfieldID field) KERNEL_RETURN;
 264   static oop jni_SetField_probe          (JavaThread *thread, jobject jobj,
 265     oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 266     jvalue *value) KERNEL_RETURN_(NULL);
 267   static oop jni_SetField_probe_nh       (JavaThread *thread, jobject jobj,
 268     oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 269     jvalue *value) KERNEL_RETURN_(NULL);
 270   static void post_field_modification_by_jni(JavaThread *thread, oop obj,
 271     Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 272     jvalue *value);
 273   static void post_raw_field_modification(JavaThread *thread, Method* method,
 274     address location, KlassHandle field_klass, Handle object, jfieldID field,
 275     char sig_type, jvalue *value) KERNEL_RETURN;
 276 
 277   static void post_method_entry          (JavaThread *thread, Method* method, frame current_frame) KERNEL_RETURN;
 278   static void post_method_exit           (JavaThread *thread, Method* method, frame current_frame) KERNEL_RETURN;
 279 
 280   static void post_class_load            (JavaThread *thread, Klass* klass) KERNEL_RETURN;
 281   static void post_class_unload          (Klass* klass) KERNEL_RETURN;
 282   static void post_class_prepare         (JavaThread *thread, Klass* klass) KERNEL_RETURN;
 283 
 284   static void post_thread_start          (JavaThread *thread) KERNEL_RETURN;
 285   static void post_thread_end            (JavaThread *thread) KERNEL_RETURN;
 286 
 287   // Support for java.lang.instrument agent loading.
 288   static bool _should_post_class_file_load_hook;
 289   inline static void set_should_post_class_file_load_hook(bool on)     { _should_post_class_file_load_hook = on;  }
 290   inline static bool should_post_class_file_load_hook()           { return _should_post_class_file_load_hook; }



 291   static void post_class_file_load_hook(Symbol* h_name, Handle class_loader,
 292                                         Handle h_protection_domain,
 293                                         unsigned char **data_ptr, unsigned char **end_ptr,
 294                                         unsigned char **cached_data_ptr,
 295                                         jint *cached_length_ptr);
 296   static void post_native_method_bind(Method* method, address* function_ptr) KERNEL_RETURN;
 297   static void post_compiled_method_load(nmethod *nm) KERNEL_RETURN;
 298   static void post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN;
 299 
 300   // used to post a CompiledMethodUnload event
 301   static void post_compiled_method_unload(jmethodID mid, const void *code_begin) KERNEL_RETURN;
 302 
 303   // similiar to post_dynamic_code_generated except that it can be used to
 304   // post a DynamicCodeGenerated event while holding locks in the VM. Any event
 305   // posted using this function is recorded by the enclosing event collector
 306   // -- JvmtiDynamicCodeEventCollector.
 307   static void post_dynamic_code_generated_while_holding_locks(const char* name, address code_begin, address code_end) KERNEL_RETURN;
 308 
 309   static void post_garbage_collection_finish() KERNEL_RETURN;
 310   static void post_garbage_collection_start() KERNEL_RETURN;
 311   static void post_data_dump() KERNEL_RETURN;
 312   static void post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN;
 313   static void post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN;
 314   static void post_monitor_wait(JavaThread *thread, oop obj, jlong timeout) KERNEL_RETURN;
 315   static void post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) KERNEL_RETURN;
 316   static void post_object_free(JvmtiEnv* env, jlong tag) KERNEL_RETURN;
 317   static void post_resource_exhausted(jint resource_exhausted_flags, const char* detail) KERNEL_RETURN;
 318   static void record_vm_internal_object_allocation(oop object) KERNEL_RETURN;
 319   // Post objects collected by vm_object_alloc_event_collector.
 320   static void post_vm_object_alloc(JavaThread *thread, oop object) KERNEL_RETURN;
 321   // Collects vm internal objects for later event posting.
 322   inline static void vm_object_alloc_event_collector(oop object) {
 323     if (should_post_vm_object_alloc()) {
 324       record_vm_internal_object_allocation(object);
 325     }
 326   }
 327   inline static void post_array_size_exhausted() {
 328     if (should_post_resource_exhausted()) {
 329       post_resource_exhausted(JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
 330                               "Requested array size exceeds VM limit");
 331     }
 332   }
 333 
 334   static void cleanup_thread             (JavaThread* thread) KERNEL_RETURN;
 335 
 336   static void oops_do(OopClosure* f) KERNEL_RETURN;
 337   static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) KERNEL_RETURN;
 338   static void gc_epilogue() KERNEL_RETURN;
 339 
 340   static void transition_pending_onload_raw_monitors() KERNEL_RETURN;
 341 
 342 #ifndef SERVICES_KERNEL
 343   // attach support
 344   static jint load_agent_library(AttachOperation* op, outputStream* out);
 345 #endif // SERVICES_KERNEL
 346 
 347   // SetNativeMethodPrefix support
 348   static char** get_all_native_method_prefixes(int* count_ptr);
 349 };
 350 
 351 // Support class used by JvmtiDynamicCodeEventCollector and others. It
 352 // describes a single code blob by name and address range.
 353 class JvmtiCodeBlobDesc : public CHeapObj<mtInternal> {
 354  private:
 355   char _name[64];
 356   address _code_begin;
 357   address _code_end;
 358 
 359  public:
 360   JvmtiCodeBlobDesc(const char *name, address code_begin, address code_end) {
 361     assert(name != NULL, "all code blobs must be named");
 362     strncpy(_name, name, sizeof(_name));
 363     _name[sizeof(_name)-1] = '\0';
 364     _code_begin = code_begin;
 365     _code_end = code_end;
 366   }
 367   char* name()                  { return _name; }
 368   address code_begin()          { return _code_begin; }


 391 // Usage :-
 392 //
 393 // {
 394 //   JvmtiDynamicCodeEventCollector event_collector;
 395 //   :
 396 //   { MutexLocker ml(...)
 397 //     :
 398 //     JvmtiExport::post_dynamic_code_generated_while_holding_locks(...)
 399 //   }
 400 //   // event collector goes out of scope => post events to profiler.
 401 // }
 402 
 403 class JvmtiDynamicCodeEventCollector : public JvmtiEventCollector {
 404  private:
 405   GrowableArray<JvmtiCodeBlobDesc*>* _code_blobs;           // collected code blob events
 406 
 407   friend class JvmtiExport;
 408   void register_stub(const char* name, address start, address end);
 409 
 410  public:
 411   JvmtiDynamicCodeEventCollector()  KERNEL_RETURN;
 412   ~JvmtiDynamicCodeEventCollector() KERNEL_RETURN;
 413   bool is_dynamic_code_event()   { return true; }
 414 
 415 };
 416 
 417 // Used to record vm internally allocated object oops and post
 418 // vm object alloc event for objects visible to java world.
 419 // Constructor enables JvmtiThreadState flag and all vm allocated
 420 // objects are recorded in a growable array. When destructor is
 421 // called the vm object alloc event is posted for each objects
 422 // visible to java world.
 423 // See jvm.cpp file for its usage.
 424 //
 425 class JvmtiVMObjectAllocEventCollector : public JvmtiEventCollector {
 426  private:
 427   GrowableArray<oop>* _allocated; // field to record vm internally allocated object oop.
 428   bool _enable;                   // This flag is enabled in constructor and disabled
 429                                   // in destructor before posting event. To avoid
 430                                   // collection of objects allocated while running java code inside
 431                                   // agent post_vm_object_alloc() event handler.
 432 
 433   //GC support
 434   void oops_do(OopClosure* f);
 435 
 436   friend class JvmtiExport;
 437   // Record vm allocated object oop.
 438   inline void record_allocation(oop obj);
 439 
 440   //GC support
 441   static void oops_do_for_all_threads(OopClosure* f);
 442 
 443  public:
 444   JvmtiVMObjectAllocEventCollector()  KERNEL_RETURN;
 445   ~JvmtiVMObjectAllocEventCollector() KERNEL_RETURN;
 446   bool is_vm_object_alloc_event()   { return true; }
 447 
 448   bool is_enabled()                 { return _enable; }
 449   void set_enabled(bool on)         { _enable = on; }
 450 };
 451 
 452 
 453 
 454 // Marker class to disable the posting of VMObjectAlloc events
 455 // within its scope.
 456 //
 457 // Usage :-
 458 //
 459 // {
 460 //   NoJvmtiVMObjectAllocMark njm;
 461 //   :
 462 //   // VMObjAlloc event will not be posted
 463 //   JvmtiExport::vm_object_alloc_event_collector(obj);
 464 //   :
 465 // }
 466 
 467 class NoJvmtiVMObjectAllocMark : public StackObj {
 468  private:
 469   // enclosing collector if enabled, NULL otherwise
 470   JvmtiVMObjectAllocEventCollector *_collector;
 471 
 472   bool was_enabled()    { return _collector != NULL; }
 473 
 474  public:
 475   NoJvmtiVMObjectAllocMark() KERNEL_RETURN;
 476   ~NoJvmtiVMObjectAllocMark() KERNEL_RETURN;
 477 };
 478 
 479 
 480 // Base class for reporting GC events to JVMTI.
 481 class JvmtiGCMarker : public StackObj {
 482  public:
 483   JvmtiGCMarker() KERNEL_RETURN;
 484   ~JvmtiGCMarker() KERNEL_RETURN;
 485 };
 486 
 487 // JvmtiHideSingleStepping is a helper class for hiding
 488 // internal single step events.
 489 class JvmtiHideSingleStepping : public StackObj {
 490  private:
 491   bool         _single_step_hidden;
 492   JavaThread * _thread;
 493 
 494  public:
 495   JvmtiHideSingleStepping(JavaThread * thread) {
 496     assert(thread != NULL, "sanity check");
 497 
 498     _single_step_hidden = false;
 499     _thread = thread;
 500     if (JvmtiExport::should_post_single_step()) {
 501       _single_step_hidden = JvmtiExport::hide_single_stepping(_thread);
 502     }
 503   }
 504 


  29 #include "memory/allocation.hpp"
  30 #include "memory/iterator.hpp"
  31 #include "oops/oop.hpp"
  32 #include "oops/oopsHierarchy.hpp"
  33 #include "runtime/frame.hpp"
  34 #include "runtime/handles.hpp"
  35 #include "utilities/globalDefinitions.hpp"
  36 #include "utilities/growableArray.hpp"
  37 
  38 // Must be included after jvmti.h.
  39 #include "code/jvmticmlr.h"
  40 
  41 // Forward declarations
  42 
  43 class JvmtiEventControllerPrivate;
  44 class JvmtiManageCapabilities;
  45 class JvmtiEnv;
  46 class JvmtiThreadState;
  47 class AttachOperation;
  48 

  49 #define JVMTI_SUPPORT_FLAG(key)                                           \
  50   private:                                                                \
  51   static bool  _##key;                                              \
  52   public:                                                                 \
  53   inline static void set_##key(bool on) {                                 \
  54     JVMTI_ONLY(_##key = (on != 0));                                       \
  55     NOT_JVMTI(report_unsupported(on));                                    \
  56   }                                                                       \
  57   inline static bool key() {                                              \
  58     JVMTI_ONLY(return _##key);                                            \
  59     NOT_JVMTI(return false);                                              \
  60   }


  61 
  62 
  63 // This class contains the JVMTI interface for the rest of hotspot.
  64 //
  65 class JvmtiExport : public AllStatic {
  66   friend class VMStructs;
  67  private:
  68 
  69 #if INCLUDE_JVMTI
  70   static int         _field_access_count;
  71   static int         _field_modification_count;
  72 
  73   static bool        _can_access_local_variables;
  74   static bool        _can_hotswap_or_post_breakpoint;
  75   static bool        _can_modify_any_class;
  76   static bool        _can_walk_any_space;
  77 #endif // INCLUDE_JVMTI
  78 
  79   JVMTI_SUPPORT_FLAG(can_get_source_debug_extension)
  80   JVMTI_SUPPORT_FLAG(can_maintain_original_method_order)
  81   JVMTI_SUPPORT_FLAG(can_post_interpreter_events)
  82   JVMTI_SUPPORT_FLAG(can_post_on_exceptions)
  83   JVMTI_SUPPORT_FLAG(can_post_breakpoint)
  84   JVMTI_SUPPORT_FLAG(can_post_field_access)
  85   JVMTI_SUPPORT_FLAG(can_post_field_modification)
  86   JVMTI_SUPPORT_FLAG(can_post_method_entry)
  87   JVMTI_SUPPORT_FLAG(can_post_method_exit)
  88   JVMTI_SUPPORT_FLAG(can_pop_frame)
  89   JVMTI_SUPPORT_FLAG(can_force_early_return)
  90 
  91   friend class JvmtiEventControllerPrivate;  // should only modify these flags
  92   JVMTI_SUPPORT_FLAG(should_post_single_step)
  93   JVMTI_SUPPORT_FLAG(should_post_field_access)
  94   JVMTI_SUPPORT_FLAG(should_post_field_modification)
  95   JVMTI_SUPPORT_FLAG(should_post_class_load)
  96   JVMTI_SUPPORT_FLAG(should_post_class_prepare)
  97   JVMTI_SUPPORT_FLAG(should_post_class_unload)


 108   JVMTI_SUPPORT_FLAG(should_post_garbage_collection_finish)
 109   JVMTI_SUPPORT_FLAG(should_post_on_exceptions)
 110 
 111   // ------ the below maybe don't have to be (but are for now)
 112   // fixed conditions here ------------
 113   // any events can be enabled
 114   JVMTI_SUPPORT_FLAG(should_post_thread_life)
 115   JVMTI_SUPPORT_FLAG(should_post_object_free)
 116   JVMTI_SUPPORT_FLAG(should_post_resource_exhausted)
 117 
 118   // we are holding objects on the heap - need to talk to GC - e.g.
 119   // breakpoint info
 120   JVMTI_SUPPORT_FLAG(should_clean_up_heap_objects)
 121   JVMTI_SUPPORT_FLAG(should_post_vm_object_alloc)
 122 
 123   // If flag cannot be implemented, give an error if on=true
 124   static void report_unsupported(bool on);
 125 
 126   // these should only be called by the friend class
 127   friend class JvmtiManageCapabilities;
 128   inline static void set_can_modify_any_class(bool on) { 
 129     JVMTI_ONLY(_can_modify_any_class = (on != 0);) 
 130   }
 131   inline static void set_can_access_local_variables(bool on) { 
 132     JVMTI_ONLY(_can_access_local_variables = (on != 0);)
 133   }
 134   inline static void set_can_hotswap_or_post_breakpoint(bool on) { 
 135     JVMTI_ONLY(_can_hotswap_or_post_breakpoint = (on != 0);)
 136   }
 137   inline static void set_can_walk_any_space(bool on) { 
 138     JVMTI_ONLY(_can_walk_any_space = (on != 0);)
 139   }
 140 
 141   enum {
 142     JVMTI_VERSION_MASK   = 0x70000000,
 143     JVMTI_VERSION_VALUE  = 0x30000000,
 144     JVMDI_VERSION_VALUE  = 0x20000000
 145   };
 146 
 147   static void post_field_modification(JavaThread *thread, Method* method, address location,
 148                                       KlassHandle field_klass, Handle object, jfieldID field,
 149                                       char sig_type, jvalue *value);
 150 
 151 
 152   // posts a DynamicCodeGenerated event (internal/private implementation).
 153   // The public post_dynamic_code_generated* functions make use of the
 154   // internal implementation.  Also called from JvmtiDeferredEvent::post()
 155   static void post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) NOT_JVMTI_RETURN;
 156 
 157  private:
 158 
 159   // GenerateEvents support to allow posting of CompiledMethodLoad and
 160   // DynamicCodeGenerated events for a given environment.
 161   friend class JvmtiCodeBlobEvents;
 162 
 163   static void post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length,
 164                                         const void *code_begin, const jint map_length,
 165                                         const jvmtiAddrLocationMap* map) NOT_JVMTI_RETURN;
 166   static void post_dynamic_code_generated(JvmtiEnv* env, const char *name, const void *code_begin,
 167                                           const void *code_end) NOT_JVMTI_RETURN;
 168 
 169   // The RedefineClasses() API breaks some invariants in the "regular"
 170   // system. For example, there are sanity checks when GC'ing nmethods
 171   // that require the containing class to be unloading. However, when a
 172   // method is redefined, the old method and nmethod can become GC'able
 173   // without the containing class unloading. The state of becoming
 174   // GC'able can be asynchronous to the RedefineClasses() call since
 175   // the old method may still be running and cannot be GC'ed until
 176   // after all old invocations have finished. Additionally, a method
 177   // that has not been redefined may have an nmethod that depends on
 178   // the redefined method. The dependent nmethod will get deopted in
 179   // this case and may also be GC'able without the containing class
 180   // being unloaded.
 181   //
 182   // This flag indicates whether RedefineClasses() has ever redefined
 183   // one or more classes during the lifetime of the VM. The flag should
 184   // only be set by the friend class and can be queried by other sub
 185   // systems as needed to relax invariant checks.
 186   static bool _has_redefined_a_class;
 187   friend class VM_RedefineClasses;
 188   inline static void set_has_redefined_a_class() {
 189     JVMTI_ONLY(_has_redefined_a_class = true;)
 190   }

 191   // Flag to indicate if the compiler has recorded all dependencies. When the
 192   // can_redefine_classes capability is enabled in the OnLoad phase then the compiler
 193   // records all dependencies from startup. However if the capability is first
 194   // enabled some time later then the dependencies recorded by the compiler
 195   // are incomplete. This flag is used by RedefineClasses to know if the
 196   // dependency information is complete or not.
 197   static bool _all_dependencies_are_recorded;
 198 
 199  public:
 200   inline static bool has_redefined_a_class() {
 201     JVMTI_ONLY(return _has_redefined_a_class);
 202     NOT_JVMTI(return false);
 203   }
 204 
 205   inline static bool all_dependencies_are_recorded() {
 206     return _all_dependencies_are_recorded;
 207   }
 208 
 209   inline static void set_all_dependencies_are_recorded(bool on) {
 210     _all_dependencies_are_recorded = (on != 0);
 211   }
 212 
 213 
 214   // let JVMTI know that the JVM_OnLoad code is running
 215   static void enter_onload_phase() NOT_JVMTI_RETURN;
 216 
 217   // let JVMTI know that the VM isn't up yet (and JVM_OnLoad code isn't running)
 218   static void enter_primordial_phase() NOT_JVMTI_RETURN;
 219 
 220   // let JVMTI know that the VM isn't up yet but JNI is live
 221   static void enter_start_phase() NOT_JVMTI_RETURN;
 222 
 223   // let JVMTI know that the VM is fully up and running now
 224   static void enter_live_phase() NOT_JVMTI_RETURN;
 225 
 226   // ------ can_* conditions (below) are set at OnLoad and never changed ------------
 227   inline static bool can_modify_any_class()                       {
 228     JVMTI_ONLY(return _can_modify_any_class);
 229     NOT_JVMTI(return false);
 230   }
 231   inline static bool can_access_local_variables()                 {
 232     JVMTI_ONLY(return _can_access_local_variables);
 233     NOT_JVMTI(return false);
 234   }
 235   inline static bool can_hotswap_or_post_breakpoint()             {
 236     JVMTI_ONLY(return _can_hotswap_or_post_breakpoint);
 237     NOT_JVMTI(return false);
 238   }
 239   inline static bool can_walk_any_space()                         {
 240     JVMTI_ONLY(return _can_walk_any_space);
 241     NOT_JVMTI(return false);
 242   }
 243 
 244   // field access management
 245   static address  get_field_access_count_addr() NOT_JVMTI_RETURN_(0);
 246 
 247   // field modification management
 248   static address  get_field_modification_count_addr() NOT_JVMTI_RETURN_(0);
 249 
 250   // -----------------
 251 
 252   static bool is_jvmti_version(jint version)                      {
 253     JVMTI_ONLY(return (version & JVMTI_VERSION_MASK) == JVMTI_VERSION_VALUE);
 254     NOT_JVMTI(return false);
 255   }
 256   static bool is_jvmdi_version(jint version)                      {
 257     JVMTI_ONLY(return (version & JVMTI_VERSION_MASK) == JVMDI_VERSION_VALUE);
 258     NOT_JVMTI(return false);
 259   }
 260   static jint get_jvmti_interface(JavaVM *jvm, void **penv, jint version) NOT_JVMTI_RETURN_(0);
 261   static void decode_version_values(jint version, int * major, int * minor,
 262                                     int * micro) NOT_JVMTI_RETURN;
 263 
 264   // single stepping management methods
 265   static void at_single_stepping_point(JavaThread *thread, Method* method, address location) NOT_JVMTI_RETURN;
 266   static void expose_single_stepping(JavaThread *thread) NOT_JVMTI_RETURN;
 267   static bool hide_single_stepping(JavaThread *thread) NOT_JVMTI_RETURN_(false);
 268 
 269   // Methods that notify the debugger that something interesting has happened in the VM.
 270   static void post_vm_start              () NOT_JVMTI_RETURN;
 271   static void post_vm_initialized        () NOT_JVMTI_RETURN;
 272   static void post_vm_death              () NOT_JVMTI_RETURN;
 273 
 274   static void post_single_step           (JavaThread *thread, Method* method, address location) NOT_JVMTI_RETURN;
 275   static void post_raw_breakpoint        (JavaThread *thread, Method* method, address location) NOT_JVMTI_RETURN;
 276 
 277   static void post_exception_throw       (JavaThread *thread, Method* method, address location, oop exception) NOT_JVMTI_RETURN;
 278   static void notice_unwind_due_to_exception (JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) NOT_JVMTI_RETURN;
 279 
 280   static oop jni_GetField_probe          (JavaThread *thread, jobject jobj,
 281     oop obj, Klass* klass, jfieldID fieldID, bool is_static)
 282     NOT_JVMTI_RETURN_(NULL);
 283   static oop jni_GetField_probe_nh       (JavaThread *thread, jobject jobj,
 284     oop obj, Klass* klass, jfieldID fieldID, bool is_static)
 285     NOT_JVMTI_RETURN_(NULL);
 286   static void post_field_access_by_jni   (JavaThread *thread, oop obj,
 287     Klass* klass, jfieldID fieldID, bool is_static) NOT_JVMTI_RETURN;
 288   static void post_field_access          (JavaThread *thread, Method* method,
 289     address location, KlassHandle field_klass, Handle object, jfieldID field) NOT_JVMTI_RETURN;
 290   static oop jni_SetField_probe          (JavaThread *thread, jobject jobj,
 291     oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 292     jvalue *value) NOT_JVMTI_RETURN_(NULL);
 293   static oop jni_SetField_probe_nh       (JavaThread *thread, jobject jobj,
 294     oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 295     jvalue *value) NOT_JVMTI_RETURN_(NULL);
 296   static void post_field_modification_by_jni(JavaThread *thread, oop obj,
 297     Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
 298     jvalue *value);
 299   static void post_raw_field_modification(JavaThread *thread, Method* method,
 300     address location, KlassHandle field_klass, Handle object, jfieldID field,
 301     char sig_type, jvalue *value) NOT_JVMTI_RETURN;
 302 
 303   static void post_method_entry          (JavaThread *thread, Method* method, frame current_frame) NOT_JVMTI_RETURN;
 304   static void post_method_exit           (JavaThread *thread, Method* method, frame current_frame) NOT_JVMTI_RETURN;
 305 
 306   static void post_class_load            (JavaThread *thread, Klass* klass) NOT_JVMTI_RETURN;
 307   static void post_class_unload          (Klass* klass) NOT_JVMTI_RETURN;
 308   static void post_class_prepare         (JavaThread *thread, Klass* klass) NOT_JVMTI_RETURN;
 309 
 310   static void post_thread_start          (JavaThread *thread) NOT_JVMTI_RETURN;
 311   static void post_thread_end            (JavaThread *thread) NOT_JVMTI_RETURN;
 312 
 313   // Support for java.lang.instrument agent loading.
 314   static bool _should_post_class_file_load_hook;
 315   inline static void set_should_post_class_file_load_hook(bool on)     { _should_post_class_file_load_hook = on;  }
 316   inline static bool should_post_class_file_load_hook()           { 
 317     JVMTI_ONLY(return _should_post_class_file_load_hook);
 318     NOT_JVMTI(return false;)
 319   }
 320   static void post_class_file_load_hook(Symbol* h_name, Handle class_loader,
 321                                         Handle h_protection_domain,
 322                                         unsigned char **data_ptr, unsigned char **end_ptr,
 323                                         unsigned char **cached_data_ptr,
 324                                         jint *cached_length_ptr) NOT_JVMTI_RETURN;
 325   static void post_native_method_bind(Method* method, address* function_ptr) NOT_JVMTI_RETURN;
 326   static void post_compiled_method_load(nmethod *nm) NOT_JVMTI_RETURN;
 327   static void post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) NOT_JVMTI_RETURN;
 328 
 329   // used to post a CompiledMethodUnload event
 330   static void post_compiled_method_unload(jmethodID mid, const void *code_begin) NOT_JVMTI_RETURN;
 331 
 332   // similiar to post_dynamic_code_generated except that it can be used to
 333   // post a DynamicCodeGenerated event while holding locks in the VM. Any event
 334   // posted using this function is recorded by the enclosing event collector
 335   // -- JvmtiDynamicCodeEventCollector.
 336   static void post_dynamic_code_generated_while_holding_locks(const char* name, address code_begin, address code_end) NOT_JVMTI_RETURN;
 337 
 338   static void post_garbage_collection_finish() NOT_JVMTI_RETURN;
 339   static void post_garbage_collection_start() NOT_JVMTI_RETURN;
 340   static void post_data_dump() NOT_JVMTI_RETURN;
 341   static void post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) NOT_JVMTI_RETURN;
 342   static void post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) NOT_JVMTI_RETURN;
 343   static void post_monitor_wait(JavaThread *thread, oop obj, jlong timeout) NOT_JVMTI_RETURN;
 344   static void post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) NOT_JVMTI_RETURN;
 345   static void post_object_free(JvmtiEnv* env, jlong tag) NOT_JVMTI_RETURN;
 346   static void post_resource_exhausted(jint resource_exhausted_flags, const char* detail) NOT_JVMTI_RETURN;
 347   static void record_vm_internal_object_allocation(oop object) NOT_JVMTI_RETURN;
 348   // Post objects collected by vm_object_alloc_event_collector.
 349   static void post_vm_object_alloc(JavaThread *thread, oop object) NOT_JVMTI_RETURN;
 350   // Collects vm internal objects for later event posting.
 351   inline static void vm_object_alloc_event_collector(oop object) {
 352     if (should_post_vm_object_alloc()) {
 353       record_vm_internal_object_allocation(object);
 354     }
 355   }
 356   inline static void post_array_size_exhausted() {
 357     if (should_post_resource_exhausted()) {
 358       post_resource_exhausted(JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
 359                               "Requested array size exceeds VM limit");
 360     }
 361   }
 362 
 363   static void cleanup_thread             (JavaThread* thread) NOT_JVMTI_RETURN;
 364 
 365   static void oops_do(OopClosure* f) NOT_JVMTI_RETURN;
 366   static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) NOT_JVMTI_RETURN;
 367   static void gc_epilogue() NOT_JVMTI_RETURN;
 368 
 369   static void transition_pending_onload_raw_monitors() NOT_JVMTI_RETURN;
 370 

 371   // attach support
 372   static jint load_agent_library(AttachOperation* op, outputStream* out) NOT_JVMTI_RETURN_(JNI_ERR);

 373 
 374   // SetNativeMethodPrefix support
 375   static char** get_all_native_method_prefixes(int* count_ptr) NOT_JVMTI_RETURN_(NULL);
 376 };
 377 
 378 // Support class used by JvmtiDynamicCodeEventCollector and others. It
 379 // describes a single code blob by name and address range.
 380 class JvmtiCodeBlobDesc : public CHeapObj<mtInternal> {
 381  private:
 382   char _name[64];
 383   address _code_begin;
 384   address _code_end;
 385 
 386  public:
 387   JvmtiCodeBlobDesc(const char *name, address code_begin, address code_end) {
 388     assert(name != NULL, "all code blobs must be named");
 389     strncpy(_name, name, sizeof(_name));
 390     _name[sizeof(_name)-1] = '\0';
 391     _code_begin = code_begin;
 392     _code_end = code_end;
 393   }
 394   char* name()                  { return _name; }
 395   address code_begin()          { return _code_begin; }


 418 // Usage :-
 419 //
 420 // {
 421 //   JvmtiDynamicCodeEventCollector event_collector;
 422 //   :
 423 //   { MutexLocker ml(...)
 424 //     :
 425 //     JvmtiExport::post_dynamic_code_generated_while_holding_locks(...)
 426 //   }
 427 //   // event collector goes out of scope => post events to profiler.
 428 // }
 429 
 430 class JvmtiDynamicCodeEventCollector : public JvmtiEventCollector {
 431  private:
 432   GrowableArray<JvmtiCodeBlobDesc*>* _code_blobs;           // collected code blob events
 433 
 434   friend class JvmtiExport;
 435   void register_stub(const char* name, address start, address end);
 436 
 437  public:
 438   JvmtiDynamicCodeEventCollector()  NOT_JVMTI_RETURN;
 439   ~JvmtiDynamicCodeEventCollector() NOT_JVMTI_RETURN;
 440   bool is_dynamic_code_event()   { return true; }
 441 
 442 };
 443 
 444 // Used to record vm internally allocated object oops and post
 445 // vm object alloc event for objects visible to java world.
 446 // Constructor enables JvmtiThreadState flag and all vm allocated
 447 // objects are recorded in a growable array. When destructor is
 448 // called the vm object alloc event is posted for each objects
 449 // visible to java world.
 450 // See jvm.cpp file for its usage.
 451 //
 452 class JvmtiVMObjectAllocEventCollector : public JvmtiEventCollector {
 453  private:
 454   GrowableArray<oop>* _allocated; // field to record vm internally allocated object oop.
 455   bool _enable;                   // This flag is enabled in constructor and disabled
 456                                   // in destructor before posting event. To avoid
 457                                   // collection of objects allocated while running java code inside
 458                                   // agent post_vm_object_alloc() event handler.
 459 
 460   //GC support
 461   void oops_do(OopClosure* f);
 462 
 463   friend class JvmtiExport;
 464   // Record vm allocated object oop.
 465   inline void record_allocation(oop obj);
 466 
 467   //GC support
 468   static void oops_do_for_all_threads(OopClosure* f);
 469 
 470  public:
 471   JvmtiVMObjectAllocEventCollector()  NOT_JVMTI_RETURN;
 472   ~JvmtiVMObjectAllocEventCollector() NOT_JVMTI_RETURN;
 473   bool is_vm_object_alloc_event()   { return true; }
 474 
 475   bool is_enabled()                 { return _enable; }
 476   void set_enabled(bool on)         { _enable = on; }
 477 };
 478 
 479 
 480 
 481 // Marker class to disable the posting of VMObjectAlloc events
 482 // within its scope.
 483 //
 484 // Usage :-
 485 //
 486 // {
 487 //   NoJvmtiVMObjectAllocMark njm;
 488 //   :
 489 //   // VMObjAlloc event will not be posted
 490 //   JvmtiExport::vm_object_alloc_event_collector(obj);
 491 //   :
 492 // }
 493 
 494 class NoJvmtiVMObjectAllocMark : public StackObj {
 495  private:
 496   // enclosing collector if enabled, NULL otherwise
 497   JvmtiVMObjectAllocEventCollector *_collector;
 498 
 499   bool was_enabled()    { return _collector != NULL; }
 500 
 501  public:
 502   NoJvmtiVMObjectAllocMark() NOT_JVMTI_RETURN;
 503   ~NoJvmtiVMObjectAllocMark() NOT_JVMTI_RETURN;
 504 };
 505 
 506 
 507 // Base class for reporting GC events to JVMTI.
 508 class JvmtiGCMarker : public StackObj {
 509  public:
 510   JvmtiGCMarker() NOT_JVMTI_RETURN;
 511   ~JvmtiGCMarker() NOT_JVMTI_RETURN;
 512 };
 513 
 514 // JvmtiHideSingleStepping is a helper class for hiding
 515 // internal single step events.
 516 class JvmtiHideSingleStepping : public StackObj {
 517  private:
 518   bool         _single_step_hidden;
 519   JavaThread * _thread;
 520 
 521  public:
 522   JvmtiHideSingleStepping(JavaThread * thread) {
 523     assert(thread != NULL, "sanity check");
 524 
 525     _single_step_hidden = false;
 526     _thread = thread;
 527     if (JvmtiExport::should_post_single_step()) {
 528       _single_step_hidden = JvmtiExport::hide_single_stepping(_thread);
 529     }
 530   }
 531 
src/share/vm/prims/jvmtiExport.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File