Mercurial > hg > truffle
annotate src/share/vm/prims/jvmtiEventController.cpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
| author | tamao |
|---|---|
| date | Tue, 05 Mar 2013 15:36:56 -0800 |
| parents | 1d1603768966 |
| children | 6b19fe41b577 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2126
diff
changeset
|
2 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1213
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1213
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1213
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "interpreter/interpreter.hpp" | |
| 27 #include "jvmtifiles/jvmtiEnv.hpp" | |
| 28 #include "memory/resourceArea.hpp" | |
| 29 #include "prims/jvmtiEventController.hpp" | |
| 30 #include "prims/jvmtiEventController.inline.hpp" | |
| 31 #include "prims/jvmtiExport.hpp" | |
| 32 #include "prims/jvmtiImpl.hpp" | |
| 33 #include "prims/jvmtiThreadState.inline.hpp" | |
| 34 #include "runtime/frame.hpp" | |
| 35 #include "runtime/thread.hpp" | |
| 36 #include "runtime/vframe.hpp" | |
| 37 #include "runtime/vframe_hp.hpp" | |
| 38 #include "runtime/vmThread.hpp" | |
| 39 #include "runtime/vm_operations.hpp" | |
| 0 | 40 |
| 41 #ifdef JVMTI_TRACE | |
| 42 #define EC_TRACE(out) if (JvmtiTrace::trace_event_controller()) { SafeResourceMark rm; tty->print_cr out; } while (0) | |
| 43 #else | |
| 44 #define EC_TRACE(out) | |
| 45 #endif /*JVMTI_TRACE */ | |
| 46 | |
| 47 // bits for standard events | |
| 48 | |
| 49 static const jlong SINGLE_STEP_BIT = (((jlong)1) << (JVMTI_EVENT_SINGLE_STEP - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 50 static const jlong FRAME_POP_BIT = (((jlong)1) << (JVMTI_EVENT_FRAME_POP - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 51 static const jlong BREAKPOINT_BIT = (((jlong)1) << (JVMTI_EVENT_BREAKPOINT - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 52 static const jlong FIELD_ACCESS_BIT = (((jlong)1) << (JVMTI_EVENT_FIELD_ACCESS - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 53 static const jlong FIELD_MODIFICATION_BIT = (((jlong)1) << (JVMTI_EVENT_FIELD_MODIFICATION - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 54 static const jlong METHOD_ENTRY_BIT = (((jlong)1) << (JVMTI_EVENT_METHOD_ENTRY - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 55 static const jlong METHOD_EXIT_BIT = (((jlong)1) << (JVMTI_EVENT_METHOD_EXIT - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 56 static const jlong CLASS_FILE_LOAD_HOOK_BIT = (((jlong)1) << (JVMTI_EVENT_CLASS_FILE_LOAD_HOOK - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 57 static const jlong NATIVE_METHOD_BIND_BIT = (((jlong)1) << (JVMTI_EVENT_NATIVE_METHOD_BIND - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 58 static const jlong VM_START_BIT = (((jlong)1) << (JVMTI_EVENT_VM_START - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 59 static const jlong VM_INIT_BIT = (((jlong)1) << (JVMTI_EVENT_VM_INIT - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 60 static const jlong VM_DEATH_BIT = (((jlong)1) << (JVMTI_EVENT_VM_DEATH - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 61 static const jlong CLASS_LOAD_BIT = (((jlong)1) << (JVMTI_EVENT_CLASS_LOAD - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 62 static const jlong CLASS_PREPARE_BIT = (((jlong)1) << (JVMTI_EVENT_CLASS_PREPARE - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 63 static const jlong THREAD_START_BIT = (((jlong)1) << (JVMTI_EVENT_THREAD_START - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 64 static const jlong THREAD_END_BIT = (((jlong)1) << (JVMTI_EVENT_THREAD_END - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 65 static const jlong EXCEPTION_THROW_BIT = (((jlong)1) << (JVMTI_EVENT_EXCEPTION - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 66 static const jlong EXCEPTION_CATCH_BIT = (((jlong)1) << (JVMTI_EVENT_EXCEPTION_CATCH - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 67 static const jlong MONITOR_CONTENDED_ENTER_BIT = (((jlong)1) << (JVMTI_EVENT_MONITOR_CONTENDED_ENTER - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 68 static const jlong MONITOR_CONTENDED_ENTERED_BIT = (((jlong)1) << (JVMTI_EVENT_MONITOR_CONTENDED_ENTERED - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 69 static const jlong MONITOR_WAIT_BIT = (((jlong)1) << (JVMTI_EVENT_MONITOR_WAIT - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 70 static const jlong MONITOR_WAITED_BIT = (((jlong)1) << (JVMTI_EVENT_MONITOR_WAITED - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 71 static const jlong DYNAMIC_CODE_GENERATED_BIT = (((jlong)1) << (JVMTI_EVENT_DYNAMIC_CODE_GENERATED - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 72 static const jlong DATA_DUMP_BIT = (((jlong)1) << (JVMTI_EVENT_DATA_DUMP_REQUEST - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 73 static const jlong COMPILED_METHOD_LOAD_BIT = (((jlong)1) << (JVMTI_EVENT_COMPILED_METHOD_LOAD - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 74 static const jlong COMPILED_METHOD_UNLOAD_BIT = (((jlong)1) << (JVMTI_EVENT_COMPILED_METHOD_UNLOAD - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 75 static const jlong GARBAGE_COLLECTION_START_BIT = (((jlong)1) << (JVMTI_EVENT_GARBAGE_COLLECTION_START - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 76 static const jlong GARBAGE_COLLECTION_FINISH_BIT = (((jlong)1) << (JVMTI_EVENT_GARBAGE_COLLECTION_FINISH - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 77 static const jlong OBJECT_FREE_BIT = (((jlong)1) << (JVMTI_EVENT_OBJECT_FREE - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 78 static const jlong RESOURCE_EXHAUSTED_BIT = (((jlong)1) << (JVMTI_EVENT_RESOURCE_EXHAUSTED - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 79 static const jlong VM_OBJECT_ALLOC_BIT = (((jlong)1) << (JVMTI_EVENT_VM_OBJECT_ALLOC - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 80 | |
| 81 // bits for extension events | |
| 82 static const jlong CLASS_UNLOAD_BIT = (((jlong)1) << (EXT_EVENT_CLASS_UNLOAD - TOTAL_MIN_EVENT_TYPE_VAL)); | |
| 83 | |
| 84 | |
| 85 static const jlong MONITOR_BITS = MONITOR_CONTENDED_ENTER_BIT | MONITOR_CONTENDED_ENTERED_BIT | | |
| 86 MONITOR_WAIT_BIT | MONITOR_WAITED_BIT; | |
| 87 static const jlong EXCEPTION_BITS = EXCEPTION_THROW_BIT | EXCEPTION_CATCH_BIT; | |
| 88 static const jlong INTERP_EVENT_BITS = SINGLE_STEP_BIT | METHOD_ENTRY_BIT | METHOD_EXIT_BIT | | |
| 89 FRAME_POP_BIT | FIELD_ACCESS_BIT | FIELD_MODIFICATION_BIT; | |
| 90 static const jlong THREAD_FILTERED_EVENT_BITS = INTERP_EVENT_BITS | EXCEPTION_BITS | MONITOR_BITS | | |
| 91 BREAKPOINT_BIT | CLASS_LOAD_BIT | CLASS_PREPARE_BIT | THREAD_END_BIT; | |
| 92 static const jlong NEED_THREAD_LIFE_EVENTS = THREAD_FILTERED_EVENT_BITS | THREAD_START_BIT; | |
| 93 static const jlong EARLY_EVENT_BITS = CLASS_FILE_LOAD_HOOK_BIT | | |
| 94 VM_START_BIT | VM_INIT_BIT | VM_DEATH_BIT | NATIVE_METHOD_BIND_BIT | | |
| 95 THREAD_START_BIT | THREAD_END_BIT | | |
| 96 DYNAMIC_CODE_GENERATED_BIT; | |
| 97 static const jlong GLOBAL_EVENT_BITS = ~THREAD_FILTERED_EVENT_BITS; | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
98 static const jlong SHOULD_POST_ON_EXCEPTIONS_BITS = EXCEPTION_BITS | METHOD_EXIT_BIT | FRAME_POP_BIT; |
| 0 | 99 |
| 100 /////////////////////////////////////////////////////////////// | |
| 101 // | |
| 102 // JvmtiEventEnabled | |
| 103 // | |
| 104 | |
| 105 JvmtiEventEnabled::JvmtiEventEnabled() { | |
| 106 clear(); | |
| 107 } | |
| 108 | |
| 109 | |
| 110 void JvmtiEventEnabled::clear() { | |
| 111 _enabled_bits = 0; | |
| 112 #ifndef PRODUCT | |
| 113 _init_guard = JEE_INIT_GUARD; | |
| 114 #endif | |
| 115 } | |
| 116 | |
| 117 void JvmtiEventEnabled::set_enabled(jvmtiEvent event_type, bool enabled) { | |
| 118 jlong bits = get_bits(); | |
| 119 jlong mask = bit_for(event_type); | |
| 120 if (enabled) { | |
| 121 bits |= mask; | |
| 122 } else { | |
| 123 bits &= ~mask; | |
| 124 } | |
| 125 set_bits(bits); | |
| 126 } | |
| 127 | |
| 128 | |
| 129 /////////////////////////////////////////////////////////////// | |
| 130 // | |
| 131 // JvmtiEnvThreadEventEnable | |
| 132 // | |
| 133 | |
| 134 JvmtiEnvThreadEventEnable::JvmtiEnvThreadEventEnable() { | |
| 135 _event_user_enabled.clear(); | |
| 136 _event_enabled.clear(); | |
| 137 } | |
| 138 | |
| 139 | |
| 140 JvmtiEnvThreadEventEnable::~JvmtiEnvThreadEventEnable() { | |
| 141 _event_user_enabled.clear(); | |
| 142 _event_enabled.clear(); | |
| 143 } | |
| 144 | |
| 145 | |
| 146 /////////////////////////////////////////////////////////////// | |
| 147 // | |
| 148 // JvmtiThreadEventEnable | |
| 149 // | |
| 150 | |
| 151 JvmtiThreadEventEnable::JvmtiThreadEventEnable() { | |
| 152 _event_enabled.clear(); | |
| 153 } | |
| 154 | |
| 155 | |
| 156 JvmtiThreadEventEnable::~JvmtiThreadEventEnable() { | |
| 157 _event_enabled.clear(); | |
| 158 } | |
| 159 | |
| 160 | |
| 161 /////////////////////////////////////////////////////////////// | |
| 162 // | |
| 163 // JvmtiEnvEventEnable | |
| 164 // | |
| 165 | |
| 166 JvmtiEnvEventEnable::JvmtiEnvEventEnable() { | |
| 167 _event_user_enabled.clear(); | |
| 168 _event_callback_enabled.clear(); | |
| 169 _event_enabled.clear(); | |
| 170 } | |
| 171 | |
| 172 | |
| 173 JvmtiEnvEventEnable::~JvmtiEnvEventEnable() { | |
| 174 _event_user_enabled.clear(); | |
| 175 _event_callback_enabled.clear(); | |
| 176 _event_enabled.clear(); | |
| 177 } | |
| 178 | |
| 179 | |
| 180 /////////////////////////////////////////////////////////////// | |
| 181 // | |
| 182 // VM_EnterInterpOnlyMode | |
| 183 // | |
| 184 | |
| 185 class VM_EnterInterpOnlyMode : public VM_Operation { | |
| 186 private: | |
| 187 JvmtiThreadState *_state; | |
| 188 | |
| 189 public: | |
| 190 VM_EnterInterpOnlyMode(JvmtiThreadState *state); | |
| 191 | |
| 192 bool allow_nested_vm_operations() const { return true; } | |
| 193 VMOp_Type type() const { return VMOp_EnterInterpOnlyMode; } | |
| 194 void doit(); | |
| 195 | |
| 196 // to do: this same function is in jvmtiImpl - should be in one place | |
| 197 bool can_be_deoptimized(vframe* vf) { | |
| 198 return (vf->is_compiled_frame() && vf->fr().can_be_deoptimized()); | |
| 199 } | |
| 200 }; | |
| 201 | |
| 202 VM_EnterInterpOnlyMode::VM_EnterInterpOnlyMode(JvmtiThreadState *state) | |
| 203 : _state(state) | |
| 204 { | |
| 205 } | |
| 206 | |
| 207 | |
| 208 void VM_EnterInterpOnlyMode::doit() { | |
| 209 // Set up the current stack depth for later tracking | |
| 210 _state->invalidate_cur_stack_depth(); | |
| 211 | |
| 212 _state->enter_interp_only_mode(); | |
| 213 | |
| 214 JavaThread *thread = _state->get_thread(); | |
| 215 if (thread->has_last_Java_frame()) { | |
| 216 // If running in fullspeed mode, single stepping is implemented | |
| 217 // as follows: first, the interpreter does not dispatch to | |
| 218 // compiled code for threads that have single stepping enabled; | |
| 219 // second, we deoptimize all methods on the thread's stack when | |
| 220 // interpreted-only mode is enabled the first time for a given | |
| 221 // thread (nothing to do if no Java frames yet). | |
| 222 int num_marked = 0; | |
| 223 ResourceMark resMark; | |
| 224 RegisterMap rm(thread, false); | |
| 225 for (vframe* vf = thread->last_java_vframe(&rm); vf; vf = vf->sender()) { | |
| 226 if (can_be_deoptimized(vf)) { | |
| 227 ((compiledVFrame*) vf)->code()->mark_for_deoptimization(); | |
| 228 ++num_marked; | |
| 229 } | |
| 230 } | |
| 231 if (num_marked > 0) { | |
| 232 VM_Deoptimize op; | |
| 233 VMThread::execute(&op); | |
| 234 } | |
| 235 } | |
| 236 } | |
| 237 | |
| 238 | |
| 239 /////////////////////////////////////////////////////////////// | |
| 240 // | |
| 241 // VM_ChangeSingleStep | |
| 242 // | |
| 243 | |
| 244 class VM_ChangeSingleStep : public VM_Operation { | |
| 245 private: | |
| 246 bool _on; | |
| 247 | |
| 248 public: | |
| 249 VM_ChangeSingleStep(bool on); | |
| 250 VMOp_Type type() const { return VMOp_ChangeSingleStep; } | |
| 251 bool allow_nested_vm_operations() const { return true; } | |
| 252 void doit(); // method definition is after definition of JvmtiEventControllerPrivate because of scoping | |
| 253 }; | |
| 254 | |
| 255 | |
| 256 VM_ChangeSingleStep::VM_ChangeSingleStep(bool on) | |
| 257 : _on(on != 0) | |
| 258 { | |
| 259 } | |
| 260 | |
| 261 | |
| 262 | |
| 263 | |
| 264 /////////////////////////////////////////////////////////////// | |
| 265 // | |
| 266 // JvmtiEventControllerPrivate | |
| 267 // | |
| 268 // Private internal implementation methods for JvmtiEventController. | |
| 269 // | |
| 270 // These methods are thread safe either because they are called | |
| 271 // in early VM initialization which is single threaded, or they | |
| 272 // hold the JvmtiThreadState_lock. | |
| 273 // | |
| 274 | |
| 275 class JvmtiEventControllerPrivate : public AllStatic { | |
| 276 static bool _initialized; | |
| 277 public: | |
| 278 static void set_should_post_single_step(bool on); | |
| 279 static void enter_interp_only_mode(JvmtiThreadState *state); | |
| 280 static void leave_interp_only_mode(JvmtiThreadState *state); | |
| 281 static void recompute_enabled(); | |
| 282 static jlong recompute_env_enabled(JvmtiEnvBase* env); | |
| 283 static jlong recompute_env_thread_enabled(JvmtiEnvThreadState* ets, JvmtiThreadState* state); | |
| 284 static jlong recompute_thread_enabled(JvmtiThreadState *state); | |
| 285 static void event_init(); | |
| 286 | |
| 287 static void set_user_enabled(JvmtiEnvBase *env, JavaThread *thread, | |
| 288 jvmtiEvent event_type, bool enabled); | |
| 289 static void set_event_callbacks(JvmtiEnvBase *env, | |
| 290 const jvmtiEventCallbacks* callbacks, | |
| 291 jint size_of_callbacks); | |
| 292 | |
| 293 static void set_extension_event_callback(JvmtiEnvBase *env, | |
| 294 jint extension_event_index, | |
| 295 jvmtiExtensionEvent callback); | |
| 296 | |
| 297 static void set_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop); | |
| 298 static void clear_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop); | |
| 299 static void clear_to_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop); | |
| 300 static void change_field_watch(jvmtiEvent event_type, bool added); | |
| 301 | |
| 302 static void thread_started(JavaThread *thread); | |
| 303 static void thread_ended(JavaThread *thread); | |
| 304 | |
| 305 static void env_initialize(JvmtiEnvBase *env); | |
| 306 static void env_dispose(JvmtiEnvBase *env); | |
| 307 | |
| 308 static void vm_start(); | |
| 309 static void vm_init(); | |
| 310 static void vm_death(); | |
| 311 | |
| 312 static void trace_changed(JvmtiThreadState *state, jlong now_enabled, jlong changed); | |
| 313 static void trace_changed(jlong now_enabled, jlong changed); | |
| 314 }; | |
| 315 | |
| 316 bool JvmtiEventControllerPrivate::_initialized = false; | |
| 317 | |
| 318 void JvmtiEventControllerPrivate::set_should_post_single_step(bool on) { | |
| 319 // we have permission to do this, VM op doesn't | |
| 320 JvmtiExport::set_should_post_single_step(on); | |
| 321 } | |
| 322 | |
| 323 | |
| 324 // This change must always be occur when at a safepoint. | |
| 325 // Being at a safepoint causes the interpreter to use the | |
| 326 // safepoint dispatch table which we overload to find single | |
| 327 // step points. Just to be sure that it has been set, we | |
| 328 // call notice_safepoints when turning on single stepping. | |
| 329 // When we leave our current safepoint, should_post_single_step | |
| 330 // will be checked by the interpreter, and the table kept | |
| 331 // or changed accordingly. | |
| 332 void VM_ChangeSingleStep::doit() { | |
| 333 JvmtiEventControllerPrivate::set_should_post_single_step(_on); | |
| 334 if (_on) { | |
| 335 Interpreter::notice_safepoints(); | |
| 336 } | |
| 337 } | |
| 338 | |
| 339 | |
| 340 void JvmtiEventControllerPrivate::enter_interp_only_mode(JvmtiThreadState *state) { | |
| 341 EC_TRACE(("JVMTI [%s] # Entering interpreter only mode", | |
| 342 JvmtiTrace::safe_get_thread_name(state->get_thread()))); | |
| 343 | |
| 344 VM_EnterInterpOnlyMode op(state); | |
| 345 VMThread::execute(&op); | |
| 346 } | |
| 347 | |
| 348 | |
| 349 void | |
| 350 JvmtiEventControllerPrivate::leave_interp_only_mode(JvmtiThreadState *state) { | |
| 351 EC_TRACE(("JVMTI [%s] # Leaving interpreter only mode", | |
| 352 JvmtiTrace::safe_get_thread_name(state->get_thread()))); | |
| 353 state->leave_interp_only_mode(); | |
| 354 } | |
| 355 | |
| 356 | |
| 357 void | |
| 358 JvmtiEventControllerPrivate::trace_changed(JvmtiThreadState *state, jlong now_enabled, jlong changed) { | |
| 359 #ifdef JVMTI_TRACE | |
| 360 if (JvmtiTrace::trace_event_controller()) { | |
| 361 SafeResourceMark rm; | |
| 362 // traces standard events only | |
| 363 for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) { | |
| 364 jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei); | |
| 365 if (changed & bit) { | |
| 366 // it changed, print it | |
| 367 tty->print_cr("JVMTI [%s] # %s event %s", | |
| 368 JvmtiTrace::safe_get_thread_name(state->get_thread()), | |
| 369 (now_enabled & bit)? "Enabling" : "Disabling", JvmtiTrace::event_name((jvmtiEvent)ei)); | |
| 370 } | |
| 371 } | |
| 372 } | |
| 373 #endif /*JVMTI_TRACE */ | |
| 374 } | |
| 375 | |
| 376 | |
| 377 void | |
| 378 JvmtiEventControllerPrivate::trace_changed(jlong now_enabled, jlong changed) { | |
| 379 #ifdef JVMTI_TRACE | |
| 380 if (JvmtiTrace::trace_event_controller()) { | |
| 381 SafeResourceMark rm; | |
| 382 // traces standard events only | |
| 383 for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) { | |
| 384 jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei); | |
| 385 if (changed & bit) { | |
| 386 // it changed, print it | |
| 387 tty->print_cr("JVMTI [-] # %s event %s", | |
| 388 (now_enabled & bit)? "Enabling" : "Disabling", JvmtiTrace::event_name((jvmtiEvent)ei)); | |
| 389 } | |
| 390 } | |
| 391 } | |
| 392 #endif /*JVMTI_TRACE */ | |
| 393 } | |
| 394 | |
| 395 | |
| 396 // For the specified env: compute the currently truly enabled events | |
| 397 // set external state accordingly. | |
| 398 // Return value and set value must include all events. | |
| 399 // But outside this class, only non-thread-filtered events can be queried.. | |
| 400 jlong | |
| 401 JvmtiEventControllerPrivate::recompute_env_enabled(JvmtiEnvBase* env) { | |
| 402 jlong was_enabled = env->env_event_enable()->_event_enabled.get_bits(); | |
| 403 jlong now_enabled = | |
| 404 env->env_event_enable()->_event_callback_enabled.get_bits() & | |
| 405 env->env_event_enable()->_event_user_enabled.get_bits(); | |
| 406 | |
| 407 switch (JvmtiEnv::get_phase()) { | |
| 408 case JVMTI_PHASE_PRIMORDIAL: | |
| 409 case JVMTI_PHASE_ONLOAD: | |
| 410 // only these events allowed in primordial or onload phase | |
| 411 now_enabled &= (EARLY_EVENT_BITS & ~THREAD_FILTERED_EVENT_BITS); | |
| 412 break; | |
| 413 case JVMTI_PHASE_START: | |
| 414 // only these events allowed in start phase | |
| 415 now_enabled &= EARLY_EVENT_BITS; | |
| 416 break; | |
| 417 case JVMTI_PHASE_LIVE: | |
| 418 // all events allowed during live phase | |
| 419 break; | |
| 420 case JVMTI_PHASE_DEAD: | |
| 421 // no events allowed when dead | |
| 422 now_enabled = 0; | |
| 423 break; | |
| 424 default: | |
| 425 assert(false, "no other phases - sanity check"); | |
| 426 break; | |
| 427 } | |
| 428 | |
| 429 // will we really send these events to this env | |
| 430 env->env_event_enable()->_event_enabled.set_bits(now_enabled); | |
| 431 | |
| 432 trace_changed(now_enabled, (now_enabled ^ was_enabled) & ~THREAD_FILTERED_EVENT_BITS); | |
| 433 | |
| 434 return now_enabled; | |
| 435 } | |
| 436 | |
| 437 | |
| 438 // For the specified env and thread: compute the currently truly enabled events | |
| 439 // set external state accordingly. Only thread-filtered events are included. | |
| 440 jlong | |
| 441 JvmtiEventControllerPrivate::recompute_env_thread_enabled(JvmtiEnvThreadState* ets, JvmtiThreadState* state) { | |
| 442 JvmtiEnv *env = ets->get_env(); | |
| 443 | |
| 444 jlong was_enabled = ets->event_enable()->_event_enabled.get_bits(); | |
| 445 jlong now_enabled = THREAD_FILTERED_EVENT_BITS & | |
| 446 env->env_event_enable()->_event_callback_enabled.get_bits() & | |
| 447 (env->env_event_enable()->_event_user_enabled.get_bits() | | |
| 448 ets->event_enable()->_event_user_enabled.get_bits()); | |
| 449 | |
| 450 // for frame pops and field watchs, computed enabled state | |
| 451 // is only true if an event has been requested | |
| 452 if (!ets->has_frame_pops()) { | |
| 453 now_enabled &= ~FRAME_POP_BIT; | |
| 454 } | |
| 455 if (*((int *)JvmtiExport::get_field_access_count_addr()) == 0) { | |
| 456 now_enabled &= ~FIELD_ACCESS_BIT; | |
| 457 } | |
| 458 if (*((int *)JvmtiExport::get_field_modification_count_addr()) == 0) { | |
| 459 now_enabled &= ~FIELD_MODIFICATION_BIT; | |
| 460 } | |
| 461 | |
| 462 switch (JvmtiEnv::get_phase()) { | |
| 463 case JVMTI_PHASE_DEAD: | |
| 464 // no events allowed when dead | |
| 465 now_enabled = 0; | |
| 466 break; | |
| 467 } | |
| 468 | |
| 469 // if anything changed do update | |
| 470 if (now_enabled != was_enabled) { | |
| 471 | |
| 472 // will we really send these events to this thread x env | |
| 473 ets->event_enable()->_event_enabled.set_bits(now_enabled); | |
| 474 | |
| 475 // If the enabled status of the single step or breakpoint events changed, | |
| 476 // the location status may need to change as well. | |
| 477 jlong changed = now_enabled ^ was_enabled; | |
| 478 if (changed & SINGLE_STEP_BIT) { | |
| 479 ets->reset_current_location(JVMTI_EVENT_SINGLE_STEP, (now_enabled & SINGLE_STEP_BIT) != 0); | |
| 480 } | |
| 481 if (changed & BREAKPOINT_BIT) { | |
| 482 ets->reset_current_location(JVMTI_EVENT_BREAKPOINT, (now_enabled & BREAKPOINT_BIT) != 0); | |
| 483 } | |
| 484 trace_changed(state, now_enabled, changed); | |
| 485 } | |
| 486 return now_enabled; | |
| 487 } | |
| 488 | |
| 489 | |
| 490 // For the specified thread: compute the currently truly enabled events | |
| 491 // set external state accordingly. Only thread-filtered events are included. | |
| 492 jlong | |
| 493 JvmtiEventControllerPrivate::recompute_thread_enabled(JvmtiThreadState *state) { | |
|
609
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
0
diff
changeset
|
494 if (state == NULL) { |
|
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
0
diff
changeset
|
495 // associated JavaThread is exiting |
|
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
0
diff
changeset
|
496 return (jlong)0; |
|
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
0
diff
changeset
|
497 } |
|
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
0
diff
changeset
|
498 |
| 0 | 499 jlong was_any_env_enabled = state->thread_event_enable()->_event_enabled.get_bits(); |
| 500 jlong any_env_enabled = 0; | |
| 501 | |
| 502 { | |
| 503 // This iteration will include JvmtiEnvThreadStates whoses environments | |
| 504 // have been disposed. These JvmtiEnvThreadStates must not be filtered | |
| 505 // as recompute must be called on them to disable their events, | |
| 506 JvmtiEnvThreadStateIterator it(state); | |
| 507 for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { | |
| 508 any_env_enabled |= recompute_env_thread_enabled(ets, state); | |
| 509 } | |
| 510 } | |
| 511 | |
| 512 if (any_env_enabled != was_any_env_enabled) { | |
| 513 // mark if event is truly enabled on this thread in any environment | |
| 514 state->thread_event_enable()->_event_enabled.set_bits(any_env_enabled); | |
| 515 | |
| 516 // compute interp_only mode | |
| 517 bool should_be_interp = (any_env_enabled & INTERP_EVENT_BITS) != 0; | |
| 518 bool is_now_interp = state->is_interp_only_mode(); | |
| 519 | |
| 520 if (should_be_interp != is_now_interp) { | |
| 521 if (should_be_interp) { | |
| 522 enter_interp_only_mode(state); | |
| 523 } else { | |
| 524 leave_interp_only_mode(state); | |
| 525 } | |
| 526 } | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
527 |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
528 // update the JavaThread cached value for thread-specific should_post_on_exceptions value |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
529 bool should_post_on_exceptions = (any_env_enabled & SHOULD_POST_ON_EXCEPTIONS_BITS) != 0; |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
530 state->set_should_post_on_exceptions(should_post_on_exceptions); |
| 0 | 531 } |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
532 |
| 0 | 533 return any_env_enabled; |
| 534 } | |
| 535 | |
| 536 | |
| 537 // Compute truly enabled events - meaning if the event can and could be | |
| 538 // sent. An event is truly enabled if it is user enabled on the thread | |
| 539 // or globally user enabled, but only if there is a callback or event hook | |
| 540 // for it and, for field watch and frame pop, one has been set. | |
| 541 // Compute if truly enabled, per thread, per environment, per combination | |
| 542 // (thread x environment), and overall. These merges are true if any is true. | |
| 543 // True per thread if some environment has callback set and the event is globally | |
| 544 // enabled or enabled for this thread. | |
| 545 // True per environment if the callback is set and the event is globally | |
| 546 // enabled in this environment or enabled for any thread in this environment. | |
| 547 // True per combination if the environment has the callback set and the | |
| 548 // event is globally enabled in this environment or the event is enabled | |
| 549 // for this thread and environment. | |
| 550 // | |
| 551 // All states transitions dependent on these transitions are also handled here. | |
| 552 void | |
| 553 JvmtiEventControllerPrivate::recompute_enabled() { | |
| 554 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 555 | |
| 556 // event enabled for any thread in any environment | |
| 557 jlong was_any_env_thread_enabled = JvmtiEventController::_universal_global_event_enabled.get_bits(); | |
| 558 jlong any_env_thread_enabled = 0; | |
| 559 | |
| 560 EC_TRACE(("JVMTI [-] # recompute enabled - before %llx", was_any_env_thread_enabled)); | |
| 561 | |
| 562 // compute non-thread-filters events. | |
| 563 // This must be done separately from thread-filtered events, since some | |
| 564 // events can occur before any threads exist. | |
| 565 JvmtiEnvIterator it; | |
| 566 for (JvmtiEnvBase* env = it.first(); env != NULL; env = it.next(env)) { | |
| 567 any_env_thread_enabled |= recompute_env_enabled(env); | |
| 568 } | |
| 569 | |
| 570 // We need to create any missing jvmti_thread_state if there are globally set thread | |
| 571 // filtered events and there weren't last time | |
| 572 if ( (any_env_thread_enabled & THREAD_FILTERED_EVENT_BITS) != 0 && | |
| 573 (was_any_env_thread_enabled & THREAD_FILTERED_EVENT_BITS) == 0) { | |
| 574 assert(JvmtiEnv::is_vm_live() || (JvmtiEnv::get_phase()==JVMTI_PHASE_START), | |
| 575 "thread filtered events should not be enabled when VM not in start or live phase"); | |
| 576 { | |
| 577 MutexLocker mu(Threads_lock); //hold the Threads_lock for the iteration | |
| 578 for (JavaThread *tp = Threads::first(); tp != NULL; tp = tp->next()) { | |
|
609
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
0
diff
changeset
|
579 // state_for_while_locked() makes tp->is_exiting() check |
| 0 | 580 JvmtiThreadState::state_for_while_locked(tp); // create the thread state if missing |
| 581 } | |
| 582 }// release Threads_lock | |
| 583 } | |
| 584 | |
| 585 // compute and set thread-filtered events | |
| 586 for (JvmtiThreadState *state = JvmtiThreadState::first(); state != NULL; state = state->next()) { | |
| 587 any_env_thread_enabled |= recompute_thread_enabled(state); | |
| 588 } | |
| 589 | |
| 590 // set universal state (across all envs and threads) | |
| 591 jlong delta = any_env_thread_enabled ^ was_any_env_thread_enabled; | |
| 592 if (delta != 0) { | |
| 593 JvmtiExport::set_should_post_field_access((any_env_thread_enabled & FIELD_ACCESS_BIT) != 0); | |
| 594 JvmtiExport::set_should_post_field_modification((any_env_thread_enabled & FIELD_MODIFICATION_BIT) != 0); | |
| 595 JvmtiExport::set_should_post_class_load((any_env_thread_enabled & CLASS_LOAD_BIT) != 0); | |
| 596 JvmtiExport::set_should_post_class_file_load_hook((any_env_thread_enabled & CLASS_FILE_LOAD_HOOK_BIT) != 0); | |
| 597 JvmtiExport::set_should_post_native_method_bind((any_env_thread_enabled & NATIVE_METHOD_BIND_BIT) != 0); | |
| 598 JvmtiExport::set_should_post_dynamic_code_generated((any_env_thread_enabled & DYNAMIC_CODE_GENERATED_BIT) != 0); | |
| 599 JvmtiExport::set_should_post_data_dump((any_env_thread_enabled & DATA_DUMP_BIT) != 0); | |
| 600 JvmtiExport::set_should_post_class_prepare((any_env_thread_enabled & CLASS_PREPARE_BIT) != 0); | |
| 601 JvmtiExport::set_should_post_class_unload((any_env_thread_enabled & CLASS_UNLOAD_BIT) != 0); | |
| 602 JvmtiExport::set_should_post_monitor_contended_enter((any_env_thread_enabled & MONITOR_CONTENDED_ENTER_BIT) != 0); | |
| 603 JvmtiExport::set_should_post_monitor_contended_entered((any_env_thread_enabled & MONITOR_CONTENDED_ENTERED_BIT) != 0); | |
| 604 JvmtiExport::set_should_post_monitor_wait((any_env_thread_enabled & MONITOR_WAIT_BIT) != 0); | |
| 605 JvmtiExport::set_should_post_monitor_waited((any_env_thread_enabled & MONITOR_WAITED_BIT) != 0); | |
| 606 JvmtiExport::set_should_post_garbage_collection_start((any_env_thread_enabled & GARBAGE_COLLECTION_START_BIT) != 0); | |
| 607 JvmtiExport::set_should_post_garbage_collection_finish((any_env_thread_enabled & GARBAGE_COLLECTION_FINISH_BIT) != 0); | |
| 608 JvmtiExport::set_should_post_object_free((any_env_thread_enabled & OBJECT_FREE_BIT) != 0); | |
| 609 JvmtiExport::set_should_post_resource_exhausted((any_env_thread_enabled & RESOURCE_EXHAUSTED_BIT) != 0); | |
| 610 JvmtiExport::set_should_post_compiled_method_load((any_env_thread_enabled & COMPILED_METHOD_LOAD_BIT) != 0); | |
| 611 JvmtiExport::set_should_post_compiled_method_unload((any_env_thread_enabled & COMPILED_METHOD_UNLOAD_BIT) != 0); | |
| 612 JvmtiExport::set_should_post_vm_object_alloc((any_env_thread_enabled & VM_OBJECT_ALLOC_BIT) != 0); | |
| 613 | |
| 614 // need this if we want thread events or we need them to init data | |
| 615 JvmtiExport::set_should_post_thread_life((any_env_thread_enabled & NEED_THREAD_LIFE_EVENTS) != 0); | |
| 616 | |
| 617 // If single stepping is turned on or off, execute the VM op to change it. | |
| 618 if (delta & SINGLE_STEP_BIT) { | |
| 619 switch (JvmtiEnv::get_phase()) { | |
| 620 case JVMTI_PHASE_DEAD: | |
| 621 // If the VM is dying we can't execute VM ops | |
| 622 break; | |
| 623 case JVMTI_PHASE_LIVE: { | |
| 624 VM_ChangeSingleStep op((any_env_thread_enabled & SINGLE_STEP_BIT) != 0); | |
| 625 VMThread::execute(&op); | |
| 626 break; | |
| 627 } | |
| 628 default: | |
| 629 assert(false, "should never come here before live phase"); | |
| 630 break; | |
| 631 } | |
| 632 } | |
| 633 | |
| 634 // set global truly enabled, that is, any thread in any environment | |
| 635 JvmtiEventController::_universal_global_event_enabled.set_bits(any_env_thread_enabled); | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
636 |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
637 // set global should_post_on_exceptions |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
638 JvmtiExport::set_should_post_on_exceptions((any_env_thread_enabled & SHOULD_POST_ON_EXCEPTIONS_BITS) != 0); |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
609
diff
changeset
|
639 |
| 0 | 640 } |
| 641 | |
| 642 EC_TRACE(("JVMTI [-] # recompute enabled - after %llx", any_env_thread_enabled)); | |
| 643 } | |
| 644 | |
| 645 | |
| 646 void | |
| 647 JvmtiEventControllerPrivate::thread_started(JavaThread *thread) { | |
| 648 assert(thread->is_Java_thread(), "Must be JavaThread"); | |
| 649 assert(thread == Thread::current(), "must be current thread"); | |
| 650 assert(JvmtiEnvBase::environments_might_exist(), "to enter event controller, JVM TI environments must exist"); | |
| 651 | |
| 652 EC_TRACE(("JVMTI [%s] # thread started", JvmtiTrace::safe_get_thread_name(thread))); | |
| 653 | |
| 654 // if we have any thread filtered events globally enabled, create/update the thread state | |
| 655 if ((JvmtiEventController::_universal_global_event_enabled.get_bits() & THREAD_FILTERED_EVENT_BITS) != 0) { | |
| 656 MutexLocker mu(JvmtiThreadState_lock); | |
| 657 // create the thread state if missing | |
| 658 JvmtiThreadState *state = JvmtiThreadState::state_for_while_locked(thread); | |
| 659 if (state != NULL) { // skip threads with no JVMTI thread state | |
| 660 recompute_thread_enabled(state); | |
| 661 } | |
| 662 } | |
| 663 } | |
| 664 | |
| 665 | |
| 666 void | |
| 667 JvmtiEventControllerPrivate::thread_ended(JavaThread *thread) { | |
| 668 // Removes the JvmtiThreadState associated with the specified thread. | |
| 669 // May be called after all environments have been disposed. | |
|
2126
db2b0f8c1cef
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
1972
diff
changeset
|
670 assert(JvmtiThreadState_lock->is_locked(), "sanity check"); |
| 0 | 671 |
| 672 EC_TRACE(("JVMTI [%s] # thread ended", JvmtiTrace::safe_get_thread_name(thread))); | |
| 673 | |
| 674 JvmtiThreadState *state = thread->jvmti_thread_state(); | |
|
2126
db2b0f8c1cef
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
1972
diff
changeset
|
675 assert(state != NULL, "else why are we here?"); |
|
db2b0f8c1cef
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
1972
diff
changeset
|
676 delete state; |
| 0 | 677 } |
| 678 | |
| 679 void JvmtiEventControllerPrivate::set_event_callbacks(JvmtiEnvBase *env, | |
| 680 const jvmtiEventCallbacks* callbacks, | |
| 681 jint size_of_callbacks) { | |
| 682 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 683 EC_TRACE(("JVMTI [*] # set event callbacks")); | |
| 684 | |
| 685 env->set_event_callbacks(callbacks, size_of_callbacks); | |
| 686 jlong enabled_bits = 0; | |
| 687 for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) { | |
| 688 jvmtiEvent evt_t = (jvmtiEvent)ei; | |
| 689 if (env->has_callback(evt_t)) { | |
| 690 enabled_bits |= JvmtiEventEnabled::bit_for(evt_t); | |
| 691 } | |
| 692 } | |
| 693 env->env_event_enable()->_event_callback_enabled.set_bits(enabled_bits); | |
| 694 recompute_enabled(); | |
| 695 } | |
| 696 | |
| 697 void | |
| 698 JvmtiEventControllerPrivate::set_extension_event_callback(JvmtiEnvBase *env, | |
| 699 jint extension_event_index, | |
| 700 jvmtiExtensionEvent callback) | |
| 701 { | |
| 702 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 703 EC_TRACE(("JVMTI [*] # set extension event callback")); | |
| 704 | |
| 705 // extension events are allocated below JVMTI_MIN_EVENT_TYPE_VAL | |
| 706 assert(extension_event_index >= (jint)EXT_MIN_EVENT_TYPE_VAL && | |
| 707 extension_event_index <= (jint)EXT_MAX_EVENT_TYPE_VAL, "sanity check"); | |
| 708 | |
| 709 | |
| 710 // As the bits for both standard (jvmtiEvent) and extension | |
| 711 // (jvmtiExtEvents) are stored in the same word we cast here to | |
| 712 // jvmtiEvent to set/clear the bit for this extension event. | |
| 713 jvmtiEvent event_type = (jvmtiEvent)extension_event_index; | |
| 714 | |
| 715 // Prevent a possible race condition where events are re-enabled by a call to | |
| 716 // set event callbacks, where the DisposeEnvironment occurs after the boiler-plate | |
| 717 // environment check and before the lock is acquired. | |
| 718 // We can safely do the is_valid check now, as JvmtiThreadState_lock is held. | |
| 719 bool enabling = (callback != NULL) && (env->is_valid()); | |
| 720 env->env_event_enable()->set_user_enabled(event_type, enabling); | |
| 721 | |
| 722 // update the callback | |
| 723 jvmtiExtEventCallbacks* ext_callbacks = env->ext_callbacks(); | |
| 724 switch (extension_event_index) { | |
| 725 case EXT_EVENT_CLASS_UNLOAD : | |
| 726 ext_callbacks->ClassUnload = callback; | |
| 727 break; | |
| 728 default: | |
| 729 ShouldNotReachHere(); | |
| 730 } | |
| 731 | |
| 732 // update the callback enable/disable bit | |
| 733 jlong enabled_bits = env->env_event_enable()->_event_callback_enabled.get_bits(); | |
| 734 jlong bit_for = JvmtiEventEnabled::bit_for(event_type); | |
| 735 if (enabling) { | |
| 736 enabled_bits |= bit_for; | |
| 737 } else { | |
| 738 enabled_bits &= ~bit_for; | |
| 739 } | |
| 740 env->env_event_enable()->_event_callback_enabled.set_bits(enabled_bits); | |
| 741 | |
| 742 recompute_enabled(); | |
| 743 } | |
| 744 | |
| 745 | |
| 746 void | |
| 747 JvmtiEventControllerPrivate::env_initialize(JvmtiEnvBase *env) { | |
| 748 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 749 EC_TRACE(("JVMTI [*] # env initialize")); | |
| 750 | |
| 751 if (JvmtiEnvBase::is_vm_live()) { | |
| 752 // if we didn't initialize event info already (this is a late | |
| 753 // launched environment), do it now. | |
| 754 event_init(); | |
| 755 } | |
| 756 | |
| 757 env->initialize(); | |
| 758 | |
| 759 // add the JvmtiEnvThreadState to each JvmtiThreadState | |
| 760 for (JvmtiThreadState *state = JvmtiThreadState::first(); state != NULL; state = state->next()) { | |
| 761 state->add_env(env); | |
| 762 assert((JvmtiEnv*)(state->env_thread_state(env)->get_env()) == env, "sanity check"); | |
| 763 } | |
| 764 JvmtiEventControllerPrivate::recompute_enabled(); | |
| 765 } | |
| 766 | |
| 767 | |
| 768 void | |
| 769 JvmtiEventControllerPrivate::env_dispose(JvmtiEnvBase *env) { | |
| 770 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 771 EC_TRACE(("JVMTI [*] # env dispose")); | |
| 772 | |
| 773 // Before the environment is marked disposed, disable all events on this | |
| 774 // environment (by zapping the callbacks). As a result, the disposed | |
| 775 // environment will not call event handlers. | |
| 776 set_event_callbacks(env, NULL, 0); | |
| 777 for (jint extension_event_index = EXT_MIN_EVENT_TYPE_VAL; | |
| 778 extension_event_index <= EXT_MAX_EVENT_TYPE_VAL; | |
| 779 ++extension_event_index) { | |
| 780 set_extension_event_callback(env, extension_event_index, NULL); | |
| 781 } | |
| 782 | |
| 783 // Let the environment finish disposing itself. | |
| 784 env->env_dispose(); | |
| 785 } | |
| 786 | |
| 787 | |
| 788 void | |
| 789 JvmtiEventControllerPrivate::set_user_enabled(JvmtiEnvBase *env, JavaThread *thread, | |
| 790 jvmtiEvent event_type, bool enabled) { | |
| 791 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 792 | |
| 793 EC_TRACE(("JVMTI [%s] # user %s event %s", | |
| 794 thread==NULL? "ALL": JvmtiTrace::safe_get_thread_name(thread), | |
| 795 enabled? "enabled" : "disabled", JvmtiTrace::event_name(event_type))); | |
| 796 | |
| 797 if (thread == NULL) { | |
| 798 env->env_event_enable()->set_user_enabled(event_type, enabled); | |
| 799 } else { | |
| 800 // create the thread state (if it didn't exist before) | |
| 801 JvmtiThreadState *state = JvmtiThreadState::state_for_while_locked(thread); | |
| 802 if (state != NULL) { | |
| 803 state->env_thread_state(env)->event_enable()->set_user_enabled(event_type, enabled); | |
| 804 } | |
| 805 } | |
| 806 recompute_enabled(); | |
| 807 } | |
| 808 | |
| 809 | |
| 810 void | |
| 811 JvmtiEventControllerPrivate::set_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) { | |
| 812 EC_TRACE(("JVMTI [%s] # set frame pop - frame=%d", | |
| 813 JvmtiTrace::safe_get_thread_name(ets->get_thread()), | |
| 814 fpop.frame_number() )); | |
| 815 | |
| 816 ets->get_frame_pops()->set(fpop); | |
| 817 recompute_thread_enabled(ets->get_thread()->jvmti_thread_state()); | |
| 818 } | |
| 819 | |
| 820 | |
| 821 void | |
| 822 JvmtiEventControllerPrivate::clear_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) { | |
| 823 EC_TRACE(("JVMTI [%s] # clear frame pop - frame=%d", | |
| 824 JvmtiTrace::safe_get_thread_name(ets->get_thread()), | |
| 825 fpop.frame_number() )); | |
| 826 | |
| 827 ets->get_frame_pops()->clear(fpop); | |
| 828 recompute_thread_enabled(ets->get_thread()->jvmti_thread_state()); | |
| 829 } | |
| 830 | |
| 831 | |
| 832 void | |
| 833 JvmtiEventControllerPrivate::clear_to_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) { | |
| 834 int cleared_cnt = ets->get_frame_pops()->clear_to(fpop); | |
| 835 | |
| 836 EC_TRACE(("JVMTI [%s] # clear to frame pop - frame=%d, count=%d", | |
| 837 JvmtiTrace::safe_get_thread_name(ets->get_thread()), | |
| 838 fpop.frame_number(), | |
| 839 cleared_cnt )); | |
| 840 | |
| 841 if (cleared_cnt > 0) { | |
| 842 recompute_thread_enabled(ets->get_thread()->jvmti_thread_state()); | |
| 843 } | |
| 844 } | |
| 845 | |
| 846 void | |
| 847 JvmtiEventControllerPrivate::change_field_watch(jvmtiEvent event_type, bool added) { | |
| 848 int *count_addr; | |
| 849 | |
| 850 switch (event_type) { | |
| 851 case JVMTI_EVENT_FIELD_MODIFICATION: | |
| 852 count_addr = (int *)JvmtiExport::get_field_modification_count_addr(); | |
| 853 break; | |
| 854 case JVMTI_EVENT_FIELD_ACCESS: | |
| 855 count_addr = (int *)JvmtiExport::get_field_access_count_addr(); | |
| 856 break; | |
| 857 default: | |
| 858 assert(false, "incorrect event"); | |
| 859 return; | |
| 860 } | |
| 861 | |
| 862 EC_TRACE(("JVMTI [-] # change field watch - %s %s count=%d", | |
| 863 event_type==JVMTI_EVENT_FIELD_MODIFICATION? "modification" : "access", | |
| 864 added? "add" : "remove", | |
| 865 *count_addr)); | |
| 866 | |
| 867 if (added) { | |
| 868 (*count_addr)++; | |
| 869 if (*count_addr == 1) { | |
| 870 recompute_enabled(); | |
| 871 } | |
| 872 } else { | |
| 873 if (*count_addr > 0) { | |
| 874 (*count_addr)--; | |
| 875 if (*count_addr == 0) { | |
| 876 recompute_enabled(); | |
| 877 } | |
| 878 } else { | |
| 879 assert(false, "field watch out of phase"); | |
| 880 } | |
| 881 } | |
| 882 } | |
| 883 | |
| 884 void | |
| 885 JvmtiEventControllerPrivate::event_init() { | |
| 886 assert(JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 887 | |
| 888 if (_initialized) { | |
| 889 return; | |
| 890 } | |
| 891 | |
| 892 EC_TRACE(("JVMTI [-] # VM live")); | |
| 893 | |
| 894 #ifdef ASSERT | |
| 895 // check that our idea and the spec's idea of threaded events match | |
| 896 for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) { | |
| 897 jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei); | |
| 898 assert(((THREAD_FILTERED_EVENT_BITS & bit) != 0) == JvmtiUtil::event_threaded(ei), | |
| 899 "thread filtered event list does not match"); | |
| 900 } | |
| 901 #endif | |
| 902 | |
| 903 _initialized = true; | |
| 904 } | |
| 905 | |
| 906 void | |
| 907 JvmtiEventControllerPrivate::vm_start() { | |
| 908 // some events are now able to be enabled (phase has changed) | |
| 909 JvmtiEventControllerPrivate::recompute_enabled(); | |
| 910 } | |
| 911 | |
| 912 | |
| 913 void | |
| 914 JvmtiEventControllerPrivate::vm_init() { | |
| 915 event_init(); | |
| 916 | |
| 917 // all the events are now able to be enabled (phase has changed) | |
| 918 JvmtiEventControllerPrivate::recompute_enabled(); | |
| 919 } | |
| 920 | |
| 921 | |
| 922 void | |
| 923 JvmtiEventControllerPrivate::vm_death() { | |
| 924 // events are disabled (phase has changed) | |
| 925 JvmtiEventControllerPrivate::recompute_enabled(); | |
| 926 } | |
| 927 | |
| 928 | |
| 929 /////////////////////////////////////////////////////////////// | |
| 930 // | |
| 931 // JvmtiEventController | |
| 932 // | |
| 933 | |
| 934 JvmtiEventEnabled JvmtiEventController::_universal_global_event_enabled; | |
| 935 | |
| 936 bool | |
| 937 JvmtiEventController::is_global_event(jvmtiEvent event_type) { | |
| 938 assert(is_valid_event_type(event_type), "invalid event type"); | |
| 939 jlong bit_for = ((jlong)1) << (event_type - TOTAL_MIN_EVENT_TYPE_VAL); | |
| 940 return((bit_for & GLOBAL_EVENT_BITS)!=0); | |
| 941 } | |
| 942 | |
| 943 void | |
| 944 JvmtiEventController::set_user_enabled(JvmtiEnvBase *env, JavaThread *thread, jvmtiEvent event_type, bool enabled) { | |
| 945 if (Threads::number_of_threads() == 0) { | |
| 946 // during early VM start-up locks don't exist, but we are safely single threaded, | |
| 947 // call the functionality without holding the JvmtiThreadState_lock. | |
| 948 JvmtiEventControllerPrivate::set_user_enabled(env, thread, event_type, enabled); | |
| 949 } else { | |
| 950 MutexLocker mu(JvmtiThreadState_lock); | |
| 951 JvmtiEventControllerPrivate::set_user_enabled(env, thread, event_type, enabled); | |
| 952 } | |
| 953 } | |
| 954 | |
| 955 | |
| 956 void | |
| 957 JvmtiEventController::set_event_callbacks(JvmtiEnvBase *env, | |
| 958 const jvmtiEventCallbacks* callbacks, | |
| 959 jint size_of_callbacks) { | |
| 960 if (Threads::number_of_threads() == 0) { | |
| 961 // during early VM start-up locks don't exist, but we are safely single threaded, | |
| 962 // call the functionality without holding the JvmtiThreadState_lock. | |
| 963 JvmtiEventControllerPrivate::set_event_callbacks(env, callbacks, size_of_callbacks); | |
| 964 } else { | |
| 965 MutexLocker mu(JvmtiThreadState_lock); | |
| 966 JvmtiEventControllerPrivate::set_event_callbacks(env, callbacks, size_of_callbacks); | |
| 967 } | |
| 968 } | |
| 969 | |
| 970 void | |
| 971 JvmtiEventController::set_extension_event_callback(JvmtiEnvBase *env, | |
| 972 jint extension_event_index, | |
| 973 jvmtiExtensionEvent callback) { | |
| 974 if (Threads::number_of_threads() == 0) { | |
| 975 JvmtiEventControllerPrivate::set_extension_event_callback(env, extension_event_index, callback); | |
| 976 } else { | |
| 977 MutexLocker mu(JvmtiThreadState_lock); | |
| 978 JvmtiEventControllerPrivate::set_extension_event_callback(env, extension_event_index, callback); | |
| 979 } | |
| 980 } | |
| 981 | |
| 982 | |
| 983 | |
| 984 | |
| 985 void | |
| 986 JvmtiEventController::set_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) { | |
| 987 MutexLocker mu(JvmtiThreadState_lock); | |
| 988 JvmtiEventControllerPrivate::set_frame_pop(ets, fpop); | |
| 989 } | |
| 990 | |
| 991 | |
| 992 void | |
| 993 JvmtiEventController::clear_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) { | |
| 994 MutexLocker mu(JvmtiThreadState_lock); | |
| 995 JvmtiEventControllerPrivate::clear_frame_pop(ets, fpop); | |
| 996 } | |
| 997 | |
| 998 | |
| 999 void | |
| 1000 JvmtiEventController::clear_to_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) { | |
| 1001 MutexLocker mu(JvmtiThreadState_lock); | |
| 1002 JvmtiEventControllerPrivate::clear_to_frame_pop(ets, fpop); | |
| 1003 } | |
| 1004 | |
| 1005 void | |
| 1006 JvmtiEventController::change_field_watch(jvmtiEvent event_type, bool added) { | |
| 1007 MutexLocker mu(JvmtiThreadState_lock); | |
| 1008 JvmtiEventControllerPrivate::change_field_watch(event_type, added); | |
| 1009 } | |
| 1010 | |
| 1011 void | |
| 1012 JvmtiEventController::thread_started(JavaThread *thread) { | |
| 1013 // operates only on the current thread | |
| 1014 // JvmtiThreadState_lock grabbed only if needed. | |
| 1015 JvmtiEventControllerPrivate::thread_started(thread); | |
| 1016 } | |
| 1017 | |
| 1018 void | |
| 1019 JvmtiEventController::thread_ended(JavaThread *thread) { | |
| 1020 // operates only on the current thread | |
| 1021 // JvmtiThreadState_lock grabbed only if needed. | |
| 1022 JvmtiEventControllerPrivate::thread_ended(thread); | |
| 1023 } | |
| 1024 | |
| 1025 void | |
| 1026 JvmtiEventController::env_initialize(JvmtiEnvBase *env) { | |
| 1027 if (Threads::number_of_threads() == 0) { | |
| 1028 // during early VM start-up locks don't exist, but we are safely single threaded, | |
| 1029 // call the functionality without holding the JvmtiThreadState_lock. | |
| 1030 JvmtiEventControllerPrivate::env_initialize(env); | |
| 1031 } else { | |
| 1032 MutexLocker mu(JvmtiThreadState_lock); | |
| 1033 JvmtiEventControllerPrivate::env_initialize(env); | |
| 1034 } | |
| 1035 } | |
| 1036 | |
| 1037 void | |
| 1038 JvmtiEventController::env_dispose(JvmtiEnvBase *env) { | |
| 1039 if (Threads::number_of_threads() == 0) { | |
| 1040 // during early VM start-up locks don't exist, but we are safely single threaded, | |
| 1041 // call the functionality without holding the JvmtiThreadState_lock. | |
| 1042 JvmtiEventControllerPrivate::env_dispose(env); | |
| 1043 } else { | |
| 1044 MutexLocker mu(JvmtiThreadState_lock); | |
| 1045 JvmtiEventControllerPrivate::env_dispose(env); | |
| 1046 } | |
| 1047 } | |
| 1048 | |
| 1049 | |
| 1050 void | |
| 1051 JvmtiEventController::vm_start() { | |
| 1052 if (JvmtiEnvBase::environments_might_exist()) { | |
| 1053 MutexLocker mu(JvmtiThreadState_lock); | |
| 1054 JvmtiEventControllerPrivate::vm_start(); | |
| 1055 } | |
| 1056 } | |
| 1057 | |
| 1058 void | |
| 1059 JvmtiEventController::vm_init() { | |
| 1060 if (JvmtiEnvBase::environments_might_exist()) { | |
| 1061 MutexLocker mu(JvmtiThreadState_lock); | |
| 1062 JvmtiEventControllerPrivate::vm_init(); | |
| 1063 } | |
| 1064 } | |
| 1065 | |
| 1066 void | |
| 1067 JvmtiEventController::vm_death() { | |
| 1068 if (JvmtiEnvBase::environments_might_exist()) { | |
| 1069 MutexLocker mu(JvmtiThreadState_lock); | |
| 1070 JvmtiEventControllerPrivate::vm_death(); | |
| 1071 } | |
| 1072 } |