Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hotspot/src/share/vm/prims/jvmtiEventController.cpp
changeset 37992 c7ec6a3275f7
parent 36508 5f9eee6b383b
child 41089 20dee76bef80
equal deleted inserted replaced
37991:ce2e1e55f28f 37992:c7ec6a3275f7 
    23  */
 
    23  */
 
    24 
    24 
    25 #include "precompiled.hpp"
 
    25 #include "precompiled.hpp"
 
    26 #include "interpreter/interpreter.hpp"
 
    26 #include "interpreter/interpreter.hpp"
 
    27 #include "jvmtifiles/jvmtiEnv.hpp"
 
    27 #include "jvmtifiles/jvmtiEnv.hpp"
 
       
    28 #include "logging/log.hpp"
 
    28 #include "memory/resourceArea.hpp"
 
    29 #include "memory/resourceArea.hpp"
 
    29 #include "prims/jvmtiEventController.hpp"
 
    30 #include "prims/jvmtiEventController.hpp"
 
    30 #include "prims/jvmtiEventController.inline.hpp"
 
    31 #include "prims/jvmtiEventController.inline.hpp"
 
    31 #include "prims/jvmtiExport.hpp"
 
    32 #include "prims/jvmtiExport.hpp"
 
    32 #include "prims/jvmtiImpl.hpp"
 
    33 #include "prims/jvmtiImpl.hpp"
 
    40 
    41 
    41 #ifdef JVMTI_TRACE
 
    42 #ifdef JVMTI_TRACE
 
    42 #define EC_TRACE(out) do { \
 
    43 #define EC_TRACE(out) do { \
 
    43   if (JvmtiTrace::trace_event_controller()) { \
 
    44   if (JvmtiTrace::trace_event_controller()) { \
 
    44     SafeResourceMark rm; \
 
    45     SafeResourceMark rm; \
 
    45     tty->print_cr out; \
 
    46     log_trace(jvmti) out; \
 
    46   } \
 
    47   } \
 
    47 } while (0)
 
    48 } while (0)
 
    48 #else
 
    49 #else
 
    49 #define EC_TRACE(out)
 
    50 #define EC_TRACE(out)
 
    50 #endif /*JVMTI_TRACE */
 
    51 #endif /*JVMTI_TRACE */
 
   342   }
 
   343   }
 
   343 }
 
   344 }
 
   344 
   345 
   345 
   346 
   346 void JvmtiEventControllerPrivate::enter_interp_only_mode(JvmtiThreadState *state) {
 
   347 void JvmtiEventControllerPrivate::enter_interp_only_mode(JvmtiThreadState *state) {
 
   347   EC_TRACE(("JVMTI [%s] # Entering interpreter only mode",
 
   348   EC_TRACE(("[%s] # Entering interpreter only mode",
 
   348             JvmtiTrace::safe_get_thread_name(state->get_thread())));
 
   349             JvmtiTrace::safe_get_thread_name(state->get_thread())));
 
   349 
   350 
   350   VM_EnterInterpOnlyMode op(state);
 
   351   VM_EnterInterpOnlyMode op(state);
 
   351   VMThread::execute(&op);
 
   352   VMThread::execute(&op);
 
   352 }
 
   353 }
 
   353 
   354 
   354 
   355 
   355 void
 
   356 void
 
   356 JvmtiEventControllerPrivate::leave_interp_only_mode(JvmtiThreadState *state) {
 
   357 JvmtiEventControllerPrivate::leave_interp_only_mode(JvmtiThreadState *state) {
 
   357   EC_TRACE(("JVMTI [%s] # Leaving interpreter only mode",
 
   358   EC_TRACE(("[%s] # Leaving interpreter only mode",
 
   358             JvmtiTrace::safe_get_thread_name(state->get_thread())));
 
   359             JvmtiTrace::safe_get_thread_name(state->get_thread())));
 
   359   state->leave_interp_only_mode();
 
   360   state->leave_interp_only_mode();
 
   360 }
 
   361 }
 
   361 
   362 
   362 
   363 
   368     // traces standard events only
 
   369     // traces standard events only
 
   369     for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {
 
   370     for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {
 
   370       jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei);
 
   371       jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei);
 
   371       if (changed & bit) {
 
   372       if (changed & bit) {
 
   372         // it changed, print it
 
   373         // it changed, print it
 
   373         tty->print_cr("JVMTI [%s] # %s event %s",
 
   374          log_trace(jvmti)("[%s] # %s event %s",
 
   374                       JvmtiTrace::safe_get_thread_name(state->get_thread()),
 
   375                       JvmtiTrace::safe_get_thread_name(state->get_thread()),
 
   375                       (now_enabled & bit)? "Enabling" : "Disabling", JvmtiTrace::event_name((jvmtiEvent)ei));
 
   376                       (now_enabled & bit)? "Enabling" : "Disabling", JvmtiTrace::event_name((jvmtiEvent)ei));
 
   376       }
 
   377       }
 
   377     }
 
   378     }
 
   378   }
 
   379   }
 
   388     // traces standard events only
 
   389     // traces standard events only
 
   389     for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {
 
   390     for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {
 
   390       jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei);
 
   391       jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei);
 
   391       if (changed & bit) {
 
   392       if (changed & bit) {
 
   392         // it changed, print it
 
   393         // it changed, print it
 
   393         tty->print_cr("JVMTI [-] # %s event %s",
 
   394          log_trace(jvmti)("[-] # %s event %s",
 
   394                       (now_enabled & bit)? "Enabling" : "Disabling", JvmtiTrace::event_name((jvmtiEvent)ei));
 
   395                       (now_enabled & bit)? "Enabling" : "Disabling", JvmtiTrace::event_name((jvmtiEvent)ei));
 
   395       }
 
   396       }
 
   396     }
 
   397     }
 
   397   }
 
   398   }
 
   398 #endif /*JVMTI_TRACE */
 
   399 #endif /*JVMTI_TRACE */
 
   561 
   562 
   562   // event enabled for any thread in any environment
 
   563   // event enabled for any thread in any environment
 
   563   jlong was_any_env_thread_enabled = JvmtiEventController::_universal_global_event_enabled.get_bits();
 
   564   jlong was_any_env_thread_enabled = JvmtiEventController::_universal_global_event_enabled.get_bits();
 
   564   jlong any_env_thread_enabled = 0;
 
   565   jlong any_env_thread_enabled = 0;
 
   565 
   566 
   566   EC_TRACE(("JVMTI [-] # recompute enabled - before " UINT64_FORMAT_X, was_any_env_thread_enabled));
 
   567   EC_TRACE(("[-] # recompute enabled - before " UINT64_FORMAT_X, was_any_env_thread_enabled));
 
   567 
   568 
   568   // compute non-thread-filters events.
 
   569   // compute non-thread-filters events.
 
   569   // This must be done separately from thread-filtered events, since some
 
   570   // This must be done separately from thread-filtered events, since some
 
   570   // events can occur before any threads exist.
 
   571   // events can occur before any threads exist.
 
   571   JvmtiEnvIterator it;
 
   572   JvmtiEnvIterator it;
 
   641     // set global should_post_on_exceptions
 
   642     // set global should_post_on_exceptions
 
   642     JvmtiExport::set_should_post_on_exceptions((any_env_thread_enabled & SHOULD_POST_ON_EXCEPTIONS_BITS) != 0);
 
   643     JvmtiExport::set_should_post_on_exceptions((any_env_thread_enabled & SHOULD_POST_ON_EXCEPTIONS_BITS) != 0);
 
   643 
   644 
   644   }
 
   645   }
 
   645 
   646 
   646   EC_TRACE(("JVMTI [-] # recompute enabled - after " UINT64_FORMAT_X, any_env_thread_enabled));
 
   647   EC_TRACE(("[-] # recompute enabled - after " UINT64_FORMAT_X, any_env_thread_enabled));
 
   647 }
 
   648 }
 
   648 
   649 
   649 
   650 
   650 void
 
   651 void
 
   651 JvmtiEventControllerPrivate::thread_started(JavaThread *thread) {
 
   652 JvmtiEventControllerPrivate::thread_started(JavaThread *thread) {
 
   652   assert(thread->is_Java_thread(), "Must be JavaThread");
 
   653   assert(thread->is_Java_thread(), "Must be JavaThread");
 
   653   assert(thread == Thread::current(), "must be current thread");
 
   654   assert(thread == Thread::current(), "must be current thread");
 
   654   assert(JvmtiEnvBase::environments_might_exist(), "to enter event controller, JVM TI environments must exist");
 
   655   assert(JvmtiEnvBase::environments_might_exist(), "to enter event controller, JVM TI environments must exist");
 
   655 
   656 
   656   EC_TRACE(("JVMTI [%s] # thread started", JvmtiTrace::safe_get_thread_name(thread)));
 
   657   EC_TRACE(("[%s] # thread started", JvmtiTrace::safe_get_thread_name(thread)));
 
   657 
   658 
   658   // if we have any thread filtered events globally enabled, create/update the thread state
 
   659   // if we have any thread filtered events globally enabled, create/update the thread state
 
   659   if ((JvmtiEventController::_universal_global_event_enabled.get_bits() & THREAD_FILTERED_EVENT_BITS) != 0) {
 
   660   if ((JvmtiEventController::_universal_global_event_enabled.get_bits() & THREAD_FILTERED_EVENT_BITS) != 0) {
 
   660     MutexLocker mu(JvmtiThreadState_lock);
 
   661     MutexLocker mu(JvmtiThreadState_lock);
 
   661     // create the thread state if missing
 
   662     // create the thread state if missing
 
   671 JvmtiEventControllerPrivate::thread_ended(JavaThread *thread) {
 
   672 JvmtiEventControllerPrivate::thread_ended(JavaThread *thread) {
 
   672   // Removes the JvmtiThreadState associated with the specified thread.
 
   673   // Removes the JvmtiThreadState associated with the specified thread.
 
   673   // May be called after all environments have been disposed.
 
   674   // May be called after all environments have been disposed.
 
   674   assert(JvmtiThreadState_lock->is_locked(), "sanity check");
 
   675   assert(JvmtiThreadState_lock->is_locked(), "sanity check");
 
   675 
   676 
   676   EC_TRACE(("JVMTI [%s] # thread ended", JvmtiTrace::safe_get_thread_name(thread)));
 
   677   EC_TRACE(("[%s] # thread ended", JvmtiTrace::safe_get_thread_name(thread)));
 
   677 
   678 
   678   JvmtiThreadState *state = thread->jvmti_thread_state();
 
   679   JvmtiThreadState *state = thread->jvmti_thread_state();
 
   679   assert(state != NULL, "else why are we here?");
 
   680   assert(state != NULL, "else why are we here?");
 
   680   delete state;
 
   681   delete state;
 
   681 }
 
   682 }
 
   682 
   683 
   683 void JvmtiEventControllerPrivate::set_event_callbacks(JvmtiEnvBase *env,
 
   684 void JvmtiEventControllerPrivate::set_event_callbacks(JvmtiEnvBase *env,
 
   684                                                       const jvmtiEventCallbacks* callbacks,
 
   685                                                       const jvmtiEventCallbacks* callbacks,
 
   685                                                       jint size_of_callbacks) {
 
   686                                                       jint size_of_callbacks) {
 
   686   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   687   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   687   EC_TRACE(("JVMTI [*] # set event callbacks"));
 
   688   EC_TRACE(("[*] # set event callbacks"));
 
   688 
   689 
   689   env->set_event_callbacks(callbacks, size_of_callbacks);
 
   690   env->set_event_callbacks(callbacks, size_of_callbacks);
 
   690   jlong enabled_bits = 0;
 
   691   jlong enabled_bits = 0;
 
   691   for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {
 
   692   for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {
 
   692     jvmtiEvent evt_t = (jvmtiEvent)ei;
 
   693     jvmtiEvent evt_t = (jvmtiEvent)ei;
 
   702 JvmtiEventControllerPrivate::set_extension_event_callback(JvmtiEnvBase *env,
 
   703 JvmtiEventControllerPrivate::set_extension_event_callback(JvmtiEnvBase *env,
 
   703                                                           jint extension_event_index,
 
   704                                                           jint extension_event_index,
 
   704                                                           jvmtiExtensionEvent callback)
 
   705                                                           jvmtiExtensionEvent callback)
 
   705 {
 
   706 {
 
   706   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   707   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   707   EC_TRACE(("JVMTI [*] # set extension event callback"));
 
   708   EC_TRACE(("[*] # set extension event callback"));
 
   708 
   709 
   709   // extension events are allocated below JVMTI_MIN_EVENT_TYPE_VAL
 
   710   // extension events are allocated below JVMTI_MIN_EVENT_TYPE_VAL
 
   710   assert(extension_event_index >= (jint)EXT_MIN_EVENT_TYPE_VAL &&
 
   711   assert(extension_event_index >= (jint)EXT_MIN_EVENT_TYPE_VAL &&
 
   711          extension_event_index <= (jint)EXT_MAX_EVENT_TYPE_VAL, "sanity check");
 
   712          extension_event_index <= (jint)EXT_MAX_EVENT_TYPE_VAL, "sanity check");
 
   712 
   713 
   748 
   749 
   749 
   750 
   750 void
 
   751 void
 
   751 JvmtiEventControllerPrivate::env_initialize(JvmtiEnvBase *env) {
 
   752 JvmtiEventControllerPrivate::env_initialize(JvmtiEnvBase *env) {
 
   752   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   753   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   753   EC_TRACE(("JVMTI [*] # env initialize"));
 
   754   EC_TRACE(("[*] # env initialize"));
 
   754 
   755 
   755   if (JvmtiEnvBase::is_vm_live()) {
 
   756   if (JvmtiEnvBase::is_vm_live()) {
 
   756     // if we didn't initialize event info already (this is a late
 
   757     // if we didn't initialize event info already (this is a late
 
   757     // launched environment), do it now.
 
   758     // launched environment), do it now.
 
   758     event_init();
 
   759     event_init();
 
   770 
   771 
   771 
   772 
   772 void
 
   773 void
 
   773 JvmtiEventControllerPrivate::env_dispose(JvmtiEnvBase *env) {
 
   774 JvmtiEventControllerPrivate::env_dispose(JvmtiEnvBase *env) {
 
   774   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   775   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   775   EC_TRACE(("JVMTI [*] # env dispose"));
 
   776   EC_TRACE(("[*] # env dispose"));
 
   776 
   777 
   777   // Before the environment is marked disposed, disable all events on this
 
   778   // Before the environment is marked disposed, disable all events on this
 
   778   // environment (by zapping the callbacks).  As a result, the disposed
 
   779   // environment (by zapping the callbacks).  As a result, the disposed
 
   779   // environment will not call event handlers.
 
   780   // environment will not call event handlers.
 
   780   set_event_callbacks(env, NULL, 0);
 
   781   set_event_callbacks(env, NULL, 0);
 
   792 void
 
   793 void
 
   793 JvmtiEventControllerPrivate::set_user_enabled(JvmtiEnvBase *env, JavaThread *thread,
 
   794 JvmtiEventControllerPrivate::set_user_enabled(JvmtiEnvBase *env, JavaThread *thread,
 
   794                                           jvmtiEvent event_type, bool enabled) {
 
   795                                           jvmtiEvent event_type, bool enabled) {
 
   795   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   796   assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");
 
   796 
   797 
   797   EC_TRACE(("JVMTI [%s] # user %s event %s",
 
   798   EC_TRACE(("[%s] # user %s event %s",
 
   798             thread==NULL? "ALL": JvmtiTrace::safe_get_thread_name(thread),
 
   799             thread==NULL? "ALL": JvmtiTrace::safe_get_thread_name(thread),
 
   799             enabled? "enabled" : "disabled", JvmtiTrace::event_name(event_type)));
 
   800             enabled? "enabled" : "disabled", JvmtiTrace::event_name(event_type)));
 
   800 
   801 
   801   if (thread == NULL) {
 
   802   if (thread == NULL) {
 
   802     env->env_event_enable()->set_user_enabled(event_type, enabled);
 
   803     env->env_event_enable()->set_user_enabled(event_type, enabled);
 
   811 }
 
   812 }
 
   812 
   813 
   813 
   814 
   814 void
 
   815 void
 
   815 JvmtiEventControllerPrivate::set_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) {
 
   816 JvmtiEventControllerPrivate::set_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) {
 
   816   EC_TRACE(("JVMTI [%s] # set frame pop - frame=%d",
 
   817   EC_TRACE(("[%s] # set frame pop - frame=%d",
 
   817             JvmtiTrace::safe_get_thread_name(ets->get_thread()),
 
   818             JvmtiTrace::safe_get_thread_name(ets->get_thread()),
 
   818             fpop.frame_number() ));
 
   819             fpop.frame_number() ));
 
   819 
   820 
   820   ets->get_frame_pops()->set(fpop);
 
   821   ets->get_frame_pops()->set(fpop);
 
   821   recompute_thread_enabled(ets->get_thread()->jvmti_thread_state());
 
   822   recompute_thread_enabled(ets->get_thread()->jvmti_thread_state());
 
   822 }
 
   823 }
 
   823 
   824 
   824 
   825 
   825 void
 
   826 void
 
   826 JvmtiEventControllerPrivate::clear_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) {
 
   827 JvmtiEventControllerPrivate::clear_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) {
 
   827   EC_TRACE(("JVMTI [%s] # clear frame pop - frame=%d",
 
   828   EC_TRACE(("[%s] # clear frame pop - frame=%d",
 
   828             JvmtiTrace::safe_get_thread_name(ets->get_thread()),
 
   829             JvmtiTrace::safe_get_thread_name(ets->get_thread()),
 
   829             fpop.frame_number() ));
 
   830             fpop.frame_number() ));
 
   830 
   831 
   831   ets->get_frame_pops()->clear(fpop);
 
   832   ets->get_frame_pops()->clear(fpop);
 
   832   recompute_thread_enabled(ets->get_thread()->jvmti_thread_state());
 
   833   recompute_thread_enabled(ets->get_thread()->jvmti_thread_state());
 
   835 
   836 
   836 void
 
   837 void
 
   837 JvmtiEventControllerPrivate::clear_to_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) {
 
   838 JvmtiEventControllerPrivate::clear_to_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) {
 
   838   int cleared_cnt = ets->get_frame_pops()->clear_to(fpop);
 
   839   int cleared_cnt = ets->get_frame_pops()->clear_to(fpop);
 
   839 
   840 
   840   EC_TRACE(("JVMTI [%s] # clear to frame pop - frame=%d, count=%d",
 
   841   EC_TRACE(("[%s] # clear to frame pop - frame=%d, count=%d",
 
   841             JvmtiTrace::safe_get_thread_name(ets->get_thread()),
 
   842             JvmtiTrace::safe_get_thread_name(ets->get_thread()),
 
   842             fpop.frame_number(),
 
   843             fpop.frame_number(),
 
   843             cleared_cnt ));
 
   844             cleared_cnt ));
 
   844 
   845 
   845   if (cleared_cnt > 0) {
 
   846   if (cleared_cnt > 0) {
 
   861   default:
 
   862   default:
 
   862     assert(false, "incorrect event");
 
   863     assert(false, "incorrect event");
 
   863     return;
 
   864     return;
 
   864   }
 
   865   }
 
   865 
   866 
   866   EC_TRACE(("JVMTI [-] # change field watch - %s %s count=%d",
 
   867   EC_TRACE(("[-] # change field watch - %s %s count=%d",
 
   867             event_type==JVMTI_EVENT_FIELD_MODIFICATION? "modification" : "access",
 
   868             event_type==JVMTI_EVENT_FIELD_MODIFICATION? "modification" : "access",
 
   868             added? "add" : "remove",
 
   869             added? "add" : "remove",
 
   869             *count_addr));
 
   870             *count_addr));
 
   870 
   871 
   871   if (added) {
 
   872   if (added) {
 
   891 
   892 
   892   if (_initialized) {
 
   893   if (_initialized) {
 
   893     return;
 
   894     return;
 
   894   }
 
   895   }
 
   895 
   896 
   896   EC_TRACE(("JVMTI [-] # VM live"));
 
   897   EC_TRACE(("[-] # VM live"));
 
   897 
   898 
   898 #ifdef ASSERT
 
   899 #ifdef ASSERT
 
   899   // check that our idea and the spec's idea of threaded events match
 
   900   // check that our idea and the spec's idea of threaded events match
 
   900   for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {
 
   901   for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {
 
   901     jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei);
 
   902     jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei);
jdk-sandbox